/*****************************************************************************\
|                                               ( )_  _                       |
|    _ _    _ __   _ _    __    ___ ___     _ _ | ,_)(_)  ___   ___     _     |
|   ( '_`\ ( '__)/'_` ) /'_ `\/' _ ` _ `\ /'_` )| |  | |/',__)/' _ `\ /'_`\   |
|   | (_) )| |  ( (_| |( (_) || ( ) ( ) |( (_| || |_ | |\__, \| ( ) |( (_) )  |
|   | ,__/'(_)  `\__,_)`\__  |(_) (_) (_)`\__,_)`\__)(_)(____/(_) (_)`\___/'  |
|   | |                ( )_) |                                                |
|   (_)                 \___/'                                                |
|                                                                             |
| General Bots Copyright (c) Pragmatismo.io. All rights reserved.             |
| Licensed under the AGPL-3.0.                                                |
|                                                                             |
| According to our dual licensing model, this program can be used either      |
| under the terms of the GNU Affero General Public License, version 3,        |
| or under a proprietary license.                                             |
|                                                                             |
| The texts of the GNU Affero General Public License with an additional       |
| permission and of our proprietary license can be found at and               |
| in the LICENSE file you have received along with this program.              |
|                                                                             |
| This program is distributed in the hope that it will be useful,             |
| but WITHOUT ANY WARRANTY, without even the implied warranty of              |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                |
| GNU Affero General Public License for more details.                         |
|                                                                             |
| "General Bots" is a registered trademark of Pragmatismo.io.                 |
| The licensing of the program under the AGPLv3 does not imply a              |
| trademark license. Therefore any rights, title and interest in              |
| our trademarks remain entirely with us.                                     |
|                                                                             |
\*****************************************************************************/

/**
 * @fileoverview General Bots server core.
 */

'use strict';

const { DialogSet, TextPrompt } = require('botbuilder-dialogs');
const UrlJoin = require('url-join');
const express = require('express');
const logger = require('../../../src/logger');
const request = require('request-promise-native');
const AuthenticationContext = require('adal-node').AuthenticationContext;

import {
  AutoSaveStateMiddleware,
  BotFrameworkAdapter,
  ConversationState,
  MemoryStorage,
  UserState
} from 'botbuilder';

import {
  GBMinInstance,
  IGBAdminService,
  IGBConversationalService,
  IGBCoreService,
  IGBPackage
} from 'botlib';
import { GBAnalyticsPackage } from '../../analytics.gblib';
import { GBCorePackage } from '../../core.gbapp';
import { GBCustomerSatisfactionPackage } from '../../customer-satisfaction.gbapp';
import { GBKBPackage } from '../../kb.gbapp';
import { GBSecurityPackage } from '../../security.gblib';
import { GBWhatsappPackage } from '../../whatsapp.gblib';
import { GuaribasInstance } from '../models/GBModel';
import { Messages } from '../strings';
import { GBAdminPackage } from './../../admin.gbapp/index';
import { GBDeployer } from './GBDeployer';

/** Minimal service layer for a bot. */

export class GBMinService {
  public core: IGBCoreService;
  public conversationalService: IGBConversationalService;
  public adminService: IGBAdminService;
  public deployer: GBDeployer;

  public corePackage = 'core.gbai';

  /**
   * Static initialization of minimal instance.
   *
   * @param core Basic database services to identify instance, for example.
   */
  constructor(
    core: IGBCoreService,
    conversationalService: IGBConversationalService,
    adminService: IGBAdminService,
    deployer: GBDeployer,
  ) {
    this.core = core;
    this.conversationalService = conversationalService;
    this.adminService = adminService;
    this.deployer = deployer;
  }

  /**
   *
   * Constructs a new minimal instance for each bot.
   *
   * @param server        An HTTP server.
   * @param appPackages   List of loaded .gbapp associated with this instance.
   *
   * @return Loaded minimal bot instance.
   *
   * */

