import chalk from 'chalk';

import { checkValidProductModuleDirectory } from '../helpers/check-valid-product-module-directory';
import { HttpMethod, getNewApiHelper } from '../helpers/root-api';
import { RootConfigWrite, isProductModuleConfig } from '../domain/root-config';
import { readAuthAndConfig } from '../helpers/read-auth-and-config';
import { getDashboardHost } from '../helpers/get-dashboard-host';
import { ProductModulePayloadType } from '../domain/invoke-payloads';
import { generatePolicyholderPayloadOrReadFromFile, readRequestPayloadFromFile } from '../helpers/payloads-helpers';
import { CollectionModuleConfig } from '../domain/collection-modules/collection-module-config';
import { runWithSpinner } from '../helpers/spinner';
import { symbols } from '../helpers/symbols';

interface InvokeCommandParams {
  quote?: boolean;
  application?: boolean;
  claim?: boolean;
  live?: boolean;
  verbose?: boolean;
}

interface InvokeCommandParsedOptions {
  onlyIssueQuote: boolean;
  onlyIssueApplication: boolean;
  openClaim: boolean;
  issueLive: boolean;
  verbose: boolean;
  draftPath: Record<string, string>;
}

const getInvokeCommandParsedOptions = (params: InvokeCommandParams): InvokeCommandParsedOptions => {
  return {
    onlyIssueQuote: params.quote || false,
    onlyIssueApplication: params.quote ? false : params.application || false,
    openClaim: params.claim || false,
    issueLive: params.live || false,
    verbose: params.verbose || false,
    draftPath: params.live ? { version: 'live' } : { version: 'draft' },
  };
};

export const validateConfigAndEnvironment = async (params: {
  apiKey: string;
  config: RootConfigWrite | CollectionModuleConfig;
}) => {
  const { apiKey, config } = params;
  if (!isProductModuleConfig(config)) {
    throw new Error('.root-config.json is not a valid product module config file.');
  }
  checkValidProductModuleDirectory({ productModuleConfig: config });

  if (apiKey && apiKey.split('_')[0] !== 'sandbox') {
    throw new Error('A sandbox API key is required to use this feature. Please update .root-auth accordingly.');
  }

  return true;
};

export const invoke = async (params: InvokeCommandParams) => {
  const authAndConfig = readAuthAndConfig();

  const valid = await validateConfigAndEnvironment(authAndConfig);
  if (!valid) {
    return;
  }
  const options = getInvokeCommandParsedOptions(params);

  const { host, organizationId } = authAndConfig.config;
  const rootApi = getNewApiHelper({ host, apiKey: authAndConfig.apiKey, throwResponseErrors: true });

  const policyholderPayload = generatePolicyholderPayloadOrReadFromFile(authAndConfig.config);
  const quotePayload = readRequestPayloadFromFile({ type: ProductModulePayloadType.Quote });

  // create the quote and policyholder
  const [quotePackage, policyholderPackage] = await runWithSpinner('Creating quote and policyholder...', () =>
    Promise.all([
      rootApi.send({
        method: HttpMethod.Post,
        path: '/insurance/quote',
        body: quotePayload,
        searchParams: options.draftPath,
      }),
      rootApi.send({ method: HttpMethod.Put, path: '/insurance/policyholders', body: policyholderPayload }),
    ]),
  );

  const { quote_package_id: quotePackageId } = quotePackage[0];
  const { policyholder_id: policyholderId } = policyholderPackage;

  // stop if the --quote is specified
  if (options.onlyIssueQuote || options.verbose) {
    console.log(`${symbols.success}${chalk.green('Quote created successfully!')}`);
    console.log(JSON.stringify(quotePackage, null, 2));

    if (options.onlyIssueQuote) {
      return;
    }
  }

  // create the application
  const applicationPayload = readRequestPayloadFromFile({ type: ProductModulePayloadType.Application });
  const applicationPackage = await runWithSpinner('Creating application...', () =>
    rootApi.send({
      method: HttpMethod.Post,
      path: '/insurance/applications',
      body: {
        quote_package_id: quotePackageId,
        policyholder_id: policyholderId,
        ...applicationPayload,
      },
      searchParams: options.draftPath,
    }),
  );

  const { application_id: applicationPackageId } = applicationPackage;

  // stop if the --application is specified
  if (options.onlyIssueApplication || options.verbose) {
    console.log(`${symbols.success}${chalk.green('Application created successfully!')}`);
    console.log(JSON.stringify(applicationPackage, null, 2));

    if (options.onlyIssueApplication) {
      return;
    }
  }

  // create policy
  const policyPackage = await runWithSpinner('Issuing policy...', () =>
    rootApi.send({
      method: HttpMethod.Post,
      path: '/insurance/policies',
      body: { application_id: applicationPackageId },
    }),
  );

  const { policy_id: policyId } = policyPackage;
  const dashboardHost = getDashboardHost(host);

  // open claim
  if (options.openClaim) {
    const claimPackage = await runWithSpinner('Opening claim...', () =>
      rootApi.send({
        method: HttpMethod.Post,
        path: '/insurance/claims',
        body: {
          policy_id: policyId,
          claimant: {
            first_name: 'Testing',
            last_name: 'Claims',
            email: 'example@email.com',
          },
        },
      }),
    );
    const { claim_id: claimId } = claimPackage;
    const claimURL = `${String(dashboardHost)}/orgs/${organizationId}/insurance/claims/${String(claimId)}`;
    const linkCLaimText = 'Click here to view on dashboard.';
    console.log(
      '\n' +
        chalk.green('Claim opened successfully! ') +
        chalk.blue(`\u001B]8;;${claimURL}\u001B\\${linkCLaimText}\u001B]8;;\u001B\\`),
    );
    return;
  }

  const policyUrl = `${dashboardHost}/orgs/${organizationId}/insurance/policies/${policyId}`;
  const linkText = 'Click here to view on dashboard.';

  console.log(
    '\n' +
      chalk.green('Policy issued successfully! ') +
      chalk.blue(`\u001B]8;;${policyUrl}\u001B\\${linkText}\u001B]8;;\u001B\\`),
  );
};