/**
 * 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 ActionsApi from '../actionssdk/api/v2'
import { AppHandler, attach } from '../../assistant'
import {
  ExceptionHandler,
  Traversed,
  Argument,
  ConversationApp,
  ConversationAppOptions,
  UnauthorizedError,
} from '../actionssdk'
import * as common from '../../common'
import { Contexts, Parameters } from './context'
import { DialogflowConversation } from './conv'
import { OAuth2Client } from 'google-auth-library'
import { BuiltinFrameworkMetadata } from '../../framework'

/** @public */
export interface DialogflowIntentHandler<
  TConvData,
  TUserStorage,
  TContexts extends Contexts,
  TConversation extends DialogflowConversation<TConvData, TUserStorage, TContexts>,
  TParameters extends Parameters,
  TArgument extends Argument,
> {
  /** @public */
  (
    conv: TConversation,
    params: TParameters,
    /**
     * The first argument value from the current intent.
     * See {@link Arguments#get|Arguments.get}
     * Same as `conv.arguments.parsed.list[0]`
     */
    argument: TArgument,
    /**
     * The first argument status from the current intent.
     * See {@link Arguments#status|Arguments.status}
     * Same as `conv.arguments.status.list[0]`
     */
    status: ActionsApi.GoogleRpcStatus | undefined,
    // tslint:disable-next-line:no-any allow developer to return any just detect if is promise
  ): Promise<any> | any
}

/** @hidden */
export interface DialogflowIntentHandlers {
  [event: string]: Function | string | undefined
}

/** @hidden */
export interface DialogflowHandlers<
  TConvData,
  TUserStorage,
  TContexts extends Contexts,
  TConversation extends DialogflowConversation<TConvData, TUserStorage, TContexts>,
> {
  intents: DialogflowIntentHandlers
  catcher: ExceptionHandler<TUserStorage, TConversation>
  fallback?: Function | string
}

/** @public */
export interface DialogflowMiddleware<
  TConversationPlugin extends DialogflowConversation
> {
  (
    /** @public */
    conv: DialogflowConversation,

    /** @public */
    framework: BuiltinFrameworkMetadata,
  ): (DialogflowConversation & TConversationPlugin) |
    void |
    Promise<DialogflowConversation & TConversationPlugin> |
    Promise<void>
}

/** @public */
export type DefaultDialogflowIntent = 'Default Welcome Intent' | 'Default Fallback Intent'

/** @public */
export interface DialogflowApp<
  TConvData,
  TUserStorage,
  TContexts extends Contexts,
  TConversation extends DialogflowConversation<TConvData, TUserStorage, TContexts>,