  public async buildMin(
    server: any,
    appPackages: IGBPackage[],
    instances: GuaribasInstance[],
  ): Promise<GBMinInstance> {
    // Serves default UI on root address '/'.

    const uiPackage = 'default.gbui';
    server.use(
      '/',
      express.static(UrlJoin(GBDeployer.deployFolder, uiPackage, 'build')),
    );

    Promise.all(
      instances.map(async instance => {
        // Gets the authorization key for each instance from Bot Service.

        const webchatToken = await this.getWebchatToken(instance);

        // Serves the bot information object via HTTP so clients can get
        // instance information stored on server.

        server.get('/instances/:botId', (req, res) => {
          (async () => {
            // Returns the instance object to clients requesting bot info.

            const botId = req.params.botId;
            const instance = await this.core.loadInstance(botId);

            if (instance) {
              const speechToken = await this.getSTSToken(instance);
              let theme = instance.theme;
              if (!theme) {
                theme = 'default.gbtheme';
              }

              res.send(
                JSON.stringify({
                  instanceId: instance.instanceId,
                  botId: botId,
                  theme: theme,
                  secret: instance.webchatKey, // TODO: Use token.
                  speechToken: speechToken,
                  conversationId: webchatToken.conversationId,
                  authenticatorTenant: instance.authenticatorTenant,
                  authenticatorClientId: instance.authenticatorClientId,
                }),
              );
            } else {
              const error = `Instance not found: ${botId}.`;
              res.sendStatus(error);
              logger.error(error);
            }
          })();
        });

        // Build bot adapter.

        const { min, adapter, conversationState } = await this.buildBotAdapter(
          instance,
        );

        // Call the loadBot context.activity for all packages.

        this.invokeLoadBot(appPackages, min, server);

        // Serves individual URL for each bot conversational interface...

        const url = `/api/messages/${instance.botId}`;
        server.post(url, async (req, res) => {
          return this.receiver(
            adapter,
            req,
            res,
            conversationState,
            min,
            instance,
            appPackages,
          );
        });
        logger.info(
          `GeneralBots(${instance.engineName}) listening on: ${url}.`,
        );

        // Serves individual URL for each bot user interface.

        const uiUrl = `/${instance.botId}`;
        server.use(
          uiUrl,
          express.static(UrlJoin(GBDeployer.deployFolder, uiPackage, 'build')),
        );

        logger.info(`Bot UI ${uiPackage} accessible at: ${uiUrl}.`);
        const state = `${instance.instanceId}${Math.floor(
          Math.random() * 1000000000,
        )}`;

        // Clients get redirected here in order to create an OAuth authorize url and redirect them to AAD.
        // There they will authenticate and give their consent to allow this app access to
        // some resource they own.
        server.get(`/${min.instance.botId}/auth`, function(req, res) {
          let authorizationUrl = UrlJoin(
            min.instance.authenticatorAuthorityHostUrl,
            min.instance.authenticatorTenant,
            '/oauth2/authorize',
          );
          authorizationUrl = `${authorizationUrl}?response_type=code&client_id=${
            min.instance.authenticatorClientId
          }&redirect_uri=${min.instance.botEndpoint}/${
            min.instance.botId
          }/token`;

          res.redirect(authorizationUrl);
        });

        // After consent is granted AAD redirects here.  The ADAL library
        // is invoked via the AuthenticationContext and retrieves an
        // access token that can be used to access the user owned resource.

        server.get(`/${min.instance.botId}/token`, async (req, res) => {
          const state = await min.adminService.getValue(
            min.instance.instanceId,
            'AntiCSRFAttackState',
          );

          if (req.query.state !== state) {
            const msg =
              'WARNING: state field was not provided as anti-CSRF token';
            logger.error(msg);
            throw new Error(msg);
          }

          const authenticationContext = new AuthenticationContext(
            UrlJoin(
              min.instance.authenticatorAuthorityHostUrl,
              min.instance.authenticatorTenant,
            ),
          );

          const resource = 'https://graph.microsoft.com';

          authenticationContext.acquireTokenWithAuthorizationCode(
            req.query.code,
            UrlJoin(instance.botEndpoint, min.instance.botId, '/token'),
            resource,
            instance.authenticatorClientId,
            instance.authenticatorClientSecret,
            async (err, token) => {
              if (err) {
                const msg = `Error acquiring token: ${err}`;
                logger.error(msg);
                res.send(msg);
              } else {
                await this.adminService.setValue(
                  instance.instanceId,
                  'refreshToken',
                  token.refreshToken,
                );
                await this.adminService.setValue(
                  instance.instanceId,
                  'accessToken',
                  token.accessToken,
                );
                await this.adminService.setValue(
                  instance.instanceId,
                  'expiresOn',
                  token.expiresOn.toString(),
                );
                await this.adminService.setValue(
                  instance.instanceId,
                  'AntiCSRFAttackState',
                  null,
                );

                res.redirect(min.instance.botEndpoint);
              }
            },
          );
        });

        // Setups handlers.
        // send: function (context.activity, next) {
        //   logger.info(
        //     `[SND]: ChannelID: ${context.activity.address.channelId}, ConversationID: ${context.activity.address.conversation},
        //      Type: ${context.activity.type}              `)
        //   this.core.createMessage(
        //     this.min.conversation,
        //     this.min.conversation.startedBy,
        //     context.activity.source,
        //     (data, err) => {
        //       logger.info(context.activity.source)
        //     }
        //   )
        //   next()
      }),
    );
  }

