###
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
###

randomIndex = (count) ->
  Math.floor Math.random() * count

shuffleArray = (array) ->
  shuffled = ( a for a in array )
  for i in [0...shuffled.length]
    j = i + Math.floor(Math.random() * (shuffled.length - i))
    a = shuffled[i]
    b = shuffled[j]
    shuffled[i] = b
    shuffled[j] = a
  return shuffled

randomArrayItem = (array) ->
  array[randomIndex(array.length)]

diceRoll = (sides) ->
  # produce a number between 1 and sides, inclusive
  sides = sides ? 6
  1 + Math.floor( Math.random() * sides )

diceCheck = (number, sides) ->
  diceRoll(sides) <= number

escapeSpeech = (line) ->
  return "" unless line?
  return "" + line

deepClone = (thing) ->
  JSON.parse( JSON.stringify(thing) )

isActuallyANumber = (data) -> not isNaN(parseInt(data))

pickSayString = (context, key, count) ->
  sayData = context.db.read('__sayHistory') ? []
  history = sayData[key] ? []
  value = 0
  switch
    when count == 2
      # with two, we can only toggle anyway
      if history[0]?
        value = 1 - history[0]
      else
        value = randomIndex(2)
      history[0] = value % 2

    when count < 5
      # until 4, the pattern below is a little
      # over constrained, producing a repeating
      # set rather than a random sequence,
      # so we only guarantee
      # no adjacent repetition instead
      value = randomIndex(count)
      if value == history[0]
        value = ( value + 1 ) % count
      history[0] = value % 5

    else
      # otherwise, guarantee we'll see at least
      # half the remaining options before repeating
      # one, up to a capped history of 8, beyond which
      # it's likely too difficult to detect repetition.
      value = randomIndex(count)
      for i in [0...count]
        break unless value in history
        value = ( value + 1 ) % count
      history.unshift value
      cap = Math.min 8, count / 2
      history = history[0...cap]

  sayData[key] = history
  context.db.write '__sayHistory', sayData
  return value % count

pickSayFragment = (context, key, options) ->
  index = pickSayString context, key, options.length
  return options[index]


exports.DataTablePrototype =
  pickRandomIndex: ->
    return randomIndex(@length)

  find: (key, value) ->
    idx = @keys[key]
    return null unless idx?
    for row in [0...length]
      if @[row][idx] == value
        return row
    return null


exports.Logging =
  log: ->
    console.log.apply( null, arguments )
  error: ->
    console.error.apply( null, arguments )


minutesBetween = (before, now) ->
  return 999999 unless before? and now?
  Math.floor( Math.abs(now - before) / (60 * 1000) )

hoursBetween = (before, now) ->
  return 999999 unless before? and now?
  Math.floor( Math.abs(now - before) / (60 * 60 * 1000) )

daysBetween = (before, now) ->
  return 999999 unless before? and now?
  now = (new Date(now)).setHours(0, 0, 0, 0)
  before = (new Date(before)).setHours(0, 0, 0, 0)
  Math.floor( Math.abs(now - before) / ( 24 * 60 * 60 * 1000 ) )


Math.clamp = (min, max, x) ->
  Math.min( Math.max( min, x ), max )

rgbFromHex = (hex) ->
  return [0,0,0] unless hex?.length?
  hex = hex[2..] if hex.indexOf('0x') == 0
  hex = hex[1..] if hex.indexOf('#') == 0
  return switch hex.length
    when 3
      read = (v) ->
        v = parseInt(v, 16)
        return v + 16 * v
      [ read(hex[0]), read(hex[1]), read(hex[2]) ]
    when 6
      [ parseInt(hex[0..1],16), parseInt(hex[2..3],16), parseInt(hex[4..5],16) ]
    else
      [0,0,0]

hexFromRGB = (rgb) ->
  r = Math.clamp( 0, 255, Math.floor(rgb[0]) ).toString(16)
  g = Math.clamp( 0, 255, Math.floor(rgb[1]) ).toString(16)
  b = Math.clamp( 0, 255, Math.floor(rgb[2]) ).toString(16)
  r = "0" + r if r.length < 2
  g = "0" + g if g.length < 2
  b = "0" + b if b.length < 2
  r + g + b

rgbFromHSL = (hsl) ->
  h = ( hsl[0] % 360 + 360 ) % 360
  s = Math.clamp( 0.0, 1.0, hsl[1] )
  l = Math.clamp( 0.0, 1.0, hsl[2] )
  h /= 60.0
  c = (1.0 - Math.abs(2.0 * l - 1.0)) * s
  x = c * (1.0 - Math.abs(h % 2.0 - 1.0))
  m = l - 0.5 * c
  c += m
  x += m
  m = Math.floor( m * 255 )
  c = Math.floor( c * 255 )
  x = Math.floor( x * 255 )
  switch Math.floor(h)
    when 0 then return [c,x,m]
    when 1 then return [x,c,m]
    when 2 then return [m,c,x]
    when 3 then return [m,x,c]
    when 4 then return [x,m,c]
    else        return [c,m,x]

