NUM_PRIORITIES = 10
DEFAULT_PRIORITY = 5

parser = require "./parser"
Queues = require "./Queues"
Job = require "./Job"
LocalDatastore = require "./LocalDatastore"
RedisDatastore = require "./RedisDatastore"
Events = require "./Events"
States = require "./States"
Sync = require "./Sync"

class Bottleneck
  Bottleneck.default = Bottleneck
  Bottleneck.Events = Events
  Bottleneck.version = Bottleneck::version = require("./version.json").version
  Bottleneck.strategy = Bottleneck::strategy = { LEAK:1, OVERFLOW:2, OVERFLOW_PRIORITY:4, BLOCK:3 }
  Bottleneck.BottleneckError = Bottleneck::BottleneckError = require "./BottleneckError"
  Bottleneck.Group = Bottleneck::Group = require "./Group"
  Bottleneck.RedisConnection = Bottleneck::RedisConnection = require "./RedisConnection"
  Bottleneck.IORedisConnection = Bottleneck::IORedisConnection = require "./IORedisConnection"
  Bottleneck.Batcher = Bottleneck::Batcher = require "./Batcher"
  jobDefaults:
    priority: DEFAULT_PRIORITY
    weight: 1
    expiration: null
    id: "<no-id>"
  storeDefaults:
    maxConcurrent: null
    minTime: 0
    highWater: null
    strategy: Bottleneck::strategy.LEAK
    penalty: null
    reservoir: null
    reservoirRefreshInterval: null
    reservoirRefreshAmount: null
    reservoirIncreaseInterval: null
    reservoirIncreaseAmount: null
    reservoirIncreaseMaximum: null
  localStoreDefaults:
    Promise: Promise
    timeout: null
    heartbeatInterval: 250
  redisStoreDefaults:
    Promise: Promise
    timeout: null
    heartbeatInterval: 5000
    clientTimeout: 10000
    Redis: null
    clientOptions: {}
    clusterNodes: null
    clearDatastore: false
    connection: null
  instanceDefaults:
    datastore: "local"
    connection: null
    id: "<no-id>"
    rejectOnDrop: true
    trackDoneStatus: false
    Promise: Promise
  stopDefaults:
    enqueueErrorMessage: "This limiter has been stopped and cannot accept new jobs."
    dropWaitingJobs: true
    dropErrorMessage: "This limiter has been stopped."

  constructor: (options={}, invalid...) ->
    @_validateOptions options, invalid
    parser.load options, @instanceDefaults, @
    @_queues = new Queues NUM_PRIORITIES
    @_scheduled = {}
    @_states = new States ["RECEIVED", "QUEUED", "RUNNING", "EXECUTING"].concat(if @trackDoneStatus then ["DONE"] else [])
    @_limiter = null
    @Events = new Events @
    @_submitLock = new Sync "submit", @Promise
    @_registerLock = new Sync "register", @Promise
    storeOptions = parser.load options, @storeDefaults, {}

    @_store = if @datastore == "redis" or @datastore == "ioredis" or @connection?
      storeInstanceOptions = parser.load options, @redisStoreDefaults, {}
      new RedisDatastore @, storeOptions, storeInstanceOptions
    else if @datastore == "local"
      storeInstanceOptions = parser.load options, @localStoreDefaults, {}
      new LocalDatastore @, storeOptions, storeInstanceOptions
    else
      throw new Bottleneck::BottleneckError "Invalid datastore type: #{@datastore}"

    @_queues.on "leftzero", => @_store.heartbeat?.ref?()
    @_queues.on "zero", => @_store.heartbeat?.unref?()

  _validateOptions: (options, invalid) ->
    unless options? and typeof options == "object" and invalid.length == 0
      throw new Bottleneck::BottleneckError "Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1."

  ready: -> @_store.ready

  clients: -> @_store.clients

  channel: -> "b_#{@id}"

  channel_client: -> "b_#{@id}_#{@_store.clientId}"

  publish: (message) -> @_store.__publish__ message

  disconnect: (flush=true) -> @_store.__disconnect__ flush

  chain: (@_limiter) -> @

  queued: (priority) -> @_queues.queued priority

  clusterQueued: -> @_store.__queued__()

  empty: -> @queued() == 0 and @_submitLock.isEmpty()

  running: -> @_store.__running__()

  done: -> @_store.__done__()

  jobStatus: (id) -> @_states.jobStatus id

  jobs: (status) -> @_states.statusJobs status

  counts: -> @_states.statusCounts()

  _randomIndex: -> Math.random().toString(36).slice(2)

  check: (weight=1) -> @_store.__check__ weight

  _clearGlobalState: (index) ->
    if @_scheduled[index]?
      clearTimeout @_scheduled[index].expiration
      delete @_scheduled[index]
      true
    else false

  _free: (index, job, options, eventInfo) ->
    try
      { running } = await @_store.__free__ index, options.weight
      @Events.trigger "debug", "Freed #{options.id}", eventInfo
      if running == 0 and @empty() then @Events.trigger "idle"
    catch e
      @Events.trigger "error", e

  _run: (index, job, wait) ->
    job.doRun()
    clearGlobalState = @_clearGlobalState.bind @, index
    run = @_run.bind @, index, job
    free = @_free.bind @, index, job

    @_scheduled[index] =
      timeout: setTimeout =>
        job.doExecute @_limiter, clearGlobalState, run, free
      , wait
      expiration: if job.options.expiration? then setTimeout ->
        job.doExpire clearGlobalState, run, free
      , wait + job.options.expiration
      job: job

  _drainOne: (capacity) ->
    @_registerLock.schedule =>
      if @queued() == 0 then return @Promise.resolve null
      queue = @_queues.getFirst()
      { options, args } = next = queue.first()
      if capacity? and options.weight > capacity then return @Promise.resolve null
      @Events.trigger "debug", "Draining #{options.id}", { args, options }
      index = @_randomIndex()
      @_store.__register__ index, options.weight, options.expiration
      .then ({ success, wait, reservoir }) =>
        @Events.trigger "debug", "Drained #{options.id}", { success, args, options }
        if success
          queue.shift()
          empty = @empty()
          if empty then @Events.trigger "empty"
          if reservoir == 0 then @Events.trigger "depleted", empty
          @_run index, next, wait
          @Promise.resolve options.weight
        else
          @Promise.resolve null

  _drainAll: (capacity, total=0) ->
    @_drainOne(capacity)
    .then (drained) =>
      if drained?
        newCapacity = if capacity? then capacity - drained else capacity
        @_drainAll(newCapacity, total + drained)
      else @Promise.resolve total
    .catch (e) => @Events.trigger "error", e

  _dropAllQueued: (message) -> @_queues.shiftAll (job) -> job.doDrop { message }

  stop: (options={}) ->
    options = parser.load options, @stopDefaults
    waitForExecuting = (at) =>
      finished = =>
        counts = @_states.counts
        (counts[0] + counts[1] + counts[2] + counts[3]) == at
      new @Promise (resolve, reject) =>
        if finished() then resolve()
        else
          @on "done", =>
            if finished()
              @removeAllListeners "done"
              resolve()
    done = if options.dropWaitingJobs
      @_run = (index, next) -> next.doDrop { message: options.dropErrorMessage }
      @_drainOne = => @Promise.resolve null
      @_registerLock.schedule => @_submitLock.schedule =>
        for k, v of @_scheduled
          if @jobStatus(v.job.options.id) == "RUNNING"
            clearTimeout v.timeout
            clearTimeout v.expiration
            v.job.doDrop { message: options.dropErrorMessage }
        @_dropAllQueued options.dropErrorMessage
        waitForExecuting(0)
    else
      @schedule { priority: NUM_PRIORITIES - 1, weight: 0 }, => waitForExecuting(1)
    @_receive = (job) -> job._reject new Bottleneck::BottleneckError options.enqueueErrorMessage
    @stop = => @Promise.reject new Bottleneck::BottleneckError "stop() has already been called"
    done

  _addToQueue: (job) =>
    { args, options } = job
    try
      { reachedHWM, blocked, strategy } = await @_store.__submit__ @queued(), options.weight
    catch error
      @Events.trigger "debug", "Could not queue #{options.id}", { args, options, error }
      job.doDrop { error }
      return false

    if blocked
      job.doDrop()
      return true
    else if reachedHWM
      shifted = if strategy == Bottleneck::strategy.LEAK then @_queues.shiftLastFrom(options.priority)
      else if strategy == Bottleneck::strategy.OVERFLOW_PRIORITY then @_queues.shiftLastFrom(options.priority + 1)
      else if strategy == Bottleneck::strategy.OVERFLOW then job
      if shifted? then shifted.doDrop()
      if not shifted? or strategy == Bottleneck::strategy.OVERFLOW
        if not shifted? then job.doDrop()
        return reachedHWM

    job.doQueue reachedHWM, blocked
    @_queues.push job
    await @_drainAll()
    reachedHWM

  _receive: (job) ->
    if @_states.jobStatus(job.options.id)?
      job._reject new Bottleneck::BottleneckError "A job with the same id already exists (id=#{job.options.id})"
      false
    else
      job.doReceive()
      @_submitLock.schedule @_addToQueue, job

  submit: (args...) ->
    if typeof args[0] == "function"
      [fn, args..., cb] = args
      options = parser.load {}, @jobDefaults
    else
      [options, fn, args..., cb] = args
      options = parser.load options, @jobDefaults

    task = (args...) =>
      new @Promise (resolve, reject) ->
        fn args..., (args...) ->
          (if args[0]? then reject else resolve) args

    job = new Job task, args, options, @jobDefaults, @rejectOnDrop, @Events, @_states, @Promise
    job.promise
    .then (args) -> cb? args...
    .catch (args) -> if Array.isArray args then cb? args... else cb? args
    @_receive job

  schedule: (args...) ->
    if typeof args[0] == "function"
      [task, args...] = args
      options = {}
    else
      [options, task, args...] = args
    job = new Job task, args, options, @jobDefaults, @rejectOnDrop, @Events, @_states, @Promise
    @_receive job
    job.promise

  wrap: (fn) ->
    schedule = @schedule.bind @
    wrapped = (args...) -> schedule fn.bind(@), args...
    wrapped.withOptions = (options, args...) -> schedule options, fn, args...
    wrapped

  updateSettings: (options={}) ->
    await @_store.__updateSettings__ parser.overwrite options, @storeDefaults
    parser.overwrite options, @instanceDefaults, @
    @

  currentReservoir: -> @_store.__currentReservoir__()

  incrementReservoir: (incr=0) -> @_store.__incrementReservoir__ incr

module.exports = Bottleneck