/* -----------------------------------------------------------------------------
Copyright 2021-2022 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- */

// Author: Kevin P. Barry [ta0kira@gmail.com]

define Counter {
  zeroIndexed (max) {
    return builder().count(max).done()
  }

  revZeroIndexed (max) {
    return builder().count(max).reverse().done()
  }

  unlimited () {
    return builder().done()
  }

  builder () {
    return CounterBuilder.new()
  }
}

define CounterBuilder {
  @value Int start
  @value Int increment
  @value optional Int limit
  @value optional Int count
  @value Bool reverse

  new () {
    return #self{ 0, 1, empty, empty, false }
  }

  done () {
    optional Int actualCount <- defer
    if (`present` limit) {
      if (increment != 0) {
        Bool missedStart <- (`require` limit - start) % increment != 0
        // NOTE: This still works if limit < start and increment < 0.
        actualCount <- (`require` limit - start) / increment + missedStart.asInt()
      } else {
        actualCount <- empty
      }
    } else {
      actualCount <- count
    }
    Int actualStart <- start
    Int actualIncrement <- increment
    if (reverse && `present` actualCount) {
      actualStart <- start + increment*(require(actualCount)-1)
      actualIncrement <- -increment
    }
    return IntCounter.new(actualStart, actualIncrement, actualCount)
  }

  start (x) {
    start <- x
    return self
  }

  count (n) {
    limit <- empty
    count <- n
    return self
  }

  limit (x) {
    count <- empty
    limit <- x
    return self
  }

  increment (x) {
    increment <- x
    return self
  }

  reverse () {
    reverse <- !reverse
    return self
  }
}

concrete IntCounter {
  @type new (Int, Int, optional Int) -> (optional Order<Int>)
}

define IntCounter {
  $ReadOnly[increment]$

  refines Order<Int>

  @value Int current
  @value Int increment
  @value optional Int remaining

  new (start, increment, count) {
    if (`present` count && `require` count <= 0) {
      return empty
    } else {
      return delegate -> #self
    }
  }

  next () {
    if (`present` remaining && `require` remaining - 1 <= 0) {
      return empty
    } else {
      if (`present` remaining) {
        remaining <- `require` remaining - 1
      }
      current <- current+increment
      return self
    }
  }

  get () {
    return current
  }
}

define Repeat {
  $ReadOnlyExcept[counter]$

  refines Order<#x>

  @value #x value
  @value Order<any> counter

  times (value, max) {
    optional Order<any> counter <- Counter.builder().count(max).done()
    if (! `present` counter) {
      return empty
    } else {
      return Repeat<#y>{ value, `require` counter }
    }
  }

  unlimited (value) {
    return Repeat<#y>{ value, `require` Counter.builder().done() }
  }

  next () {
    optional Order<any> next <- counter.next()
    if (! `present` next) {
      return empty
    } else {
      counter <- `require` next
      return self
    }
  }

  get () {
    return value
  }
}

define Ranges {
  min (x, y) {
    return minMax(x, y){0}
  }

  max (x, y) (z) {
    return minMax(x, y){1}
  }

  minMax (x, y) {
    // NOTE: Using y < x makes the default x, y when they are equal.
    if (y `#x.lessThan` x) {
      return y, x
    } else {
      return x, y
    }
  }
}