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

# causes every request and response object to be written to the logs
loggingLevel = process?.env?.loggingLevel ? null

# when enabled, logs out every state transition when it happens, useful for tracing what
# order things happened in  when something goes wrong
logStateTraces = process?.env?.logStateTraces in [ 'true', true ]
enableStateTracing = (process?.env?.enableStateTracing in [ 'true', true ]) or logStateTraces

# hack for over aggressive Show caching
shouldUniqueURLs = process?.env?.shouldUniqueURLs == 'true'

# assets root location is determined by an external variable
litexa.assetsRoot = process?.env?.assetsRoot ? litexa.assetsRoot

exports.handlerSteps = handlerSteps = {}

exports.handler = (event, lambdaContext, callback) ->

  handlerContext =
    originalEvent: event
    litexa: litexa

  # patch for testing support to be able to toggle this without
  # recreating the lambda
  if event.__logStateTraces?
    logStateTraces = event.__logStateTraces

  switch loggingLevel
    when 'verbose'
      # when verbose logging, dump the whole event to the console
      # this is pretty quick, but it makes for massive logs
      exports.Logging.log "VERBOSE REQUEST " + JSON.stringify(event, null, 2)
    when 'terse'
      exports.Logging.log "VERBOSE REQUEST " + JSON.stringify(event.request, null, 2)

  # patch when missing so downstream doesn't have to check
  unless event.session?
    event.session = {}
  unless event.session.attributes?
    event.session.attributes = {}

  handlerSteps.extractIdentity(event, handlerContext)
  .then ->
    handlerSteps.checkFastExit(event, handlerContext)
  .then (proceed) ->
    unless proceed
      return callback null, {}

    handlerSteps.runConcurrencyLoop(event, handlerContext)
    .then (response) ->
      # if we have post process extensions, then run each one in series
      promise = Promise.resolve()
      for extensionName, events of extensionEvents
        if events.beforeFinalResponse?
          try
            await events.beforeFinalResponse response
          catch err
            exports.Logging.error "Failed to execute the beforeFinalResponse
              event for extension #{extensionName}: #{err}"
            throw err
      return response
    .then (response) ->
      # if we're fully resolved here, we can return the final result
      if loggingLevel
        exports.Logging.log "VERBOSE RESPONSE " + JSON.stringify(response, null, 2)
      callback null, response
    .catch (err) ->
      # otherwise, we've failed, so return as an error, without data
      callback err, null


handlerSteps.extractIdentity = (event, handlerContext) ->
  new Promise (resolve, reject) ->
    # extract the info we consider to be the user's identity. Note
    # different events may provide this information in different places
    handlerContext.identity = identity = {}
    if event.context?.System?
      identity.requestAppId = event.context.System.application?.applicationId
      identity.userId = event.context.System.user?.userId
      identity.deviceId = event.context.System.device?.deviceId
    else if event.session?
      identity.requestAppId = event.session.application?.applicationId
      identity.userId = event.session.user?.userId
      identity.deviceId = 'no-device'
    resolve()



getLanguage = (event) ->
  # work out the language, from the locale, if it exists
  language = 'default'
  if event.request.locale?
    lang = event.request.locale
    langCode = lang[0...2]

    for __language of __languages
      if (lang.toLowerCase() is __language.toLowerCase()) or (langCode is __language)
        language = __language

  return language



handlerSteps.checkFastExit = (event, handlerContext) ->

  # detect fast exit for valid events we don't route yet, or have no response to
  terminalEvent = false
  switch event.request.type
    when 'System.ExceptionEncountered'
      exports.Logging.error "ERROR System.ExceptionEncountered: #{JSON.stringify(event.request)}"
      terminalEvent = true
    when 'SessionEndedRequest'
      terminalEvent = true

  unless terminalEvent
    return true

  # this is an event that ends the session, but we may have code
  # that needs to cleanup on skill exist that result in a BD write
  new Promise (resolve, reject) ->
    originalSessionAttributes = JSON.parse JSON.stringify event.session.attributes

    tryToClose = ->
      dbKey = litexa.overridableFunctions.generateDBKey(handlerContext.identity)

      db.fetchDB { identity: handlerContext.identity, dbKey, sessionAttributes: originalSessionAttributes, fetchCallback: (err, dbObject) ->
        if err?
          return reject(err)

        language = getLanguage(event)

        if litexa.sessionTerminatingCallback?
          stateContext =
            now: (new Date(event.request?.timestamp)).getTime()
            requestId: event.request.requestId
            language: language
            event: event
            request: event?.request ? {}
            db: new DBTypeWrapper dbObject, language
            sessionAttributes: event?.session?.attributes
          litexa.sessionTerminatingCallback(stateContext) 

        # all clear, we don't have anything active
        if loggingLevel
          exports.Logging.log "VERBOSE Terminating input handler early"

        # write back the object, to clear our memory
        dbObject.finalize (err) ->
          return reject(err) if err?
          if dbObject.repeatHandler
            tryToClose()
          else
            return resolve(false)
      }
    tryToClose()


