import { useSelector } from 'react-redux';
import { qAdjustmentsResp } from '@root/store/qAdjustments/qAdjustments.selector';
import { generatedScoreSelector } from '@root/store/generateScore/generateScore.selector';
import { companyInformation, getModels} from '@root/store/companyInformation/companyInformation.selector';
import { companyDataSettingSelector } from '@root/store/companyDataSettings/companyDataSettings.selector';
import { formatDate, getPercentageRounding, getEnabledAdjStepsIds, checkEpdCompany } from '@utils/common';
import { rg_3UploadProps, stepIds } from '@root/constants';
import { sizeAdjustmentsResp } from '@root/store/sizeAdjustments/sizeAdjustments.selector';
import { progressTracker } from '@root/store/progressTracker/progressTracker.selector';
import { loadPitAdjResp } from '@root/store/loadPitAdj/loadPitAdj.selector';
import _ from 'lodash';
import { parentAndGovernment } from '@root/store/parentAndGovernment/parentAndGovernment.selector';
import { isRgPlusUser } from '@root/store/userInformation/userInformation.reducer';
const PropUploadDateFormat = 'MM/DD/YYYY';

export const GetPropUploadObject = () => {
    const qAdjustments = useSelector(qAdjustmentsResp);
    const scoringData = useSelector(generatedScoreSelector);
    const { steppers } = useSelector(progressTracker);
    const { companySelectedData, companyMetaData, expectedPdData, expectedPitMsScore ,
      newCompanyName, createdCompanyId, companyData} = useSelector(companyInformation);
    const modelsdata = useSelector(getModels);
    const companyDataSettings = useSelector(companyDataSettingSelector);
    const { sizeAdjustments, sizeAdjSections } = useSelector(sizeAdjustmentsResp);
    const { loadPitAdj } = useSelector(loadPitAdjResp);
    const { parentCompany, selectedDataInputs } = useSelector(parentAndGovernment);
    const { companyId, isPropCompany, csCompanyId, isUnlinkCompany } = companyData;
    const adjStepsIds = getEnabledAdjStepsIds(steppers);
    const financialStatementData = companyDataSettings?.selectedValues?.financialStatement;
    const isEPD = checkEpdCompany(companySelectedData?.type?.value, companyDataSettings?.selectedValues?.financialType);
    const selectedPeriodFiscalYear= isEPD
      ? companyDataSettings?.selectedValues?.selectPeriod.value : financialStatementData.fiscalYear;
    const selectedPeriod = financialStatementData.periodType === 'FY' || !financialStatementData.fiscalQuarter ?
        `FY${selectedPeriodFiscalYear}` :
        `LTM${financialStatementData.fiscalQuarter}${financialStatementData.fiscalYear}`;
    const fillingCurrencyCode = isEPD ? 'USD' : companyDataSettings?.selectedValues?.currency?.value;
    const parentFillingCurrency = selectedDataInputs?.currency?.value;
    const compositeResponse = scoringData?.generatedScore?.scoringData?.[0];
    const companyType = compositeResponse ? compositeResponse['Public/Private Status'] : '';
    const {isEsgSelected, esgFinalScores} = qAdjustments;
    const isRgPlus = useSelector(isRgPlusUser);
    const capsAndRg3User = isRgPlus;

    let qAdjustmentsRationales = {};
    let qAdjustmentObj = {};
    const sizeAdjustmentObj = {};
    if (adjStepsIds.includes(stepIds.QUALITATIVE_ADJUSTMENTS)) {
      qAdjustmentsRationales = qAdjustments?.qAdjustments?.currentResp?.data?.
        reduce((obj, item) => {
          obj[`${isEPD ? 'EPD_' : 'FN_'}${item.id}_RATIONALE`] = item.rational;
          return obj;
        }, {});
      qAdjustmentObj = qAdjustments?.qAdjustments?.currentResp?.data?.
        reduce((obj, item) => {
          obj[`${isEPD ? 'EPD_' : ''}${item.id}`] = item.displayValues?.find(e => e.displayName
            === item.defaultValue)?.value;
          return obj;
        }, {});
    }

    const isParentOrGovSelected = (adjStepsIds?.includes(stepIds.PARENT_ADJUSTMENTS) ||
     adjStepsIds?.includes(stepIds.GOVERNMENT_SUPPORT)) ? 'Yes' : 'No';
    const epdTempObject = {...expectedPdData, ...sizeAdjustments?.currentResp?.data};
    const isPitApplied = loadPitAdj?.currentResp?.creditCycle && adjStepsIds?.includes(stepIds.Pd_ADJUSTMENTS);
    const tempObject = {
        companyID: companyId || createdCompanyId,
        csCompanyId: isUnlinkCompany ? csCompanyId : null,
        companyInfo : {
            countryISOCode: companySelectedData?.country?.value,
            ...(isEPD && {stateCode : companySelectedData?.state?.code, stateId : companySelectedData?.state?.id }),
            picsCode: companySelectedData?.industry?.value,
            picsType: 'GICS',
            statementDate: financialStatementData?.value,
            statusType:companySelectedData?.type?.value,
            newCompany: !companyId || isUnlinkCompany,
            isPropCompany,
            isUnlinkCompany,
            scoreDate: formatDate(companyDataSettings?.selectedValues?.scoreDate,PropUploadDateFormat),
            currentDate: formatDate(new Date(), PropUploadDateFormat),
            fillingCurrency: fillingCurrencyCode,
            currencyCode: companyMetaData.currencies?.find(c => c.code === fillingCurrencyCode)?.other,
            parentCurrencyCode: companyMetaData.currencies?.find(c => c.code === parentFillingCurrency)?.other,
            periodType: companyDataSettings?.selectedValues?.periodType?.label,
            quarter: `Q${financialStatementData?.fiscalQuarter || 4}`,
            year: selectedPeriodFiscalYear,
            periodDate: getEPDPeriodDate(isEPD, companyDataSettings),
            fnModelId: Number(modelsdata?.FN),
            cmModelId: Number(modelsdata?.CM),
            selectedPeriod,
            isEPD,
            pitAdjDate: formatDate(loadPitAdj?.currentResp?.pitAdjustmentDate|| new Date(), PropUploadDateFormat),
            status: companyType,
            parentCompanyId: parentCompany?.value,
            parentCompanyName: parentCompany?.label,
            newCompanyName
        },
        version: (()=> isRgPlus ? 'V3' : 'V2')()
    };
    if (compositeResponse) {
        const pitResponse = scoringData?.generatedScore?.pitMsAdjustResponse?.[0];
        const fnObj = modelsdata?.FN && getFNUploadObject(
          tempObject,
          compositeResponse.fn,
          companyType,
          qAdjustmentsRationales,
          isPitApplied,
          expectedPitMsScore,
          isParentOrGovSelected,
          compositeResponse.riskgauge,
          capsAndRg3User
        );
        const cmObj = modelsdata?.CM && getCMUploadObject(
          tempObject,
          compositeResponse.cm,
          companyType,
          isPitApplied,
          expectedPitMsScore,
          isParentOrGovSelected,
          compositeResponse.riskgauge
        );
        const epdObj = getEPDUploadObject(
          tempObject,
          compositeResponse.epd,
          qAdjustmentsRationales,
          qAdjustmentObj,
          isEPD,
          epdTempObject,
          sizeAdjSections,
          sizeAdjustments,
          isPitApplied,
          expectedPitMsScore,
          adjStepsIds,
          capsAndRg3User,
          sizeAdjustmentObj
        );
        const rg_3 = capsAndRg3User ? getRgPlusCapObject({
          isEPD,
          companyType,
          companySelectedData,
          adjStepsIds,
          qAdjustmentObj,
          qAdjustmentsRationales,
          fnCmObj: {...fnObj, ...cmObj},
          epdObj,
          isEsgSelected,
          esgFinalScores,
          sizeAdjustmentObj,
          isPitApplied,
          tempObject
        }) : null;
        _.merge(tempObject, {
          rg: (() => !(isRgPlus) ?
           getRGUploadObject(tempObject, compositeResponse, pitResponse, isRgPlus) : null)(),
          fn: fnObj,
          cm: cmObj,
          epd: epdObj,
          ...(rg_3 && { rg_3 })
        });
    }
    return tempObject;
};

