import { decode, encode } from "js-base64";

import type { RoomAndCustomerCounterValue } from "@/components/widget/travel-planner/components/customer-group-select/components/room-and-customer-counter";
import type { ICoreSummaryPassenger } from "@/features/core/summary/types/core-summary.types";

export type CacheKeys = "form" | "addons" | "cancellationPolicy";

const localStateCache = {
  getUrlKey: (key: string) => {
    return process?.env?.NODE_ENV === "development"
      ? `state__${key}`
      : `lsc__${key}`; // Local State Cache Key
  },
  set: (key: CacheKeys, value: Record<string, unknown> | Array<unknown>) => {
    const cacheKey = localStateCache.getUrlKey(key);
    const content =
      process?.env?.NODE_ENV === "development"
        ? JSON.stringify(value)
        : encode(JSON.stringify(value));
    localStorage.removeItem(cacheKey);
    localStorage.setItem(cacheKey, content);
  },
  get: (key: CacheKeys) => {
    const cacheKey = localStateCache.getUrlKey(key);
    const value = localStorage.getItem(cacheKey);
    if (!value) return null;
    const content =
      process?.env?.NODE_ENV === "development" ? value : decode(value);
    return JSON.parse(content);
  },
  delete: (key: CacheKeys) => {
    const cacheKey = localStateCache.getUrlKey(key);
    localStorage.removeItem(cacheKey);
  },
};

const commonGeneralFormFields = [
  "kvkk",
  "specialNote",
  "address",
  "birthDate",
  "city",
  "country",
  "email",
  "gender",
  "identity",
  "identityCheck",
  "name",
  "phone",
  "surname",
] as string[];

const commonBillgingFormFields = [
  "billingInfo-address",
  "billingInfo-city",
  "billingInfo-country",
  "billingInfo-email",
  "billingInfo-name",
  "billingInfo-companyTitle",
  "billingInfo-companyTaxOffice",
  "billingInfo-surname",
  "billingInfo-taxNo",
  "billingInfo-tc",
  "billingInfo-tcCheck",
  "billingInfoCompOpen",
  "billingInfo-billing-type",
] as string[];

const hotelFormFields = [
  ...commonGeneralFormFields,
  ...commonBillgingFormFields,
] as string[];
const flightFormFields = [
  ...commonGeneralFormFields,
  ...commonBillgingFormFields,
  "passport",
  "passportDate",
  "passportCountry",
] as string[];

const tourFormFields = [
  ...commonGeneralFormFields,
  ...commonBillgingFormFields,
  "specialServiceRequests",
] as string[];

const transferFormFields = [
  ...commonGeneralFormFields,
  ...commonBillgingFormFields,
  "arrivalInfo-address",
  "arrivalInfo-airlineName",
  "arrivalInfo-arrivalTime",
  "arrivalInfo-departureTime",
  "arrivalInfo-flightDate",
  "arrivalInfo-flightNo",
  "departureInfo-address",
  "departureInfo-airlineName",
  "departureInfo-arrivalTime",
  "departureInfo-departureTime",
  "departureInfo-flightDate",
  "departureInfo-flightNo",
  "invoice-note",
  "request-note",
] as string[];

const rentACarFormFields = [
  ...commonGeneralFormFields,
  ...commonBillgingFormFields,
] as string[];

const localStateCacheTypes = {
  hotelFormFields,
  tourFormFields,
  flightFormFields,
  transferFormFields,
  rentACarFormFields,
};

export const useLocalStateCache = (
  type?: keyof typeof localStateCacheTypes,
  passengersGroups: ICoreSummaryPassenger[][] = [],
) => {
  /**
   * @description return type(defaultValues) is any because of the local state cache values can be any type according to used places.
   * @description this func gets cached values from local storage and returns them for core-summary-form and other distinct structures .
   */
  function getLocalStateCacheValues() {
    const defaultValues: any = {};
    if (!type) return defaultValues;
    if (passengersGroups.length === 0) return defaultValues;

    const localValues = localStateCache.get("form");
    if (localValues) {
      Object.keys(localValues).forEach((key) => {
        const [groupKeyWithRoomIndex, , ...passengerFormItems] = key.split("-");
        const groupKeyArr = groupKeyWithRoomIndex?.split("_");
        const roomIndex = groupKeyArr?.[2];

        // If there is room index, it means that the form item is related to a passenger's field.
        if (!!roomIndex && passengersGroups[+roomIndex]) {
          for (const [, passenger] of passengersGroups[+roomIndex]?.entries() ??
            []) {
            const newPassengerFormItem = `${groupKeyWithRoomIndex}-${passenger.key}-${passenger.type}${passengerFormItems?.[1] ? `-${passengerFormItems?.[1]}` : ""}`;
            // eslint-disable-next-line no-continue
            if (passenger.type !== passengerFormItems?.[0]) continue;
            if (
              typeof defaultValues[newPassengerFormItem] === "undefined" &&
              localStateCacheTypes[type].includes(passengerFormItems?.[1] || "")
            ) {
              defaultValues[newPassengerFormItem] = localValues[key];
              break;
            } else if (
              passenger.type === "employee" &&
              !localStateCacheTypes[type].includes(
                passengerFormItems?.[1] || "",
              ) &&
              defaultValues[newPassengerFormItem] === undefined
            ) {
              defaultValues[newPassengerFormItem] = localValues[key];
              break;
            }
          }
        } else if (
          groupKeyWithRoomIndex &&
          localStateCacheTypes[type].includes(key)
        ) {
          defaultValues[key] = localValues[key];
        }
      });
      return defaultValues;
    }
    return defaultValues;
  }

  /**
   *
   * @description we use this function when user submit travel planner form and we need to set selected employees to local state cache.
   * @description then we can use these values in core-summary-form on coporate mode to set employee info to form as defaultValue.
   *
   * @param roomAndCustomerInfo
   * @param employees
   * @returns
   */
  function setSelectedEmployees(
    roomAndCustomerInfo: RoomAndCustomerCounterValue[],
    employees: {
      name: string;
      value: string;
    }[],
  ) {
    const localValues = localStateCache.get("form");
    if (!localValues) return;
    const regex = /.*-employee/;
    const newLocalValues = Object.keys(localValues)
      .filter((key) => !regex.test(key))
      .reduce(
        (acc, key) => {
          acc[key] = localValues[key];
          return acc;
        },
        {} as Record<string, unknown>,
      );

    const usedPassengerIndexes = [] as number[];

    roomAndCustomerInfo.forEach((roomAndCustomer, roomIndex) => {
      const employeeCount = roomAndCustomer.employee?.count;

      if (!employeeCount) return;

      new Array(employeeCount).fill(0).forEach(() => {
        const newPassengerIndex = employees.findIndex(
          (_, index) => !usedPassengerIndexes.includes(index),
        );

        usedPassengerIndexes.push(newPassengerIndex);

        const newPassengerKey = `group_key_${roomIndex}-employee${newPassengerIndex}-employee`;

        newLocalValues[newPassengerKey] = employees[newPassengerIndex]?.value;
      });
    });

    localStateCache.set("form", newLocalValues);
  }
  return {
    getLocalStateCacheValues,
    setSelectedEmployees,
  };
};

export default localStateCache;