  /**
   * Get Webchat key from Bot Service.
   *
   * @param instance The Bot instance.
   *
   */
  public async getWebchatToken(instance: any) {
    const options = {
      url: 'https://directline.botframework.com/v3/directline/tokens/generate',
      method: 'POST',
      headers: {
        Authorization: `Bearer ${instance.webchatKey}`,
      },
    };

    try {
      const json = await request(options);
      return Promise.resolve(JSON.parse(json));
    } catch (error) {
      const msg = `[botId:${
        instance.botId
      }] Error calling Direct Line client, verify Bot endpoint on the cloud. Error is: ${error}.`;
      return Promise.reject(new Error(msg));
    }
  }

  /**
   * Gets a Speech to Text / Text to Speech token from the provider.
   *
   * @param instance The general bot instance.
   *
   */
  public async getSTSToken(instance: any) {
    // TODO: Make dynamic: https://CHANGE.api.cognitive.microsoft.com/sts/v1.0

    const options = {
      url: 'https://westus.api.cognitive.microsoft.com/sts/v1.0/issueToken',
      method: 'POST',
      headers: {
        'Ocp-Apim-Subscription-Key': instance.speechKey,
      },
    };

    try {
      return await request(options);
    } catch (error) {
      const msg = `Error calling Speech to Text client. Error is: ${error}.`;
      return Promise.reject(new Error(msg));
    }
  }

  private async buildBotAdapter(instance: any) {
    const adapter = new BotFrameworkAdapter({
      appId: instance.marketplaceId,
      appPassword: instance.marketplacePassword,
    });

    const storage = new MemoryStorage();
    const conversationState = new ConversationState(storage);
    const userState = new UserState(storage);
    adapter.use(new AutoSaveStateMiddleware(conversationState, userState));

    // The minimal bot is built here.

    const min = new GBMinInstance();
    min.botId = instance.botId;
    min.bot = adapter;
    min.userState = userState;
    min.core = this.core;
    min.conversationalService = this.conversationalService;
    min.adminService = this.adminService;
    min.instance = await this.core.loadInstance(min.botId);
    min.userProfile = conversationState.createProperty('userProfile');
    const dialogState = conversationState.createProperty('dialogState');
    min.dialogs = new DialogSet(dialogState);
    min.dialogs.add(new TextPrompt('textPrompt'));

    return { min, adapter, conversationState };
  }

