/* eslint-disable react/jsx-no-bind */
import type { PropsWithChildren } from "react";

import Form from "@/components/form/form";
import { DateHelper } from "@/libs/helpers/date-time-helper";
import { useUserInformationsMutation } from "@/services/eva-display/user/user-information.service";
import { useNotifyStore } from "@/store/notify-store/use-notify-store";

import type { ICorePassengerInformation } from "../types/core-summary.types";

export const GROUP_KEY_PREFIX = "group_key"; // it cant include "-" character

interface CoreSummaryProps<PrefixesValues> extends PropsWithChildren {
  defaultValues?: any;
  formItemPrefixes?: string[];
  onSubmit: (values: {
    passengers: Partial<ICorePassengerInformation>[];
    invoiceNote?: string;
    requestNote?: string;
    values?: PrefixesValues;
    paymentCard?: {
      creditCard: string;
      fullname: string;
      cardExpire: string;
      cardCvv: string;
    };
  }) => void;
}

const CoreSummary = <PrefixesValues,>(
  props: CoreSummaryProps<PrefixesValues>,
) => {
  const userInformationsMutation = useUserInformationsMutation();
  const { setNotify } = useNotifyStore();

  async function getPassengersFromForm(values: any) {
    const groups: any = {};

    Object.entries(values)
      .filter(([x]) => x.startsWith(GROUP_KEY_PREFIX))
      .forEach(([key, value]) => {
        const [groupKey, passengerKey, passengerType, passengerField] =
          key.split("-");
        if (!groupKey || !passengerKey || !passengerType) {
          throw new Error("Invalid key");
        }

        if (!groups[groupKey]) {
          groups[groupKey] = [];
        }

        if (passengerType === "employee") {
          groups[groupKey].push({
            key: passengerKey,
            type: passengerType,
            value,
          });
        } else if (passengerType === "guest" || passengerType === "child") {
          if (passengerField) {
            const passengerIndex: any =
              groups[groupKey].findIndex((x: any) => x.key === passengerKey) ??
              {};
            if (passengerIndex === -1) {
              const passenger: any = {
                key: passengerKey,
                type: passengerType,
              };
              passenger[passengerField] = value;
              groups[groupKey].push(passenger);
            } else {
              const passenger = groups[groupKey][passengerIndex];
              passenger[passengerField] = value;
              groups[groupKey][passengerIndex] = passenger;
            }
          }
        }
      });

    const passengerList: any[] = [];

    Object.entries(groups)
      .filter(([key]) => key !== "group_key")
      .forEach(([key, value]: any[]) => {
        value.forEach((passenger: any) => {
          passengerList.push({
            ...passenger,
            groupKey: key,
          });
        });
      });

    const employeeIds = passengerList
      .filter((x) => !!x.value)
      .map((x) => +x.value);
    const employeeInformations = await userInformationsMutation.mutateAsync({
      userIds: employeeIds,
    });

    const usersHasntInformations = employeeIds.filter(
      (x) => !employeeInformations.find((y) => y.userId === x),
    );
    const hasAllUsersInformations = usersHasntInformations.length === 0;
    if (!hasAllUsersInformations) {
      setNotify({
        title: "Uyarı",
        message: "Kullanıcı bilgilerine ulaşılamadı",
        variant: "warning",
      });
      throw new Error("Employee informations not found");
    }

    let employeeIndex = 0;

    const corePassengerInformations: Partial<ICorePassengerInformation>[] =
      passengerList.map((formPassenger, formPassengerIndex) => {
        if (formPassenger.type === "employee") {
          const employeeInformation = employeeInformations[employeeIndex];
          employeeIndex += 1;

          if (!employeeInformation) {
            throw new Error("Employee informations not found");
          }

          return {
            groupKey: formPassenger.groupKey,
            index: formPassengerIndex,
            key: formPassenger.key,
            passengerType: formPassenger.type,
            type: formPassenger.type,
            email: employeeInformation.email,
            phoneNumber: employeeInformation.phoneNumber,
            name: employeeInformation.userDetail.firstName,
            surname: employeeInformation.userDetail.lastName,
            identity: employeeInformation.passaportDetail.citizenNo,
            birthDate: DateHelper.isoStringToFullYearString(
              employeeInformation.userDetail.birthDate,
              ".",
            ),
            gender: employeeInformation.userDetail.gender,
          };
        }

        return {
          birthDate: formPassenger.birthDate,
          email: formPassenger.email,
          gender: formPassenger.gender,
          name: formPassenger.name,
          surname: formPassenger.surname,
          identity: formPassenger.tc,
          groupKey: formPassenger.groupKey,
          index: formPassengerIndex,
          key: formPassenger.key,
          passengerType: formPassenger.type,
          phoneNumber: formPassenger.phone,
          type: formPassenger.type,
        };
      });

    return corePassengerInformations;
  }

  function getPrefixesObjectFromForm(values: any) {
    const result = new Map();
    props.formItemPrefixes?.forEach((prefix) => {
      result.set(prefix, {});
    });

    Object.entries(values).forEach(([key, value]) => {
      const [prefix, fieldName] = key.split("-");
      if (prefix && fieldName) {
        if (result.has(prefix)) {
          result.set(prefix, {
            ...result.get(prefix),
            [fieldName]: value,
          });
        }
      }
    });

    return Object.fromEntries(result);
  }

  async function handleSubmit(values: any) {
    const passengers = await getPassengersFromForm(values);
    const prefixesValues = getPrefixesObjectFromForm(values);
    const paymentCard = values.creditCard
      ? {
          creditCard: values.creditCard,
          fullname: values.fullname,
          cardExpire: values.cardExpire,
          cardCvv: values.cardCvv,
        }
      : undefined;
    props.onSubmit({
      passengers,
      invoiceNote: values["invoice-note"],
      paymentCard,
      requestNote: values["request-note"],
      values: prefixesValues,
    });
  }

  return (
    <div>
      <Form onSubmit={handleSubmit} defaultValues={props.defaultValues}>
        {props.children}
      </Form>
    </div>
  );
};

export { default as CoreSummaryContent } from "./core-summary-content";
export { default as CoreSummaryHeader } from "./core-summary-header";
export { default as CoreSummaryPassengerGroup } from "./core-summary-passenger-group";
export default CoreSummary;