> extends ConversationApp<TConvData, TUserStorage> {
  /** @hidden */
  _handlers: DialogflowHandlers<TConvData, TUserStorage, TContexts, TConversation>

  /**
   * Sets the IntentHandler to be execute when the fulfillment is called
   * with a given Dialogflow intent name.
   *
   * @param intent The Dialogflow intent name to match.
   *     When given an array, sets the IntentHandler for any intent name in the array.
   * @param handler The IntentHandler to be executed when the intent name is matched.
   *     When given a string instead of a function, the intent fulfillment will be redirected
   *     to the IntentHandler of the redirected intent name.
   * @public
   */
  intent<TParameters extends Parameters>(
    intent: DefaultDialogflowIntent | DefaultDialogflowIntent[],
    handler: DialogflowIntentHandler<
      TConvData,
      TUserStorage,
      TContexts,
      TConversation,
      TParameters,
      Argument
    > | string,
  ): this

  /**
   * Sets the IntentHandler to be execute when the fulfillment is called
   * with a given Dialogflow intent name.
   *
   * @param intent The Dialogflow intent name to match.
   *     When given an array, sets the IntentHandler for any intent name in the array.
   * @param handler The IntentHandler to be executed when the intent name is matched.
   *     When given a string instead of a function, the intent fulfillment will be redirected
   *     to the IntentHandler of the redirected intent name.
   * @public
   */
  intent<TArgument extends Argument>(
    intent: DefaultDialogflowIntent | DefaultDialogflowIntent[],
    handler: DialogflowIntentHandler<
      TConvData,
      TUserStorage,
      TContexts,
      TConversation,
      Parameters,
      TArgument
    > | string,
  ): this

  /**
   * Sets the IntentHandler to be execute when the fulfillment is called
   * with a given Dialogflow intent name.
   *
   * @param intent The Dialogflow intent name to match.
   *     When given an array, sets the IntentHandler for any intent name in the array.
   * @param handler The IntentHandler to be executed when the intent name is matched.
   *     When given a string instead of a function, the intent fulfillment will be redirected
   *     to the IntentHandler of the redirected intent name.
   * @public
   */
  intent<TParameters extends Parameters, TArgument extends Argument>(
    intent: DefaultDialogflowIntent | DefaultDialogflowIntent[],
    handler: DialogflowIntentHandler<
      TConvData,
      TUserStorage,
      TContexts,
      TConversation,
      TParameters,
      TArgument
    > | string,
  ): this

  /**
   * Sets the IntentHandler to be execute when the fulfillment is called
   * with a given Dialogflow intent name.
   *
   * @param intent The Dialogflow intent name to match.
   *     When given an array, sets the IntentHandler for any intent name in the array.
   * @param handler The IntentHandler to be executed when the intent name is matched.
   *     When given a string instead of a function, the intent fulfillment will be redirected
   *     to the IntentHandler of the redirected intent name.
   * @public
   */
  intent<TParameters extends Parameters>(
    intent: string | string[],
    handler: DialogflowIntentHandler<
      TConvData,
      TUserStorage,
      TContexts,
      TConversation,
      TParameters,
      Argument
    > | string,
  ): this

  /**
   * Sets the IntentHandler to be execute when the fulfillment is called
   * with a given Dialogflow intent name.
   *
   * @param intent The Dialogflow intent name to match.
   *     When given an array, sets the IntentHandler for any intent name in the array.
   * @param handler The IntentHandler to be executed when the intent name is matched.
   *     When given a string instead of a function, the intent fulfillment will be redirected
   *     to the IntentHandler of the redirected intent name.
   * @public
   */
  intent<TArgument extends Argument>(
    intent: string | string[],
    handler: DialogflowIntentHandler<
      TConvData,
      TUserStorage,
      TContexts,
      TConversation,
      Parameters,
      TArgument
    > | string,
  ): this

  /**
   * Sets the IntentHandler to be execute when the fulfillment is called
   * with a given Dialogflow intent name.
   *
   * @param intent The Dialogflow intent name to match.
   *     When given an array, sets the IntentHandler for any intent name in the array.
   * @param handler The IntentHandler to be executed when the intent name is matched.
   *     When given a string instead of a function, the intent fulfillment will be redirected
   *     to the IntentHandler of the redirected intent name.
   * @public
   */
  intent<TParameters extends Parameters, TArgument extends Argument>(
    intent: string | string[],
    handler: DialogflowIntentHandler<
      TConvData,
      TUserStorage,
      TContexts,
      TConversation,
      TParameters,
      TArgument
    > | string,
  ): this

  /** @public */
  catch(catcher: ExceptionHandler<TUserStorage, TConversation>): this

  /** @public */
  fallback(
    handler: DialogflowIntentHandler<
      TConvData,
      TUserStorage,
      TContexts,
      TConversation,
      Parameters,
      Argument
    > | string,
  ): this

  /** @hidden */
  _middlewares: DialogflowMiddleware<DialogflowConversation<{}, {}, Contexts>>[]

  /** @public */
  middleware<TConversationPlugin extends DialogflowConversation<{}, {}, Contexts>>(
    middleware: DialogflowMiddleware<TConversationPlugin>,
  ): this

  /** @public */
  verification?: DialogflowVerification | DialogflowVerificationHeaders
}

/** @public */
export interface DialogflowVerificationHeaders {
  /**
   * A header key value pair to check against.
   * @public
   */
  [key: string]: string
}

/** @public */
export interface DialogflowVerification {
  /**
   * An object representing the header key to value map to check against,
   * @public
   */
  headers: DialogflowVerificationHeaders

  /**
   * Custom status code to return on verification error.
   * @public
   */
  status?: number

  /**
   * Custom error message as a string or a function that returns a string
   * given the original error message set by the library.
   *
   * The message will get sent back in the JSON top level `error` property.
   * @public
   */
  error?: string | ((error: string) => string)
}

/** @public */
export interface DialogflowOptions<
  TConvData,
  TUserStorage
> extends ConversationAppOptions<TConvData, TUserStorage> {
  /**
   * Verifies whether the request comes from Dialogflow.
   * Uses header keys and values to check against ones specified by the developer
   * in the Dialogflow Fulfillment settings of the app.
   *
   * HTTP Code 403 will be thrown by default on verification error.
   *
   * @public
   */
  verification?: DialogflowVerification | DialogflowVerificationHeaders
}

/** @public */
export interface Dialogflow {
  /** @public */
  <
    TConvData,
    TUserStorage,
    TContexts extends Contexts = Contexts,
    Conversation extends DialogflowConversation<TConvData, TUserStorage, TContexts> =
      DialogflowConversation<TConvData, TUserStorage, TContexts>,
  >(
    options?: DialogflowOptions<TConvData, TUserStorage>,
  ): AppHandler & DialogflowApp<
    TConvData,
    TUserStorage,
    TContexts,
    Conversation
  >

  /** @public */
  <
    TContexts extends Contexts,
    Conversation extends DialogflowConversation<{}, {}, TContexts> =
      DialogflowConversation<{}, {}, TContexts>,
  >(
    options?: DialogflowOptions<{}, {}>,
  ): AppHandler & DialogflowApp<
    {},
    {},
    TContexts,
    Conversation
  >

  /** @public */
  <TConversation extends DialogflowConversation<{}, {}> = DialogflowConversation<{}, {}>>(
    options?: DialogflowOptions<{}, {}>,
  ): AppHandler & DialogflowApp<{}, {}, Contexts, TConversation>
}

const isVerification =
  (verification: DialogflowVerification | DialogflowVerificationHeaders):
    verification is DialogflowVerification =>
      typeof (verification as DialogflowVerification).headers === 'object'

