'use client';

import React, { useState, useCallback, useMemo, useEffect } from 'react';
import {
  Dialog,
  DialogTrigger,
  DialogContent,
  DialogTitle,
  DialogDescription,
  DialogClose,
} from '@/components/ui/dialog';
import CommonImage from '@/components/common/CommonImage';
import { Text } from '@/components/ui/text';
import { VisuallyHidden } from '@radix-ui/react-visually-hidden';
import { useForm } from 'react-hook-form';
import { Form } from '@/components/ui/form';
import { z } from 'zod';
import { zodResolver } from '@hookform/resolvers/zod';
import {
  API_ENDPOINTS,
  VC_ASSOCIATE_TYPES,
  VC_COMMISSION_TYPE,
} from '@/constants';
import { useToast } from '@/hooks/use-toast';
import { UnknownRecord } from '@/types';
import { globalApiGet, globalApiPost } from '@/services/global/globalApiCalls';
import { Button } from '@/components/ui/button';
import StepOneInfo from '../form-components/StepOneInfo';
import { getMonthShortName } from '@/utils/formatDate';
import CommissionResponseCards from '../form-components/CommissionResponseCards';
import { getStatus } from './operations';
import { AddCommissionContractProps } from '../../contracts/forms/constants';
import { VCM_M } from '@/constants/typo/submit-alerts';
import { useAppToast } from '@/hooks/useAppToast';

