/**
 * 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 { AppHandler, attach } from '../../assistant'
import {
  ExceptionHandler,
  Argument,
  Intent,
  Traversed,
  ConversationAppOptions,
  ConversationApp,
  UnauthorizedError,
} from './conversation'
import { ActionsSdkConversation } from './conv'
import { OAuth2Client } from 'google-auth-library'
import * as common from '../../common'
import { BuiltinFrameworkMetadata } from '../../framework'

/** @public */
export interface ActionsSdkIntentHandler<
  TConvData,
  TUserStorage,
  TConversation extends ActionsSdkConversation<TConvData, TUserStorage>,
  TArgument extends Argument,
> {
  /** @public */
  (
    conv: TConversation,
    /**
     * The user's raw input query.
     * See {@link Input#raw|Input.raw}
     * Same as `conv.input.raw`
     */
    input: string,
    /**
     * 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: Api.GoogleRpcStatus | undefined,
    // tslint:disable-next-line:no-any allow developer to return any just detect if is promise
  ): Promise<any> | any
}

/** @hidden */
export interface ActionSdkIntentHandlers {
  [intent: string]: ActionsSdkIntentHandler<
    {},
    {},
    ActionsSdkConversation<{}, {}>,
    Argument
  > | string | undefined
}

/** @hidden */
export interface ActionsSdkHandlers<
  TConvData,
  TUserStorage,
  TConversation extends ActionsSdkConversation<TConvData, TUserStorage>
> {
  intents: ActionSdkIntentHandlers
  catcher: ExceptionHandler<TUserStorage, TConversation>
  fallback?: ActionsSdkIntentHandler<
    {},
    {},
    ActionsSdkConversation<{}, {}>,
    Argument
  > | string
}

/** @public */
export interface ActionsSdkMiddleware<
  TConversationPlugin extends ActionsSdkConversation<{}, {}>
> {
  /** @public */
  (
    /** @public */
    conv: ActionsSdkConversation<{}, {}>,

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

/** @public */
export interface ActionsSdkApp<
  TConvData,
  TUserStorage,
  TConversation extends ActionsSdkConversation<TConvData, TUserStorage>
> extends ConversationApp<TConvData, TUserStorage> {
  /** @hidden */
  _handlers: ActionsSdkHandlers<TConvData, TUserStorage, TConversation>

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

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

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

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

  /** @hidden */
  _middlewares: ActionsSdkMiddleware<ActionsSdkConversation<{}, {}>>[]

  /** @public */
  middleware<TConversationPlugin extends ActionsSdkConversation<{}, {}>>(
    middleware: ActionsSdkMiddleware<TConversationPlugin>,
  ): this

  /** @public */
  verification?: ActionsSdkVerification | string
}

/** @public */
export interface ActionsSdk {
  /** @public */
  <
    TConvData,
    TUserStorage,
    Conversation extends ActionsSdkConversation<TConvData, TUserStorage> =
      ActionsSdkConversation<TConvData, TUserStorage>,
  >(
    options?: ActionsSdkOptions<TConvData, TUserStorage>,
  ): AppHandler & ActionsSdkApp<
    TConvData,
    TUserStorage,
    Conversation
  >

  /** @public */
  <Conversation extends ActionsSdkConversation<{}, {}> = ActionsSdkConversation<{}, {}>>(
    options?: ActionsSdkOptions<{}, {}>,
  ): AppHandler & ActionsSdkApp<{}, {}, Conversation>
}

/** @public */
export interface ActionsSdkVerification {
  /**
   * Google Cloud Project ID for the Assistant app.
   * @public
   */
  project: string

  /**
   * 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 ActionsSdkOptions<
  TConvData,
  TUserStorage
> extends ConversationAppOptions<TConvData, TUserStorage> {
  /**
   * Validates whether request is from Google through signature verification.
   * Uses Google-Auth-Library to verify authorization token against given Google Cloud Project ID.
   * Auth token is given in request header with key, "authorization".
   *
   * HTTP Code 403 will be thrown by default on verification error.
   *
   * @example
   * ```javascript
   *
   * const app = actionssdk({ verification: 'nodejs-cloud-test-project-1234' })
   * ```
   *
   * @public
   */
  verification?: ActionsSdkVerification | string
}

/**
 * This is the function that creates the app instance which on new requests,
 * creates a way to interact with the conversation API directly from Assistant,
 * providing implementation for all the methods available in the API.
 *
 * Only supports Actions SDK v2.
 *
 * @example
 * ```javascript
 *
 * const app = actionssdk()
 *
 * app.intent('actions.intent.MAIN', conv => {
 *   conv.ask('How are you?')
 * })
 * ```
 *
 * @public
 */
export const actionssdk: ActionsSdk = <
  TConvData,
  TUserStorage,
  TConversation extends ActionsSdkConversation<TConvData, TUserStorage>
>(
  options: ActionsSdkOptions<TConvData, TUserStorage> = {},
) => attach<ActionsSdkApp<TConvData, TUserStorage, TConversation>>({
  _handlers: {
    intents: {},
    catcher: (conv, e) => {
      throw e
    },
  },
  _middlewares: [],
  intent<TInput>(
    this: ActionsSdkApp<TConvData, TUserStorage, TConversation>,
    intents: string | string[],
    handler: ActionsSdkIntentHandler<TConvData, TUserStorage, TConversation, TInput> | string,
  ) {
    for (const intent of common.toArray(intents)) {
      this._handlers.intents[intent] = handler
    }
    return this
  },
  catch(this: ActionsSdkApp<TConvData, TUserStorage, TConversation>, catcher) {
    this._handlers.catcher = catcher
    return this
  },
  fallback(this: ActionsSdkApp<TConvData, TUserStorage, TConversation>, handler) {
    this._handlers.fallback = handler
    return this
  },
  middleware(
    this: ActionsSdkApp<TConvData, TUserStorage, TConversation>,
    middleware,
  ) {
    this._middlewares.push(middleware)
    return this
  },
  init: options.init,
  verification: options.verification,
  _client: (options.verification || options.clientId) ?
    new OAuth2Client(options.clientId) : undefined,
  auth: options.clientId ? {
    client: {
      id: options.clientId,
    },
  } : undefined,
  ordersv3: options.ordersv3 || false,
  async handler(
    this: AppHandler & ActionsSdkApp<TConvData, TUserStorage, TConversation>,
    body: Api.GoogleActionsV2AppRequest,
    headers,
    metadata = {},
  ) {
    const { debug, init, verification, ordersv3 } = this
    if (verification) {
      const {
        project,
        status = 403,
        error = (e: string) => e,
      } = typeof verification === 'string' ? { project: verification } : verification
      const token = headers['authorization'] as string
      try {
        await this._client!.verifyIdToken({
          idToken: token,
          audience: project,
        })
      } catch (e) {
        return {
          status,
          body: {
            error: typeof error === 'string' ? error :
              error(`ID token verification failed: ${e.stack || e.message || e}`),
          },
        }
      }
    }
    let conv = new ActionsSdkConversation({
      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) {
      const result = middleware(conv, metadata)
      conv = (result instanceof ActionsSdkConversation ? result : ((await result) || conv)) as (
        ActionsSdkConversation<TConvData, TUserStorage>
      )
    }
    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) {
          throw new Error(`Actions SDK 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.input.raw,
          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)