/**
 * This is the function that creates the app instance which on new requests,
 * creates a way to handle the communication with Dialogflow's fulfillment API.
 *
 * Supports Dialogflow v1 and v2.
 *
 * @example
 * ```javascript
 *
 * const app = dialogflow()
 *
 * app.intent('Default Welcome Intent', conv => {
 *   conv.ask('How are you?')
 * })
 * ```
 *
 * @public
 */
export const dialogflow: Dialogflow = <
  TConvData,
  TUserStorage,
  TContexts extends Contexts,
  TConversation extends DialogflowConversation<TConvData, TUserStorage, TContexts>
>(
  options: DialogflowOptions<TConvData, TUserStorage> = {},
) => attach<DialogflowApp<TConvData, TUserStorage, TContexts, TConversation>>({
  _handlers: {
    intents: {},
    catcher: (conv, e) => {
      throw e
    },
  },
  _middlewares: [],
  intent<TParameters extends Parameters, TArgument extends Argument>(
    this: DialogflowApp<TConvData, TUserStorage, TContexts, TConversation>,
    intents: string | string[],
    handler: DialogflowIntentHandler<
      TConvData,
      TUserStorage,
      TContexts,
      TConversation,
      TParameters,
      TArgument
    >,
  ) {
    for (const intent of common.toArray(intents)) {
      this._handlers.intents[intent] = handler
    }
    return this
  },
  catch(this: DialogflowApp<TConvData, TUserStorage, TContexts, TConversation>, catcher) {
    this._handlers.catcher = catcher
    return this
  },
  fallback(this: DialogflowApp<TConvData, TUserStorage, TContexts, TConversation>, handler) {
    this._handlers.fallback = handler
    return this
  },
  middleware(
    this: DialogflowApp<TConvData, TUserStorage, TContexts, TConversation>,
    middleware,
  ) {
    this._middlewares.push(middleware)
    return this
  },
  init: options.init,
  verification: options.verification,
  _client: options.clientId ? new OAuth2Client(options.clientId) : undefined,
  auth: options.clientId ? {
    client: {
      id: options.clientId,
    },
  } : undefined,
  ordersv3: options.ordersv3 || false,
  async handler(
    this: AppHandler & DialogflowApp<TConvData, TUserStorage, TContexts, TConversation>,
    body: Api.GoogleCloudDialogflowV2WebhookRequest,
    headers,
    metadata = {},
  ) {
    const { debug, init, verification, ordersv3 } = this
    if (verification) {
      const {
        headers: verificationHeaders,
        status = 403,
        error = (e: string) => e,
      } = isVerification(verification) ? verification :
        { headers: verification } as DialogflowVerification
      for (const key in verification) {
        const check = headers[key.toLowerCase()]
        if (!check) {
          return {
            status,
            body: {
              error: typeof error === 'string' ? error :
                error('A verification header key was not found'),
            },
          }
        }
        const value = verificationHeaders[key]
        const checking = common.toArray(check)
        if (checking.indexOf(value) < 0) {
          return {
            status,
            body: {
              error: typeof error === 'string' ? error :
                error('A verification header value was invalid'),
            },
          }
        }
      }
    }
    let conv = new DialogflowConversation<TConvData, TUserStorage, TContexts>({
      body,
      headers,
      init: init && init(),
      debug,
      ordersv3,
    })
    if (conv.user.profile.token) {
      await conv.user._verifyProfile(this._client!, this.auth!.client.id)
    }
    for (const middleware of this._middlewares) {
      // tslint:disable-next-line:no-any genericize Conversation type
      const result = middleware(conv as any, metadata)
      conv = (result instanceof DialogflowConversation ? result : ((await result) || conv)) as (
        DialogflowConversation<TConvData, TUserStorage, TContexts>
      )
    }
    const log = debug ? common.info : common.debug
    log('Conversation', common.stringify(conv, 'request', 'headers', 'body'))
    const { intent } = conv
    const traversed: Traversed = {}
    let handler: typeof this._handlers.intents[string] = intent
    while (typeof handler !== 'function') {
      if (typeof handler === 'undefined') {
        if (!this._handlers.fallback) {
          if (!intent) {
            throw new Error('No intent was provided and fallback handler is not defined.')
          }
          throw new Error(`Dialogflow IntentHandler not found for intent: ${intent}`)
        }
        handler = this._handlers.fallback
        continue
      }
      if (traversed[handler]) {
        throw new Error(`Circular intent map detected: "${handler}" traversed twice`)
      }
      traversed[handler] = true
      handler = this._handlers.intents[handler]
    }
    try {
      try {
        await handler(
          conv,
          conv.parameters,
          conv.arguments.parsed.list[0],
          conv.arguments.status.list[0],
        )
      } catch (e) {
        await this._handlers.catcher(conv as TConversation, e)
      }
    } catch (e) {
      if (e instanceof UnauthorizedError) {
        return {
          status: 401,
          headers: {},
          body: {},
        }
      }
      throw e
    }
    return {
      status: 200,
      headers: {},
      body: conv.serialize(),
    }
  },
}, options)