/**
 * 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, OnInit, Input, Output, EventEmitter, inject, ChangeDetectorRef } from '@angular/core';
import { UntypedFormGroup, UntypedFormBuilder, Validators } from '@angular/forms';
import { SettingsService } from 'app/settings/settings.service';
import { Dates } from 'app/core/utils/dates';

/** Custom Services */
import { RecurringDepositsService } from '../../recurring-deposits.service';
import { MatTooltip } from '@angular/material/tooltip';
import { MatStepperPrevious, MatStepperNext } from '@angular/material/stepper';
import { FaIconComponent } from '@fortawesome/angular-fontawesome';
import { STANDALONE_SHARED_IMPORTS } from 'app/standalone-shared.module';
import { IntroducerSearchComponent } from 'app/shared/introducer-search/introducer-search.component';

/**
 * Recurring Deposits Account Details Step
 */
@Component({
  selector: 'mifosx-recurring-deposits-account-details-step',
  templateUrl: './recurring-deposits-account-details-step.component.html',
  styleUrls: ['./recurring-deposits-account-details-step.component.scss'],
  imports: [
    ...STANDALONE_SHARED_IMPORTS,
    MatTooltip,
    MatStepperPrevious,
    FaIconComponent,
    MatStepperNext,
    IntroducerSearchComponent
  ]
})
export class RecurringDepositsAccountDetailsStepComponent implements OnInit {
  private formBuilder = inject(UntypedFormBuilder);
  private recurringDepositsService = inject(RecurringDepositsService);
  private settingsService = inject(SettingsService);
  private dateUtils = inject(Dates);
  private cdr = inject(ChangeDetectorRef);

  /** Recurring Deposits Account Template */
  @Input() recurringDepositsAccountTemplate: any;

  /** Minimum date allowed. */
  minDate = new Date(2000, 0, 1);
  /** Maximum date allowed. */
  maxDate = new Date();
  /** Product Data */
  productData: any;
  /** Field Officer Data */
  fieldOfficerData: any;
  /** For edit recurring deposits form */
  isFieldOfficerPatched = false;
  /** Recurring Deposits Account Details Form */
  recurringDepositAccountDetailsForm!: UntypedFormGroup;

  isProductSelected = false;
  introducerId: number | null = null;
  introducerName: string | null = null;
  introducerCif: string | null = null;

  /** Recurring Deposits Account Template with product data  */
  @Output() recurringDepositsAccountProductTemplate = new EventEmitter();

  /** Local copy of product template for displaying classification info */
  productTemplate: any = null;

  constructor() {
    this.createRecurringDepositsAccountDetailsForm();
  }

  ngOnInit() {
    this.maxDate = this.settingsService.businessDate;
    this.buildDependencies();
    if (this.recurringDepositsAccountTemplate) {
      this.productData = this.recurringDepositsAccountTemplate.productOptions;
      if (this.recurringDepositsAccountTemplate.depositProductId) {
        // Edit mode: patch from saved data
        this.recurringDepositAccountDetailsForm.patchValue({
          productId: this.recurringDepositsAccountTemplate.depositProductId,
          submittedOnDate:
            this.recurringDepositsAccountTemplate.timeline.submittedOnDate &&
            new Date(this.recurringDepositsAccountTemplate.timeline.submittedOnDate),
          externalId: this.recurringDepositsAccountTemplate.externalId
        });
      } else {
        // New account: default submittedOnDate to today's business date
        this.recurringDepositAccountDetailsForm.patchValue({
          submittedOnDate: this.settingsService.businessDate
        });
      }
    }
  }

  /**
   * Creates recurring deposits account details form.
   */
  createRecurringDepositsAccountDetailsForm() {
    this.recurringDepositAccountDetailsForm = this.formBuilder.group({
      productId: [
        '',
        Validators.required
      ],
      submittedOnDate: [
        '',
        Validators.required
      ],
      fieldOfficerId: [''],
      externalId: [''],
      balanceSwapOption: [false],
      msme: [false],
      autoDebitFacility: [false]
    });
  }

  /**
   * Fetches recurring deposits account product template on productId value changes
   */
  buildDependencies() {
    const clientId = this.recurringDepositsAccountTemplate.clientId;
    this.recurringDepositAccountDetailsForm.get('productId')!.valueChanges.subscribe((productId: string) => {
      this.recurringDepositsService
        .getRecurringDepositsAccountTemplate(clientId, productId)
        .subscribe((response: any) => {
          // Ensure currency is included in the product template
          if (!response.currency) {
            // Try to get currency from the selected product
            const selectedProduct = this.recurringDepositsAccountTemplate.productOptions?.find(
              (product: any) => product.id == productId
            );
            if (selectedProduct?.currency) {
              response.currency = selectedProduct.currency;
            } else if (this.recurringDepositsAccountTemplate.currency) {
              response.currency = this.recurringDepositsAccountTemplate.currency;
            }
          }
          this.productTemplate = response;
          this.recurringDepositsAccountProductTemplate.emit(response);
          this.fieldOfficerData = response.fieldOfficerOptions;
          this.isProductSelected = true;
          // Pre-populate toggles from product defaults (user can override)
          this.recurringDepositAccountDetailsForm.patchValue({
            balanceSwapOption: !!response.balanceSwapOption,
            msme: !!response.msme,
            autoDebitFacility: !!response.autoDebitFacility
          });
          this.cdr.detectChanges();
          if (!this.isFieldOfficerPatched && this.recurringDepositsAccountTemplate.fieldOfficerId) {
            this.recurringDepositAccountDetailsForm
              .get('fieldOfficerId')!
              .patchValue(this.recurringDepositsAccountTemplate.fieldOfficerId);
            this.isFieldOfficerPatched = true;
          } else {
            this.recurringDepositAccountDetailsForm.get('fieldOfficerId')!.patchValue('');
          }
        });
    });
  }

  /**
   * Returns true if a value is not null, undefined, or empty string.
   */
  hasValue(val: any): boolean {
    return val !== null && val !== undefined && val !== '';
  }

  /**
   * Formats template dates into the current CBS date format.
   * Handles backend date arrays like [2026, 4, 20] as well as strings and Date objects.
   */
  formatTemplateDate(value: any): string {
    if (!value) {
      return '';
    }

    let dateValue: Date | null = null;

    if (value instanceof Date) {
      dateValue = value;
    } else if (Array.isArray(value) && value.length >= 3) {
      dateValue = new Date(value[0], value[1] - 1, value[2]);
    } else {
      dateValue = new Date(value);
    }

    if (!dateValue || Number.isNaN(dateValue.getTime())) {
      return Array.isArray(value) ? value.join('/') : String(value);
    }

    return this.dateUtils.formatDate(dateValue, 'M/d/yyyy') || '';
  }

  /**
   * Returns recurring deposits account details form value.
   */
  onIntroducerChange(event: { clientId: number; displayName: string; cifNumber?: string } | null): void {
    this.introducerId = event?.clientId ?? null;
    this.introducerName = event?.displayName ?? null;
    this.introducerCif = event?.cifNumber ?? null;
  }

  get recurringDepositAccountDetails() {
    const value = this.recurringDepositAccountDetailsForm.value;
    if (this.introducerId) {
      value.introducerId = this.introducerId;
      value.introducerName = this.introducerName;
      value.introducerCif = this.introducerCif;
    }
    return value;
  }
}