const getRgPlusCapObject = ({
  isEPD, companyType, companySelectedData, adjStepsIds, qAdjustmentObj,
   qAdjustmentsRationales, fnCmObj, epdObj, isEsgSelected, esgFinalScores, sizeAdjustmentObj,
   isPitApplied, tempObject}) => {
  const { companyInfo } = tempObject;
  const isParentAdj = adjStepsIds?.includes(stepIds.PARENT_ADJUSTMENTS);
  const isGovAdj = adjStepsIds.includes(stepIds.GOVERNMENT_SUPPORT);
  const isQualitativeAdj = adjStepsIds?.includes(stepIds.QUALITATIVE_ADJUSTMENTS);
  const rgPlusProps: any = {};
  const qAdj = {};
  const qAdjObj = Object.keys(qAdjustmentObj).length ? {...qAdjustmentObj} :
    {...setDefaultValueOnEmpty({}, undefined), 'QUALITY_OF_MANAGEMENT': undefined};
  const defualtVal = '-999';
  rg_3UploadProps.forEach(prop => {
    const propValue = isEPD ? epdObj?.[`EPD_${prop}`] : fnCmObj[prop] || qAdjustmentsRationales[`FN_${prop}`];
    if(propValue !== undefined) {
      rgPlusProps[prop] = propValue;
    }
    if(qAdjObj && (Object.keys(qAdjObj).includes(prop) || Object.keys(qAdjObj).includes(`EPD_${prop}`))){
      qAdj[prop] = isQualitativeAdj ? (isEPD ? qAdjObj[`EPD_${prop}`] : qAdjObj[prop]) : defualtVal;
    }
    if(qAdjustmentsRationales && (Object.keys(qAdjustmentsRationales).includes(prop)
       || Object.keys(qAdjustmentsRationales).includes(`EPD_${prop}`))){
      qAdj[prop] = isQualitativeAdj ? (isEPD ? qAdjustmentsRationales[`EPD_${prop}`] : qAdjustmentsRationales[prop]) : null;
    }
  });
  rgPlusProps.COMPANY_TYPE = companyType;
  rgPlusProps.COMPANY_COUNTRY_CODE = companySelectedData?.country?.value;
  rgPlusProps.COMPANY_INDUSTRY_CODE = companySelectedData?.industry?.value;
  if(isEPD && companySelectedData?.country?.value === 'USA' && companySelectedData?.state?.value !== '') {
    rgPlusProps.COMPANY_STATE_CODE = companySelectedData?.state?.value;
  }
  if(isEPD){
    rgPlusProps.ADJ_ASSETS = sizeAdjustmentObj?.ADJ_ASSETS || defualtVal;
    rgPlusProps.ADJ_REVENUE = sizeAdjustmentObj?.ADJ_REVENUE || defualtVal;
    rgPlusProps.ADJ_TOTAL_EMPLOYEES = sizeAdjustmentObj?.ADJ_TOTAL_EMPLOYEES || defualtVal;
  }

  rgPlusProps.PG_LABEL = isParentAdj && isGovAdj ? 'PG' : (isParentAdj ? 'P' : (isGovAdj ? 'G' : 'NA'));

  const removeQadjPrefix: any = (()=>{
    const qAdjObjKeys = {};
    const qAdjKeysRationale = {};
    Object.keys(qAdjObj)?.forEach(key => {
      if(key.includes('EPD_') || key.includes('FN_')){
        const newKey = key.includes('EPD_') ? key.replace('EPD_', '') : key.replace('FN_', '');
        qAdjObjKeys[newKey] = isQualitativeAdj && isEsgSelected ? qAdjObj[key] : defualtVal;
      } else {
        qAdjObjKeys[key] = isQualitativeAdj && isEsgSelected ? qAdjObj[key] : defualtVal;
      }
    });
    Object.keys(qAdjustmentsRationales)?.forEach(key => {
      if(key.includes('EPD_') || key.includes('FN_')){
        const newKey = key.includes('EPD_') ? key.replace('EPD_', '') : key.replace('FN_', '');
        qAdjKeysRationale[newKey] = isEsgSelected ? qAdjustmentsRationales[key] : null;
      } else {
        qAdjKeysRationale[key] = isEsgSelected ? qAdjustmentsRationales[key] : null;
      }
    });
    return {...qAdjObjKeys, ...qAdjKeysRationale};
  })();

    //QESG dataitems
    rgPlusProps.ENVIRONMENTAL_PRACTICES = removeQadjPrefix?.ENVIRONMENTAL || defualtVal;
    rgPlusProps.SOCIAL_STANDING = removeQadjPrefix?.SOCIAL || defualtVal;
    rgPlusProps.QUALITY_OF_GOVERNANCE = removeQadjPrefix?.GOVERNANCE || defualtVal;
    rgPlusProps.ADJ_COMPETITIVE_POSITION = (() => isQualitativeAdj && isEsgSelected ?
        esgFinalScores?.NEW_ADJ_COMPETITIVE_POSITION_VALUE ||
          esgFinalScores?.ADJ_COMPETITIVE_POSITION_VALUE : defualtVal)();
    rgPlusProps.ADJ_MGT_GOVERNANCE = (() => isQualitativeAdj && isEsgSelected ?
        esgFinalScores?.NEW_ADJ_QUALITY_OF_MANAGEMENT_VALUE ||
          esgFinalScores?.ADJ_QUALITY_OF_MANAGEMENT_VALUE : defualtVal)();
    rgPlusProps.ENVIRONMENTAL_PRACTICES_RATIONALE = removeQadjPrefix.ENVIRONMENTAL_RATIONALE;
    rgPlusProps.SOCIAL_STANDING_RATIONALE = removeQadjPrefix.SOCIAL_RATIONALE;
    rgPlusProps.QUALITY_OF_GOVERNANCE_RATIONALE = removeQadjPrefix.GOVERNANCE_RATIONALE;

    rgPlusProps.RG_MODEL_VERSION = getModelVersion(true);
    rgPlusProps.PD_ADJUSTMENT_DATE = isPitApplied ? companyInfo.pitAdjDate : null;

  return {...rgPlusProps, ...qAdj};
};

