import React, { useEffect, useRef, useState } from 'react';
import { Modal, Form, Input, notification } from 'antd';
import MasterEmployees from '@/components/masterDropdowns/MasterEmployees';
import { addLaunchSales, updateLaunchSales } from '../service';
import type { ModalBoxProps } from '../interface';
import { useDispatch, useSelector } from 'react-redux';
import { type AppDispatch, type RootState } from '@/store/store';
import { addLaunchTeam, editLaunchTeam } from '../slice';
import { leadsValidator } from '@/utills/validator';
import { DataType } from '@/app/designations/interface';
import { fetchRoles } from '@/app/role/slice';
import { getRoleIdMap } from '@/utills/helper';
import { useRoles } from '@/hooks/useRoles';
type GetFieldValue = (name: string) => string | undefined;

const TeamAddModal: React.FC<ModalBoxProps> = ({
  isModalOpen,
  handleClose,
  handleOk,
  data,
  id,
  storeData,
  check,
  setStoreData,
  teamHeadId,
  reporting_manager_id,
  initialValues,
}) => {
  const dispatch: AppDispatch = useDispatch();

  const [form] = Form.useForm();
  const preSalesRef = useRef<any>(null);
  const fieSalesRef = useRef<any>(null);
  const [preSalesUser, setPreSalesUser] = useState<{ value: number; label: string }>({ value: 0, label: '' });
  const [fieldSalesUser, setFieldSalesUser] = useState<{ value: number; label: string }>({ value: 0, label: '' });
  const [roleFilters] = useState<any>({
      page: 1,
      sortColumn: 'sort_order',
    });
  const { launch_sales, launchDetailsre } = useSelector((state: RootState) => ({
    launch_sales: state?.launches?.launchesId?.launch_sales || [],
    launchDetailsre: state?.launches?.launchesId,
  }));
  const modalTitle = data === null ? 'Add New Pair' : 'Edit Pair';
  const [isPreSalesSelected, setIsPreSalesSelected] = useState(false);
  const { roles } = useSelector((state: RootState) => state.roles);
  // Derive manager ids from the new managers array (role_name keyed),
  // falling back to the flat cluster_manager_id / team_lead_id fields the API returns.
  const managersMap: Record<string, number> = (launchDetailsre?.managers ?? []).reduce(
    (acc: Record<string, number>, m: { role_name: string; user_id: number }) => {
      acc[`${m.role_name}_id`] = Number(m.user_id);
      return acc;
    },
    {}
  );

  const clusterId = managersMap.cluster_manager_id || launchDetailsre?.cluster_manager_id;
  const leadId = managersMap.team_lead_id || launchDetailsre?.team_lead_id;

  useEffect(() => {
    if(roles?.length === 0) {
      dispatch(fetchRoles(roleFilters));
    }
  }, [roles, dispatch, roleFilters]);

  let allRoles = getRoleIdMap(roles);
  const { getRoleByName } = useRoles();
  useEffect(() => {
    setIsPreSalesSelected(!!form.getFieldValue('pre_sales_id'));
  }, [form]);

  useEffect(() => {
    if (
      data !== null &&
            typeof data === 'object' &&
            'pre_sales_id' in data &&
            'pre_sales_leads' in data &&
            'field_sales_id' in data &&
            'field_sales_leads' in data
    ) {
      // Edit mode: populate form with existing record
      form.setFieldsValue({
        field_sales_id: data?.field_sales_id,
        field_sales_leads: data?.field_sales_leads,
      });
      if (data?.pre_sales_id && data?.pre_sales_id != 0) {
        form.setFieldsValue({
          pre_sales_id: data?.pre_sales_id,
          pre_sales_leads: data?.pre_sales_leads,
        });
      }
      setIsPreSalesSelected(!!data.pre_sales_id && data.pre_sales_id !== 0);
    } else if (data === null && (initialValues?.pre_sales_id || initialValues?.field_sales_id)) {
      // Add New mode: pre-populate from outside-selected Pre/Field Sales dropdowns
      form.resetFields();
      if (initialValues.pre_sales_id) {
        form.setFieldsValue({
          pre_sales_id: initialValues.pre_sales_id,
          pre_sales_leads: initialValues.pre_sales_leads ?? undefined,
        });
        setIsPreSalesSelected(true);
        setPreSalesUser({ value: initialValues.pre_sales_id, label: initialValues.pre_sales_name || '' });
      }
      if (initialValues.field_sales_id) {
        form.setFieldsValue({
          field_sales_id: initialValues.field_sales_id,
          field_sales_leads: initialValues.field_sales_leads ?? undefined,
        });
        setFieldSalesUser({ value: initialValues.field_sales_id, label: initialValues.field_sales_name || '' });
      }
    } else {
      form.resetFields();
    }
  // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [data, form, initialValues?.pre_sales_id, initialValues?.field_sales_id]);

  const onFinish = async(values: DataType): Promise<void> => {
    try {
      const teamPairs = check === 'edit' ? storeData.launch_sales : launch_sales;
      // const checkIsFieldDuplicate =
      //           teamPairs?.filter((item: { id: number; field_sales_id: string | number | boolean | symbol | object | null | undefined; }) => {
      //             if (data !== null) {
      //               return data?.id != item.id && item.field_sales_id == values.field_sales_id;
      //             } else {
      //               return item.field_sales_id == values.field_sales_id;
      //             }
      //           }) || [];
      const checkIsPairDuplicate =
                teamPairs?.filter((item: { id: number; pre_sales_id: string | number | boolean | symbol | object | null | undefined; field_sales_id: string | number | boolean | symbol | object | null | undefined; }) => {
                  if (data !== null) {
                    return (
                      data?.id != item.id &&
                            item.pre_sales_id == values.pre_sales_id &&
                            item.field_sales_id == values.field_sales_id
                    );
                  } else {
                    return (
                      item.pre_sales_id == values.pre_sales_id &&
                            item.field_sales_id == values.field_sales_id
                    );
                  }
                }) || [];
      // if (checkIsFieldDuplicate?.length > 0) {
      //   Modal.error({
      //     title: 'Duplicate Field Sales',
      //     content: <>This field sales has already been added to the list below.</>,
      //   });
      //   return;
      // }

      if (checkIsPairDuplicate?.length > 0) {
        Modal.error({
          title: 'Duplicate Pair',
          content: <>This pair is already added to the list below.</>,
        });
        return;
      }
      const payload = {
        launch_id: id,
        field_sales_id: values.field_sales_id,
        field_sales_leads: values.field_sales_leads,
        pre_sales_id: values.pre_sales_id || 0,
        pre_sales_leads: values.pre_sales_leads || 0,
      };

      if (data !== null) {
        await updateLaunchSales(data?.id, payload)
          .then((response) => {
            notification.success({
              message: 'Success',
              description: response?.message,
            });

            dispatch(editLaunchTeam({ ...response?.data }));
            form.resetFields();
            handleOk();
          })
          .catch((error) => {
            notification.error({
              message: 'Error',
              description: error?.response?.data?.message,
            });
          });
      } else {
        if (id !== undefined && id !== null) {
          await addLaunchSales(payload)
            .then((response) => {
              notification.success({
                message: 'Success',
                description: response?.message,
              });
              if (check === 'edit') {
                setStoreData({
                  ...storeData,
                  launch_sales: [...(storeData.launch_sales || []), response.data],
                });
              } else {
                dispatch(addLaunchTeam(response.data));
              }
              form.resetFields();
              setPreSalesUser({ value: 0, label: '' });
              setFieldSalesUser({ value: 0, label: '' });
              handleOk();
            })
            .catch((error) => {
              notification.error({
                message: 'Error',
                description: error?.response?.data?.message,
              });
            });
        } else {
          // Create mode: no launch id yet, store pair locally
          setStoreData({
            ...storeData,
            launch_sales: [
              ...(storeData.launch_sales || []),
              {
                pre_sales_id: Number(values.pre_sales_id) || 0,
                pre_sales_name: preSalesUser.label,
                pre_sales_leads: Number(values.pre_sales_leads) || null,
                field_sales_id: Number(values.field_sales_id),
                field_sales_name: fieldSalesUser.label,
                field_sales_leads: Number(values.field_sales_leads),
              },
            ],
          });
          form.resetFields();
          setPreSalesUser({ value: 0, label: '' });
          setFieldSalesUser({ value: 0, label: '' });
          handleOk();
        }
      }
    } catch (error) {
      console.error('Error adding sales:', error);
    }
  };

  const preSalesIsRequiredValidator = ({ getFieldValue }: { getFieldValue: GetFieldValue }) => ({
    validator(_: unknown, value: string | undefined) {
      const preSalesLeads = getFieldValue('pre_sales_leads');
      if (preSalesLeads && !value) {
        return Promise.reject(new Error('Please Select a Pre Sales'));
      }
      return Promise.resolve();
    },
  });
  const preSalesFilter =
        check === 'edit'
          ? {
            role_id: getRoleByName('pre_sales')?.id,
            city_id: storeData?.city_id,
            reporting_manager_id: reporting_manager_id ? `${reporting_manager_id}` : undefined,
            status: 'active',
          }
          : {
            role_id: getRoleByName('pre_sales')?.id,
            city_id: launchDetailsre?.city_id,
            reporting_manager_id: [clusterId, leadId].filter(id => id && id !== 0).join(', ') || undefined,
            status: 'active',
          };
  const fieldSalesFilter =
        check === 'edit'
          ? {
            role_id: `${getRoleByName('field_sales')?.id}, ${getRoleByName('team_lead')?.id}`,
            city_id: storeData?.city_id,
            reporting_manager_id: reporting_manager_id ? `${reporting_manager_id}` : undefined,
            status: 'active',
          }
          : {
            role_id: `${getRoleByName('field_sales')?.id}, ${getRoleByName('team_lead')?.id}`,
            city_id: launchDetailsre?.city_id,
            reporting_manager_id: [clusterId, leadId].filter(id => id && id !== 0).join(', ') || undefined,
            status: 'active',
          };

  return (
    <Modal
      title={modalTitle}
      open={isModalOpen}
      onOk={() => {
        form.submit();
      }}
      okText={data !== null ? 'Update' : 'Save'}
      onCancel={() => {
        form.resetFields();
        setPreSalesUser({ value: 0, label: '' });
        setFieldSalesUser({ value: 0, label: '' });
        handleClose();
      }}
      className="custom-new-modal">
      <Form
        form={form}
        onFinish={onFinish}
        colon={false}
        labelCol={{ span: 8 }}
        wrapperCol={{ span: 16 }}>
        <MasterEmployees
          forwardRef={preSalesRef}
          label="Pre sales"
          name="pre_sales_id"
          placeholder="Select User"
          filter={preSalesFilter}
          defaultOption={
            initialValues?.pre_sales_id
              ? { value: initialValues.pre_sales_id, label: initialValues.pre_sales_name || '' }
              : null
          }
          onSelect={(value) => {
            setIsPreSalesSelected(!!value);
            form.setFieldsValue({ pre_sales_id: value });
          }}
          onChange={(value, items: any) => {
            setIsPreSalesSelected(!!value);
            form.setFieldsValue({ preSalesUserName: items });
            if (items) setPreSalesUser({ label: items.label ?? '', value: Number(items.value) });
          }}
          rules={[preSalesIsRequiredValidator]}
          onClear={() => {
            form.setFieldsValue({ pre_sales_leads: null });
          }}
        />
        <Form.Item
          name="pre_sales_leads"
          label="Leads (Pre-Sales)"
          rules={[
            ({ getFieldValue }) => ({
              async validator(_: unknown, value: string | undefined) {
                if (
                  getFieldValue('pre_sales_id') !== undefined &&
                getFieldValue('pre_sales_id') !== null
                ) {
                  if (value === undefined || value === null || value === '') {
                    return Promise.reject(new Error('Please Enter Pre Sales Leads'));
                  }

                  // Convert value to string for validation
                  const valueString = String(value);

                  // Check if the value contains only digits
                  if (!/^\d+$/.test(valueString)) {
                    return Promise.reject(new Error('Please enter a valid number. No letters or symbols allowed.'));
                  }

                  // Check if the number has more than 2 digits
                  if (valueString.length > 2) {
                    return Promise.reject(new Error('Maximum 2 Digits Allowed'));
                  }
                }

                return Promise.resolve();
              },
            }),
          ]}
        >
          <Input placeholder="Enter Pre Sales Lead" disabled={!isPreSalesSelected} />
        </Form.Item>
        <MasterEmployees
          forwardRef={fieSalesRef}
          label="Field sales"
          name="field_sales_id"
          placeholder="Select User"
          defaultOption={
            initialValues?.field_sales_id
              ? { value: initialValues.field_sales_id, label: initialValues.field_sales_name || '' }
              : null
          }
          onSelect={(value) => {
            form.setFieldsValue({ field_sales_id: value });
          }}
          onChange={(value, items: any) => {
            if (items) setFieldSalesUser({ label: items.label ?? '', value: Number(items.value) });
          }}
          rules={[{ required: true, message: 'Please Select Field Sales' }]}
          filter={fieldSalesFilter}
          onClear={() => {
            form.setFieldsValue({ field_sales_leads: null });
            setFieldSalesUser({ value: 0, label: '' });
          }}
          localExclude={(data: { id: number; role_id: number }[]) =>
            check == 'edit'
              ? teamHeadId
                ? data.filter(
                    (d) =>
                      d.role_id != getRoleByName('team_lead')?.id ||
                      Number(teamHeadId) == d.id
                  )
                : data
              : leadId
                ? data.filter(
                    (d) =>
                      d.role_id !== getRoleByName('team_lead')?.id ||
                      Number(leadId) === d.id
                  )
                : data
          }
        />
        <Form.Item
          name="field_sales_leads"
          label="Leads (Field Sales)"
          rules={[
            {
              required: true,
              validator: leadsValidator,
            },
          ]}>
          <Input placeholder="Enter Field Sales Lead" />
        </Form.Item>
      </Form>
    </Modal>
  );
};

export default TeamAddModal;