/**
 * Copyright 2018 Google Inc. All Rights Reserved.
 *
 * 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.
 */

import * as Api from './api/v2'
import * as ApiV1 from './api/v1'
import * as ActionsApi from '../actionssdk/api/v2'
import { Conversation, ConversationBaseOptions, ConversationOptionsInit } from '../actionssdk'
import { ProtoAny, JsonObject } from '../../common'
import { Contexts, ContextValues, Parameters } from './context'
import { Incoming } from './incoming'

const CONV_DATA_CONTEXT = '_actions_on_google'
const CONV_DATA_CONTEXT_LIFESPAN = 99
const SIMULATOR_WARNING = 'Cannot display response in Dialogflow simulator. ' +
  'Please test on the Google Assistant simulator instead.'

/** @hidden */
export interface SystemIntent {
  intent: string
  data: ProtoAny<string, JsonObject>
}

/** @hidden */
export interface GoogleAssistantResponse {
  expectUserResponse?: boolean
  noInputPrompts?: ActionsApi.GoogleActionsV2SimpleResponse[]
  isSsml?: boolean
  richResponse?: ActionsApi.GoogleActionsV2RichResponse
  systemIntent?: SystemIntent
  userStorage?: string
  speechBiasingHints?: string[]
}

/** @hidden */
export interface PayloadGoogle {
  google: GoogleAssistantResponse
}

/** @public */
export interface DialogflowConversationOptions<
  TConvData,
  TUserStorage
> extends ConversationBaseOptions<TConvData, TUserStorage> {
  /** @public */
  body?: Api.GoogleCloudDialogflowV2WebhookRequest | ApiV1.DialogflowV1WebhookRequest
}

const isV1 = (
  body: Api.GoogleCloudDialogflowV2WebhookRequest | ApiV1.DialogflowV1WebhookRequest,
): body is ApiV1.DialogflowV1WebhookRequest => !!(body as ApiV1.DialogflowV1WebhookRequest).result

const isSimulator = (
  body: Api.GoogleCloudDialogflowV2WebhookRequest | ApiV1.DialogflowV1WebhookRequest,
) => {
  if (isV1(body)) {
    return !body.originalRequest
  }
  if (!body.originalDetectIntentRequest) {
    return false
  }
  return Object.keys(body.originalDetectIntentRequest.payload!).length === 0 &&
    !!body.responseId
}

const getRequest = (
  body: Api.GoogleCloudDialogflowV2WebhookRequest | ApiV1.DialogflowV1WebhookRequest,
): ActionsApi.GoogleActionsV2AppRequest => {
  if (isV1(body)) {
    const { originalRequest = {} } = body
    const { data = {} } = originalRequest
    return data
  }
  const { originalDetectIntentRequest = {} } = body
  const { payload = {} } = originalDetectIntentRequest
  return payload
}

const serializeData = <TConvData>(data: TConvData) =>
  JSON.stringify(data)

const deserializeData = <TContexts extends Contexts, TConvData>(
  contexts: ContextValues<TContexts>, defaultData?: TConvData,
): TConvData => {
  const context = contexts.get(CONV_DATA_CONTEXT)
  if (context) {
    const { data } = context.parameters
    if (typeof data === 'string') {
      return JSON.parse(data)
    }
  }

  return Object.assign({}, defaultData) as TConvData
}

/** @public */
export class DialogflowConversation<
  TConvData = JsonObject,
  TUserStorage = JsonObject,
  TContexts extends Contexts = Contexts,