const getEPDPeriodDate = (isEPD, companyDataSettings) => isEPD
    ? `12/31/${companyDataSettings?.selectedValues?.selectPeriod.value}`
    : formatDate(companyDataSettings?.selectedValues?.financialStatement?.periodDate, PropUploadDateFormat);

/* eslint-disable */
const getEPDUploadObject = (
    completeData,
    epdObject,
    qAdjustmentsRationales,
    qAdjustmentObj,
    isEPD,
    epdTempObject,
    sizeAdjSections,
    sizeAdjustments,
    isPitApplied,
    expectedTempPitMsScore,
    adjStepsIds,
    capsAndRg3User,
    sizeAdjustmentObj
  ) => {
      if (isEPD && epdTempObject.data) {
        const expectedEPDData = epdTempObject.data.response.outputs[0];
        const epdQAdjRationales = {...qAdjustmentsRationales};
        const epdQAdjObj = {...qAdjustmentObj};
        const epdDistribution = distribution => distribution.map(item => `${item.score}:${item.totalCount}`).join(';');
        const epdDistributionCountry_Industry = (data,ind) => data.map(item=>{
               const outputString = item[ind].map(a=> `${a.name}-${a.count}`).join('|');
               return `${item.score}:${outputString}`;
            }).join(';');
        const epdServiceObj = {
          EPD_REGION_CODE: expectedEPDData.regionCode,
          EPD_MEDIAN_REVENUE: expectedEPDData.medianRevenue,
          EPD_SECTOR_CODE: expectedEPDData.sectorCode,
          EPD_MAPPING_PERIOD: expectedEPDData.mappingPeriod,
          EPD_BENCHMARK_PERIOD: expectedEPDData.benchmarkPeriod,
          EPD_GLOBAL_DISTRIBUTION_COUNTRY: epdDistributionCountry_Industry(
            expectedEPDData.scoreDistribution,
            'countries'
          ),
          EPD_GLOBAL_DISTRIBUTION_INDUSTRY: epdDistributionCountry_Industry(
            expectedEPDData.scoreDistribution,
            'industries'
          ),
          EPD_LOCAL_DISTRIBUTION_COUNTRY: epdDistributionCountry_Industry(
            expectedEPDData.localScoreDistribution,
            'countries'
          ),
          EPD_LOCAL_DISTRIBUTION_INDUSTRY: epdDistributionCountry_Industry(
            expectedEPDData.localScoreDistribution,
            'industries'
          ),
          EPD_GLOBAL_DISTRIBUTION: epdDistribution(
            expectedEPDData.scoreDistribution
          ),
          EPD_LOCAL_DISTRIBUTION: epdDistribution(
            expectedEPDData.localScoreDistribution
          ),
          EPD_REGION_SECTOR_OBS_CNT: expectedEPDData.regionSectorObservationCount
        };//12
        const sovObj = epdObject?.adjusted?.sov;
        const adjustedObj = epdObject?.adjusted;
        const isSizeAdjApplied = adjStepsIds?.includes(stepIds.SIZE_ADJUSTMENTS);
        const { currentResp } = sizeAdjustments;
        const selectedSizeAdjValues = currentResp?.data;
        const { totalAssets, totalEmployees, totalRevenue } = sizeAdjSections;
        const getRevenueRangeNum = revenueRange => {
            const bucket = selectedSizeAdjValues?.revenueBuckets?.find(item => item.displayValue === revenueRange);
            return bucket ? `${bucket?.lowerBound}` : null;
        };
        //Check selected size adj value and fill in size adjustment object
        (() => {
          if(totalAssets){
            sizeAdjustmentObj.ADJ_ASSETS = isSizeAdjApplied ? selectedSizeAdjValues?.totalAssets?.value : null;
          } else if(totalEmployees){
            sizeAdjustmentObj.ADJ_TOTAL_EMPLOYEES = isSizeAdjApplied ? selectedSizeAdjValues?.totalEmployees?.value : null;
          } else if(totalRevenue){
            sizeAdjustmentObj.ADJ_REVENUE = isSizeAdjApplied ?
             getRevenueRangeNum(selectedSizeAdjValues?.totalRevenue?.revenueRange) : null;
          }
        })();
        const compInfo = completeData.companyInfo;
        const isEPDPlus = capsAndRg3User && (compInfo.countryISOCode === 'USA');
        const epdTempObj = {
            'EPD_MODEL_VERSION': 2.0,
            'EPD_COUNTRYISOCODE': compInfo.countryISOCode,
            'EPD_SCOREDATE': compInfo.scoreDate,
            'EPD_SOV_1YR_IMPL_SCORE': sovObj?.score,
            'EPD_SOV_1YR_PD': sovObj?.pd,
            'EPD_STANDALONE_ANCHOR_IMPL_SCORE': isEPDPlus ? epdObject?.output?.ANCHOR_CREDIT_WORTHINESS
                : epdObject?.unadjusted?.score,
            'EPD_STANDALONE_ANCHOR_PD': isEPDPlus ? epdObject?.output?.ANCHOR_PD : epdObject?.unadjusted?.pd,
            'EPD_STANDALONE_1YR_SIZE_ADJ_IMPL_SCORE': isEPDPlus ? epdObject?.output?.SIZE_ADJUSTMENT_CREDIT_WORTHINESS
                : adjustedObj?.rev?.score,
            'EPD_STANDALONE_1YR_SIZE_ADJ_PD': isEPDPlus ? epdObject?.output?.SIZE_ADJUSTMENT_PD : adjustedObj?.rev?.pd,
            'EPD_STANDALONE_1YR_Q_MOD_IMPL_SCORE': isEPDPlus ? epdObject?.output?.ANCHOR_CREDIT_WORTHINESS
                : adjustedObj?.qModifier?.score,
            'EPD_STANDALONE_1YR_Q_MOD_PD': isEPDPlus ? epdObject?.output?.ANCHOR_PD : adjustedObj?.qModifier?.pd,
            'EPD_STANDALONE_1YR_IMPL_SCORE': isEPDPlus ? epdObject?.output?.ANCHOR_CREDIT_WORTHINESS
                : (adjustedObj?.qModifier?.score || adjustedObj?.rev?.score),
            'EPD_STANDALONE_1YR_PD': isEPDPlus ? epdObject?.output?.ANCHOR_PD : (adjustedObj?.qModifier?.pd || adjustedObj?.rev?.pd),
            'EPD_PERIODDATE': compInfo.periodDate,
            'EPD_Q_MODIFIERS': 'D; QM; PB',
            'EPD_INDUSTRY_CLASSIFICATION_CODE': compInfo.picsCode,
            'CA_PD_METRIC': 'EPD',
            'EPD_PROPRIETARYUPLOAD_DATE': formatDate(new Date(), PropUploadDateFormat),
            'EPD_ADJ_TOTAL_EMPLOYEES': capsAndRg3User ? null : sizeAdjustmentObj?.ADJ_TOTAL_EMPLOYEES || null,
            'EPD_ADJ_REVENUE': capsAndRg3User ? null : sizeAdjustmentObj?.ADJ_REVENUE || null,
            'EPD_ADJ_ASSETS': capsAndRg3User ? null : sizeAdjustmentObj?.ADJ_ASSETS || null,
            'EPD_CREDIT_CYCLE_ADJUSTED_PD': isPitApplied ? expectedTempPitMsScore?.fn?.pit_adj_pd : null, //fill value here from fn object
            'EPD_PD_ADJUSTMENT_DATE': isPitApplied ? compInfo.pitAdjDate : null,
            'EPD_PIT_ADJUSTED_METRIC': isPitApplied ? 'IQ_EPD_SOV_1YR_PD' : null
        };//22
        if(capsAndRg3User){
          const updateObjKeys = (obj, val) => {
            Object.keys(obj).forEach(key => {
              obj[key] = val;
            });
          };
          updateObjKeys(epdQAdjRationales, null);
          updateObjKeys(epdQAdjObj, '-999');
        }
        return { ...epdTempObj, ...epdQAdjRationales, ...epdServiceObj, ...epdQAdjObj};
    }
    return null;
};
/* eslint-enable */