brightenColor = (c, percent) ->
  isHex = false
  unless Array.isArray(c)
    c = rgbFromHex(c)
    isHex = true
  c = interpolateRGB c, [255,255,255], percent / 100.0
  if isHex
    return hexFromRGB(c)
  return c

interpolateRGB = (c1, c2, l) ->
  [r, g, b] = c1
  r += (c2[0] - r) * l
  g += (c2[1] - g) * l
  b += (c2[2] - b) * l
  [r.toFixed(0), g.toFixed(0), b.toFixed(0)]


reportValueMetric = ( metricType, value, unit ) ->
  params =
    MetricData: []
    Namespace: 'Litexa'

  params.MetricData.push {
    MetricName: metricType
    Dimensions: [
      {
        Name: 'project'
        Value: litexa.projectName
      }
    ],
    StorageResolution: 60
    Timestamp: new Date().toISOString()
    Unit: unit ? 'None'
    Value: value ? 1
  }
  #console.log "reporting metric #{JSON.stringify(params)}"

  return unless cloudWatch?
  cloudWatch.putMetricData params, (err, data) ->
    if err?
      console.error( "Cloudwatch metrics write fail #{err}" )

litexa.extensions =
  postProcessors: []
  extendedEvents: {}
  load: (location, name) ->
    # during testing, this might already be in the shared context, skip it if so
    if name of litexa.extensions
      #console.log ("skipping extension load, already loaded")
      return

    testing = if litexa.localTesting then "(test mode)" else ""
    #console.log "loading extension #{location}/#{name} #{testing}"
    fullPath = "#{litexa.modulesRoot}/#{location}/#{name}/litexa.extension"
    lib = litexa.extensions[name] = require fullPath

    if lib.loadPostProcessor?
      handler = lib.loadPostProcessor(litexa.localTesting)
      if handler?
        #console.log "installing post processor for extension #{name}"
        handler.extensionName = name
        litexa.extensions.postProcessors.push handler

    if lib.events?
      for k, v of lib.events(false)
        #console.log "registering extended event #{k}"
        litexa.extensions.extendedEvents[k] = v


  finishedLoading: ->
    # sort the postProcessors by their actions
    processors = litexa.extensions.postProcessors
    count = processors.length

    # identify dependencies
    for a in processors
      a.dependencies = []
      continue unless a.consumesTags?
      for tag in a.consumesTags
        for b in processors when b != a
          continue unless b.producesTags?
          if tag in b.producesTags
            a.dependencies.push b

    ready = ( a for a in processors when a.dependencies.length == 0 )
    processors = ( p for p in processors when p.dependencies.length > 0 )
    sorted = []
    for guard in [0...count]
      break if ready.length == 0
      node = ready.pop()
      for p in processors
        p.dependencies = ( pp for pp in p.dependencies when pp != node )
        if p.dependencies.length == 0
          ready.push p
      processors = ( p for p in processors when p.dependencies.length > 0 )
      sorted.push node

    unless sorted.length == count
      throw new Error "Failed to sort postprocessors by dependency"

    litexa.extensions.postProcessors = sorted


class DBTypeWrapper
  constructor: (@db, @language) ->
    @cache = {}

  read: (name) ->
    if name of @cache
      return @cache[name]
    dbType = __languages[@language].dbTypes[name]
    value = @db.read name

    if dbType?.prototype?
      # if this is a typed variable, and it appears
      # the type is a constructible, e.g. a Class
      if value?
        # patch the prototype if it exists
        Object.setPrototypeOf value, dbType.prototype
      else
        # or construct a new instance
        value = new dbType
        @db.write name, value

    else if dbType?.Prepare?
      # otherwise if it's typed and it provides a
      # wrapping Prepare function
      unless value?
        if dbType.Initialize?
          # optionally invoke an initialize
          value = dbType.Initialize()
        else
          # otherwise assume we start from an
          # empty object
          value = {}
        @db.write name, value
      # wrap the cached object, whatever it is
      # the function wants to return. Note it's
      # still the input value object that gets saved
      # to the database either way!
      value = dbType.Prepare(value)

    @cache[name] = value
    return value

  write: (name, value) ->
    # clear out the cache on any writes
    delete @cache[name]

    dbType = __languages[@language].dbTypes[name]
    if dbType?
      # for typed objects, we can only replace with
      # another object, OR clear out the object and
      # let initialization happen again on the next
      # read, whenever that happens
      if not value?
        @db.write name, null
      else if typeof(value) == 'object'
        @db.write name, value
      else
        throw new Error "@#{name} is a typed variable, you can only assign an object or null to it."
    else
      @db.write name, value

  finalize: (cb) ->
    @db.finalize cb

