"use client";

import { useEffect, useMemo, useRef, useState } from "react";
import InputItem from "@/app/Components/FormItems";
import PageHead from "@/app/Components/PageHead";
import { Modal, Table } from "antd";
import { apiGetLimit, frontEndUrl } from "@/app/utils/variables";
import { parseArrayField } from "@/app/utils/parseArrayField";
import {
  usePathname,
  useRouter,
  useParams,
  useSearchParams,
} from "next/navigation";

import { useSiteContext } from "@/app/Context/SiteContext";

import DocumentPDF from "@/app/Components/PDF/DocumentPDF";
import QuotationForm from "@/app/Components/Forms/QuotationForm";
import ProformaForm from "@/app/Components/Forms/ProformaForm";
import InvoiceForm from "@/app/Components/Forms/InvoiceForm";
import InventoryForm from "@/app/Components/Forms/InventoryForm";
import UnitForm from "@/app/Components/Forms/UnitForm";
import CustomerForm from "@/app/Components/Forms/CustomerForm";
import LeadForm from "@/app/Components/Forms/LeadForm";
import SupplierForm from "@/app/Components/Forms/SupplierForm";
import PurchaseForm from "@/app/Components/Forms/PurchaseForm";
import UserForm from "@/app/Components/Forms/UserForm";
import { requiredFields } from "@/app/utils/requiredFields";
import RoleForm from "./Forms/RoleForm";
import DeliveryNoteForm from "./Forms/DeliveryNoteForm";
import { AlertMessage } from "./AlertMessage";
import { checkStock } from "../utils/checkStock";
import { getDefaultForm } from "../utils/formFields";
import ExpenseForm from "./Forms/ExpenceForm";
import PrivilegeActions, {
  hasModuleActionPermission,
} from "../utils/auth/PrivilegeActions";
import SupplierPaymentForm from "./Forms/SupplierPayment";
import { formatTime } from "../utils/formattedDateWithTime";
import PurchaseOrderForm from "./Forms/PurchaseOrderForm";
import FormActionButtons from "./FormActionButtons";
import { handleRecordStatus } from "../utils/handleRecordStatus";
import { advanceSumPayAndBalance } from "../utils/advanceSumPayAndBalance";
import SalesReturnForm from "./Forms/SalesReturnForm";
import { buildDocFileName } from "../utils/buildDocFileName";
import CustomerPaymentForm from "@/app/Components/Forms/CustomerPaymentForm";
import { formatCleanText } from "../utils/formatCleanText";
import { calculateGrandTotal } from "../utils/calculateGrandTotal";
import { getDiscountAmounts } from "../utils/getDiscountAmounts";
import { isHaveSettingsPage } from "../utils/isHaveSettingsPage";
import PurchaseReturnForm from "./Forms/PurchaseReturnForm";
import { useQuery, useQueryClient } from "@tanstack/react-query";
import SalesOrderForm from "./Forms/SalesOrderForm";
import { getTaxById } from "../utils/getTaxById";

const fetcher = async (url) => {
  const res = await fetch(url);
  if (!res.ok) throw new Error("API Error");
  return res.json();
};