const getFNQModifiersStr = (DIVERSIFICATION, QOM, PAYMENT_BEHAVIOR) => {
  const FN_Q_MODIFIERS_ARR = [];
  DIVERSIFICATION && FN_Q_MODIFIERS_ARR.push('D');
  QOM && FN_Q_MODIFIERS_ARR.push('QM');
  PAYMENT_BEHAVIOR && FN_Q_MODIFIERS_ARR.push('PB');
  return FN_Q_MODIFIERS_ARR.join('; ');
};

const setDefaultValueOnEmpty = (fnData, defaultVal) => ({
    DIVERSIFICATION: fnData.DIVERSIFICATION || defaultVal,
    COMPETITIVE_POSITION: fnData.COMPETITIVE_POSITION || defaultVal,
    CAPITAL_STRUCTURE: fnData.CAPITAL_STRUCTURE || defaultVal,
    FINANCIAL_POLICY: fnData.FINANCIAL_POLICY || defaultVal,
    MANAGEMENT_GOVERNANCE: fnData.MANAGEMENT_GOVERNANCE || defaultVal,
    PAYMENT_BEHAVIOR: fnData.PAYMENT_BEHAVIOR || defaultVal,
    Q_MODIFIER_PD : fnData.Q_MODIFIER_PD || defaultVal
  });

