/**
 * Copyright since 2025 Mifos Initiative
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

/** Angular Imports */
import { Component, ViewChild, inject } from '@angular/core';
import { ActivatedRoute, Router } from '@angular/router';

/** Custom Services */
import { RecurringDepositsService } from '../recurring-deposits.service';
import { SettingsService } from 'app/settings/settings.service';
import { ProductsService } from 'app/products/products.service';
import { AlertService } from 'app/core/alert/alert.service';

/** Step Components */
import { RecurringDepositsAccountDetailsStepComponent } from '../recurring-deposits-account-stepper/recurring-deposits-account-details-step/recurring-deposits-account-details-step.component';
import { Dates } from 'app/core/utils/dates';
import { MatTabsModule } from '@angular/material/tabs';
import { FaIconComponent } from '@fortawesome/angular-fontawesome';
import { RecurringDepositsAccountCurrencyStepComponent } from '../recurring-deposits-account-stepper/recurring-deposits-account-currency-step/recurring-deposits-account-currency-step.component';
import { RecurringDepositsAccountInterestRateChartStepComponent } from '../recurring-deposits-account-stepper/recurring-deposits-account-interest-rate-chart-step/recurring-deposits-account-interest-rate-chart-step.component';
import { RecurringDepositsAccountPreviewStepComponent } from '../recurring-deposits-account-stepper/recurring-deposits-account-preview-step/recurring-deposits-account-preview-step.component';
import { RecurringDepositsAccountMaturityTermsStepComponent } from '../recurring-deposits-account-stepper/recurring-deposits-account-maturity-terms-step/recurring-deposits-account-maturity-terms-step.component';
import { STANDALONE_SHARED_IMPORTS } from 'app/standalone-shared.module';

/**
 * Create new recurring deposit account
 */
@Component({
  selector: 'mifosx-create-recurring-deposits-account',
  templateUrl: './create-recurring-deposits-account.component.html',
  styleUrls: ['./create-recurring-deposits-account.component.scss'],
  imports: [
    ...STANDALONE_SHARED_IMPORTS,
    MatTabsModule,
    FaIconComponent,
    RecurringDepositsAccountDetailsStepComponent,
    RecurringDepositsAccountCurrencyStepComponent,
    RecurringDepositsAccountInterestRateChartStepComponent,
    RecurringDepositsAccountMaturityTermsStepComponent,
    RecurringDepositsAccountPreviewStepComponent
  ]
})
export class CreateRecurringDepositsAccountComponent {
  private route = inject(ActivatedRoute);
  private router = inject(Router);
  private dateUtils = inject(Dates);
  private recurringDepositsService = inject(RecurringDepositsService);
  private settingsService = inject(SettingsService);
  private productsService = inject(ProductsService);
  private alertService = inject(AlertService);

  @ViewChild(RecurringDepositsAccountDetailsStepComponent, { static: true })
  recurringDepositsAccountDetailsStep: RecurringDepositsAccountDetailsStepComponent;

  @ViewChild(RecurringDepositsAccountCurrencyStepComponent)
  recurringDepositsAccountCurrencyStep: RecurringDepositsAccountCurrencyStepComponent;

  @ViewChild(RecurringDepositsAccountInterestRateChartStepComponent)
  recurringDepositsAccountChartStep: RecurringDepositsAccountInterestRateChartStepComponent;

  @ViewChild(RecurringDepositsAccountPreviewStepComponent)
  recurringDepositsAccountPreviewStep: RecurringDepositsAccountPreviewStepComponent;

  @ViewChild(RecurringDepositsAccountMaturityTermsStepComponent)
  recurringDepositsAccountMaturityTermsStep: RecurringDepositsAccountMaturityTermsStepComponent;

  /** Recurring Deposits Account Template */
  recurringDepositsAccountTemplate: any;
  /** Recurring Deposit Account Product Template */
  recurringDepositsAccountProductTemplate: any;
  /** Currently visible wizard tab (0-indexed). */
  selectedTabIndex = 0;
  /** Total wizard tabs — Product, Currency, Chart, Preview. */
  private readonly totalTabs = 5;
  /** Active CBS base interest rate versions */
  cbsBaseRates: any[] = [];
  /** Selected tenure value and frequency from calculator */
  selectedTenureValue: number | null = null;
  selectedTenureFrequencyId: number | null = null;
  selectedDepositAmount: number | null = null;
  rdAppliedRate: number | null = null;
  rdIsSeniorCitizen = false;

  constructor() {
    this.route.data.subscribe((data: { recurringDepositsAccountTemplate: any }) => {
      this.recurringDepositsAccountTemplate = data.recurringDepositsAccountTemplate;
    });
  }

