core.agate

class Nil { }
class Bool { }
class Int { }
class Float { }
class Char { }
class Fn { }

class Iterable {
  all(predicate) {
    def value = true
    for (element in this) {
      value = predicate(element)
      if (!value) {
        return value
      }
    }
    return value
  }

  any(predicate) {
    def value = false
    for (element in this) {
      value = predicate(element)
      if (value) {
        return value
      }
    }
    return value
  }

  none(predicate) {
    return !.any(predicate)
  }

  size {
    def counter = 0
    for (element in this) {
      counter = counter + 1
    }
    return counter
  }

  first {
    def iterator = .iterate(nil)
    return iterator != nil ? .iterator_value(iterator) : nil
  }

  count(predicate) {
    def counter = 0
    for (element in this) {
      if (predicate(element)) {
        counter = counter + 1
      }
    }
    return counter
  }

  contains(value) {
    for (element in this) {
      if (element == value) {
        return true
      }
    }
    return false
  }

  empty { .iterate(nil) ? false : true }

  each(fn) {
    for (element in this) {
      fn(element)
    }
  }

  join() { .join("") }

  join(sep) {
    if (!(sep is String) && !(sep is Char)) {
      System.abort("Argument must be a character or a string.")
    }
    def res = ""
    def first = true
    for (element in this) {
      if (first) {
        first = false
      } else {
        res = res + sep.to_s
      }
      res = res + element.to_s
    }
    return res
  }

  map(fn) { __MapIterable.new(this, fn) }

  skip(count) {
    if (!(count is Int) || count < 0) {
      System.abort("Count must be a non-negative integer.")
    }
    return __SkipIterable.new(this, count)
  }

  take(count) {
    if (!(count is Int) || count < 0) {
      System.abort("Count must be a non-negative integer.")
    }
    return __TakeIterable.new(this, count)
  }

  uniq() { __UniqIterable.new(this) }

  where(predicate) { __WhereIterable.new(this, predicate) }

  accumulate(val, op) {
    for (element in this) {
      val = op(val, element)
    }
    return val
  }

  reduce(op) {
    def iter = .iterate(nil)
    if (iter == nil) {
      System.abort("Cannot reduce an empty sequence.")
    }
    def result = .iterator_value(iter)
    while (iter = .iterate(iter)) {
      result = op(result, .iterator_value(iter))
    }
    return result
  }

  min { .reduce {|lhs,rhs| lhs < rhs ? lhs : rhs } }
  max { .reduce {|lhs,rhs| lhs < rhs ? rhs : lhs } }
  sum { .reduce {|lhs,rhs| lhs + rhs } }
  product { .reduce {|lhs,rhs| lhs * rhs } }

  sorted(comp) {
    def iter = .iterate(nil)
    if (iter == nil) {
      return true
    }
    def prev = .iterator_value(iter)
    while (iter = .iterate(iter)) {
      def curr = .iterator_value(iter)
      if (comp(curr, prev)) {
        return false
      }
      prev = curr
    }
    return true
  }

  sorted() { .sorted {|lhs,rhs| lhs < rhs } }

  to_a {
    def array = Array.new()
    for (element in this) {
      array.append(element)
    }
    return array
  }
}

class Comparable {
  ==(other) { .cmp(other) == 0 }
  !=(other) { .cmp(other) != 0 }
  <(other) { .cmp(other) < 0 }
  <=(other) { .cmp(other) <= 0 }
  >(other) { .cmp(other) > 0 }
  >=(other) { .cmp(other) >= 0 }
}

class __MapIterable {
  mixin Iterable

  construct new(seq, fn) {
    @seq = seq
    @fn = fn
  }

  iterate(iterator) { @seq.iterate(iterator) }
  iterator_value(iterator) { @fn(@seq.iterator_value(iterator)) }
}

class __SkipIterable {
  mixin Iterable

  construct new(seq, count) {
    @seq = seq
    @count = count
  }

  iterate(iterator) {
    if (iterator) {
      return @seq.iterate(iterator)
    }
    iterator = @seq.iterate(iterator)
    def count = @count
    while (count > 0 && iterator) {
      iterator = @seq.iterate(iterator)
      count = count - 1
    }
    return iterator
  }

  iterator_value(iterator) { @seq.iterator_value(iterator) }
}

class __TakeIterable {
  mixin Iterable

  construct new(seq, count) {
    @seq = seq
    @count = count
  }

  iterate(iterator) {
    if (!iterator) {
      @taken = 1
    } else {
      @taken = @taken + 1
    }
    return @taken > @count ? nil : @seq.iterate(iterator)
  }

  iterator_value(iterator) { @seq.iterator_value(iterator) }
}

class __UniqIterable {
  mixin Iterable

  construct new(seq) {
    @seq = seq
  }

  iterate(iterator) {
    if (iterator == nil) {
      iterator = @seq.iterate(iterator)
      if (iterator != nil) {
        @prev = @seq.iterator_value(iterator)
      }
    } else {
      while (iterator = @seq.iterate(iterator)) {
        def curr = @seq.iterator_value(iterator)
        if (curr != @prev) {
          @prev = curr
          break
        }
      }
    }
    return iterator
  }