const getFNUploadObject = (
    completeData,
    fnObject,
    companyType,
    qAdjustmentsRationales,
    isPitApplied,
    expectedTempPitMsScore,
    isParentOrGovSelected,
    rgObject,
    capsAndRg3User
  ) => {
    let fnObjData = fnObject && _.cloneDeep(fnObject);
      if (fnObjData) {
        const compInfo = completeData.companyInfo;
        const isRgSovPgAvailable = !rgObject?.rgSovPG?.errorMessage;
        const defaultMatrixVal = '-999';
        const otherProps = {
            FN_Q_MODIFIERS: getFNQModifiersStr(
              fnObjData?.DIVERSIFICATION,
              fnObjData?.QUALITY_OF_MANAGEMENT || fnObjData?.MANAGEMENT_GOVERNANCE,
              fnObjData?.PAYMENT_BEHAVIOR
            ),
            SCORE_DATE: compInfo.scoreDate,
            FINANCIAL_STATEMENT_DATE: compInfo.periodDate,
            CA_PROP_COMP_PG: isParentOrGovSelected,
            CA_PARENT_ID: compInfo.parentCompanyId,
            CA_PARENT_NAME: compInfo.parentCompanyName,
            //FN_MACRO_FINAL_METRIC: 'P',
            FN_MODEL_VERSION: 2,
            //CA_PROP_COMP_PG: null, //yes if P&G is applied otherwise No, If IQP_FN_PG_LABEL Yes, if albel is - No
            FN_COMPANY_TYPE: companyType,
            FN_PROPRIETARYUPLOAD_DATE: formatDate(new Date(), PropUploadDateFormat), //Todays date
            FN_CREDIT_CYCLE_ADJUSTED_PD: isPitApplied ? expectedTempPitMsScore?.fn?.pit_adj_pd: null, //fill value here from fn object
            FN_PD_ADJUSTMENT_DATE: isPitApplied ? compInfo.pitAdjDate : null,
            FN_PIT_ADJUSTED_METRIC: isPitApplied ?
              (isRgSovPgAvailable ? 'IQ_FN_PG_SOV_1YR_PD' : 'IQ_FN_SOV_1YR_PD') : null
        };
        fnObjData = {
            ...fnObjData,
            ...otherProps,
            ...(capsAndRg3User ? {} : qAdjustmentsRationales),
            ...setDefaultValueOnEmpty(fnObjData, defaultMatrixVal)
        };
        fnObjData.PARENTAL_SUPPORT_CAPPED_PD = fnObjData.PARENTAL_SUPPORT_CAPPED_PD || fnObjData.PG_SUPPORT_CAPPED_PD;
        fnObjData.PARENTAL_SUPPORT_CAPPED_SCORE = fnObjData.PG_SUPPORT_CAPPED_SCORE || fnObjData.PG_SUPPORT_CAPPED_SCORE;
        fnObjData.PARENTAL_SUPPORT_STANDALONE_PD =
          fnObjData.PARENTAL_SUPPORT_STANDALONE_PD || fnObjData.PG_SUPPORT_STANDALONE_PD;
        fnObjData.PARENTAL_SUPPORT_STANDALONE_SCORE =
          fnObjData.PARENTAL_SUPPORT_STANDALONE_SCORE || fnObjData.PG_SUPPORT_STANDALONE_SCORE;
        if (fnObjData.PARENT_RATING_USED === 'IQ_FN_STANDALONE_1YR_PD') {
          fnObjData.FN_PARENT_MODEL_VERSION = 2;
          fnObjData.PARENT_RATING_USED = '';
        }
        if(fnObjData.Q_MODIFIER_CAPPED_PD) {
          fnObjData.PD = fnObjData.Q_MODIFIER_CAPPED_PD;
        }
      }
    return fnObjData || null;
};