  next(): void {
    if (this.selectedTabIndex < this.totalTabs - 1) {
      this.selectedTabIndex += 1;
    }
  }

  prev(): void {
    if (this.selectedTabIndex > 0) {
      this.selectedTabIndex -= 1;
    }
  }

  /**
   * Sets recurring deposits account product template.
   * Also fetches the active CBS base interest rate chart.
   */
  setTemplate($event: any) {
    this.recurringDepositsAccountProductTemplate = $event;
    this.productsService.getFdBaseInterestRates().subscribe({
      next: (rates: any[]) => (this.cbsBaseRates = rates || []),
      error: () => (this.cbsBaseRates = [])
    });
  }

  /** Captures tenure selection from calculator */
  handleTenureSelected($event: any) {
    this.selectedTenureValue = $event.depositPeriod;
    this.selectedTenureFrequencyId = $event.depositPeriodFrequencyId;
    this.selectedDepositAmount = $event.depositAmount;
    this.rdAppliedRate = $event.appliedRate ?? null;
    this.rdIsSeniorCitizen = $event.isSeniorCitizen ?? false;
  }

  /** Get Recurring Deposit Account Details Form Data */
  get recurringDepositAccountDetailsForm() {
    return this.recurringDepositsAccountDetailsStep.recurringDepositAccountDetailsForm;
  }

  /** Retrieves Data of all forms */
  get recurringDepositAccountData() {
    return {
      ...this.recurringDepositsAccountDetailsStep.recurringDepositAccountDetails
    };
  }

  get recurringDepositAccount() {
    return {
      ...this.recurringDepositsAccountDetailsStep.recurringDepositAccountDetails
    };
  }

  get rdTenureDays(): number | null {
    return this.recurringDepositsAccountChartStep?.matchResult?.tenureDays ?? null;
  }

  get rdApplicableSlab(): any | null {
    return this.recurringDepositsAccountChartStep?.matchResult?.slab ?? null;
  }

  get rdMaturityAmount(): number | null {
    return this.recurringDepositsAccountChartStep?.matchResult?.maturityAmount ?? null;
  }

  get rdInterestEarned(): number | null {
    return this.recurringDepositsAccountChartStep?.matchResult?.interestEarned ?? null;
  }

  get rdDaysInYear(): number | null {
    return this.recurringDepositsAccountChartStep?.matchResult?.daysInYear ?? null;
  }

  get submittedOnDate(): Date | null {
    return this.recurringDepositAccountDetailsForm?.value?.submittedOnDate ?? null;
  }

  get rdCurrencyFlags() {
    return {
      autoDebitFacility: this.recurringDepositsAccountCurrencyStep?.autoDebitFacility ?? false
    };
  }