export default function AddEdit({ mode: propMode }) {
  const pathname = usePathname();
  const { id } = useParams();
  const router = useRouter();
  const searchParams = useSearchParams();
  const typeForMode = pathname.split("/")[2] || "quote";

  // Determine mode
  const isEditMode = propMode
    ? propMode === "edit"
    : pathname.includes("/edit");

  const typeFor = pathname.split("/")[1] || "quote";
  const chekLeadIsActive = searchParams.get("lead") === "true";

  const {
    activeCurrency,
    setActiveCurrency,
    lineItems,
    newTax,
    setLineItems,
    selectedCustomer,
    setSelectedCustomer,
    formActionLoading,
    setCurrentDiscountPercentage,
    setCurrentDiscountAmount,
    previewModal,
    setPreviewModal,
    activeCustomers,
    serials,
    // leadData,
    //settings,
    paymentInvoices,
    brandData,
    customerRelatedData,
    showStockErrorModal,
    setShowStockErrorModal,
    customMessage,
    setProceed,
    draftId,
    lineProfit,
    setLineProfit,
    selectedSupplierCurrency,
    recurringInvoice,
    paymentBalance,
    currentSession,
    selectedSupplier,
    sendingOptions,
    refundAmount,
    setCloseQuote,
    uploadStatus,
    paymentPurchases,
    purchaseId,
    useCustomerWalletAmount,
    totalAmountPayabale,
    usedSerials,
    serialNumberErros,
    selectedWalletTotal,
    payingAmount,
    remainingAmount,
    usedWalletItemForPay,
    useAmountForWallet,
    reversalAmount,
    paidProformas,
  } = useSiteContext();

  const [leadData, setLeadData] = useState([]);
  const [currentTax, setCurrentTax] = useState("");



  const pdfRef = useRef(null);

  // const [isInitialized, setIsInitialized] = useState(false);
  const currency = activeCurrency;

  const queryClient = useQueryClient();

  /* ===============================
     RECORD (EDIT MODE)
  ================================ */
  const recordApiUrl = isEditMode
    ? `/api/${typeFor}?${typeFor}_id=${id}`
    : null;

  const { data: recordData, isPending: recordLoading } = useQuery({
    queryKey: ["record", typeFor, id],
    queryFn: () => fetcher(recordApiUrl),
    enabled: !!recordApiUrl,
  });

  const mutateRecord = () =>
    queryClient.invalidateQueries(["record", typeFor, id]);

  /* ===============================
     CUSTOMERS
  ================================ */
  const { data: getCustomers } = useQuery({
    queryKey: ["customer", apiGetLimit],
    queryFn: () => fetcher(`/api/customer?limit=${apiGetLimit}`),
  });

  const mutateCustomers = () => queryClient.invalidateQueries(["customer"]);

  /* ===============================
     SETTINGS (DYNAMIC)
  ================================ */
  const settingsUrl =
    typeFor === "supplier"
      ? "/api/purchase_settings"
      : typeFor === "customerpayment" || typeFor === "supplierpayment"
        ? "/api/payment_settings"
        : isHaveSettingsPage(typeFor)
          ? `/api/${typeFor}_settings`
          : typeFor === "purchaseorder"
            ? "/api/purchase_settings"
            : null;

  const { data: getSettings } = useQuery({
    queryKey: ["settings", typeFor],
    queryFn: () => fetcher(settingsUrl),
    enabled: !!settingsUrl,
  });



  const mutateSettings = () =>
    queryClient.invalidateQueries(["settings", typeFor]);

  /* ===============================
     GLOBAL SETTINGS
  ================================ */
  const { data: getEmailSetting } = useQuery({
    queryKey: ["email_settings"],
    queryFn: () => fetcher("/api/email_settings"),
  });

  const { data: getBrandSetting } = useQuery({
    queryKey: ["brand_settings"],
    queryFn: () => fetcher("/api/brand_settings"),
  });

  /* ===============================
     LIST HELPERS
  ================================ */
  const listQuery = (key, url) =>
    useQuery({
      queryKey: [key, apiGetLimit],
      queryFn: () => fetcher(url),
    });

  /* ===============================
     DOCUMENT LISTS
  ================================ */
  const { data: getQuotes } = listQuery(
    "quote",
    `/api/quote?limit=${apiGetLimit}`,
  );
  const mutateQuotes = () => queryClient.invalidateQueries(["quote"]);

  const { data: getSalesOrder } = listQuery(
    "salesorder",
    `/api/salesorder?limit=${apiGetLimit}`,
  );
  const mutateSalesOrder = () => queryClient.invalidateQueries(["salesorder"]);

  const { data: getInvoices } = listQuery(
    "invoice",
    `/api/invoice?limit=${apiGetLimit}`,
  );
  const mutateInvoices = () => queryClient.invalidateQueries(["invoice"]);

  const { data: getSupplier } = listQuery(
    "supplier",
    `/api/supplier?limit=${apiGetLimit}`,
  );
  const mutateSuppliers = () => queryClient.invalidateQueries(["supplier"]);

  const { data: getProforma } = listQuery(
    "proforma",
    `/api/proforma?limit=${apiGetLimit}`,
  );
  const mutateProforma = () => queryClient.invalidateQueries(["proforma"]);

  const { data: getInventory } = listQuery(
    "inventory",
    `/api/inventory?limit=${apiGetLimit}`,
  );
  const mutateInventory = () => queryClient.invalidateQueries(["inventory"]);

  const { data: getDeliveryNote } = listQuery(
    "deliverynote",
    `/api/deliverynote?limit=${apiGetLimit}`,
  );
  const mutateDeliveryNote = () =>
    queryClient.invalidateQueries(["deliverynote"]);

  const { data: getPayments } = listQuery(
    "customerpayment",
    `/api/customerpayment?limit=${apiGetLimit}`,
  );
  const mutatePayment = () =>
    queryClient.invalidateQueries(["customerpayment"]);

  const { data: getSupplierPayment } = listQuery(
    "supplierpayment",
    `/api/supplierpayment?limit=${apiGetLimit}`,
  );
  const mutateSupplierPayment = () =>
    queryClient.invalidateQueries(["supplierpayment"]);

  const { data: getPurchases } = listQuery(
    "purchase",
    `/api/purchase?limit=${apiGetLimit}`,
  );
  const mutatePurchase = () => queryClient.invalidateQueries(["purchase"]);

  const { data: getPurchasesOrder } = listQuery(
    "purchaseorder",
    `/api/purchaseorder?limit=${apiGetLimit}`,
  );
  const mutatePurchaseOrder = () =>
    queryClient.invalidateQueries(["purchaseorder"]);

  const { data: getExpenses } = listQuery(
    "expense",
    `/api/expense?limit=${apiGetLimit}`,
  );
  const mutateExpenses = () => queryClient.invalidateQueries(["expense"]);

  const { data: getRole } = listQuery("role", `/api/role?limit=${apiGetLimit}`);
  const mutateRole = () => queryClient.invalidateQueries(["role"]);

  const { data: getBankTransations } = listQuery(
    "bank_transaction",
    `/api/transation_bank?limit=${apiGetLimit}`,
  );
  const mutateBankTransations = () =>
    queryClient.invalidateQueries(["bank_transaction"]);

  const { data: getSalesReturn } = listQuery(
    "salesreturn",
    `/api/salesreturn?limit=${apiGetLimit}`,
  );
  const mutateSalesReturn = () =>
    queryClient.invalidateQueries(["salesreturn"]);

  const { data: getPurchaseReturn } = listQuery(
    "purchasereturn",
    `/api/purchasereturn?limit=${apiGetLimit}`,
  );
  const mutatePurchaseReturn = () =>
    queryClient.invalidateQueries(["purchasereturn"]);

  const record = recordData?.[typeFor];

  const allQuotes = getQuotes?.quote;
  const allSalesOrder = getSalesOrder?.salesorder;
  const allProforma = getProforma?.proforma;
  const allDeliveryNote = getDeliveryNote?.deliverynote;
  const brandSettings = getBrandSetting?.settings?.[0];
  const emailSettings = getEmailSetting?.settings?.[0];
  const allInvoices = getInvoices?.invoice;
  const allPayments = getPayments?.customerpayment;
  const suppliers = getSupplier?.supplier;
  const inventory = getInventory?.inventory;
  const customers = getCustomers?.customer;
  const allPurchases = getPurchases?.purchase;
  const allPurchasesOrder = getPurchasesOrder?.purchaseorder;
  const allExpenses = getExpenses?.expense;
  const allRoles = getRole?.role;
  const settings = getSettings?.settings[0];
  const allSupplierPayment = getSupplierPayment?.supplierpayment;
  const allBankTransations = getBankTransations?.records;
  const allSalesreturn = getSalesReturn?.salesreturn;
  const allPurchaseReturn = getPurchaseReturn?.purchasereturn;




  const parseToISO = (dateString) => {
    if (!dateString || typeof dateString !== "string") return null;

    dateString = dateString.trim();

    // Normalize separators -> space
    const normalized = dateString
      .replace(/[.,/-]/g, " ")
      .replace(/\s+/g, " ")
      .trim();

    let parts = normalized.split(" ");

    const months = {
      january: 0,
      february: 1,
      march: 2,
      april: 3,
      may: 4,
      june: 5,
      july: 6,
      august: 7,
      september: 8,
      october: 9,
      november: 10,
      december: 11,
    };

    // If first part is weekday name — remove it
    if (
      parts.length > 0 &&
      isNaN(parts[0]) &&
      !(parts[0].toLowerCase() in months)
    ) {
      parts.shift();
    }

    if (parts.length < 3) return null;

    let day, month, year;

    const isMonth0 = parts[0] && months[parts[0].toLowerCase()] !== undefined;
    const isMonth1 = parts[1] && months[parts[1].toLowerCase()] !== undefined;

    //  Text month formats
    if (isMonth0 || isMonth1) {
      if (isMonth0) {
        // e.g. "September 17 2025"
        month = months[parts[0].toLowerCase()];
        day = Number(parts[1]);
        year = Number(parts[2]);
      } else {
        // e.g. "17 September 2025"
        day = Number(parts[0]);
        month = months[parts[1].toLowerCase()];
        year = Number(parts[2]);
      }
    }
    //  Numeric formats
    else {
      const [p0, p1, p2] = parts;
      if (!p0 || !p1 || !p2) return null;

      if (p0.length === 4) {
        year = Number(p0);
        month = Number(p1) - 1;
        day = Number(p2);
      } else if (p2.length === 4) {
        if (Number(p0) <= 31 && Number(p1) <= 12) {
          day = Number(p0);
          month = Number(p1) - 1;
          year = Number(p2);
        } else {
          month = Number(p0) - 1;
          day = Number(p1);
          year = Number(p2);
        }
      } else return null;
    }

    if (
      isNaN(year) ||
      isNaN(month) ||
      isNaN(day) ||
      year < 1000 ||
      month < 0 ||
      month > 11 ||
      day < 1 ||
      day > 31
    )
      return null;

    const date = new Date(Date.UTC(year, month, day));
    if (isNaN(date.getTime())) return null;

    return date.toISOString();
  };

  const getLastCode = (dataArray, typeFor, settings = {}, varData = []) => {
    if (!dataArray || !typeFor) return;

    // Dynamically assign values from varData or fallback to settings
    const [
      prefix = settings.prefix || "",
      paddingStr = settings.padding ?? "0",
      startFromStr = settings.startFrom ?? "1",
    ] = varData;

    const padding = parseInt(paddingStr, 10);
    const startFrom = parseInt(startFromStr, 10);
    const numberKey = `${typeFor}_number`;

    // If no data, return starting code
    if (!Array.isArray(dataArray) || dataArray.length === 0) {
      return `${prefix}-${String(startFrom).padStart(padding, "0")}`;
    }

    const codes = dataArray
      .map((item) => item?.[numberKey])
      .filter(
        (code) => typeof code === "string" && code.startsWith(`${prefix}-`),
      )
      .map((code) => {
        const num = parseInt(code.replace(`${prefix}-`, ""), 10);
        return { code, num: isNaN(num) ? 0 : num };
      });

    if (codes.length === 0) {
      return `${prefix}-${String(startFrom).padStart(padding, "0")}`;
    }

    const latest = codes.reduce((a, b) => (a.num > b.num ? a : b));
    const nextNum = latest.num + 1;

    return `${prefix}-${String(nextNum).padStart(padding, "0")}`;
  };

  const suppliersName =
    (suppliers &&
      suppliers.map((q) => ({
        id: q.supplier_id,
        name: q.name,
        currency: q.currency,
        contact_persons: parseArrayField(q.contact_persons),
        email: q.email,

        contact_number: q?.contact_number,
        address_line: q?.address_line,
        website: q?.website,
        tax_number: q?.tax_number,
        supplier_type: q?.supplier_type,
        supplier_docs: q?.supplier_docs,
      }))) ||
    [];

  const allData = {
    invoice: allInvoices,
    quote: allQuotes,
    salesorder: allSalesOrder,
    proforma: allProforma,
    deliverynote: allDeliveryNote,
    customerpayment: allPayments,
    purchase: allPurchases,
    purchaseorder: getPurchasesOrder,
    expense: allExpenses,
    role: allRoles,
    supplierpayment: allSupplierPayment,
    supplier: suppliers,
    inventory: inventory,
    salesreturn: allSalesreturn,
    purchasereturn: allPurchaseReturn,
  };

  const now = new Date();
  const time = now.toLocaleTimeString("en-GB");

  useEffect(() => {
    if (typeof window !== "undefined") {
      setLeadData(parseArrayField(sessionStorage.getItem("leadData")));
    }
  }, []);

  // useEffect(() => {
  //   if (typeof window !== "undefined") {
  //     sessionStorage.removeItem("leadData");
  //     setLeadData([]);
  //   }
  // }, [pathname]);

  const checkLastCode = useMemo(() => {
    const dataArray = allData[typeFor];

    // Dynamic array — you can change order or add more values
    return getLastCode(
      typeFor === "purchaseorder" ? dataArray?.purchaseorder : dataArray,
      typeFor,
      settings,
      typeFor === "supplierpayment"
        ? [
          settings?.paymentPrefix,
          settings?.paymentPadding,
          settings?.paymentStartFrom,
        ]
        : typeFor === "purchaseorder"
          ? [settings?.po_prefix, settings?.po_padding, settings?.po_startFrom]
          : typeFor === "supplier"
            ? [
              settings?.prefixSupplier,
              settings?.paddingSupplier,
              settings?.startFromSupplier,
            ]
            : [settings?.prefix, settings?.padding, settings?.startFrom],
    );
  }, [allData, typeFor, settings, router]);

  const formatDateForInput = (dateString) => {
    if (!dateString) return "";
    try {
      const date = new Date(dateString);
      return date.toISOString().split("T")[0];
    } catch {
      return "";
    }
  };

  function isBalanceZero(balanceAmount) {
    if (!balanceAmount) return false;
    const cleanBalance = balanceAmount.toString().replace(/[^\d.]/g, "");
    return parseFloat(cleanBalance) === 0;
  }

  const getLastId = (dataArray, typeFor, startFrom = 1) => {
    if (!Array.isArray(dataArray) || dataArray.length === 0) {
      return startFrom;
    }

    // Dynamically detect the ID key — supports patterns like "inventory_id", "id", etc.
    const possibleKeys = [
      `${typeFor}_id`,
      "id",
      `${typeFor}Id`,
      `${typeFor}ID`,
    ];

    const idKey =
      possibleKeys.find((key) => key in dataArray[0]) || `${typeFor}_id`;

    const ids = dataArray
      .map((item) => parseInt(item?.[idKey], 10))
      .filter((id) => !isNaN(id));

    if (ids.length === 0) {
      return startFrom;
    }

    const latestId = Math.max(...ids);
    return latestId + 1;
  };

  //GET LATS ID
  const nextId = getLastId(allData[typeFor], typeFor);

  //GET LAST BANK TRANSATION ID

  const nextBankTranstionId = getLastId(allBankTransations, false);

  useEffect(() => {
    if (checkLastCode && !isEditMode) {
      setForm((prevForm) => ({
        ...prevForm,
        itemNumber: checkLastCode,
      }));
    }
  }, [checkLastCode, isEditMode]);

  const [form, setForm] = useState(() => {
    const defaultForm = getDefaultForm(
      typeFor,
      settings,
      chekLeadIsActive,
      leadData,
      checkLastCode,
    );

    //   // If in edit mode and record exists, merge record data into default form
    if (isEditMode && record) {
      return {
        ...defaultForm,
        ...record,
        contact_persons: parseArrayField(record.contact_persons),
        inventory_price: record.price, //parseInventoryPrices(record.price),
        buying_price: record.buying_price, //parseInventoryPrices(record.buying_price),
        attachments: record.attachments !== "false",
        //  itemNumber: record[`${typeFor}_number`] || "",
        // Format date fields individually
        quote_date:
          formatDateForInput(record.quote_date) || defaultForm.quote_date,
        invoice_date:
          formatDateForInput(record.invoice_date) || defaultForm.invoice_date,
        proforma_date:
          formatDateForInput(record.proforma_date) || defaultForm.proforma_date,
        purchase_date:
          formatDateForInput(record.purchase_date) || defaultForm.purchase_date,
        purchaseorder_date:
          formatDateForInput(record.purchaseorder_date) ||
          defaultForm.purchaseorder_date,
        payment_date:
          formatDateForInput(record.payment_date) || defaultForm.payment_date,
        cheque_date:
          formatDateForInput(record.cheque_date) || defaultForm.cheque_date,
        updated_line_items: record?.updated_line_items || [],
      };
    }

    return {
      ...defaultForm,
      // itemNumber: checkLastCode || "",
    };
  });

  useEffect(() => {
    if (!isEditMode || !record) return;

    const defaultForm = getDefaultForm(
      typeFor,
      settings,
      chekLeadIsActive,
      leadData,
    );

    const updatedForm = {
      ...defaultForm,
      ...record,
      contact_persons: parseArrayField(record.contact_persons),
      inventory_price: record?.price, //parseInventoryPrices(record.price),
      buying_price: record?.buying_price, // parseInventoryPrices(record.buying_price),
      attachments: record.attachments !== "false",
      itemNumber: record[`${typeFor}_number`] || "",
      stock: record?.stock || 0,
      quote_date:
        formatDateForInput(record.quote_date) || defaultForm.quote_date,
      invoice_date:
        formatDateForInput(record.invoice_date) || defaultForm.invoice_date,
      proforma_date:
        formatDateForInput(record.proforma_date) || defaultForm.proforma_date,
      purchase_date:
        formatDateForInput(record.purchase_date) || defaultForm.purchase_date,
      purchaseorder_date:
        formatDateForInput(record.purchaseorder_date) ||
        defaultForm.purchaseorder_date,
      payment_date:
        formatDateForInput(record.payment_date) || defaultForm.payment_date,
      cheque_date:
        formatDateForInput(record.cheque_date) || defaultForm.cheque_date,
    };

    setForm(updatedForm);
    // setIsInitialized(true); // Ensure this happens once
  }, [record, isEditMode]);

  useEffect(() => {
    if (isEditMode && record) {
      const defaultForm = getDefaultForm(
        typeFor,
        settings,
        chekLeadIsActive,
        leadData,
      );

      let updatedForm = {
        ...defaultForm,
        ...record,
        contact_persons: parseArrayField(record.contact_persons),
        inventory_price: record.price, //parseInventoryPrices(record.price),
        buying_price: record.buying_price, //parseInventoryPrices(record.buying_price),
        supplier_name: record?.supplierpayment_name,
        attachments: record.attachments !== "false",
        itemNumber: record[`${typeFor}_number`] || "",
        stock: record?.stock || 0,

        // Format dates properly
        quote_date:
          formatDateForInput(record.quote_date) || defaultForm.quote_date,
        invoice_date:
          formatDateForInput(record.invoice_date) || defaultForm.invoice_date,
        proforma_date:
          formatDateForInput(record.proforma_date) || defaultForm.proforma_date,
        purchase_date:
          formatDateForInput(record.purchase_date) || defaultForm.purchase_date,
        purchaseorder_date:
          formatDateForInput(record.purchaseorder_date) ||
          defaultForm.purchaseorder_date,
        payment_date:
          formatDateForInput(record.payment_date) || defaultForm.payment_date,
        cheque_date:
          formatDateForInput(record.cheque_date) || defaultForm.cheque_date,
      };

      // Handle roles specifically
      if (typeFor === "role") {
        let parsedPrivileges = [];

        if (record.privileges) {
          if (Array.isArray(record.privileges)) {
            parsedPrivileges = record.privileges;
          } else if (typeof record.privileges === "string") {
            try {
              parsedPrivileges = JSON.parse(record.privileges);
            } catch (e) {
              console.error("Error parsing privileges:", e);
              parsedPrivileges = [];
            }
          } else if (typeof record.privileges === "object") {
            parsedPrivileges = record.privileges;
          }
        }

        updatedForm = {
          ...updatedForm,
          role_name: record.role_name || "",
          //   status: record.status || "Active",
          privileges: parsedPrivileges,
        };
      }

      setForm(updatedForm);

      // Set line items from record
      try {
        const items =
          typeof record.line_items === "string"
            ? JSON.parse(record.line_items)
            : record.line_items || [];
        setLineItems(items);
      } catch {
        setLineItems([]);
      }

      // Set selected customer
      if (record.customer_name && customers) {
        const customer = customers.find(
          (c) =>
            c.display_name === record.customer_name ||
            c.customer_code === record.customer_name ||
            c.company_name === record.customer_name ||
            c.customer_id === record.customer_id,
        );
        if (customer) {
          setSelectedCustomer(customer);
        }
      }

      //  setIsInitialized(true);
    }
  }, [
    isEditMode,
    record,
    customers,
    typeFor,
    settings,
    chekLeadIsActive,
    leadData,
    // isInitialized,
  ]);



  const { finalDate, docFile } = buildDocFileName({
    typeFor,
    form,
  });





  useEffect(() => {
    let totalProfit = 0;

    // Ensure lineItems is always an array
    const items = Array.isArray(lineItems) ? lineItems : [];

    items.forEach((item) => {
      const price = parseFloat(item?.price) || 0;
      const buyingPrice = parseFloat(item?.buying_price) || 0;
      const qty = parseFloat(item?.qty) || 1;

      let discount = 0;

      if (item?.discountPercentage) {
        discount = (price * item.discountPercentage) / 100;
      } else if (item?.discountAmount) {
        discount = parseFloat(item.discountAmount) || 0;
      }

      const sellingPriceAfterDiscount = price - discount;

      const taxRate = parseFloat(


        getTaxById(
          newTax || selectedCustomer?.customer_tax,
          brandData?.global_tax
        )?.value




      ) || 0;


      const tax = (sellingPriceAfterDiscount * qty * taxRate) / 100;

      setCurrentTax(tax)


      const profitPerItem =
        (sellingPriceAfterDiscount - buyingPrice) * qty - tax;

      totalProfit += profitPerItem;
    });

    setLineProfit(totalProfit.toFixed(2));
  }, [lineItems, brandSettings?.global_tax]);

  const formatDocs = (form, location = "customer_docs") => {
    if (!form || !Array.isArray(form?.[location])) return [];

    return form[location].map((doc) => {
      const file = doc?.docFile?.[0] || {};
      return {
        docName: doc?.docName || "",
        docExpiryDate: doc?.docExpiryDate || "",
        uploadedPath: doc?.uploadedPath || "",
        uploadedName: doc?.uploadedName || "",
        size: file?.size || doc?.size || null,
        type: file?.type || doc?.type || "",
      };
    });
  };

  const getFormData = (status = "Draft") => {
    const typeKey = typeFor;
    const subtotal = calculateGrandTotal(
      lineItems,
      form.discount,
      form.discount_global,
      null,
      null,
      brandSettings && brandSettings?.global_tax,
    );
    const discountAmount = getDiscountAmounts(
      lineItems,
      form.discount,
      form.discount_global,
      null,
      null,
      null,
      brandSettings && brandSettings?.global_tax,
    );
    const grandTotal = calculateGrandTotal(
      lineItems,
      form.discount,
      form.discount_global,
      null,
      null,
      brandSettings && brandSettings?.global_tax,
    );

    const toNumber = (val) => {
      if (typeof val === "number") return val;
      if (!val) return 0;
      return parseFloat(String(val).replace(/[^\d.-]/g, "")) || 0;
    };


    const base = {
      ...(isEditMode && {
        [`${typeKey}_id`]: record?.[`${typeKey}_id`],
        updated_time:
          form.updated_time || formatTime(brandData?.time_zone, time) || "",
        updated_username:
          form.updated_username || currentSession?.user?.username || "",
        created_time:
          form.created_time || formatTime(brandData?.time_zone, time) || "",
        created_username:
          form.created_username || currentSession?.user?.username || "",
        created_by:
          currentSession?.user?.id || "",
        assigned_to: "",
        //  created_at:   new Date() ||  "",
        // updated_at: new Date() || "",
      }),
      [`${typeKey}_number`]: form.itemNumber || "",
      customer_info: form.customer_info || "",
      customer_name: form.customer_name || selectedCustomer?.display_name || "",
      supplier_name: form.supplier_name || "",
      customer_id: form?.customer_id || selectedCustomer?.customer_id || "",
      currency: currency || form.currency || "",
      notes: form.notes || "",
      created_by:
        currentSession?.user?.id || "",
      assigned_to: `[*]`,
      status: JSON.stringify(
        isEditMode
          ? (form?.status ??
            record?.status ??
            handleRecordStatus(typeFor, form?.status ?? record?.status))
          : handleRecordStatus(typeFor, form?.status ?? record?.status),
      ),

      //    status:
      // typeFor === "customer" ||
      // typeFor === "unit" ||
      // typeFor === "inventory" ||
      // typeFor === "supplier"
      //   ? JSON.stringify(getStatusById(12))
      //   : typeFor === "lead"
      //   ? JSON.stringify(getStatusById(14))
      //   : JSON.stringify(
      //       isEditMode
      //         ? form.status
      //         : handleRecordStatus(
      //             typeFor,
      //             form?.status || record?.status
      //           )
      //     ),

      doc: docFile ? `doc/${typeKey}/${docFile}` : null,

      ...(!isEditMode && {
        // created_at: new Date() || "",
        // updated_at:  "fgfdgdfgdfgdfgdfgdfgfdg",
        created_time:
          form.created_time || formatTime(brandData?.time_zone, time) || "",
        created_username:
          form.created_username || currentSession?.user?.username || "",
      }),
    };

    if (typeKey === "user") {
      const userData = {
        ...base,
        avatar: form.avatar || "",
        full_name: form.full_name,
        username: form.username,
        email: form.email,
        designation: form.designation,
        mobile_number: form.mobile_number,
        digital_signature: form.digital_signature,
        email_signature: form.email_signature,
        role_id: form.change_to_superadmin ? "superadmin" : form.role_id || 0,
        team_leader: form.team_leader || false,
        privileges:
          typeof form.privileges === "string"
            ? form.privileges
            : JSON.stringify(form.privileges),
        //  status: form.status || record?.status || "Inactive",
      };
      if (form.password && form.password.trim() !== "") {
        userData.password = form.password;
      }
      if (isEditMode) {
        userData.id = id;
      }
      return userData;
    }

    // Add type-specific fields
    switch (typeKey) {
      case "quote":
        return {
          ...base,
          // quote_id: form?.quote_id,
          // quote_number: form.itemNumber || "",
          customer_info: form.customer_info,
          quote_date: parseToISO(form?.quote_date) || "",
          expiry_date: parseToISO(settings?.expiryDays) || "", //form.expiry_date || "",
          quote_content: form.quote_content || "",
          general_terms_conditions:
            form.general_terms_conditions || settings?.terms_conditions || "",
          signature: form.signature || "",
          subtotal: calculateGrandTotal(
            lineItems,
            form.discount,
            form.discount_global,
            null,
            null,
            null,
          ),
          discount: form.discount || "",
          discount_global: discountAmount,
          total_quote_value: calculateGrandTotal(
            lineItems,
            form.discount,
            form.discount_global,
            null,
            null,
            null,
          ),
          line_items: lineItems || form.line_items,
          attachments: form.attachments || "",
          winning_probability: form.winning_probability || "",
          profit: lineProfit || 0,
          notes: form.notes || "",
        };



      case "salesorder":
        return {
          ...base,
          customer_info: form.customer_info,
          quote_info: form.quote_id,
          salesorder_date: parseToISO(form?.quote_date) || "",
          expiry_date: parseToISO(settings?.expiryDays) || "", //form.expiry_date || "",
          salesorder_content: form.quote_content || "",
          general_terms_conditions:
            form.general_terms_conditions || settings?.terms_conditions || "",
          signature: form.signature || "",
          subtotal: calculateGrandTotal(
            lineItems,
            form.discount,
            form.discount_global,
            null,
            null,
            null,
          ),
          discount: form.discount || "",
          discount_global: discountAmount,
          total_salesorder_value: calculateGrandTotal(
            lineItems,
            form.discount,
            form.discount_global,
            null,
            null,
            null,
          ),
          line_items: lineItems || form.line_items,
          attachments: form.attachments || "",
          profit: lineProfit || 0,
          notes: form.notes || "",
        };



      case "deliverynote":
        return {
          ...base,
          customer_info: form.customer_info,
          deliverynote_date: parseToISO(form.deliverynote_date) || "",
          deliverynote_content: form.quote_content || "",
          general_terms_conditions:
            form.general_terms_conditions || settings?.terms_conditions || "",
          line_items: lineItems,
          line_items_short: customMessage || [],
          lpo: form.lpo || "",
          quote_id: form.quote_id || "",
          proforma_id: form.proforma_id || "",
          notes: form.notes || "",
          serializationSerial: Object.entries(usedSerials || {})
            .map(([inventory_id, serials]) => ({
              inventory_id: Number(inventory_id),
              used_serialization: {
                deliverynote_number: form.deliverynote_number || "",
                usedSerial: serials.filter((s) => s.trim()),
              },
            }))
            .filter((item) => item.used_serialization.usedSerial.length),
        };

      case "proforma":
        return {
          ...base,
          customer_info: form.customer_info,
          proforma_date: parseToISO(form.proforma_date) || "",
          expiry_date: parseToISO(settings?.expiryDays) || "",
          cheque_date: parseToISO(form.cheque_date),
          quote_ref_number: form?.quote_ref_number || "",
          lpo_number: form?.lpo_number || "",
          proforma_terms: form?.proforma_terms || "",
          subtotal,
          discount_global: discountAmount,
          total_proforma_value: grandTotal,
          balance_amount: paymentBalance || 0,
          refund_amount: refundAmount || 0,
          line_items: lineItems,
          customer_id: form?.customer_id || selectedCustomer?.customer_id || "",
          advance_payment_received:
            form?.advance_payment_received || totalAmountPayabale || 0,
          progress_amount_payable: form?.progress_amount_payable || 0,
          profit: lineProfit || 0,
          notes: form?.notes || "",
        };

      case "invoice":
        return {
          ...base,
          customer_info: form?.customer_info,
          invoice_date: parseToISO(form?.invoice_date) || "",
          expiry_date: parseToISO(settings?.expiryDays) || "",
          quote_ref_number: form?.quote_ref_number || "",
          proforma_ref_number: form?.proforma_ref_number || "",
          delivery_note_ref_number: form?.delivery_note_ref_number || "",
          lpo_number: form?.lpo_number || "",
          terms: form?.terms || "",
          notes: form?.notes || "",
          // terms: form?.general_terms_conditions || "",
          // notes: form?.internal_notes || "",
          subtotal: form?.total_value || subtotal || 0,
          discount_global: discountAmount,


          total_invoice_value: (Number(form?.total_value) + Number(currentTax)) || (Number(subtotal) + Number(currentTax)) || 0,
          balance_amount: (Number(form?.total_value) + Number(currentTax)) || (Number(subtotal) + Number(currentTax)) || 0,


          line_items: lineItems,
          updated_line_items: form?.updated_line_items || "",
          advance_payment_received: form?.advance_payment_received || 0,
          progress_amount_payable: form?.progress_amount_payable || 0,
          profit: lineProfit || 0,

          //RECURRING INVOICE
          customer_id: form?.customer_id || selectedCustomer?.customer_id || "",
          //  invoice_number: form[`${typeFor}_number`] || "",
          recurring_repeat_every: form?.recurring_repeat_every || "",
          recurring_interval_count: form?.recurring_interval_count || "",
          recurring_start_date: parseToISO(form?.recurring_start_date) || "",
          recurring_end_date: parseToISO(form?.recurring_end_date) || "",
          recurring_never_expire: form?.recurring_never_expire || false,
          next_due_date: parseToISO(form?.next_due_date) || "",
          // status: recurringInvoice ? "active" : "inactive",
          recurringinvoice_created_at: new Date(),
          recurringinvoice_updated_at: new Date(),
          invoice_docs:
            (form?.invoice_docs && formatDocs(form, "invoice_docs")) || [],
          recurring: form?.recurring,

        };

      case "customerpayment":
        const { totalPayAmount, totalBalanceAmount } =
          advanceSumPayAndBalance(paidProformas);

        const resolvedPayingAmount =
          payingAmount != null && payingAmount !== ""
            ? payingAmount
            : totalPayAmount;

        const payingAmountFormatted = `${currency} ${toNumber(
          resolvedPayingAmount,
        ).toFixed(2)}`;

        const balanceAmount = `${currency} ${toNumber(
          paymentBalance ?? totalBalanceAmount,
        ).toFixed(2)}`;

        return {
          ...base,
          customer_info: form?.customer_info,
          payment_date: parseToISO(form?.payment_date) || "",
          payment_amount: payingAmountFormatted || null,
          payment_number: form?.itemNumber || "",
          balance_amount: balanceAmount || 0,
          wallet_amount: `${currency} ${parseFloat(
            selectedWalletTotal || 0,
          ).toFixed(2)}`,
          payment_type: formatCleanText(form?.payment_type) || "",

          transaction_type:
            refundAmount > 0
              ? "Refund"
              : reversalAmount > 0
                ? "Reversal"
                : "Payment",

          payment_bank: form?.payment_bank || "",
          cheque_number: form?.cheque_number || "",
          cheque_date: parseToISO(form?.cheque_date),
          reference_no: form?.reference_no || "",
          payee_bank: form?.payee_bank || "",
          pdc_date: parseToISO(form?.pdc_date) || "",
          pdc_number: form?.pdc_number || "",
          pdc_status: form.payment_type === "pdc" ? "pending" : "",
          add_attachment: form?.attachments,
          notes: form?.notes || "",
          invoice_id: JSON.stringify(paymentInvoices) || "",
          current_invoice_number: form?.current_invoice_number || "",
          advance_payment_received: `${currency} ${parseFloat(
            form?.advance_payment_received || 0,
          ).toFixed(2)}`,
          progress_amount_payable: `${currency} ${parseFloat(
            form?.progress_amount_payable || 0,
          ).toFixed(2)}`,
          total_invoice_value: `${currency} ${parseFloat(
            form?.total_invoice_value || 0,
          ).toFixed(2)}`,
          bank_transaction_id: nextBankTranstionId || "",
        };

      case "supplierpayment":
        return {
          ...base,
          payment_date: parseToISO(form?.payment_date) || "",

          payment_amount: payingAmount
            ? `${currency} ${parseFloat(payingAmount || 0).toFixed(2)}`
            : null,

          balance_amount: paymentBalance || 0,
          wallet_amount: `${currency} ${parseFloat(
            selectedWalletTotal || 0,
          ).toFixed(2)}`,

          supplierpayment_name: form?.supplier_name || "",
          supplier_id: selectedSupplier?.supplier_id || "",
          purchase_id: JSON.stringify(paymentPurchases) || "",
          payment_type: formatCleanText(form?.payment_type) || "",
          payment_bank: form?.payment_bank || "",
          cheque_number: form?.cheque_number || "",
          pdc_date: parseToISO(form?.pdc_date) || "",
          pdc_number: form?.pdc_number || "",
          cheque_date: parseToISO(form?.cheque_date) || null,
          reference_no: form?.reference_no || "",
          add_attachment: form?.add_attachment || form?.attachments || "", // depending on your field naming
          //   doc: form?.doc || null, // if you want to include doc as well
          notes: form?.notes || "",
          // purchase_id: form?.purchase_id || "",                    // replaced invoice_id with purchase_id
          current_purchase_number: form?.current_purchase_number || "", // replaced current_invoice_number
          advance_payment_received: form?.advance_payment_received
            ? `${currency} ${parseFloat(form?.advance_payment_received).toFixed(
              2,
            )}`
            : `${currency} 0.00`,
          progress_amount_payable: form?.progress_amount_payable
            ? `${currency} ${parseFloat(form?.progress_amount_payable).toFixed(
              2,
            )}`
            : `${currency} 0.00`,
          total_invoice_value: form?.total_invoice_value
            ? `${currency} ${parseFloat(form?.total_invoice_value).toFixed(2)}`
            : `${currency} 0.00`,
          created_username:
            form?.created_username || currentSession?.user?.username || "",
        };

      case "inventory":
        return {
          ...base,
          inventory_type: JSON.stringify(form?.inventory_type),
          inventory_name: form?.inventory_name,
          description: form?.description,
          unit: form?.unit,
          price: form?.inventory_price || "",
          buying_price: form?.buying_price || "",
          sku: form?.sku || "",
          stock: record?.stock || 0,
          supplier_prices: form?.supplier_prices || [],
          serialization: form?.serializationCheck,
          composite_products: form?.composite_products || [],
          service_charge: form?.service_charge || "",
        };

      case "unit":
        return {
          ...base,
          unit_name: form?.unit_name,
          description: form?.description,
        };

      case "customer":
        return {
          ...base,
          avatar: form?.avatar,
          customer_type: form?.customer_type,
          lead_source: form?.lead_source,
          salutation: form?.salutation,
          name: form?.name,
          email: form?.email,
          phone: form?.phone,
          whatsapp: form?.whatsapp,
          default_currency: form?.default_currency,
          website: form?.website,
          gst_vat_number: form?.gst_vat_number,
          address_line_1: form?.address_line_1,
          address_line_2: form?.address_line_2,
          country: form?.country,
          state_province: form?.state_province,
          city: form?.city,
          zip_postal_code: form?.zip_postal_code,
          shipping_address_line_1: form?.shipping_address_line_1,
          shipping_country: form?.shipping_country,
          shipping_state_province: form?.shipping_state_province,
          shipping_city: form?.shipping_city,
          shipping_zip_postal_code: form?.shipping_zip_postal_code,
          contact_persons: JSON.stringify(form?.contact_persons || []),
          billing_notes: form?.billing_notes,
          //  status: form?.status,
          industry: form?.industry,
          customer_docs:
            (form?.customer_docs && formatDocs(form, "customer_docs")) || [],
          customer_tax: JSON.stringify(form?.customer_tax) || ""
        };

      case "lead":
        return {
          ...base,
          avatar: form?.avatar,
          customer_type: form?.customer_type,
          lead_type: form?.lead_type,
          lead_source: form?.lead_source,
          name: form?.name,
          // display_name: form?.display_name,
          email: form?.email,
          phone: form?.phone,
          whatsapp: form?.whatsapp,
          website: form?.website,
          contact_salutation: form?.contact_salutation,
          contact_full_name: form?.contact_name,
          contact_designation: form?.designation,
          department: form?.department,
          contact_phone: form?.contact_mobile,
          land_phone: form?.land_phone,
          contact_email: form?.contact_email,
          contact_persons: JSON.stringify(form?.contact_persons || []),
          converted_to_customer: form?.converted_to_customer || "0",
        };

      case "supplier":
        return {
          ...base,
          avatar: form?.avatar,
          supplier_number: form?.itemNumber || "",
          supplier_type: form?.supplier_type,
          name: form?.name,
          email: form?.email,
          contact_number: form?.contact_number,
          address_line: form?.address_line,
          website: form?.website,
          currency: form?.currency,
          payment_terms: form?.payment_terms,
          tax_number: form?.tax_number,
          credit_limit: form?.credit_limit,
          contact_salutation: form?.contact_salutation,
          contact_name: form?.contact_name,
          designation: form?.designation,
          department: form?.department,
          contact_mobile: form?.contact_mobile,
          land_phone: form?.land_phone,
          contact_email: form?.contact_email,
          contact_persons: JSON.stringify(form?.contact_persons || []),
          supplier_docs:
            (form?.supplier_docs && formatDocs(form, "supplier_docs")) || [],
        };

      case "role":
        return {
          //  ...(isEditMode && { id: record?.id }),
          ...base,
          role_name: form?.role_name || "",
          role_type: form?.role_type || "",
          privileges: form?.privileges || [],
          //  status: form?.status || "Active",
        };

      case "purchase":
        return {
          ...base,
          purchase_number: form?.itemNumber || "",
          supplier_name: form?.supplier_name,
          supplier_id: form?.supplier_id || selectedSupplier?.supplier_id || "",
          invoice_number: form?.invoice_number,
          purchaseorder_ref_number: form?.purchaseorder_ref_number,
          purchase_date: parseToISO(form?.purchase_date) || "",
          payment_terms: form?.payment_terms || "",
          line_items: lineItems,
          total_value: form?.total_value || "",
          balance_amount: form?.total_value || "",
          currency: activeCurrency,
          tax: form?.add_tax ? `yes` : `no`,
          lpo: form?.lpo_number || "",
          created_username:
            form?.created_username || currentSession?.user?.username || "",
        };

      case "purchaseorder":
        return {
          ...base,
          purchaseorder_number: form?.itemNumber || "",
          supplier_name: form?.supplier_name,
          supplier_id: form?.supplier_id || selectedSupplier?.supplier_id || "",
          // invoice_number: form?.invoice_number,
          purchaseorder_date: parseToISO(form?.purchaseorder_date),
          line_items: lineItems,

          total_value: form?.total_value || "",
          balance_amount: form?.total_value || "",

          currency: activeCurrency,
          tax: form?.add_tax ? `yes` : `no`,
          created_username:
            form?.created_username || currentSession?.user?.username || "",
          quote_reference: form?.quote_reference || "",
          ship_via: form?.ship_via || "",
          fob: form?.fob || "",
          po_terms_conditions:
            form?.po_terms_conditions || settings?.po_terms_conditions || "",
          po_payment_terms: form?.po_payment_terms || "",
        };

      case "expense":
        return {
          ...base,
          expense_number: form?.itemNumber || "",
          // expense_number: form?.expense_number || form?.itemNumber || "",
          type_of_expense: form?.type_of_expense || "",
          amount: parseFloat(form?.amount_with_tax || form?.amount) || 0,
          description: form?.description || "",
          expense_date: parseToISO(form?.expense_date) || form?.expense_date || new Date().toISOString().split("T")[0],
          created_by: currentSession?.user?.id || "",
        };

      case "salesreturn":
        return {
          ...base,

          salesreturn_number: form?.itemNumber || "",
          invoice_info: JSON.stringify(form?.invoice_info) || "",
          payment_info: JSON.stringify(form?.payment_info) || "",
          customer_name: form?.customer_name || "",
          qty: Number(form?.sales_qty || 0),
          return_qty: Number(form?.sales_return_qty || 0),
          amount: String(form?.sales_amount || 0),
          return_amount: String(form?.sales_return_amount || 0),
          salesreturn_date: form?.salesreturn_date || "",
          line_items: form?.line_items || [],
          updated_line_items: form?.updated_line_items || [],
          doc: docFile ? `doc/${typeKey}/${docFile}` : null,
          terms_and_conditions: form?.general_terms_conditions || null,
          internal_notes: form?.notes || null,
          salesreturn_date: form?.salesreturn_date || null,
          delivery_notes:
            JSON.stringify(form?.delivery_note_ref_number) || null,
          used_serial_numbers: JSON.stringify(form?.serialization) || null,
        };

      case "purchasereturn":
        return {
          ...base,

          purchasereturn_number: form?.itemNumber || "",
          purchase_info: JSON.stringify(form?.purchase_info) || "",
          payment_info: JSON.stringify(form?.payment_info) || "",
          supplier_name: form?.supplier_name || "",
          purchase_order: form?.purchase_order || "",
          qty: Number(form?.purchase_qty || 0),
          return_qty: Number(form?.purchase_return_qty || 0),
          amount: String(form?.purchase_amount || 0),
          return_amount: String(form?.purchase_return_amount || 0),
          salesreturn_date: form?.salesreturn_date || "",
          line_items: form?.line_items || [],
          updated_line_items: form?.updated_line_items || [],
          purchasereturn_date: form?.salesreturn_date || null,
        };

      default:
        return base;
    }
  };

  const pageTitle = isEditMode
    ? `Edit ${typeFor[0].toUpperCase() + typeFor.slice(1)}`
    : `Add New ${typeFor[0].toUpperCase() + typeFor.slice(1)}`;

  if (
    isEditMode &&
    recordLoading

    // || !isInitialized
  )
    if (currentSession?.user?.role_id !== "superadmin") {
      // return <Loader full />;

      const lockedStatuses = {
        quote: ["Approved", "Send"],
        customerpayment: ["Send"],
        deliverynote: ["Converted"],
        invoice: ["Send"],
        proforma: ["Send"], // uncomment if needed
      };

      const isLocked =
        lockedStatuses[typeFor]?.includes(record?.status) ||
        (typeFor === "customerpayment" &&
          isBalanceZero(record?.balance_amount));

      if (isLocked) {
        return (
          <div className="container py-10">
            <AlertMessage
              type="error"
              message={`Cannot edit this ${typeFor}!`}
            />
          </div>
        );
      }
    }

  if (hasModuleActionPermission(typeFor, propMode) === false) {
    return (
      <div className="container py-10">
        <AlertMessage type="error" message={`Cannot edit this ${typeFor}!`} />
      </div>
    );
  }

  //ATTACHEMNT

  const testAttachment = async () => {
    const pdfUrl = `${frontEndUrl}api/proxy?fileUrl=${frontEndUrl}uploads/doc/quote/quote-qt-2-U2FsdGVkX1-nmi4zdN1NuFBuJVNHIaYHyrdE8DEY3bMby-upturnist-U2FsdGVkX1_0_LjkoRXKRAcTeuTaM9UJ50DfkqnsHaA.pdf`;

    const res = await fetch(pdfUrl); // or waitForPDF(pdfUrl)
    const blob = await res.blob();

    const attachmentFile = new File([blob], "quote.pdf", {
      type: "application/pdf",
    });

    return [attachmentFile]; // always return the file
  };

  return (
    <>
      <PageHead
        actionButtons={
          <>
            <PrivilegeActions module={typeFor}>
              <div data-action="edit">
                {typeFor === "lead" && typeForMode === "edit" && (
                  <InputItem
                    type="button"
                    title="Convert to Customer"
                    onClick={(e) => {
                      typeof window !== "undefined" &&
                        sessionStorage.setItem(
                          "leadData",
                          JSON.stringify(record),
                        );

                      router.push(`${frontEndUrl}customer/add?lead=true`);
                    }}
                  />
                )}
              </div>
            </PrivilegeActions>
          </>
        }
        title={pageTitle}
        typeFor={typeFor}
        typeForMode={typeForMode}
      />

      {/* {formActionLoading && <Loader full />} */}

      <div
        ref={pdfRef}
        id="pdf-content"
        style={{
          position: "absolute",
          top: "-9999px",
          left: "-9999px",
          width: "794px",
          minHeight: "1123px",
          backgroundColor: "#ffffff",
          boxShadow: "none",
          border: "none",
          colorAdjust: "exact",
          WebkitPrintColorAdjust: "exact",
          overflow: "hidden",
        }}
      >
        <DocumentPDF
          type={typeFor}
          brandSettings={brandData}
          selectedCustomer={selectedCustomer}
          selectedSupplier={selectedSupplier}
          // transformedData={transformedData}
          form={form}
          settings={settings}
          currency={currency}
          discountPercentage={form?.discount}
          discountAmount={form?.discount_global}
          allProformas={allProforma}
        />
      </div>

      <div className="w-full mt-5  bg-white dark:bg-black border border-gray-200 dark:border-gray-800 sm:p-[30px] p-5 pt-2  rounded-xl border-gray-200 dark:border-gray-800">
        {typeFor === "quote" && (
          <QuotationForm
            form={form}
            setForm={setForm}
            settings={settings}
            currency={currency}
            enableGlobalDiscount={false}
            allInventory={inventory}
            isEditMode={isEditMode}
            type={typeFor}
            pathname={pathname}
          />
        )}

        {typeFor === "salesorder" && (
          <SalesOrderForm
            form={form}
            setForm={setForm}
            settings={settings}
            currency={currency}
            enableGlobalDiscount={false}
            allInventory={inventory}
            isEditMode={isEditMode}
            type={typeFor}
            pathname={pathname}
          />
        )}


        {typeFor === "deliverynote" && (
          <DeliveryNoteForm
            form={form}
            setForm={setForm}
            settings={settings}
            isEditMode={isEditMode}
            type={typeFor}
            allInventory={inventory}
          />
        )}

        {typeFor === "proforma" && (
          <ProformaForm
            form={form}
            setForm={setForm}
            settings={settings}
            allQuotes={allQuotes}
            enableGlobalDiscount={false}
            onReferenceChange={(type, selectedValues) => {
              if (type === "quote") {
                setForm((prev) => ({
                  ...prev,
                  quote_ref_number: selectedValues || "",
                  proforma_ref_number: [],
                }));
              } else if (type === "proforma") {
                setForm((prev) => ({
                  ...prev,
                  proforma_ref_number: selectedValues || "",
                  quote_ref_number: [],
                }));
              }
            }}
            currency={currency}
            brandSettings={brandData}
            allInventory={inventory}
            isEditMode={isEditMode}
            type={typeFor}
          />
        )}

        {typeFor === "invoice" && (
          <InvoiceForm
            form={form}
            setForm={setForm}
            allProforma={allProforma}
            allQuotes={allQuotes}
            settings={settings}
            currency={currency}
            enableGlobalDiscount={false}
            brandSettings={brandData}
            onReferenceChange={(type, selectedValues) => {
              if (type === "quote") {
                setForm((prev) => ({
                  ...prev,
                  quote_ref_number: selectedValues || "",
                  proforma_ref_number: [],
                  delivery_note_ref_number: [],
                }));
              } else if (type === "proforma") {
                setForm((prev) => ({
                  ...prev,
                  proforma_ref_number: selectedValues || "",
                  quote_ref_number: [],
                  delivery_note_ref_number: [],
                }));
              } else if (type === "deliverynote") {
                setForm((prev) => ({
                  ...prev,
                  delivery_note_ref_number: selectedValues || "",
                  quote_ref_number: "",
                  proforma_ref_number: "",
                }));
              }
            }}
            allDeliveryNote={allDeliveryNote}
            allPayments={allPayments}
            allInventory={inventory}
            allProformas={allProforma}
            isEditMode={isEditMode}
            type={typeFor}
          />
        )}

        {typeFor === "customerpayment" && (
          <CustomerPaymentForm
            form={form}
            setForm={setForm}
            brandSettings={brandSettings}
          />
        )}

        {typeFor === "supplierpayment" && (
          <SupplierPaymentForm
            form={form}
            setForm={setForm}
            allPurchase={allPurchases}
            brandSettings={brandSettings}
            supplierPayment={allSupplierPayment}
          />
        )}

        {typeFor === "inventory" && (
          <InventoryForm
            form={form}
            setForm={setForm}
            brandSettings={brandData}
            allSuppliers={suppliers}
            isEditMode={isEditMode}
          />
        )}

        {typeFor === "unit" && <UnitForm form={form} setForm={setForm} />}

        {typeFor === "customer" && (
          <CustomerForm
            form={form}
            setForm={setForm}
            brandSettings={brandData}
            isEditMode={isEditMode}
          />
        )}

        {typeFor === "user" && (
          <UserForm
            form={form}
            setForm={setForm}
            isAdmin={currentSession}
            typeFor={typeFor}
            id={id}
            status={record?.status || "Inactive"}
            isEditMode={isEditMode}
          />
        )}
        {typeFor === "role" && <RoleForm form={form} setForm={setForm} />}

        {typeFor === "lead" && <LeadForm form={form} setForm={setForm} />}

        {typeFor === "supplier" && (
          <SupplierForm
            form={form}
            setForm={setForm}
            type={typeFor}
            isEditMode={isEditMode}
          />
        )}

        {typeFor === "purchaseorder" && (
          <PurchaseOrderForm
            form={form}
            setForm={setForm}
            brandSettings={brandData}
            allSuppliers={suppliers}
            isEditMode={isEditMode}
            allInventory={inventory}
            allProformas={allProforma}
            allPayments={allPayments}
            enableGlobalDiscount={false}
            type={typeFor}
            settings={settings}
          />
        )}

        {typeFor === "purchase" && (
          <PurchaseForm
            form={form}
            setForm={setForm}
            brandSettings={brandData}
            allSuppliers={suppliers}
            allProformas={allProforma}
            allPayments={allPayments}
            enableGlobalDiscount={false}
            allPurchasesOrder={allPurchasesOrder}
            onReferenceChange={(type, selectedValues) => {
              setForm((prev) => ({
                ...prev,
                purchaseorder_ref_number: selectedValues || "",
              }));
            }}
            type={typeFor}
          />
        )}

        {typeFor === "expense" && (
          <ExpenseForm
            form={form}
            setForm={setForm}
            brandSettings={brandData}
            settings={settings}
          />
        )}

        {typeFor === "salesreturn" && (
          <SalesReturnForm
            form={form}
            setForm={setForm}
            settings={settings}
            allDeliveryNote={allDeliveryNote}
            allPayments={allPayments}
            pathname={pathname}
            isEditMode={isEditMode}
          />
        )}

        {typeFor === "purchasereturn" && (
          <PurchaseReturnForm
            form={form}
            setForm={setForm}
            settings={settings}
            allPurchaseOrder={allPurchasesOrder}
            allSupplierPayments={allSupplierPayment}
            pathname={pathname}
            isEditMode={isEditMode}
          />
        )}

        <div className="container">
          <FormActionButtons
            isEditMode={isEditMode}
            typeFor={typeFor}
            form={form}
            docFile={docFile}
            brandData={brandData}
            emailSettings={emailSettings}
            settings={settings}
            inventory={inventory}
            requiredFields={requiredFields}
            recurringInvoice={recurringInvoice}
            getFormData={getFormData}
            mutateCustomers={mutateCustomers}
            mutateQuotes={mutateQuotes}
            mutateInvoices={mutateInvoices}
            mutateSuppliers={mutateSuppliers}
            mutateProforma={mutateProforma}
            mutateInventory={mutateInventory}
            mutateDeliveryNote={mutateDeliveryNote}
            mutatePayment={mutatePayment}
            mutateExpenses={mutateExpenses}
            mutatePurchase={mutatePurchase}
            mutateSupplierPayment={mutateSupplierPayment}
            mutateRole={mutateRole}
            draftId={draftId}
            selectedCustomer={selectedCustomer}
            chekLeadIsActive={chekLeadIsActive}
            currentSession={currentSession}
            hasModuleActionPermission={hasModuleActionPermission}
            uploadStatus={uploadStatus}
            sendingOptions={sendingOptions}
            setPreviewModal={setPreviewModal}
            nextId={nextId}
            payments={allPayments}
            formActionLoading={formActionLoading}
            pdfRef={pdfRef}
          />

        </div>
      </div>

      <Modal
        styles={{
          content: {
            borderRadius: 20,
            padding: 30,
            fontSize: 20,
          },
        }}
        title={`Preview ${typeFor[0].toUpperCase() + typeFor.slice(1)}`}
        open={previewModal}
        onOk={() => setPreviewModal(false)}
        onCancel={() => setPreviewModal(false)}
        footer={null}
        width={{
          xs: "90%",
          sm: "80%",
          md: "70%",
          lg: "60%",
          xl: "60%",
          xxl: "60%",
        }}
      >
        <DocumentPDF
          type={typeFor}
          brandSettings={brandData}
          selectedCustomer={selectedCustomer}
          //   transformedData={transformedData}
          form={form}
          settings={settings}
          currency={currency}
          discountPercentage={form?.discount}
          discountAmount={form?.discount_global}
        />
      </Modal>

      <Modal
        styles={{
          content: {
            borderRadius: 20,
            padding: 30,
            fontSize: 20,
          },
        }}
        title="Stock not available"
        closable={{ "aria-label": "Custom Close Button" }}
        open={showStockErrorModal}
        onCancel={() => {
          setProceed(false);
          setShowStockErrorModal(false);
          setCloseQuote(true);
        }}
        footer={null}
      >
        <div className="my-3">
          <AlertMessage
            type="error"
            message={
              "Not enough Stock. Continue to proceed with available stock?"
            }
          />
        </div>

        <div className="border mb-3 rounded-lg overflow-hidden border-gray-100">
          <Table
            dataSource={customMessage || []}
            columns={[
              {
                title: "Item",
                dataIndex: "item_name",
                key: "item_name",
              },
              {
                title: "Available",
                dataIndex: "available",
                key: "available",
              },
              {
                title: "Requested",
                dataIndex: "requested",
                key: "requested",
              },
              {
                title: "Short By",
                dataIndex: "shortBy",
                key: "shortBy",
                render: (text) => (
                  <span style={{ color: "red", fontWeight: "bold" }}>
                    {text}
                  </span>
                ),
              },
            ]}
            pagination={false}
            rowKey={(record) => record.id}
            size="small"
            rowClassName={() => "crm-row"}
            scroll={{ x: true }}
            className="crm-table"
          />
        </div>

        {checkStock(lineItems, inventory)?.[0]?.availableStock !== 0 && (
          <InputItem
            type="button"
            title="Proceed to continue"
            placeholder="Confirm"
            onClick={() => {
              setShowStockErrorModal(false);
              setProceed(true);
              setCloseQuote(true);
            }}
            btnColor="primary"
            btnvariant="solid"
          />
        )}
      </Modal>
    </>
  );
}