"use client";

import { it } from "node:test";
import { useState, useEffect } from "react";

// -----------------------------------------------------
// FINAL BOOKING TYPE (ALL API FIELDS INCLUDED)
// -----------------------------------------------------
export interface Booking {
  id: string;
  bookingId: string;

  // Guest
  guestName: string;
  guestId: string;
  mobile: string;
  email: string;
  gender: string;
  billingAddress: string;
  state: string;
  district: string;
  country: string;
  countryCode: string;
  guestStatus: string;
  guestHistory: string;
  nationality: string;

  // Room
  roomNumber: string;
  roomType: string;
  roomCategory: string;

  // Dates
  checkIn: string;
  checkOut: string;
  bookingDate: string;
  createdDate: string;
  lastUpdated: string;

  // Programme
  programmeName: string;

  // Payment
  amount: number;
  discountPercent: number;
  discount: number;
  amountRecieved: number;
  totalAmountBeforeDiscount: number;
  totalAmountReceived: number;
  balance: number;
  pendingAmount: number;

  currency: string;
  originalAmount : string;
  paymentReceivedDate: string;
  paymentMode: string;
  receiptNumber: string;
  paymentLocation: string;
  collectionBy: string;
  paymentSettlementStatus: string;

  uploadScreenShot: string;
  paymentCollectionHistory: string;

  // Payment Internal
  receivedAmount: number;
  receivedPercentage: number;
  paymentStatus: "pending" | "payment_pending" | "partial" | "paid";

  // Booking details
  bookingStatus: string;
  bookingType: string;
  bookingTakenBy: string;
  groupBooking: string;
  dataSource: string;

  // PI
  piLink: string;
  piNumber: string;

  // Cancel info
  cancelledRemarks: string;
  cancelledReason: string;

  // Additional booking logs
  approvalGivenDate: string;
  approvedTillDate: string;
  approvalScreenShot: string;
  approvalRemarks: string;
  approvedBy: string;

  mlsummary: string;
  // mlRemarks: string;
  editActionStatus: string;

  purposeOfStay: string;
  adults: string;
  male: string;
  female: string;
  children: string;
  repeat: string;
  clientCategory: string;
  clientType: string;
  bookerEmail: string;
  bookerPhone: string;

  // Cross-team statuses
  accountsVerifyStatus: string;
  paymentSettlement: string;
  frontOfficeStatus: string;
  verfiedOrNot: string;

  source: string;
  assignedTo: string;
  team: "sales" | "accounts";

  totalAmount: string;
  paidAmount: string;

  status: string;

  whatsappToClient: string;
  whatsappToStaff: string;
  emailToClient: string;
  emailToStaff: string;

  editID: string;
  doerDelay: string;
  accountsDelay: string;
  foDelay: string;
  paymentDelay: string;

  isAutoReleased: string;
  autoRelease: string;
  autoreleaseReason: string;
  autoReleasedAt: string;
  autoReleaseNotes: string;
  cancelByUserCheck: string;
  piHistoryLink: string;
  bSource: string;
  collectionHistory: any[];
  salesPersonStage: Map<string, string>;
  accountsPersonStage: Map<string, string>;
  foPersonStage: Map<string, string>;
  checkOutPersonStage: Map<string, string>;
  arrivalTime?: string
  arrivalMode?: string
  arrivalPickup?: string
  departureTime?: string
  departureMode?: string
  departurePickup?: string
  mlFinalStatus?: string
  mlRemarks?: string

}


export interface PendingCount {
  employeeName: string;
  newBookings: number;
  accountVerify: number;
  finalTransfer: number;
  deleteComplete: number;
}

// -----------------------------------------------------
// HELPERS
// -----------------------------------------------------
const toNumber = (val: any): number => {
  if (val === undefined || val === null || val === "") return 0;
  const num = Number(String(val).replace(/[₹$,]/g, ""));
  return isNaN(num) ? 0 : num;
};

const normalizeStatus = (s: string): any => {
  s = (s || "").toLowerCase();
  if (s.includes("cancel")) return "cancelled";
  if (s.includes("auto")) return "auto_release";
  if (s.includes("pending")) return "pending";
  return "Confirm-Verified";
};

const computePaymentStatus = (amount: number, received: number): any => {
  if (received === 0) return "payment_pending";
  if (received >= amount) return "paid";
  return "partial";
};

// SOURCE NORMALIZER
const normalizeSource = (s: string = "") => {
  const v = s.trim().toLowerCase();
  if (!v) return "Others";

  if (v.includes("online") || v.includes("website") || v.includes("portal") || v.includes("web"))
    return "Online Booking Engine";
  if (v.includes("ota") || v.includes("booking.com"))
    return "OTA";
  if (v.includes("agent") || v.includes("travel"))
    return "Travel Agent";
  if (v.includes("direct"))
    return "Direct Booking";

  return "Others";
};