handlerSteps.runConcurrencyLoop = (event, handlerContext) ->

  # to solve for concurrency, we keep state in a database
  # and support retrying all the logic after this point
  # in the event that the database layer detects a collision

  return new Promise (resolve, reject) ->
    numberOfTries = 0
    requestTimeStamp = (new Date(event.request?.timestamp)).getTime()

    language = getLanguage(event)
    litexa.language = language
    handlerContext.identity.litexaLanguage = language

    runHandler = ->
      numberOfTries += 1
      if numberOfTries > 1
        exports.Logging.log "CONCURRENCY LOOP iteration #{numberOfTries}, denied db write"

      dbKey = litexa.overridableFunctions.generateDBKey(handlerContext.identity)
      sessionAttributes = JSON.parse JSON.stringify event.session.attributes
      db.fetchDB { identity: handlerContext.identity, dbKey, sessionAttributes: sessionAttributes, fetchCallback: (err, dbObject) ->
        # build the context object for the state machine
        try

          stateContext =
            say: []
            reprompt: []
            directives: []
            shouldEndSession: false
            now: requestTimeStamp
            settings: {}
            traceHistory: []
            requestId: event.request.requestId
            language: language
            event: event
            request: event.request ? {}
            db: new DBTypeWrapper dbObject, language
            sessionAttributes: sessionAttributes

          stateContext.settings = stateContext.db.read("__settings") ? { resetOnLaunch: true }

          unless dbObject.isInitialized()
            dbObject.initialize()
            await __languages[stateContext.language].enterState.initialize?(stateContext)

          await handlerSteps.parseRequestData stateContext
          await handlerSteps.initializeMonetization stateContext, event
          # in the special case of us launching the skill from cold, we want to 
          # warm up the landing state first, before delivering it the intent
          if !stateContext.currentState and stateContext.handoffState
            await handlerSteps.enterLaunchHandoffState stateContext 
          await handlerSteps.routeIncomingIntent stateContext
          await handlerSteps.walkStates stateContext
          response = await handlerSteps.createFinalResult stateContext

          if event.__reportStateTrace
            response.__stateTrace = stateContext.traceHistory

          if dbObject.repeatHandler
            # the db failed to save, repeat the whole process
            await runHandler()
          else
            resolve response

        catch err
          reject err
      }

    # kick off the first one
    await runHandler()


handlerSteps.parseRequestData = (stateContext) ->
  request = stateContext.request

  # this is litexa's dynamic request context, i.e. accesible from litexa as $something
  stateContext.slots =
    request: request

  stateContext.oldInSkillProducts = stateContext.inSkillProducts = stateContext.db.read("__inSkillProducts") ? { inSkillProducts: [] }

  # note:
  # stateContext.handoffState  : who will handle the next intent
  # stateContext.handoffIntent : which intent will be delivered next
  # stateContext.currentState  : which state are we ALREADY in
  # stateContext.nextState     : which state is queued up to be transitioned into next

  stateContext.handoffState = null
  stateContext.handoffIntent = false
  stateContext.currentState = stateContext.db.read "__currentState"
  stateContext.nextState = null

  if request.type == 'LaunchRequest'
    reportValueMetric 'Launches'

  initializeExtensionObjects stateContext

  switch request.type
    when 'IntentRequest', 'LaunchRequest'
      incomingState = stateContext.currentState

      # don't have a current state? Then we're going to launch
      unless incomingState
        incomingState = 'launch'
        stateContext.currentState = null

      # honor resetOnLaunch
      isColdLaunch = request.type == 'LaunchRequest' or stateContext.event.session?.new
      if stateContext.settings.resetOnLaunch and isColdLaunch
        incomingState = 'launch'
        stateContext.currentState = null

      if request?.intent
        intent = request.intent
        stateContext.intent = intent.name
        if intent.slots?
          for name, obj of intent.slots
            stateContext.slots[name] = obj.value
            authorities = obj.resolutions?.resolutionsPerAuthority ? []
            for auth in authorities 
              if auth? and auth.status?.code == 'ER_SUCCESS_MATCH'
                value = auth.values?[0]?.value?.name
                if value?
                  stateContext.slots[name] = value

        stateContext.handoffIntent = true
        stateContext.handoffState = incomingState
        stateContext.nextState = null
      else
        stateContext.intent = null
        stateContext.handoffIntent = false
        stateContext.handoffState = null
        stateContext.nextState = incomingState

    when 'Connections.Response'
      stateContext.intent = 'Connections.Response'
      stateContext.handoffIntent = true

      # if we get this and we're not in progress,
      # then reroute to the launch state
      if stateContext.currentState?
        stateContext.handoffState = stateContext.currentState
      else
        stateContext.nextState = 'launch'
        stateContext.handoffState = 'launch'

    else
      stateContext.intent = request.type
      stateContext.handoffIntent = true
      stateContext.handoffState = stateContext.currentState
      stateContext.nextState = null

      handled = false

      for extensionName, requests of extensionRequests
        if request.type of requests
          handled = true
          func = requests[request.type]
          if typeof(func) == 'function'
            func(request)

      if request.type in litexa.extendedEventNames
        handled = true

      unless handled
        throw new Error "unrecognized event type: #{request.type}"