# Monetization
inSkillProductBought = (stateContext, referenceName) ->
  isp = await getProductByReferenceName(stateContext, referenceName)
  return (isp?.entitled == 'ENTITLED')

getProductByReferenceName = (stateContext, referenceName) ->
  if stateContext.monetization.fetchEntitlements
    await fetchEntitlements stateContext

  for p in stateContext.monetization.inSkillProducts
    if p.referenceName == referenceName
      return p
  return null

getProductByProductId = (stateContext, productId) ->
  if stateContext.monetization.fetchEntitlements
    await fetchEntitlements stateContext

  for p in stateContext.monetization.inSkillProducts
    if p.productId == productId
      return p
  return null

buildBuyInSkillProductDirective = (stateContext, referenceName) ->
  isp = await getProductByReferenceName stateContext, referenceName
  unless isp?
    console.log "buildBuyInSkillProductDirective(): in-skill product \"#{referenceName}\" not
      found."
    return

  stateContext.directives.push {
      "type": "Connections.SendRequest"
      "name": "Buy"
      "payload": {
        "InSkillProduct": {
          "productId": isp.productId
        }
      }
      "token": "bearer " + stateContext.event.context.System.apiAccessToken
    }

  stateContext.shouldEndSession = true

fetchEntitlements = (stateContext, ignoreCache = false) ->
  if !stateContext.monetization.fetchEntitlements and !ignoreCache
    return Promise.resolve()

  new Promise (resolve, reject) ->
    try
      https = require('https')
    catch
      console.log "skipping fetchEntitlements, no https present"
      reject()

    unless stateContext.event.context.System.apiEndpoint
      # If there's no API endpoint this is an offline test.
      resolve()

    # endpoint is region-specific:
    # e.g. https://api.amazonalexa.com vs. https://api.eu.amazonalexa.com
    apiEndpoint = stateContext.event.context.System.apiEndpoint
    apiEndpoint = apiEndpoint.replace("https://", "")
    apiPath = "/v1/users/~current/skills/~current/inSkillProducts"
    token = "bearer " + stateContext.event.context.System.apiAccessToken

    options =
      host: apiEndpoint
      path: apiPath
      method: 'GET'
      headers:
        "Content-Type": 'application/json'
        "Accept-Language": stateContext.request.locale
        "Authorization": token

    req = https.get options, (res) =>
      res.setEncoding("utf8")

      if res.statusCode != 200
        reject()

      returnData = ""
      res.on 'data', (chunk) =>
        returnData += chunk

      res.on 'end', () =>
        console.log("fetchEntitlements() returned: #{returnData}")
        stateContext.monetization.inSkillProducts = JSON.parse(returnData).inSkillProducts ? []
        stateContext.monetization.fetchEntitlements = false
        stateContext.db.write "__monetization", stateContext.monetization
        resolve()

    req.on 'error', (e) ->
      console.log "Error while querying inSkillProducts: #{e}"
      reject(e)

getReferenceNameByProductId = (stateContext, productId) ->
  for p in stateContext.monetization.inSkillProducts
    if p.productId == productId
      return p.referenceName
  return null

buildCancelInSkillProductDirective = (stateContext, referenceName) =>
  isp = await getProductByReferenceName(stateContext, referenceName)
  unless isp?
    console.log "buildCancelInSkillProductDirective(): in-skill product \"#{referenceName}\" not
      found."
    return

  stateContext.directives.push {
      "type": "Connections.SendRequest"
      "name": "Cancel"
      "payload": {
        "InSkillProduct": {
          "productId": isp.productId
        }
      }
      "token": "bearer " + stateContext.event.context.System.apiAccessToken
    }

  stateContext.shouldEndSession = true

buildUpsellInSkillProductDirective = (stateContext, referenceName, upsellMessage = '') =>
  isp = await getProductByReferenceName(stateContext, referenceName)
  unless isp?
    console.log "buildUpsellInSkillProductDirective(): in-skill product \"#{referenceName}\" not
      found."
    return

  stateContext.directives.push {
      "type": "Connections.SendRequest"
      "name": "Upsell"
      "payload": {
        "InSkillProduct": {
          "productId": isp.productId
        }
        "upsellMessage": upsellMessage
      }
      "token": "bearer " + stateContext.event.context.System.apiAccessToken
    }

  stateContext.shouldEndSession = true