import deepmerge from 'deepmerge';

import { NodeProfile } from '../../@types/nodeProfile';
import PARTY from '../../enum/party';
import envConfig from '../../env/env-config';
import { getNodeProfile, IDENTITY_SEPARATOR } from '../../env/nodeProfile';
import * as dateUtil from '../dateUtil';
import { generateDocumentSourceJson } from '../generateDocumentSourceJson';
import { generateOtherDocumentsJson } from '../generateOtherDocumentsJson';
import scenarioContext from '../scenarioContext';
import default_dc_payload from './default_dc_payload';
import { generateChildIdentityName } from './multiIdentityUtil';
import { uploadAttachments } from './uploadAttachments';

export async function generateDCPayload(documentSourceDataTable: any, dcScenario: any, attachmentNum: number) {
  const randomDate = dateUtil.getRandomDate();
  scenarioContext().dc.randomDate = randomDate;

  const attachments = await uploadAttachments(attachmentNum, dcScenario);
  scenarioContext().dc.attachments = attachments;
  const documentSource = generateDocumentSourceJson(documentSourceDataTable);
  const otherDocumentsRequired = generateOtherDocumentsJson(documentSourceDataTable);
  let partiesPayload = {
    applicant: getNodeProfile(envConfig.scenario[dcScenario].applicant).name,
    beneficiary: getNodeProfile(envConfig.scenario[dcScenario].beneficiary).name,
    issuer: getNodeProfile(envConfig.scenario[dcScenario].issuingBank).name,
    advisingBank: getNodeProfile(envConfig.scenario[dcScenario].advisingBank).name,
    confirmingBank: getNodeProfile(envConfig.scenario[dcScenario].confirmingBank)?.name ?? null,
    availableWithBank: getNodeProfile(envConfig.scenario[dcScenario].nominatedBank)?.name ?? null,
    drawee: null,
    requestedBy: getNodeProfile(envConfig.scenario[dcScenario].applicant).name,
    counterparty: getNodeProfile(envConfig.scenario[dcScenario].beneficiary).name,
    availableWithAnyBank: getNodeProfile(envConfig.scenario[dcScenario].nominatedBank) ? false : true
  };

  if (scenarioContext().scenario) {
    const nodesObj = Object.assign({}, scenarioContext().scenario);
    partiesPayload = updatePartiesPayload(nodesObj, partiesPayload);
  }

  let payload = {
    args: {
      props: {
        applicationDate: dateUtil.getTodayDate(),
        expiryDate: randomDate,
        incoterms: 'EXW',
        documentsRequired: documentSource,
        documentsSource: 'VOLTRON',
        otherDocumentsRequired: otherDocumentsRequired,
        confirmation: envConfig.scenario[dcScenario].confirmation,
        attachments: attachments,
        typeCredit: null,
        typeCredits: [
          {
            typeCredit: 'SIGHT',
            availableCreditsProps: {}
          },
          {
            typeCredit: 'DEFERRED_PAYMENT',
            availableCreditsProps: {
              deferredPaymentDetails: 'Deferred payment\nNegotiation / Deferred payment details'
            }
          },
          {
            typeCredit: 'NEGOTIABLE_CREDIT',
            availableCreditsProps: {
              deferredPaymentDetails: 'Negotiation\nNegotiation / Deferred payment details'
            }
          }
        ],
        parties: partiesPayload,
        partyAddresses: {
          applicant: getNodeProfile(envConfig.scenario[dcScenario].applicant).address,
          beneficiary: getNodeProfile(envConfig.scenario[dcScenario].beneficiary).address,
          issuer: getNodeProfile(envConfig.scenario[dcScenario].issuingBank).address,
          advisingBank: getNodeProfile(envConfig.scenario[dcScenario].advisingBank).address,
          confirmingBank: getNodeProfile(envConfig.scenario[dcScenario].confirmingBank)?.address ?? null,
          availableWithBank: getNodeProfile(envConfig.scenario[dcScenario].nominatedBank)?.address ?? 'Any address',
          drawee: null
        }
      }
    }
  };

  payload = deepmerge(default_dc_payload, payload, {
    arrayMerge: (destinationArray: any, sourceArray: any, options: any) => sourceArray
  });
  return payload;
}

function updatePartiesPayload(scenarioNodes: Record<PARTY, string> | {}, partiesPayload: any): any {
  const updatedPayload = Object.assign({}, partiesPayload);
  Object.entries(scenarioNodes).forEach(([party, node]) => {
    const { nodeProps, isChildIdentity } = getPartyDetails(party, node);
    const x500name = isChildIdentity
      ? generateChildIdentityName(nodeProps.name, nodeProps.childIdentities[node.split(IDENTITY_SEPARATOR)[1]])
      : nodeProps.name;
    updatedPayload[getTrxParty(party)] = x500name;
  });
  return updatedPayload;
}

function getTrxParty(party: string) {
  let result = party;
  if (party == PARTY.ISSUING_BANK) {
    result = 'issuer';
  } else if (party == PARTY.NOMINATED_BANK) {
    result = 'availableWithBank';
  }
  return result;
}

function getPartyDetails(party: string, node: string): { nodeProps: NodeProfile; isChildIdentity: boolean } {
  let isChildIdentity = false;
  let nodeProps = getNodeProfile(node);
  if (!scenarioContext().isScenarioPartyAChild(party)) {
    return { nodeProps, isChildIdentity };
  }
  nodeProps = getNodeProfile(node.split(IDENTITY_SEPARATOR)[0]);
  isChildIdentity = true;
  return { nodeProps, isChildIdentity };
}