> extends Conversation<TUserStorage> {
  /** @public */
  body: Api.GoogleCloudDialogflowV2WebhookRequest | ApiV1.DialogflowV1WebhookRequest

  /**
   * Get the current Dialogflow action name.
   *
   * @example
   * ```javascript
   *
   * app.intent('Default Welcome Intent', conv => {
   *   const action = conv.action
   * })
   * ```
   *
   * @public
   */
  action: string

  /**
   * Get the current Dialogflow intent name.
   *
   * @example
   * ```javascript
   *
   * app.intent('Default Welcome Intent', conv => {
   *   const intent = conv.intent // will be 'Default Welcome Intent'
   * })
   * ```
   *
   * @public
   */
  intent: string

  /**
   * The Dialogflow parameters from the current intent.
   * Values will only be a string, an Object, or undefined if not included.
   *
   * Will also be sent via intent handler 3rd argument which is the encouraged method to retrieve.
   *
   * @example
   * ```javascript
   *
   * // Encouraged method through intent handler
   * app.intent('Tell Greeting', (conv, params) => {
   *   const color = params.color
   *   const num = params.num
   * })
   *
   * // Encouraged method through destructuring in intent handler
   * app.intent('Tell Greeting', (conv, { color, num }) => {
   *   // now use color and num as variables
   * }))
   *
   * // Using conv.parameters
   * app.intent('Tell Greeting', conv => {
   *   const parameters = conv.parameters
   *   // or destructed
   *   const { color, num } = conv.parameters
   * })
   * ```
   *
   * @public
   */
  parameters: Parameters

  /** @public */
  contexts: ContextValues<TContexts>

  /** @public */
  incoming: Incoming

  /**
   * The user's raw input query.
   *
   * @example
   * ```javascript
   *
   * app.intent('User Input', conv => {
   *   conv.close(`You said ${conv.query}`)
   * })
   * ```
   *
   * @public
   */
  query: string

  /**
   * The session data in JSON format.
   * Stored using contexts.
   *
   * @example
   * ```javascript
   *
   * app.intent('Default Welcome Intent', conv => {
   *   conv.data.someProperty = 'someValue'
   * })
   * ```
   *
   * @public
   */
  data: TConvData

  /** @public */
  version: number

  /** @hidden */
  _followup?: Api.GoogleCloudDialogflowV2EventInput | ApiV1.DialogflowV1FollowupEvent

  /** @hidden */
  _init: ConversationOptionsInit<TConvData, TUserStorage>

  /** @public */
  constructor(options: DialogflowConversationOptions<TConvData, TUserStorage> = {}) {
    const { body = {} } = options

    super({
      request: getRequest(body),
      headers: options.headers,
      init: options.init,
      ordersv3: options.ordersv3,
    })

    this.body = body

    if (isV1(this.body)) {
      this.version = 1

      const { result = {} } = this.body
      const {
        action = '',
        parameters = {},
        contexts,
        resolvedQuery = '',
        metadata = {},
        fulfillment,
      } = result
      const { intentName = '' } = metadata

      this.action = action
      this.intent = intentName
      this.parameters = parameters
      this.contexts = new ContextValues(contexts)
      this.incoming = new Incoming(fulfillment)
      this.query = resolvedQuery
    } else {
      this.version = 2

      const { queryResult = {} } = this.body
      const {
        action = '',
        parameters = {},
        outputContexts,
        intent = {},
        queryText = '',
        fulfillmentMessages,
      } = queryResult
      const { displayName = '' } = intent

      this.action = action
      this.intent = displayName
      this.parameters = parameters
      this.contexts = new ContextValues(outputContexts, this.body.session)
      this.incoming = new Incoming(fulfillmentMessages)
      this.query = queryText
    }

    for (const key in this.parameters) {
      const value = this.parameters[key]
      if (typeof value !== 'object') {
        // Convert all non-objects to strings for consistency
        this.parameters[key] = String(value)
      }
    }

    this.data = deserializeData(this.contexts, this._init.data)
  }

  /**
   * Triggers an intent of your choosing by sending a followup event from the webhook.
   * Final response can theoretically include responses but these will not be handled
   * by Dialogflow. Dialogflow will not pass anything back to Google Assistant, therefore
   * Google Assistant specific information, most notably conv.user.storage, is ignored.
   *
   * @example
   * ```javascript
   *
   * const app = dialogflow()
   *
   * // Create a Dialogflow intent with event 'apply-for-license-event'
   *
   * app.intent('Default Welcome Intent', conv => {
   *   conv.followup('apply-for-license-event', {
   *     date: new Date().toISOString(),
   *   })
   *   // The dialogflow intent with the 'apply-for-license-event' event
   *   // will be triggered with the given parameters `date`
   * })
   * ```
   *
   * @param event Name of the event
   * @param parameters Parameters to send with the event
   * @param lang The language of this query.
   *     See {@link https://dialogflow.com/docs/languages|Language Support}
   *     for a list of the currently supported language codes.
   *     Note that queries in the same session do not necessarily need to specify the same language.
   *     By default, it is the languageCode sent with Dialogflow's queryResult.languageCode
   * @public
   */
  followup(event: string, parameters?: Parameters, lang?: string) {
    this._responded = true
    if (this.version === 1) {
      this._followup = {
          name: event,
          data: parameters,
      }
      return this
    }
    const body = this.body as Api.GoogleCloudDialogflowV2WebhookRequest
    this._followup = {
      name: event,
      parameters,
      languageCode: lang || body.queryResult!.languageCode,
    }
    return this
  }

  /** @public */
  serialize(): Api.GoogleCloudDialogflowV2WebhookResponse | ApiV1.DialogflowV1WebhookResponse {
    if (this._raw) {
      return this._raw
    }
    let payload: PayloadGoogle | undefined
    if (this._followup) {
      this.digested = true
    } else {
      const {
        richResponse,
        expectUserResponse,
        userStorage,
        expectedIntent,
        noInputPrompts,
        speechBiasingHints,
      } = this.response()
      const google: GoogleAssistantResponse = {
        expectUserResponse,
        systemIntent: expectedIntent && {
          intent: expectedIntent.intent!,
          data: expectedIntent.inputValueData as ProtoAny<string, JsonObject>,
        },
        noInputPrompts,
        speechBiasingHints,
      }
      if (richResponse.items!.length) {
        google.richResponse = richResponse
      }
      if (userStorage) {
        google.userStorage = userStorage
      }
      payload = { google }
    }
    const convDataDefault = deserializeData<TContexts, TConvData>(this.contexts, this._init.data)
    const convDataIn = serializeData(convDataDefault)
    const convDataOut = serializeData(this.data)
    if (convDataOut !== convDataIn) {
      // Previously was setting every webhook call
      // But now will only set if different so lifespan does not get reset
      this.contexts.set(CONV_DATA_CONTEXT, CONV_DATA_CONTEXT_LIFESPAN, {
        data: convDataOut,
      })
    }
    const simulator = isSimulator(this.body)
    if (this.version === 1) {
      const response: ApiV1.DialogflowV1WebhookResponse = {
        data: payload,
        followupEvent: this._followup,
      }
      const contextOut = this.contexts._serializeV1()
      if (contextOut.length) {
        response.contextOut = contextOut
      }
      if (simulator && payload) {
        const { richResponse = {} } = payload.google
        const { items = [] } = richResponse
        // Simulator only shows speech response
        // Since this is only shown to the simulator as text, the speech is the displayText
        response.speech = SIMULATOR_WARNING
        if (!payload.google.systemIntent && items.length < 2) {
          for (const { simpleResponse } of items) {
            if (simpleResponse) {
              response.speech = simpleResponse.displayText ||
              simpleResponse.textToSpeech
              break
            }
          }
        }
      }
      return response
    }
    const response: Api.GoogleCloudDialogflowV2WebhookResponse = {
      payload,
      followupEventInput: this._followup,
    }
    const outputContexts = this.contexts._serialize()
    if (outputContexts.length) {
      response.outputContexts = outputContexts
    }
    if (simulator && payload) {
      const { richResponse = {} } = payload.google
      const { items = [] } = richResponse
      response.fulfillmentText = SIMULATOR_WARNING
      if (!payload.google.systemIntent && items.length < 2) {
        for (const { simpleResponse } of items) {
          if (simpleResponse) {
            response.fulfillmentText = simpleResponse.displayText ||
            simpleResponse.textToSpeech
            break
          }
        }
      }
    }
    return response
  }
}