// -----------------------------------------------------
// FINAL UPDATED HOOK — ALL API FIELDS INCLUDED
// -----------------------------------------------------
export function useBookings() {
  const [bookings, setBookings] = useState<Booking[]>([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<any>(null);
  const [pendingCount, setPendingCount] = useState<PendingCount[]>([]);

  useEffect(() => {
    async function fetchData() {
      try {
        setLoading(true);

        const res = await fetch(
          "https://script.google.com/macros/s/AKfycbwpbLZ2qiWthyEBKoTovx40lgclcqe8FdwoaurGdWJJ3MJ0F7KjnrJdO0wGJVkw_tOm/exec"
        );
        const json = await res.json();
        const data = json?.bookings || [];

        const formatted: Booking[] = data.map((item: any) => {

          const amount = toNumber(item.paymentDetails.amount);
          const orgAmount = toNumber(item.paymentDetails.amountOriginal);
          
          const amountRecieved = toNumber(item.paymentDetails.amountRecieved); // FIXED
          const balance = toNumber(item.paymentDetails.balance);
          console.log(item.bookingId, orgAmount,amountRecieved , computePaymentStatus(orgAmount, amountRecieved), );
          const receivedPct =
            orgAmount > 0 ? Math.round((amountRecieved / orgAmount) * 100) : 0;

          // const updatedCheckOutPersonStage = new Map<string, string>();
          if(item.checkoutPersonStage){
            item.checkoutPersonStage["1"].planned = amountRecieved >= orgAmount ? "Done" : item.checkoutPersonStage["1"].planned;
            item.checkoutPersonStage["1"].actual = amountRecieved >= orgAmount ? "Done" : item.checkoutPersonStage["1"].actual;
            item.checkoutPersonStage["1"].status = amountRecieved >= orgAmount ? "Auto-Done" : item.checkoutPersonStage["1"].status;
          }

          return {
            id: item.id,
            bookingId: item.bookingId,

            // Guest
            guestName: item.guestDetails.guestName || "-",
            guestId: item.guestDetails.guestID || "",
            mobile: item.guestDetails.mobile || "",
            email: item.guestDetails.email || "",
            gender: item.guestDetails.gender || "",
            billingAddress: item.guestDetails.billingAddress || "",
            state: item.guestDetails.state || "",
            district: item.guestDetails.district || "",
            country: item.guestDetails.country || "",
            countryCode: item.guestDetails.countryCode || "",
            guestStatus: item.guestDetails.guestStatus || "",
            guestHistory: item.guestDetails.guestHistory || "",
            nationality: item.guestDetails.country || "",

            // Room
            roomNumber: item.roomDetails.roomNo,
            roomType: item.roomDetails.roomType || "",
            roomCategory: item.roomDetails.roomCategory || "",

            // Dates
            checkIn: item.arrivalDate,
            checkOut: item.departureDate,
            bookingDate: item.bookingDate,
            createdDate: item.bookingDate,
            lastUpdated: item.timestamp,

            // Programme
            programmeName: item.programeName || "-",

            // Payment
            amount,
            discountPercent: item.paymentDetails.discountPercent || 0,
            discount: item.paymentDetails.discount || 0,
            amountRecieved,
            totalAmountBeforeDiscount: toNumber(item.paymentDetails.totalAmountBeforeDiscount),
            totalAmountReceived: toNumber(item.paymentDetails.totalAmountReceived),
            balance,
            pendingAmount: toNumber(item.paymentDetails.pendingAmount),
            currency: item.paymentDetails.currency || "",
            originalAmount : item.paymentDetails.amountOriginal || "",

            paymentReceivedDate: item.paymentDetails.paymentReceivedDate || "",
            paymentMode: item.paymentDetails.paymentMode || "",
            receiptNumber: item.paymentDetails.receiptNumber || "",
            paymentLocation: item.paymentDetails.paymentLocation || "",
            collectionBy: item.paymentDetails.collectionBy || "",

            uploadScreenShot: item.paymentDetails.uploadedScreenshot || "",
            paymentCollectionHistory: item.paymentDetails.paymentCollectionHistory || "",

            receivedAmount: amountRecieved,
            receivedPercentage: receivedPct,
            paymentStatus: computePaymentStatus(orgAmount, amountRecieved),
            // paymentSettlementStatus:
            //   amountRecieved >= amount
            //     ? "full_payment_received"
            //     : amountRecieved > 0
            //     ? "partial_payment"
            //     : "pending",

            paymentSettlementStatus: amountRecieved >= orgAmount ? "Auto-Done" : item.paymentSettlementStatus || "pending",
            // Booking Details
            bookingStatus: item.bookingDetails.bookingStatus,
            bookingType: item.bookingDetails.bookingType,
            bookingTakenBy: item.bookingDetails.bookingTakenBy,
            groupBooking: item.bookingDetails.groupBooking,
            dataSource: item.bookingDetails.dataSource,

            // PI
            piLink: item.piDetails.piLink || "",
            piNumber: item.piDetails.piNumber || "",

            cancelledRemarks: item.cancelledRemarks || "",
            cancelledReason: item.cancelledReason || "",

            // Approval
            approvalGivenDate: item.approvalGivenDate || "",
            approvedTillDate: item.approvedTillDate || "",
            approvalScreenShot: item.approvalScreenShot || "",
            approvalRemarks: item.approvalRemarks || "",
            approvedBy: item.approvedBy || "",

            // Logs
            mlsummary: item.mlsummary || "",
            // mlRemarks: item.mlRemarks || "",
            editActionStatus: item.editActionStatus || "pending",

            purposeOfStay: item.purposeOfStay || "",
            adults: item.adults || "0",
            male: item.male || "0",
            female: item.female || "0",
            children: item.children || "0",
            repeat: item.repeat || "",
            clientCategory: item.clientCategory || "",
            clientType: item.clientType || "",
            bookerEmail: item.bookerEmail || "",
            bookerPhone: item.bookerPhone || "",

            // Cross-team statuses from API
            salesTeamStatus: item.editActionStatus || "",
            accountsVerifyStatus: item.accountsVerifyStatus || item.accountsVerificationStatus || "pending",
            paymentSettlement: item.paymentSettlementStatus || "pending",
            frontOfficeStatus: item.frontOfficeStatus || "pending",

            verfiedOrNot: item.status || "Unverified",

            source: normalizeSource(item.bookingDetails.dataSource),
            assignedTo: item.bookingDetails.bookingTakenBy,
            team: "sales",

            totalAmount: String(amount),
            paidAmount: String(amountRecieved),

            status: normalizeStatus(item.bookingDetails.bookingStatus),

            whatsappToClient: item.whatsappToClient || "",
            whatsappToStaff: item.whatsappToStaff || "",
            emailToClient: item.emailToClient || "",
            emailToStaff: item.emailToStaff || "",

            editID: item.editID || "",
            isAutoReleased: item.isAutoReleased || "",
            autoRelease: item.autoRelease || "",
            autoreleaseReason: item.autoReleaseReason || "",
            autoReleasedAt: item.autoReleasedAt || "",
            autoReleaseNotes: item.autoReleaseNotes || "",
            cancelByUserCheck: item.cancelByUserCheck || "",
            piHistoryLink: item.piHistoryLink || "",
            bSource: item.bSource || "",
            collectionHistory: item.collectionHistory || [],
            doerDelay: item.doerDelay || "",
            accountsDelay: item.accountsDelay || "",
            foDelay: item.foDelay || "",
            paymentDelay: item.paymentDelay || "",
            salesPersonStage: item.salesPersonStage || new Map<string, string>(),
            accountsPersonStage: item.accountsPersonStage || new Map<string, string>(),
            foPersonStage: item.foPersonStage || new Map<string, string>(),
            checkOutPersonStage: item.checkoutPersonStage || new Map<string, string>(),
            // Travel Details
            arrivalTime: item.travelDetails?.arrivalTime || "",
            arrivalMode: item.travelDetails?.arrivalMode || "",
            arrivalPickup: item.travelDetails?.arrivalPickup || "",
            departureTime: item.travelDetails?.departureTime || "",
            departureMode: item.travelDetails?.departureMode || "",
            departurePickup: item.travelDetails?.departurePickup || "",

            mlFinalStatus: item.mlDetails.mlFinalStatus || "",
            mlRemarks: item.mlDetails.mlRemarks || "",


          };
        });
        const pendingData = json?.pendingCounts || [];
        const formattedPending: PendingCount[] = pendingData.map((item: any) => {
          return {
            employeeName: item.employee || "-",
            newBookings: item.newBookings || 0,
            accountVerify: item.accountsVerify || 0,
            finalTransfer: item.finalTransfer || 0,
            deleteComplete: item.deleteComplete || 0,
          };
        });
        setPendingCount(formattedPending);
        setBookings(formatted);
      } catch (err) {
        console.error(err);
        setError(err);
      } finally {
        setLoading(false);
      }
    }

    fetchData();
  }, []);

  return { bookings, pendingCount, loading, error };
}