  iterator_value(iterator) { @seq.iterator_value(iterator) }
}

class __WhereIterable {
  mixin Iterable

  construct new(seq, fn) {
    @seq = seq
    @fn = fn
  }

  iterate(iterator) {
    while (iterator = @seq.iterate(iterator)) {
      if (@fn(@seq.iterator_value(iterator))) {
        break
      }
    }
    return iterator
  }

  iterator_value(iterator) { @seq.iterator_value(iterator) }
}

class Array {
  mixin Iterable

  append_all(seq) {
    for (elem in seq) {
      .append(elem)
    }
    return seq
  }

  sort() { .sort {|lhs,rhs| lhs < rhs } }

  sort(comp) {
    if (!(comp is Fn) || comp.arity != 2) {
      System.abort("comp must be a function with two parameters.")
    }
    .__quicksort(0, .size - 1, comp)
    return this
  }

  partition(pred) { .__partition(0, .size - 1, pred) }

  to_s { "[%(.join(", "))]" }

  __quicksort(lo, hi, comp) {
    if (lo < hi) {
      def mid = lo + (hi - lo) / 2
      def p = .__three_way_partition(lo, hi, this[mid], comp)
      .__quicksort(lo, p[0] - 1, comp)
      .__quicksort(p[1] + 1, hi, comp)
    }
  }

  __partition(lo, hi, pred) {
    def mid = lo
    for (i in lo..hi) {
      if (pred(this[i])) {
        .swap(i, mid)
        mid = mid + 1
      }
    }
    return mid
  }

  __three_way_partition(lo, hi, pivot, comp) {
    def i = lo
    def j = lo
    def k = hi
    while (j <= k) {
      if (comp(this[j], pivot)) {
        .swap(i, j)
        i = i + 1
        j = j + 1
      } else if (comp(pivot, this[j])) {
        .swap(j, k)
        k = k - 1
      } else {
        j = j + 1
      }
    }
    return (i, k)
  }

  clone() {
    def a = []
    for (item in this) {
      a.append(item.clone())
    }
    return a
  }

  to_a { this[0..-1] }

  +(other) {
    def result = .to_a
    result.append_all(other)
    return result
  }

  *(count) {
    if (!(count is Int) || count < 0) {
      System.abort("Count must be a non-negative integer.")
    }
    def result = []
    for (i in 0...count) {
      result.append_all(this)
    }
    return result
  }
}

class String {
  mixin Iterable

  ltrim() { .__trim(" \n\t\r", true, false) }
  ltrim(chars) { .__trim(chars, true, false) }

  rtrim() { .__trim(" \n\t\r", false, true) }
  rtrim(chars) { .__trim(chars, false, true) }

  trim() { .__trim(" \n\t\r", true, true) }
  trim(chars) { .__trim(chars, true, true) }
}

class MapEntry {
  construct new(key, value) {
    @key = key
    @value = value
  }

  key { @key }
  value { @value }

  to_s { "%(@key): %(@value)" }
}

class __MapKeyIterable {
  mixin Iterable

  construct new(map) {
    @map = map
  }

  iterate(iterator) { @map.iterate(iterator) }
  iterator_value(iterator) { @map.__key_from_iterator(iterator) }
}

class __MapValueIterable {
  mixin Iterable

  construct new(map) {
    @map = map
  }

  iterate(iterator) { @map.iterate(iterator) }
  iterator_value(iterator) { @map.__value_from_iterator(iterator) }
}

class Map {
  mixin Iterable

  keys { __MapKeyIterable.new(this) }
  values { __MapValueIterable.new(this) }

  iterator_value(iterator) { MapEntry.new(.__key_from_iterator(iterator), .__value_from_iterator(iterator)) }

  contains(key) { .__contains(key, key.hash) }
  insert(key, value) { .__insert(key, value, key.hash) }
  erase(key) { .__erase(key, key.hash) }

  [key] { .__subscript_getter(key, key.hash) }
  [key]=(value) { .__subscript_setter(key, value, key.hash) }

  at(key) { .__at(key, key.hash) }

  to_s { "{%(.join(", "))}" }

  clone() {
    def m = { }
    for (kv in this) {
      m.insert(kv.key.clone(), kv.value.clone())
    }
    return m
  }

  __put(key, value) { .__put(key, value, key.hash) }
}

class Tuple {
  mixin Iterable
  to_s { "(%(.join(", ")))" }
}

class Range {
  mixin Iterable
}

class IO {
  static print(obj) { .__print(obj.to_s) }

  static println() {
    .__print("\n")
  }

  static println(obj) {
    .__print(obj.to_s)
    .__print("\n")
    return obj
  }

  static input(message) {
    .__print(message.to_s)
    return .input()
  }
}

class Math { }
class System { }

class Random {
  float(end) { .float() * end }
  float(start, end) { .float() * (end - start) + start }
}