  /**
   * Submits the recurring deposit form to create a new recurring deposit account
   */
  submit() {
    const detailsStep = this.recurringDepositsAccountDetailsStep;
    if (detailsStep.selectedAccountStatus === 'JOINT' && detailsStep.totalJointSharePercentage !== 100) {
      this.alertService.alert({
        type: 'Error',
        message: `Total ownership is ${detailsStep.totalJointSharePercentage}%. It must equal 100% before submitting.`
      });
      return;
    }
    if (
      this.recurringDepositsAccountProductTemplate?.nominationFacility &&
      (this.recurringDepositsAccountCurrencyStep?.nominees ?? []).length === 0
    ) {
      this.alertService.alert({
        type: 'Error',
        message: 'Nomination Facility is enabled for this product. Please add at least one nominee before submitting.'
      });
      return;
    }
    if (this.recurringDepositsAccountProductTemplate?.introducerRequired && !detailsStep?.introducerId) {
      this.alertService.alert({
        type: 'Error',
        message: 'This product requires an introducer. Please choose an existing customer as introducer before submitting.'
      });
      return;
    }
    if (!this.selectedTenureValue || this.selectedTenureFrequencyId === null) {
      this.alertService.alert({
        type: 'Error',
        message: 'Please enter the Deposit Tenure and click "Find Rate" before submitting.'
      });
      return;
    }
    if (!this.selectedDepositAmount || this.selectedDepositAmount <= 0) {
      this.alertService.alert({
        type: 'Error',
        message: 'Please enter the Monthly Installment amount and click "Find Rate" before submitting.'
      });
      return;
    }
    // Same limits the server enforces - checked here so the message names the numbers before anything is sent.
    const minInstallment = Number(this.recurringDepositsAccountProductTemplate?.minDepositAmount) || 0;
    const maxInstallment = Number(this.recurringDepositsAccountProductTemplate?.maxDepositAmount) || 0;
    if (minInstallment > 0 && this.selectedDepositAmount < minInstallment) {
      this.alertService.alert({
        type: 'Error',
        message: `Installment ${this.selectedDepositAmount} is below this product's minimum of ${minInstallment}.`
      });
      return;
    }
    if (maxInstallment > 0 && this.selectedDepositAmount > maxInstallment) {
      this.alertService.alert({
        type: 'Error',
        message: `Installment ${this.selectedDepositAmount} is above this product's maximum of ${maxInstallment}.`
      });
      return;
    }
    if (
      this.recurringDepositsAccountCurrencyStep?.autoDebitFacility &&
      detailsStep?.selectedLinkedAccount?.accountType !== 'SAVINGS'
    ) {
      this.alertService.alert({
        type: 'Error',
        message:
          'Auto Debit collects each installment from the linked account. Link a Savings account under Deposit Account Link, or turn Auto Debit off.'
      });
      return;
    }
    const lienError = this.recurringDepositsAccountCurrencyStep?.lienPercentageError;
    if (lienError) {
      this.alertService.alert({ type: 'Error', message: `Loan against this RD: ${lienError}` });
      return;
    }
    if (!detailsStep?.selectedCustomerSegment) {
      this.alertService.alert({ type: 'Error', message: 'Please select a Customer Segment before submitting.' });
      return;
    }
    const locale = this.settingsService.language.code;
    const dateFormat = this.settingsService.dateFormat;
    const monthDayFormat = 'dd MMMM';
    const pt = this.recurringDepositsAccountProductTemplate;

    const details = this.recurringDepositAccount;
    const currencyStep = this.recurringDepositsAccountCurrencyStep;

    // Terms — pulled from product template
    const terms: any = {};
    if (pt?.nominalAnnualInterestRate != null) terms.nominalAnnualInterestRate = pt.nominalAnnualInterestRate;
    if (pt?.interestCompoundingPeriodType?.id != null)
      terms.interestCompoundingPeriodType = pt.interestCompoundingPeriodType.id;
    if (pt?.interestPostingPeriodType?.id != null) terms.interestPostingPeriodType = pt.interestPostingPeriodType.id;
    if (pt?.interestCalculationType?.id != null) terms.interestCalculationType = pt.interestCalculationType.id;
    if (pt?.interestCalculationDaysInYearType?.id != null)
      terms.interestCalculationDaysInYearType = pt.interestCalculationDaysInYearType.id;

    // Settings — pulled from product template
    const settings: any = {};
    if (pt?.lockinPeriodFrequency != null) settings.lockinPeriodFrequency = pt.lockinPeriodFrequency;
    if (pt?.lockinPeriodFrequencyType?.id != null) settings.lockinPeriodFrequencyType = pt.lockinPeriodFrequencyType.id;
    if (pt?.minDepositTerm != null) settings.minDepositTerm = pt.minDepositTerm;
    if (pt?.minDepositTermType?.id != null) settings.minDepositTermTypeId = pt.minDepositTermType.id;
    if (pt?.inMultiplesOfDepositTerm != null) settings.inMultiplesOfDepositTerm = pt.inMultiplesOfDepositTerm;
    if (pt?.inMultiplesOfDepositTermType?.id != null)
      settings.inMultiplesOfDepositTermTypeId = pt.inMultiplesOfDepositTermType.id;
    if (pt?.maxDepositTerm != null) settings.maxDepositTerm = pt.maxDepositTerm;
    if (pt?.maxDepositTermType?.id != null) settings.maxDepositTermTypeId = pt.maxDepositTermType.id;
    if (pt?.preClosurePenalApplicable != null) settings.preClosurePenalApplicable = pt.preClosurePenalApplicable;
    if (pt?.preClosurePenalInterest != null) settings.preClosurePenalInterest = pt.preClosurePenalInterest;
    if (pt?.preClosurePenalInterestOnType?.id != null)
      settings.preClosurePenalInterestOnTypeId = pt.preClosurePenalInterestOnType.id;
    if (pt?.maturityInstructionId != null) settings.maturityInstructionId = pt.maturityInstructionId;
    if (pt?.transferInterestToSavings != null) settings.transferInterestToSavings = pt.transferInterestToSavings;
    if (pt?.withHoldTax != null) settings.withHoldTax = pt.withHoldTax;

    // Flags and other product defaults
    const productDefaults: any = {
      isCalendarInherited: pt?.isCalendarInherited ?? false,
      isMandatoryDeposit: pt?.isMandatoryDeposit ?? false,
      allowWithdrawal: pt?.allowWithdrawal ?? false,
      // Money paid ahead of a due date counts towards the next installments. Without this an advance cash
      // payment stayed unallocated: the schedule kept showing the installment unpaid, so Auto Debit collected it
      // a second time and the missed-installment penalty charged it. The RD product form has no such option, so
      // the product's value was always false.
      adjustAdvanceTowardsFuturePayments: true,
      autoDebitFacility: currencyStep?.autoDebitFacility ?? pt?.autoDebitFacility ?? false,
      // Lien Marked products only - the server ignores it otherwise and caps it at the product's limit.
      ...(currencyStep?.lienAllowed && currencyStep?.lienPercentage != null
        ? { lienPercentage: Number(currencyStep.lienPercentage) }
        : {})
    };

    // Charges from product template
    const rawCharges: any[] = pt?.charges ?? [];

    const recurringDepositAccount: any = {
      ...details,
      ...terms,
      ...settings,
      ...(this.recurringDepositsAccountMaturityTermsStep?.closureSettings ?? {}),
      ...productDefaults,
      clientId: this.recurringDepositsAccountTemplate.clientId,
      mandatoryRecommendedDepositAmount: pt?.minDepositAmount ?? 0,
      recurringFrequency: pt?.recurringFrequency ?? 1,
      recurringFrequencyType: pt?.recurringFrequencyType ?? 2, // Monthly
      submittedOnDate: this.dateUtils.formatDate(details.submittedOnDate, dateFormat),
      expectedFirstDepositOnDate: this.dateUtils.formatDate(details.expectedFirstDepositOnDate, dateFormat),
      dateFormat,
      monthDayFormat,
      locale,
      charts: [
        {
          chartSlabs:
            pt?.accountChart?.chartSlabs ?? pt?.activeChart?.chartSlabs ?? pt?.interestRateCharts?.[0]?.chartSlabs ?? []
        }
      ],
      charges: rawCharges.map((charge: any) => ({
        chargeId: charge.chargeId ?? charge.id,
        amount: charge.amount,
        dueDate: charge.dueDate && this.dateUtils.formatDate(charge.dueDate, dateFormat),
        feeOnMonthDay: charge.feeOnMonthDay,
        feeInterval: charge.feeInterval
      }))
    };

    // Tenure override from interest rate chart calculator
    if (this.selectedTenureValue && this.selectedTenureFrequencyId !== null) {
      recurringDepositAccount.depositPeriod = this.selectedTenureValue;
      recurringDepositAccount.depositPeriodFrequencyId = this.selectedTenureFrequencyId;
    } else if (this.rdTenureDays) {
      recurringDepositAccount.depositPeriod = this.rdTenureDays;
      recurringDepositAccount.depositPeriodFrequencyId = 0; // Days
    }

    // Amount override from calculator if provided
    if (this.selectedDepositAmount) {
      recurringDepositAccount.mandatoryRecommendedDepositAmount = this.selectedDepositAmount;
    }

    // Senior citizen rate override
    if (this.rdIsSeniorCitizen && this.rdAppliedRate != null && this.rdAppliedRate > 0) {
      recurringDepositAccount.isSeniorCitizen = true;
      recurringDepositAccount.seniorCitizenInterestRate = this.rdAppliedRate;
      recurringDepositAccount.nominalAnnualInterestRate = this.rdAppliedRate;
    }

    const nominees = this.recurringDepositsAccountCurrencyStep?.nominees ?? [];
    if (nominees.length > 0) {
      recurringDepositAccount.nominees = nominees.map((n: any) => ({
        nomineeClientId: n.nomineeClientId,
        nominationType: n.nominationType,
        relationshipId: n.relationshipId,
        percentageShare: n.percentageShare,
        nomineeIsMinor: n.nomineeIsMinor,
        ...(n.guardianClientId ? { guardianClientId: n.guardianClientId } : {}),
        remarks: n.remarks
      }));
    }

    this.recurringDepositsService.createRecurringDepositAccount(recurringDepositAccount).subscribe({
      next: (response: any) => {
        this.router.navigate(
          [
            '../',
            response.resourceId
          ],
          { relativeTo: this.route }
        );
      },
      error: (error: any) => {
        const errorCode =
          error?.error?.errors?.[0]?.userMessageGlobalisationCode ?? error?.error?.userMessageGlobalisationCode;
        if (errorCode === 'error.msg.savings.account.duplicate.product.for.client') {
          this.alertService.alert({
            type: 'Error',
            message:
              'This client already has an active Recurring Deposit account with the selected product. Please choose a different product.'
          });
        } else if (errorCode === 'error.msg.savingsaccount.duplicate.externalId') {
          this.alertService.alert({
            type: 'Error',
            message: 'An account with this External ID already exists. Please use a unique External ID.'
          });
        }
      }
    });
  }
}