handlerSteps.initializeMonetization = (stateContext, event) ->
  stateContext.monetization = stateContext.db.read("__monetization")
  unless stateContext.monetization?
    stateContext.monetization = {
      fetchEntitlements: false
      inSkillProducts: []
    }
    stateContext.db.write "__monetization", stateContext.monetization

  if event.request?.type in [ 'Connections.Response', 'LaunchRequest' ]
    attributes = event.session.attributes
    # invalidate monetization cache
    stateContext.monetization.fetchEntitlements = true
    stateContext.db.write "__monetization", stateContext.monetization

  return Promise.resolve()


handlerSteps.enterLaunchHandoffState = (stateContext) ->
  state = stateContext.handoffState
  unless state of __languages[stateContext.language].enterState
    throw new Error "Entering an unknown state `#{state}`"
  await __languages[stateContext.language].enterState[state](stateContext)
  stateContext.currentState = stateContext.handoffState

  if enableStateTracing
    stateContext.traceHistory.push stateContext.handoffState
  if logStateTraces
    item = "enter (at launch) #{stateContext.handoffState}"
    exports.Logging.log "STATETRACE " + item




handlerSteps.routeIncomingIntent = (stateContext) ->
  if stateContext.nextState
    unless stateContext.nextState of __languages[stateContext.language].enterState
      # we've been asked to execute a non existant state!
      # in order to have a chance at recovering, we have to drop state
      # which means when next we launch we'll start over

      # todo: reroute to launch anyway?
      await new Promise (resolve, reject) ->
        stateContext.db.write "__currentState", null
        stateContext.db.finalize (err) ->
          reject new Error "Invalid state name `#{stateContext.nextState}`"

  # if we have an intent, handle it with the current state
  # but if that handler sets a handoff, then following that
  # and keep following them until we've actually handled it
  for i in [0...10]
    return unless stateContext.handoffIntent
    stateContext.handoffIntent = false

    if enableStateTracing
      item = "#{stateContext.handoffState}:#{stateContext.intent}"
      stateContext.traceHistory.push item

    if logStateTraces
      item = "drain intent #{stateContext.intent} in #{stateContext.handoffState}"
      exports.Logging.log "STATETRACE " + item

    await __languages[stateContext.language].processIntents[stateContext.handoffState]?(stateContext)


  throw new Error "Intent handler recursion error, exceeded 10 steps"


handlerSteps.walkStates = (stateContext) ->

  # keep processing state transitions until we're done
  MaximumTransitionCount = 500
  for i in [0...MaximumTransitionCount]
    # prime the next transition
    nextState = stateContext.nextState

    # stop if there isn't one
    unless nextState
      return

    # run the exit handler if there is one
    lastState = stateContext.currentState
    if lastState?
      await __languages[stateContext.language].exitState[lastState](stateContext)

    # check in case the exit handler caused a redirection
    nextState = stateContext.nextState

    unless nextState
      return

    # the state transition resets the next transition state
    # and implies that we'll go back to opening the mic
    stateContext.nextState = null
    stateContext.shouldEndSession = false
    delete stateContext.shouldDropSession

    stateContext.currentState = nextState

    if enableStateTracing
      stateContext.traceHistory.push nextState

    if logStateTraces
      item = "enter #{nextState}"
      exports.Logging.log "STATETRACE " + item

    unless nextState of __languages[stateContext.language].enterState
      throw new Error "Transitioning to an unknown state `#{nextState}`"
    await __languages[stateContext.language].enterState[nextState](stateContext)

    if stateContext.handoffIntent
      stateContext.handoffIntent = false
      if enableStateTracing
        stateContext.traceHistory.push stateContext.handoffState
      if logStateTraces
        item = "drain intent #{stateContext.intent} in #{stateContext.handoffState}"
        exports.Logging.log "STATETRACE " + item
      await __languages[stateContext.language].processIntents[stateContext.handoffState]?(stateContext)

  exports.Logging.error "States error: exceeded #{MaximumTransitionCount} transitions."
  if enableStateTracing
    exports.Logging.error "States visited: [#{stateContext.traceHistory.join(' -> ')}]"
  else
    exports.Logging.error "Set 'enableStateTracing' to get a history of which states were visited."

  throw new Error "States error: exceeded #{MaximumTransitionCount} transitions.
    Check your logic for non-terminating loops."