const getCMUploadObject = (completeData,
   cmObject,
   companyType,
   isPitApplied,
   expectedTempPitMsScore,
   isParentOrGovSelected,
   rgObject) => {
    if (cmObject) {
        const compInfo = completeData.companyInfo;
        const isRgSovPgAvailable = !rgObject?.rgSovPG?.errorMessage;
        const cmObjectProps = {
            CM_COMPANY_TYPE: companyType,
            CA_PROP_COMP_PG: isParentOrGovSelected,
            CM_MODEL_VERSION: 3,
            //CM_MACRO_FINAL_METRIC: 'P',
            SCORE_DATE: compInfo.scoreDate,
            FINANCIAL_STATEMENT_DATE: compInfo.periodDate,
            CM_CREDIT_CYCLE_ADJUSTED_PD: (isPitApplied && expectedTempPitMsScore?.cm?.pit_adj_pd)
              ? (parseFloat(expectedTempPitMsScore?.cm?.pit_adj_pd) * 100) : null, //fill value here from cm object
            CM_PD_ADJUSTMENT_DATE: isPitApplied ? compInfo.pitAdjDate : null,
            CM_PIT_ADJUSTED_METRIC: isPitApplied ?
              (isRgSovPgAvailable ? 'IQ_CM_PG_SOV_SCORE' : 'IQ_CM_SOV_SCORE') : null
        };
        cmObject = {...cmObject, ...cmObjectProps};
        if (cmObject.PARENT_RATING_USED === 'IQ_FN_STANDALONE_1YR_PD') {
          cmObject.CM_PARENT_MODEL_VERSION = 3;
          cmObject.PARENT_RATING_USED = '';
        }
    }
    return cmObject || null;
};