  private invokeLoadBot(appPackages: any[], min: any, server: any) {
    const sysPackages = new Array<IGBPackage>();
    // NOTE: A semicolon is necessary before this line.
    [
      GBCorePackage,
      GBSecurityPackage,
      GBAdminPackage,
      GBKBPackage,
      GBAnalyticsPackage,
      GBCustomerSatisfactionPackage,
      GBWhatsappPackage,
    ].forEach(sysPackage => {
      const p = Object.create(sysPackage.prototype) as IGBPackage;
      p.loadBot(min);
      sysPackages.push(p);
      if (sysPackage.name === 'GBWhatsappPackage') {
        const url = '/instances/:botId/whatsapp';
        server.post(url, (req, res) => {
          p.channel.received(req, res);
        });
      }
    }, this);

    appPackages.forEach(e => {
      e.sysPackages = sysPackages;
      e.loadBot(min);
    }, this);
  }

  /**
   * Bot Service hook method.
   */
  private receiver(
    adapter: BotFrameworkAdapter,
    req: any,
    res: any,
    conversationState: ConversationState,
    min: any,
    instance: any,
    appPackages: any[],
  ) {
    return adapter.processActivity(req, res, async context => {
      const state = conversationState.get(context);
      const step = await min.dialogs.createContext(context, state);
      step.context.activity.locale = 'en-US'; // TODO: Make dynamic.

      try {
        const user = await min.userProfile.get(context, {});

        if (!user.loaded) {
          await min.conversationalService.sendEvent(step, 'loadInstance', {
            instanceId: instance.instanceId,
            botId: instance.botId,
            theme: instance.theme ? instance.theme : 'default.gbtheme',
            secret: instance.webchatKey,
          });
          user.loaded = true;
          user.subjects = [];
          await min.userProfile.set(step.context, user);
        }

        logger.info(
          `User>: ${context.activity.text} (${context.activity.type}, ${
            context.activity.name
          }, ${context.activity.channelId}, {context.activity.value})`,
        );
        if (
          context.activity.type === 'conversationUpdate' &&
          context.activity.membersAdded.length > 0
        ) {
          const member = context.activity.membersAdded[0];
          if (member.name === 'GeneralBots') {
            logger.info(`Bot added to conversation, starting chat...`);
            appPackages.forEach(e => {
              e.onNewSession(min, step);
            });
            // Processes the root dialog.

            await step.beginDialog('/');
          } else {
            logger.info(`Member added to conversation: ${member.name}`);
          }

          // Processes messages.
        } else if (context.activity.type === 'message') {
          // Checks for /admin request.

          if (context.activity.text === 'admin') {
            await step.beginDialog('/admin');

            // Checks for /menu JSON signature.
          } else if (context.activity.text.startsWith('{"title"')) {
            await step.beginDialog('/menu', {
              data: JSON.parse(context.activity.text),
            });

            // Otherwise, continue to the active dialog in the stack.
          } else {
            if (step.activeDialog) {
              await step.continueDialog();
            } else {
              await step.beginDialog('/answer', {
                query: context.activity.text,
              });
            }
          }

          // Processes events.
        } else if (context.activity.type === 'event') {
          // Empties dialog stack before going to the target.

          await step.endAll();

          if (context.activity.name === 'whoAmI') {
            await step.beginDialog('/whoAmI');
          } else if (context.activity.name === 'showSubjects') {
            await step.beginDialog('/menu');
          } else if (context.activity.name === 'giveFeedback') {
            await step.beginDialog('/feedback', {
              fromMenu: true,
            });
          } else if (context.activity.name === 'showFAQ') {
            await step.beginDialog('/faq');
          } else if (context.activity.name === 'answerEvent') {
            await step.beginDialog('/answerEvent', {
              questionId: (context.activity as any).data,
              fromFaq: true,
            });
          } else if (context.activity.name === 'quality') {
            await step.beginDialog('/quality', {
              score: (context.activity as any).data,
            });
          } else if (context.activity.name === 'updateToken') {
            const token = (context.activity as any).data;
            await step.beginDialog('/adminUpdateToken', { token: token });
          } else {
            await step.continueDialog();
          }
        }
      } catch (error) {
        const msg = `ERROR: ${error.message} ${error.stack ? error.stack : ''}`;
        logger.error(msg);

        await step.context.sendActivity(
          Messages[step.context.activity.locale].very_sorry_about_error,
        );
        await step.beginDialog('/ask', { isReturning: true });
      }
    });
  }
}