handlerSteps.createFinalResult = (stateContext) ->

  stripSSML = (line) ->
    return undefined unless line?
    line = line.replace /<[^>]+>/g, ''
    line.replace /[ ]+/g, ' '

  # invoke any 'afterStateMachine' extension events
  for extensionName, events of extensionEvents
    try
      await events.afterStateMachine?()
    catch err
      exports.Logging.error "Failed to execute afterStateMachine
        for extension #{extensionName}: #{err}"
      throw err

  hasDisplay = stateContext.event.context?.System?.device?.supportedInterfaces?.Display?

  # start building the final response json object
  wrapper =
    version: "1.0"
    sessionAttributes: stateContext.sessionAttributes
    userAgent: userAgent # this userAgent value is generated in project-info.coffee and injected in skill.coffee
    response:
      shouldEndSession: stateContext.shouldEndSession

  response = wrapper.response

  if stateContext.shouldDropSession
    delete response.shouldEndSession

  # build outputSpeech and reprompt from the accumulators
  joinSpeech = (arr, language = 'default') ->
    return '' unless arr
    result = arr[0]
    for line in arr[1..]
      # If the line starts with punctuation, don't add a space before.
      if line.match /^[?!:;,.]/
        result += line
      else
        result += " #{line}"

    result = result.replace /(  )/g, ' '
    if litexa.sayMapping[language]
      for mapping in litexa.sayMapping[language]
        result = result.replace mapping.from, mapping.to
    return result

  if stateContext.say? and stateContext.say.length > 0
    response.outputSpeech =
      type: "SSML"
      ssml: "<speak>#{joinSpeech(stateContext.say, stateContext.language)}</speak>"
      playBehavior: "REPLACE_ALL"

  if stateContext.reprompt? and stateContext.reprompt.length > 0
    response.reprompt =
      outputSpeech:
        type: "SSML",
        ssml: "<speak>#{joinSpeech(stateContext.reprompt, stateContext.language)}</speak>"

  if stateContext.card?
    card = stateContext.card
    title = card.title ? ""
    content = card.content ? ""
    if card.repeatSpeech and stateContext.say?
      parts = for s in stateContext.say
        stripSSML(s)
      content += parts.join('\n')
    content = content ? ""

    response.card =
      type: "Simple"
      title: title ? ""

    response.card.title = response.card.title.trim()

    if card.imageURLs?
      response.card.type = "Standard"
      response.card.text = content ? ""
      response.card.image =
        smallImageUrl: card.imageURLs.cardSmall
        largeImageUrl: card.imageURLs.cardLarge
      response.card.text = response.card.text.trim()
    else
      response.card.type = "Simple"
      response.card.content = content
      response.card.content = response.card.content.trim()

    keep = false
    keep = true if response.card.title.length > 0
    keep = true if response.card.text?.length > 0
    keep = true if response.card.content?.length > 0
    keep = true if response.card.image?.smallImageUrl?
    keep = true if response.card.image?.largeImageUrl?
    unless keep
      delete response.card


  if stateContext.musicCommand?
    stateContext.directives = stateContext.directives ? []
    switch stateContext.musicCommand.action
      when 'play'
        stateContext.directives.push
          type: "AudioPlayer.Play"
          playBehavior: "REPLACE_ALL"
          audioItem:
            stream:
              url: stateContext.musicCommand.url
              token: "no token"
              offsetInMilliseconds: 0
      when 'stop'
        stateContext.directives.push
          type: "AudioPlayer.Stop"


  # store current state for next time, unless we're intentionally ending
  if stateContext.shouldEndSession
    stateContext.currentState = null
  if stateContext.currentState == null
    response.shouldEndSession = true
  stateContext.db.write "__currentState", stateContext.currentState
  stateContext.db.write "__settings", stateContext.settings

  # filter out any directives that were marked for removal
  stateContext.directives = ( d for d in stateContext.directives when not d?.DELETEME )
  if stateContext.directives? and stateContext.directives.length > 0
    response.directives = stateContext.directives

  # last chance, see if the developer left a postprocessor to run here
  if litexa.responsePostProcessor?
    litexa.responsePostProcessor wrapper, stateContext

  if stateContext.shouldEndSession && litexa.sessionTerminatingCallback?
    # we're about to quit, won't get session ended, 
    # so this counts as the very last moment in this session
    litexa.sessionTerminatingCallback(stateContext) 

  return await new Promise (resolve, reject) ->
    stateContext.db.finalize (err, info) ->
      if err?
        unless db.repeatHandler
          reject err
      resolve wrapper