const getModelVersion = isRgPlusUser => isRgPlusUser ? 3: 2;

//This method prepares all the data which gets uploaded for RG.
const getRGUploadObject = (completeCompanyData, compositeResponse, pitResponse, isRgPlus) => {
    const completeData = completeCompanyData?.companyInfo;
    if (compositeResponse?.riskgauge) {
        const rgObject = compositeResponse?.riskgauge;
        const isRgSovPgAvailable = rgObject?.rgSovPG && !rgObject?.rgSovPG?.errorMessage;
        const pickedRgObject = (() =>isRgSovPgAvailable ? rgObject?.rgSovPG : rgObject?.rgSov)();
        if(!pickedRgObject) {return null;}
        const isMsPresent = Boolean(pickedRgObject?.pdmsContribution);
        const isFnPresent = Boolean(pickedRgObject?.pdfnContribution);
        const isCmPresent = Boolean(pickedRgObject?.cmContribution);
        const isEpdPresent = Boolean(compositeResponse?.epd);
        const isBenchmarkUsed = pickedRgObject?.pdmsBenchmarkType && pickedRgObject?.pdmsBenchmarkDate && isMsPresent;
        const [pdmsContributionValue,pdfnContributionValue,cmContributionValue] = getPercentageRounding([
            pickedRgObject?.pdmsContribution,
            pickedRgObject?.pdfnContribution,
            pickedRgObject?.cmContribution
        ]);

        const rgUploadObject = {
            //Company Demographics
            RG_COUNTRY_ISO_CODE: completeData.countryISOCode,
            RG_INDUSTRY_CLASSIFICATION_CODE: completeData.picsCode,
            RG_COMPANY_TYPE: compositeResponse['Public/Private Status'],

            //RG Details
            RG_SCORE_ONE_TO_HUNDRED: pickedRgObject.rgScoreOneToHundred,
            RG_CREDIT_SCORE: pickedRgObject.rgCreditScore,
            RG_1YR_PD: pickedRgObject.rgPd,
            RG_SCORE_ONE_TO_NINE: pickedRgObject.rgScoreOneToNine,
            RG_SCORE_DATE: completeData.scoreDate,
            RG_MODEL_VERSION: getModelVersion(isRgPlus),
            FINANCIALTEMPLATE: 'Standard'
        };

        if (pitResponse && (pitResponse.adjust_for_pit || pitResponse.adjust_for_mkt) && !pitResponse.error) {
            _.merge(rgUploadObject, {
                RG_CC_ADJ_ONE_TO_HUNDRED: pitResponse.pit_adj_pd_hundred_scale,
                RG_CC_ADJ_SCORE: pitResponse.pit_adj_score,
                RG_CC_ADJ_1YR_PD: pitResponse.pit_adj_pd,
                RG_CC_ADJ_ONE_TO_NINE: pitResponse.pit_adj_pd_nine_scale,
                RG_PD_ADJ_DATE: completeData.pitAdjDate //Fill in the blanks
            });
        }

        if (isEpdPresent) {
            _.merge(rgUploadObject, {
                RG_EPD_1YR_PD: pickedRgObject.pdfnPd,
                RG_EPD_PD_METRIC: 'IQ_FN_SOV_1YR_PD',
                RG_EPD_ABS_CONTRIBUTION: pdfnContributionValue,
                RG_EPD_FIN_STATEMENT_DATE: completeData.periodDate,
                RG_EPD_MODEL_VERSION: 2,
                RG_EPD_STANDALONE_ONE_TO_HUNDRED: pickedRgObject.pdfnScoreOneToHundred,
                RG_EPD_STANDALONE_CREDIT_SCORE: pickedRgObject.pdfnCreditScore,
                RG_EPD_STANDALONE_1YR_PD: pickedRgObject.pdfnPd,
                RG_EPD_STANDALONE_ONE_TO_NINE: pickedRgObject.pdfnScoreOneToNine,
                RG_EPD_SCORE_DATE: completeData.scoreDate,
                RG_EPD_PERIOD: completeData.selectedPeriod
            });
        } else if (isFnPresent) {
            _.merge(rgUploadObject, {
                RG_FN_1YR_PD: pickedRgObject.pdfnPd, //should this be trimmed to 6 decimals ?
                RG_FN_ABS_CONTRIBUTION: pdfnContributionValue, //This is getting prop uploaded as number without decimals
                RG_FN_STANDALONE_ONE_TO_HUNDRED: pickedRgObject.pdfnScoreOneToHundred,
                RG_FN_STANDALONE_CREDIT_SCORE: pickedRgObject.pdfnCreditScore,
                RG_FN_STANDALONE_1YR_PD: pickedRgObject.pdfnPd, //should this be trimmed to 6 decimals ?
                RG_FN_STANDALONE_ONE_TO_NINE: pickedRgObject.pdfnScoreOneToNine,
                RG_FN_SCORE_DATE: completeData.scoreDate,
                RG_FN_PERIOD: completeData.selectedPeriod,
                RG_FN_PD_METRIC: isRgSovPgAvailable ? 'IQ_FN_PG_SOV_1YR_PD' : 'IQ_FN_SOV_1YR_PD',
                RG_FN_FIN_STATEMENT_DATE: completeData.periodDate,
                RG_FN_MODEL_VERSION: 2
            });
        }

        if (isCmPresent) {
            _.merge(rgUploadObject, {
                RG_CM_SCORE: pickedRgObject.cmCreditScore,
                RG_CM_UNROUNDED_SCORE: pickedRgObject.cmPd, //should this be trimmed to 6 decimals ?
                RG_CM_ABS_CONTRIBUTION: cmContributionValue, //This is getting prop uploaded as number without decimals
                RG_CM_STANDALONE_ONE_TO_HUNDRED: pickedRgObject.cmScoreOneToHundred,
                RG_CM_STANDALONE_CREDIT_SCORE: pickedRgObject.cmCreditScore,
                RG_CM_STANDALONE_1YR_PD: pickedRgObject.cmPd, //should this be trimmed to 6 decimals ?
                RG_CM_STANDALONE_ONE_TO_NINE: pickedRgObject.cmScoreOneToNine,
                RG_CM_SCORE_DATE: completeData.scoreDate,
                RG_CM_PERIOD: completeData.selectedPeriod,
                RG_CM_MODEL_VERSION: 3,
                RG_CM_FIN_STATEMENT_DATE: completeData.periodDate,
                RG_CM_SCORE_METRIC: isRgSovPgAvailable ? 'IQ_CM_PG_SOV_SCORE': 'IQ_CM_SOV_SCORE'
            });
        }

        if (isMsPresent) {
            _.merge(rgUploadObject, {
              RG_MS_1YR_PD: isBenchmarkUsed ? null : pickedRgObject.pdmsPd, //should this be trimmed to 6 decimals ?
              RG_MS_ABS_CONTRIBUTION: pdmsContributionValue, //This is getting prop uploaded as number without decimals
              RG_MS_BENCHMARK_1YR_PD: !isBenchmarkUsed
                ? null
                : pickedRgObject.pdmsPd,
              RG_MS_BENCHMARK_PD_TYPE: pickedRgObject.pdmsBenchmarkType,
              RG_MS_BENCHMARK_PD_DATE: pickedRgObject.pdmsBenchmarkDate,
              RG_MS_STANDALONE_ONE_TO_HUNDRED:
                pickedRgObject.pdmsScoreOneToHundred,
              RG_MS_STANDALONE_CREDIT_SCORE: pickedRgObject.pdmsCreditScore,
              RG_MS_STANDALONE_1YR_PD: pickedRgObject.pdmsPd, //should this be trimmed to 6 decimals ?
              RG_MS_STANDALONE_ONE_TO_NINE: pickedRgObject.pdmsScoreOneToNine,
              RG_MS_MODEL_VERSION: 2,
              RG_MS_SCORE_DATE:
                !isBenchmarkUsed && rgObject?.pdms?.data_date
                  ? formatDate(rgObject.pdms.data_date, PropUploadDateFormat)
                  : null,
              RG_MS_BENCHMARK_PD_QUANTILE: isBenchmarkUsed ? 'MEDIAN' : null, //Should this be hardcoded?
              RG_MS_PD_METRIC: 'IQ_MS_SOV_1YR_PD'
            });
        }
        return rgUploadObject;
    }
    return null;
};

export const getModelsPresentAndRGObject = compositeResponse => {
        const rgObject = compositeResponse?.riskgauge;
        const isRgSovPgAvailable = !rgObject?.rgSovPG?.errorMessage;
        const pickedRgObject = isRgSovPgAvailable
          ? rgObject?.rgSovPG
          : rgObject?.rgSov;
          if(!pickedRgObject) {return null;}
        const isMsPresent = Boolean(pickedRgObject?.pdmsContribution);
        const isFnPresent = Boolean(pickedRgObject?.pdfnContribution);
        const isCmPresent = Boolean(pickedRgObject?.cmContribution);
        const isEpdPresent = Boolean(compositeResponse?.epd);

        return {
            models:{
                isMsPresent,
                isFnPresent,
                isCmPresent,
                isEpdPresent
            },
            pickedRgObject
        };
};