const EnquiryResponse: React.FC<AddCommissionContractProps> = ({
  record,
  triggerIcon,
  bucket,
  handlePaginatedRecords,
}) => {
  const { toast } = useToast();
  const { showSuccess, showError } = useAppToast();
  const [dialogKey, setDialogKey] = useState(0);
  const [isOpen, setIsOpen] = useState(false);
  const [nextStepValues, setNextStepValues] = useState<UnknownRecord[]>([]);
  const [eligibleCases, setEligibleCases] = useState<UnknownRecord[]>([]);
  const [reasons, setReasons] = useState<UnknownRecord[]>([]);
  const [isFormInitialized, setIsFormInitialized] = useState(false);
  const [existingCommissionAmount, setExistingCommissionAmount] = useState<
    any[]
  >([]);
  const [totalCommission, setTotalCommission] = useState<string | number>('');
  const [isLoading, setIsLoading] = useState(false);

  const [differenceReasons, setDifferenceReasons] = useState<UnknownRecord[]>(
    [],
  );

  const EditCommissionEnquirySchema =
    bucket?.crud?.edit.schema.validatorResponse;

  const responses = useMemo(() => {
    if (!isFormInitialized || eligibleCases.length === 0) return [];
    return eligibleCases.map((rec) => String(rec.response || ''));
  }, [eligibleCases, isFormInitialized]);

  const getDefaultValues = useCallback(() => {
    return {
      associate_id: String(record?.associate_id ?? ''),
      currency: String(record?.currency ?? ''),
      net_amount: String(record?.net_amount ?? ''),
      items: record?.items ?? [],
      visa_service_country_id: String(record?.visa_service_country_id ?? ''),
      institute_id: String(record?.institute_id ?? ''),
      client_from_country_id: String(record?.client_from_country_id ?? ''),
      intake_id: String(record?.intake_id ?? ''),
      applicable_on_id: String(record?.applicable_on_id ?? ''),
      contract_set_id: String(record?.contract_set_id ?? ''),
      commission_instance_id: String(record?.commission_instance ?? ''),
      invoice_branch_id: String(record?.invoice_branch_id ?? ''),
      invoice_bank_account_id: String(record?.invoice_bank_account_id ?? ''),
      ma_commission_type: String(record?.ma_commission_type ?? ''),
      ma_commission_percentage: String(record?.ma_commission_percentage ?? ''),
      ma_commission_amount: String(record?.ma_commission_amount ?? ''),
    };
  }, [record]);

  const form = useForm<z.infer<typeof EditCommissionEnquirySchema>>({
    resolver: zodResolver(EditCommissionEnquirySchema),
    defaultValues: getDefaultValues(),
  });

  const {
    control,
    formState: { isSubmitting, errors },
    getValues,
    setError,
    clearErrors,
    setValue,
    reset,
  } = form;

  const enquiryType = useMemo(
    () => bucket?.additional_info?.contract_type,
    [bucket],
  );

  const enquiryTypeLabel = useMemo(
    () => (enquiryType ? VC_ASSOCIATE_TYPES[enquiryType as string] : ''),
    [enquiryType],
  );

  useEffect(() => {
    if (eligibleCases.length > 0 && !isFormInitialized && !isLoading) {
      const initialItems = eligibleCases.map((rec, index) => {
        const visaCaseId = String(rec.visa_case_id ?? rec.id);

        const sameCaseRecords = eligibleCases.filter(
          (r) => String(r.visa_case_id ?? r.id) === visaCaseId,
        );

        const initialItem = {
          response: rec.response || '',
          commission_date:
            rec.commission_date && rec.response ? rec.commission_date : '',
          difference: rec.difference || '',
          difference_reason: rec.difference_reason || '',
          remarks: rec.remarks || '',
          response_reason: rec.response_reason || '',
          response_reason_id: rec.response_reason_id || '',
          difference_reason_id: rec.difference_reason_id || '',

          // Commission data
          tuition_fees: rec.tuition_fees || '0',
          commission_type: rec.commission_type || '1',
          commission_percentage: rec.commission_percentage || '0',
          commission_amount: rec.commission_amount || '0',
          tuition_fees_currency: rec.tuition_fees_currency || 'USD',
          commission_currency: rec.commission_currency || 'USD',
          ma_commission_type: rec.ma_commission_type || '1',
          ma_commission_percentage: String(rec.ma_commission_percentage) || '0',
          ma_commission_amount: String(rec.ma_commission_amount) || '0',

          // Student data
          case_uid: rec.case_uid,
          course_end_date: rec.course_end_date,
          course_start_date: rec.course_start_date,
          fname: rec.fname,
          lname: rec.lname,
          student_uid: rec.student_uid,
          visa_result_on: rec.visa_result_on,
          visa_status: rec.visa_status,
          id: rec.main_id ?? rec.id,
          visa_case_id: visaCaseId,
          modified_by_user: String(rec.modified_by_user ?? ''),
          is_revised: rec.response === '' ? '1' : '0',

          // Grouping metadata
          group_index: sameCaseRecords.findIndex(
            (r) => r.main_id === rec.main_id || r.id === rec.id,
          ),
          group_total: sameCaseRecords.length,
          group_id: visaCaseId,
        };

        return initialItem;
      });

      let commissionAmount = 0;

      // Reset existing commission amounts
      setExistingCommissionAmount([]);

      initialItems.forEach((item: any, index) => {
        const amount = parseFloat(item.commission_amount) || 0;
        commissionAmount += amount;

        setExistingCommissionAmount((prev) => ({
          ...prev,
          [index]: item,
        }));

        Object.keys(item).forEach((key) => {
          setValue(`items.${index}.${key}`, item[key]);
        });
      });

      commissionAmount = parseFloat(commissionAmount.toFixed(2));
      // setValue(`received.total_amount`, String(commissionAmount));
      setTotalCommission(commissionAmount);

      setIsFormInitialized(true);
    }
  }, [eligibleCases, isFormInitialized, setValue, isLoading]);

  const handleDialogOpen = async () => {
    try {
      const details = await globalApiPost(
        API_ENDPOINTS.VC_ENQUIRY.DETAILS_BY_ID,
        { id: String(record?.id), association_type: enquiryType },
      );

      setEligibleCases(Array.isArray(details) ? details : []);

      const diffReasons = (await globalApiGet(
        API_ENDPOINTS.VC_ENQUIRY.DIFFERENCE_REASONS,
      )) as { list?: UnknownRecord[] };

      setDifferenceReasons(
        Array.isArray(diffReasons.list) ? diffReasons.list : [],
      );
    } catch (error) {
      console.error('Error fetching details:', error);
      setEligibleCases([]);
    }
  };

  const handleOpenChange = async (open: boolean) => {
    setIsOpen(open);
    if (open) {
      setIsLoading(true);

      // Reset ALL states completely
      setDialogKey((prev) => prev + 1);
      setEligibleCases([]);
      setReasons([]);
      setNextStepValues([]);
      setExistingCommissionAmount([]);
      setTotalCommission('');
      setIsFormInitialized(false);
      reset(getDefaultValues());

      try {
        await handleDialogOpen();

        const set: UnknownRecord = await globalApiGet(
          `${API_ENDPOINTS.VCM.CONTRACT_SET_DETAILS_BY_ID}/${record?.contract_set_id}`,
        );

        const applicableOn: UnknownRecord = await globalApiPost(
          `${API_ENDPOINTS.VCM.CONTRACT_APPLICABLE_ON_BY_ID}`,
          { id: String(record?.applicable_on_id), type: '2' },
        );

        let applicableOnIndex = 0;
        if (applicableOn && record?.applicable_on_id) {
          applicableOnIndex = applicableOn.findIndex(
            (item: { id: number | string }) =>
              String(item.id) === String(record?.applicable_on_id),
          );
        }

        const baseValues = [
          { title: 'Client Country', value: record?.client_country?.name },
          { title: 'Visa Service Country', value: record?.visa_country?.name },
          {
            title: 'Institute',
            value: `${record?.institute?.institueName} (${record?.institute?.UID})`,
          },
          {
            title: 'Intake',
            value: `${getMonthShortName(
              record?.intake?.intakemonth,
              false,
            )}-${record?.intake?.intakeyear}`,
          },
          {
            title: 'Applicable On',
            value: `Applicable On Set - ${applicableOnIndex + 1}`,
          },
          { title: 'Contract Set', value: `${set?.set_name}` },
          {
            title: 'Commission Instance',
            value: `Instance ${record?.instance?.instance}`,
          },
          { title: 'Invoice Branch', value: record?.branch?.center_name },
          {
            title: 'Invoice Bank Account',
            value: `${record?.bank?.acc_number} - ${record?.bank?.bank_name}, ${record?.bank?.company_bank_address}`,
          },
        ];

        if (Number(enquiryType) === 2) {
          baseValues.splice(2, 0, {
            title: 'Associate',
            value:
              `${record?.associate?.masteragentName} (${record?.associate?.uid})` ||
              'N/A',
          });
        }

        const commissionType = Number(record?.ma_commission_type);

        const commissionTypeObj = VC_COMMISSION_TYPE.find(
          (item) => item.id === commissionType,
        );

        let maCommissionField: any[] = [];

        if (commissionType === 1) {
          maCommissionField = [
            {
              title: '(MA) Commission Amount',
              value: record?.ma_commission_amount ?? 'N/A',
            },
          ];
        } else if (commissionType === 2) {
          maCommissionField = [
            {
              title: '(MA) Commission Percentage',
              value: record?.ma_commission_percentage
                ? `${record.ma_commission_percentage}%`
                : 'N/A',
            },
          ];
        }

        const finalValues =
          Number(enquiryType) === 2
            ? [
                ...baseValues,
                {
                  title: '(MA) Commission Type',
                  value: commissionTypeObj?.label || 'N/A',
                },
                ...maCommissionField,
              ]
            : baseValues;

        setNextStepValues(finalValues);

        const responseReasons = (await globalApiGet(
          API_ENDPOINTS.VC_ENQUIRY.RESPONSE_REASONS,
        )) as { list?: UnknownRecord[] };

        setReasons(
          Array.isArray(responseReasons.list) ? responseReasons.list : [],
        );
      } catch (error) {
        console.error('Error loading dialog data:', error);
        toast({
          variant: 'destructive',
          title: 'Failed to load dialog data',
          duration: 2000,
        });
      } finally {
        setIsLoading(false);
      }
    } else {
      // Clean up when closing
      setIsFormInitialized(false);
      setEligibleCases([]);
      setNextStepValues([]);
      setReasons([]);
      setExistingCommissionAmount([]);
      setTotalCommission('');
    }
  };

  const getMasterAgentCommissionValues = useCallback(
    (items: UnknownRecord[]) => {
      const firstItem = items[0] ?? {};

      return {
        ma_commission_type: String(
          firstItem.ma_commission_type ?? getValues('ma_commission_type') ?? '',
        ),
        ma_commission_percentage: String(
          firstItem.ma_commission_percentage ??
            getValues('ma_commission_percentage') ??
            '',
        ),
        ma_commission_amount: String(
          firstItem.ma_commission_amount ??
            getValues('ma_commission_amount') ??
            '',
        ),
      };
    },
    [getValues],
  );

  const onSubmit = useCallback(
    async (data: z.infer<typeof EditCommissionEnquirySchema>) => {
      try {
        const latestFormValues = getValues();
        const items = latestFormValues.items || [];

        if (items.length === 0) {
          toast({
            variant: 'destructive',
            title: 'No commission items to submit.',
            duration: 2000,
          });
          return;
        }

        for (let i = 0; i < items.length; i++) {
          const item = items[i];

          if (String(item.is_revised) === '1') {
            const commissionDate = item.commission_date;
            if (!commissionDate) {
              setError(`items.${i}.commission_date`, {
                type: 'manual',
                message: 'Commission Date is required.',
              });
              return;
            }

            const dateRegex =
              /^(0[1-9]|[12][0-9]|3[01])\/(0[1-9]|1[0-2])\/\d{4}$/;

            if (!dateRegex.test(commissionDate)) {
              setError(`items.${i}.commission_date`, {
                type: 'manual',
                message: 'Commission Date must be in DD/MM/YYYY format.',
              });
              return;
            }

            const [day, month, year] = commissionDate.split('/').map(Number);

            const enteredDate = new Date(year, month - 1, day);

            if (
              enteredDate.getDate() !== day ||
              enteredDate.getMonth() !== month - 1 ||
              enteredDate.getFullYear() !== year
            ) {
              setError(`items.${i}.commission_date`, {
                type: 'manual',
                message: 'Invalid Commission Date.',
              });
              return;
            }

            const currentYear = new Date().getFullYear();

            if (year < currentYear - 1 || year > currentYear) {
              setError(`items.${i}.commission_date`, {
                type: 'manual',
                message: `Commission Date year must be between ${currentYear - 1} and ${currentYear}.`,
              });
              return;
            }

            enteredDate.setHours(0, 0, 0, 0);

            const today = new Date();
            today.setHours(0, 0, 0, 0);

            if (enteredDate > today) {
              setError(`items.${i}.commission_date`, {
                type: 'manual',
                message: 'Commission Date cannot be a future date.',
              });
              return;
            }

            if (String(item.response) === '2') {
              if (
                !item.difference_reason_id ||
                String(item.difference_reason_id).trim() === ''
              ) {
                setError(`items.${i}.difference_reason_id`, {
                  type: 'manual',
                  message: 'Difference Reason is required.',
                });
                return;
              }

              if (!item.remarks || String(item.remarks).trim() === '') {
                setError(`items.${i}.remarks`, {
                  type: 'manual',
                  message: 'Remarks is required.',
                });
                return;
              }
            }
          }
        }

        let netAmount = 0;
        const responseSet: string[] = [];

        // Step 1: Group last item by case_uid
        const lastMap: Record<string, any> = {};

        items.forEach((item: any) => {
          lastMap[item.case_uid] = item; // overwrite → keeps last
          responseSet.push(String(item.response || ''));
        });

        // Step 2: Calculate netAmount using last items only
        Object.values(lastMap).forEach((item: any) => {
          if (item.response == 1) {
            netAmount += parseFloat(item.commission_amount) || 0;
          }
        });

        netAmount = parseFloat(netAmount.toFixed(2));
        netAmount = parseFloat(netAmount.toFixed(2));

        let submissionData = {
          ...latestFormValues,
          id: String(record?.id ?? ''),
          association_type: enquiryType,
          currency:
            items[0]?.tuition_fees_currency ||
            items[0]?.commission_currency ||
            'USD',
          net_amount: String(netAmount),
          accept_status: getStatus(responseSet),
          ...(enquiryType === '2' ? getMasterAgentCommissionValues(items) : {}),
          items: items.map((item: any) => ({
            ...item,
            tuition_fees: String(item.tuition_fees || '0'),
            commission_type: String(item.commission_type || '1'),
            commission_amount: String(item.commission_amount || '0'),
            commission_percentage: String(item.commission_percentage || '0'),
            response: String(item.response || ''),
            commission_date: String(item.commission_date)
              ? String(item.commission_date)
              : '',
          })),
        };

        if (enquiryType === '1') {
          delete submissionData.associate_id;
          delete submissionData.ma_commission_type;
          delete submissionData.ma_commission_percentage;
          delete submissionData.ma_commission_amount;
        }

        const res = await globalApiPost(
          API_ENDPOINTS.VC_ENQUIRY.ADD_RESPONSE,
          submissionData,
          false,
        );

        if ((res as any).success) {
          handlePaginatedRecords(1, {});
          form.reset();
          setIsOpen(false);
          showSuccess(VCM_M.ENQUIRY.RESPONSE_SUBMIT);
        } else {
          showError((res as any).errors, VCM_M.ENQUIRY.RESPONSE_SUBMIT_ERROR);
        }
      } catch (error) {
        console.error('Submission error:', error);
        showError(error, VCM_M.ENQUIRY.RESPONSE_SUBMIT_ERROR);
      }
    },
    [
      getValues,
      handlePaginatedRecords,
      toast,
      record?.id,
      responses,
      getMasterAgentCommissionValues,
    ],
  );

  const getDialogTitle = () => {
    if (!isFormInitialized || responses.length === 0) {
      return `Commission Enquiry Response - ${enquiryTypeLabel}`;
    }

    const hasEmptyResponses = responses.includes('');
    const hasRejectedResponses = responses.includes('2');

    if (!hasEmptyResponses && !hasRejectedResponses) {
      return `Commission Received - ${enquiryTypeLabel}`;
    }

    return `Commission Enquiry Response - ${enquiryTypeLabel}`;
  };

  return (
    <Dialog open={isOpen} onOpenChange={handleOpenChange}>
      <DialogTrigger asChild>
        {triggerIcon || (
          <Button className="button-action">
            <CommonImage
              src={'/main/Activate.png'}
              width={15}
              height={15}
              alt={'Enquiry Response'}
              classname="info-icon"
            />
          </Button>
        )}
      </DialogTrigger>

      <DialogContent
        key={dialogKey}
        className="modal-common-widget w-full max-w-7xl p-0 m-0 table-modal-settings state-widget"
        onInteractOutside={(e) => e.preventDefault()}
        onEscapeKeyDown={(e) => e.preventDefault()}
        onClick={(e) => e.stopPropagation()}
      >
        <DialogTitle className="p-5 modal-header">
          {getDialogTitle()}
        </DialogTitle>
        <DialogDescription>{''}</DialogDescription>
        <DialogClose asChild>
          <button
            onClick={() => setIsOpen(false)}
            className="dialog-close absolute right-4 top-4 rounded-sm opacity-70 transition-opacity hover:opacity-100 focus:outline-none z-[9]"
            aria-label="Close"
          >
            <CommonImage
              src="/main/cross-arrow.webp"
              width={15}
              height={15}
              alt="Close"
              classname="dialog-close-img"
            />
          </button>
        </DialogClose>
        <VisuallyHidden>
          <DialogTitle>Hidden Title</DialogTitle>
        </VisuallyHidden>

        {isLoading ? (
          <div className="flex justify-center items-center p-8">
            <Text>Loading commission data...</Text>
          </div>
        ) : (
          <Form {...form}>
            <form
              onSubmit={form.handleSubmit(onSubmit, (errors) => {
                console.log('Validation failed:', errors);
              })}
            >
              <Text className="main-scroll-widget">
                <div className="flex justify-between items-center">
                  <h6 className="font-semibold ml-6">
                    Record Commission Enquiry Response
                  </h6>
                </div>
                <Text className="flex flex-wrap p-2 form-mid mt-0">
                  <StepOneInfo titles={nextStepValues} />
                  {isFormInitialized && eligibleCases.length > 0 && (
                    <CommissionResponseCards
                      instanceSelected={{}}
                      control={control}
                      records={eligibleCases}
                      reasons={reasons}
                      setValue={setValue}
                      existingCommissionAmount={existingCommissionAmount}
                      totalCommission={totalCommission}
                      responses={responses}
                      setError={setError}
                      clearErrors={clearErrors}
                      differenceReasons={differenceReasons}
                      isReceived={false}
                      enquiryType={enquiryType as string}
                    />
                  )}
                </Text>
              </Text>
              {responses?.includes('') && (
                <div className="modal-footer flex justify-end items-end footer-modal text-right gap-2 m-0 pr-4 p-2">
                  <Button
                    type="submit"
                    disabled={isSubmitting}
                    className="m-0 filter-search-btn tracking-wider w-40 primary-button"
                  >
                    {isSubmitting && (
                      <span className="h-4 w-4 animate-spin rounded-full border-2 border-white border-t-transparent" />
                    )}
                    {isSubmitting ? 'Submitting...' : 'Submit'}
                  </Button>
                </div>
              )}
            </form>
          </Form>
        )}
      </DialogContent>
    </Dialog>
  );
};

export default EnquiryResponse;