"use client";

import { useEffect, useMemo, useState } from "react";
import { useRouter } from "next/navigation";
import { useAppSelector } from "@/store/hooks";
import {
  getVehiclesByCityAndDuration,
  getCustomerProfile,
  getExploreMoreRides,
} from "@/api/bookingApi";
import {
  ChevronLeft,
  ChevronDown,
  Star,
  Fuel,
  Gauge,
  Settings,
  Zap,
  Clock,
  Cog,
  Weight,
} from "lucide-react";
import Image from "next/image";

/* ---------------- HELPERS ---------------- */

const formatTime = (iso: string | null) => {
  if (!iso) return "";
  return new Date(iso).toLocaleTimeString("en-IN", {
    hour: "2-digit",
    minute: "2-digit",
    hour12: true,
  });
};

const formatDate = (iso: string | null) => {
  if (!iso) return "";
  return new Date(iso).toLocaleDateString("en-IN", {
    day: "2-digit",
    month: "short",
    year: "numeric",
  });
};

const getDuration = (from: string | null, to: string | null) => {
  if (!from || !to) return "";
  const diff = new Date(to).getTime() - new Date(from).getTime();
  const hrs = Math.floor(diff / (1000 * 60 * 60));
  const mins = Math.floor((diff / (1000 * 60)) % 60);
  return `${hrs} hrs, ${mins} mins`;
};



/* ---------------- COMPONENT ---------------- */

const API_BASE = process.env.NEXT_PUBLIC_API_URL;

export default function VehiclesPage({
  searchParams,
}: {
  searchParams: any;
}) {
  const router = useRouter();

  const { access_token } = useAppSelector((s) => s.auth);

  type RangeType = "SMALL" | "MEDIUM" | "LARGE";
  const rangeSteps: RangeType[] = ["SMALL", "MEDIUM", "LARGE"];

  const city = searchParams?.city || "";
  const rentalType = searchParams?.rental_type || "daily";
const from = searchParams?.from || null;



  const months = Number(searchParams?.months || 1);

  const to =
  rentalType === "monthly"
    ? (() => {
        if (!from) return null;

        const end = new Date(from);

        end.setMonth(end.getMonth() + months);

        return end.toISOString();
      })()
    : searchParams?.to || null;
    
  const [filters, setFilters] = useState<Record<string, string[]>>({});
  const [openFilter, setOpenFilter] = useState<string | null>(null);

  const [exploreRides, setExploreRides] = useState<any[]>([]);

const selectedMake = searchParams?.make || null;
const selectedModel = searchParams?.model || null;

  const durationType =
    rentalType === "monthly" ? "MONTHLY" : "HOURLY";

const quantity = useMemo(() => {
  if (durationType === "MONTHLY") {
    return months || 1; // ✅ fallback
  }

  if (!from || !to) return 1;

  const start = new Date(from);
  const end = new Date(to);

  // ✅ SAFETY CHECK (MOST IMPORTANT)
  if (isNaN(start.getTime()) || isNaN(end.getTime())) {
    return 1;
  }

  const diff = end.getTime() - start.getTime();

  return Math.max(Math.ceil(diff / (1000 * 60 * 60)), 1);
}, [durationType, from, to, months]);

  const [vehicles, setVehicles] = useState<any[]>([]);
  const [customerId, setCustomerId] = useState<string | null>(null);
  const [range, setRange] = useState<RangeType>("SMALL");
  const [apiRange, setApiRange] = useState<any>(null);
  const [allVehicles, setAllVehicles] = useState<any[]>([]);

  const rangeIndex = rangeSteps.indexOf(range);

  const rangeConfig = {
    SMALL: {
      km: apiRange ? quantity * apiRange.selected.values.small : 120,
      label: "Small",
      size: "S",
    },
    MEDIUM: {
      km: apiRange ? quantity * apiRange.selected.values.medium : 150,
      label: "Medium",
      size: "M",
    },
    LARGE: {
      km: apiRange ? quantity * apiRange.selected.values.large : 200,
      label: "Large",
      size: "L",
    },
  };

  /* ---------------- API ---------------- */

  const getExploreMinPrice = (v: any) => {
  const size = rangeConfig[range].size;
  let min = Infinity;

  v.pickup_options?.forEach((p: any) => {
    p.plans?.forEach((plan: any) => {
      if (plan.size === size && plan.price < min) {
        min = plan.price;
      }
    });
  });

  return min === Infinity ? v.starting_price : min;
};

  useEffect(() => {
  if (!city) return;

  getExploreMoreRides({
    city,
    duration_type: durationType,
    quantity,
    ...(from && { from_date: from }),
...(to && { to_date: to }),
  }).then((res) => {
    setExploreRides(res?.submodels || []);
  });
}, [city, durationType, quantity, from, to]);

  useEffect(() => {
    if (!access_token) return;

    getCustomerProfile().then((res) => {
      setCustomerId(res?.id);
    });
  }, [access_token]);

useEffect(() => {
  if (!city) return;

  const finalFilters: any = { ...filters };

  // ✅ Apply default ONLY if user hasn’t selected
  if (selectedMake && !filters.make_name?.length) {
    finalFilters.make_name = [selectedMake];
  }

  if (selectedModel && !filters.model_name?.length) {
    finalFilters.model_name = [selectedModel];
  }

  getVehiclesByCityAndDuration({
    city,
    duration_type: durationType,
    quantity,
    ...(from && { from_date: from }),
    ...(to && { to_date: to }),
    filters: finalFilters, // ✅ FIXED
  }).then((res) => {
    setVehicles(res?.vehicles || []);
    setApiRange(res?.range || null);
  });
}, [city, durationType, quantity, from, to, filters, selectedMake, selectedModel]);



  /* ---------------- PRICE ---------------- */

  const getMinPrice = (v: any) => {
    const size = rangeConfig[range].size;
    let min = Infinity;

    v.partners.forEach((p: any) => {
      p.plans.forEach((plan: any) => {
        if (plan.size === size && plan.price < min) {
          min = plan.price;
        }
      });
    });

    return min === Infinity ? v.min_price : min;
  };

  const booking = {
  city,
  from,
  to,
  durationType,
  quantity,
};

const handleFilterChange = (key: string, value: string) => {
  setFilters((prev) => {
    const current = prev[key] || [];

    if (current.includes(value)) {
      // remove
      const updated = current.filter((v) => v !== value);
      return { ...prev, [key]: updated };
    } else {
      // add
      return { ...prev, [key]: [...current, value] };
    }
  });
};

useEffect(() => {
  if (!city) return;

 getVehiclesByCityAndDuration({
  city,
  duration_type: durationType,
  quantity,
  ...(from && { from_date: from }),
  ...(to && { to_date: to }),
  filters: {},
}).then((res) => {
    setAllVehicles(res?.vehicles || []);
  });
}, [city, durationType, quantity, from, to]);

useEffect(() => {
  if (selectedMake || selectedModel) {
    setFilters((prev) => ({
      ...prev,
      ...(selectedMake && { make_name: [selectedMake] }),
      ...(selectedModel && { model_name: [selectedModel] }),
    }));
  }
}, []);


const dynamicFilters = useMemo(() => {
  const map: any = {
    BRAND: { key: "make_name", values: new Set() },
    MODEL: { key: "model_name", values: new Set() },
    TYPE: { key: "category", values: new Set() },
    ENGINE: { key: "fueltype", values: new Set() },
  };

  allVehicles.forEach((v: any) => {
    const attr = v.submodel?.attributes || {};

    if (v.make_name) map.BRAND.values.add(v.make_name);
    if (v.model_name) map.MODEL.values.add(v.model_name);
    if (attr.category) map.TYPE.values.add(attr.category);
    if (attr.fueltype) map.ENGINE.values.add(attr.fueltype);
  });

  return Object.entries(map).map(([label, data]: any) => ({
    label,
    key: data.key,
    options: Array.from(data.values),
  }));
}, [allVehicles]);


function FilterItem({
  title,
  isOpen,
  onClick,
  children,
}: any) {
  return (
    <div className="border-b last:border-none">

      <button
        onClick={onClick}
        className="w-full flex items-center justify-between px-4 py-4 text-sm font-semibold text-gray-700 hover:bg-gray-50"
      >
        <span>{title}</span>
        <ChevronDown
          size={16}
          className={`transition-transform ${
            isOpen ? "rotate-180" : ""
          }`}
        />
      </button>

      {isOpen && children}
    </div>
  );
}

  /* ---------------- UI ---------------- */

  return (
    <div  className="min-h-screen bg-[#fafafa]">
      {/* ================= HEADER ================= */}

<div className="sticky top-[80px] z-40 bg-primary px-4 md:px-10 py-4 md:py-6">
  
  <div className="flex flex-col md:flex-row md:items-center md:justify-between gap-4 text-white">

    {/* LEFT SECTION */}
    <div className="flex items-center gap-3 flex-wrap">

      {/* BACK */}
      <button
        onClick={() =>
  router.push(
    `/?city=${city}&rental_type=${rentalType}&from=${from || ""}&to=${to || ""}&months=${months}`
  )
}
        className="bg-white/20 p-2 md:p-3 rounded-lg"
      >
        <ChevronLeft size={18} />
      </button>

      {/* FROM */}
      <div>
        <div className="text-sm font-semibold">
          {formatTime(from)}
        </div>
        <div className="text-xs opacity-80">
          {formatDate(from)}
        </div>
      </div>

      <Clock size={16} />

      {/* DURATION */}
      <div className="text-sm">
        {durationType === "MONTHLY"
          ? `${months} month(s)`
          : getDuration(from, to)}
      </div>

      <div className="hidden md:block text-xl">→</div>

      {/* TO */}
      <div>
        <div className="text-sm font-semibold">
          {formatTime(to)}
        </div>
        <div className="text-xs opacity-80">
          {formatDate(to)}
        </div>
      </div>
    </div>

    {/* RIGHT SECTION (RANGE) */}
    <div className="w-full md:w-[320px]">

      <div className="flex justify-between text-sm mb-1">
        <span>Range</span>
        <span>{rangeConfig[range].km} Km</span>
      </div>

      <input
        type="range"
        min={0}
        max={2}
        value={rangeIndex}
        onChange={(e) =>
          setRange(rangeSteps[Number(e.target.value)])
        }
        className="w-full accent-white"
      />

      <div className="flex justify-between text-xs mt-1">
        {rangeSteps.map((r) => (
          <span key={r}>
            {rangeConfig[r].label}
          </span>
        ))}
      </div>

    </div>

  </div>
</div>

      {/* BODY */}
      <div className="max-w-7xl mx-auto p-4 md:p-6 grid grid-cols-1 lg:grid-cols-4 gap-6">

        {/* FILTER (HIDDEN MOBILE) */}
<div className="hidden lg:block">
  <div className="bg-white rounded-2xl border border-orange-200 overflow-hidden">

    

    {/* PRICE (static for now) */}
   <FilterItem
  title="PRICE"
  isOpen={openFilter === "PRICE"}
  onClick={() =>
    setOpenFilter(openFilter === "PRICE" ? null : "PRICE")
  }
>
  <div className="px-4 pb-4 space-y-3">

    <input
      type="number"
      placeholder="Min Price"
      className="w-full border rounded px-2 py-1 text-xs"
      value={filters.price_min?.[0] || ""}
      onChange={(e) =>
        setFilters((prev) => ({
          ...prev,
          price_min: [e.target.value],
        }))
      }
    />

    <input
      type="number"
      placeholder="Max Price"
      className="w-full border rounded px-2 py-1 text-xs"
      value={filters.price_max?.[0] || ""}
      onChange={(e) =>
        setFilters((prev) => ({
          ...prev,
          price_max: [e.target.value],
        }))
      }
    />

    {(filters.price_min || filters.price_max) && (
      <button
        className="text-primary text-xs"
        onClick={() =>
          setFilters((prev) => {
            const updated = { ...prev };
            delete updated.price_min;
            delete updated.price_max;
            return updated;
          })
        }
      >
        Clear Price
      </button>
    )}
  </div>
</FilterItem>

    {/* DYNAMIC FILTERS */}
    {dynamicFilters.map((filter: any) => (
      <FilterItem
        key={filter.label}
        title={filter.label}
        isOpen={openFilter === filter.label}
        onClick={() =>
          setOpenFilter(
            openFilter === filter.label ? null : filter.label
          )
        }
      >
        <div className="px-4 pb-4">

  {/* ✅ ADD THIS BLOCK HERE */}
  <div className="flex justify-between items-center pb-2 text-xs">
    <span className="text-gray-500">
      {(filters[filter.key] || []).length} selected
    </span>

    {filters[filter.key]?.length > 0 && (
      <button
        className="text-primary"
        onClick={() =>
          setFilters((prev) => {
            const updated = { ...prev };
            delete updated[filter.key];
            return updated;
          })
        }
      >
        Clear
      </button>
    )}
  </div>

  {/* 👇 YOUR EXISTING OPTIONS */}
  <div className="space-y-2">
    {filter.options.map((opt: string) => (
      <label
        key={opt}
        className="flex items-center gap-2 text-xs cursor-pointer"
      >
        <input
          type="checkbox"
          checked={(filters[filter.key] || []).includes(opt)}
          onChange={() => handleFilterChange(filter.key, opt)}
        />
        {opt}
      </label>
    ))}
  </div>

</div>
      </FilterItem>
    ))}

  </div>
</div>

        {/* VEHICLES */}
        <div className="lg:col-span-3 grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4 md:gap-6">
          {vehicles.map((v) => {
            const isAvailable = v.vehicle_count > 0;
            const attrs = v.submodel?.attributes || {};

            return (
<div
  key={v.submodel_id}
  className={`bg-white rounded-2xl shadow-sm hover:shadow-xl 
              transition-all duration-300 flex flex-col h-full overflow-hidden ${
    isAvailable ? "cursor-pointer" : "opacity-70"
  }`}
   onClick={() => {
      if (!isAvailable) return;

      router.push(
        `/partner-pricing?submodel=${encodeURIComponent(
          JSON.stringify(v)
        )}&partners=${encodeURIComponent(
          JSON.stringify(v.partners)
        )}&booking=${encodeURIComponent(
          JSON.stringify({ ...booking, range })
        )}`
      );
    }}
>

  {/* CONTENT */}
  <div className="p-3 sm:p-4 flex flex-col h-full">

    {/* IMAGE */}
    <div className="h-28 sm:h-32 flex items-center justify-center">
     <Image
  alt="Image"
  src={`${API_BASE}${v.image_url}`}
  width={300}
  height={200}
  className="object-contain max-h-full max-w-full"
/>
    </div>


    {/* TITLE */}
    <h3 className="text-sm font-semibold text-gray-800 text-center mt-2">
      {v.make_name} {v.submodel_name}
    </h3>

    {/* AVAILABILITY */}
    <div className="text-center text-xs mt-1">
      {isAvailable ? (
        <span className="text-green-600 font-medium">
          Only {v.vehicle_count} left
        </span>
      ) : (
        <span className="text-red-500 font-medium">
          Not Available
        </span>
      )}
    </div>

    {/* RATING */}
    <div className="flex items-center justify-center gap-1 mt-1 text-xs text-gray-500">
      <Star className="text-yellow-400 fill-yellow-400" size={14} />
      <span className="font-medium text-gray-700">4.5</span>
    </div>

    {/* SPECS */}
    <div className="grid grid-cols-2 gap-y-3 gap-x-4 mt-4 text-xs text-gray-600 justify-items-center">

      <Spec icon={<Fuel size={14} />} text={attrs.fueltype} />
      <Spec icon={<Gauge size={14} />} text={`${attrs.mileage} KMPL`} />
      <Spec icon={<Zap size={14} />} text={`${attrs.power} BHP`} />
      <Spec icon={<Settings size={14} />} text={`${attrs.torque} Nm`} />
      <Spec icon={<Weight size={14} />} text={`${attrs.weight} Kg`} />
      <Spec icon={<Cog size={14} />} text={attrs.transmission} />

    </div>

    {/* PRICE */}
    <div className="mt-auto pt-4 flex justify-between ml-3 mr-3">
      <p className="text-2xs text-gray-400 text-center">
        Price starting @
      </p>

      <p className="text-center font-semibold text-gray-900 mt-1">
        ₹ {getMinPrice(v)}
      </p>
    </div>

  </div>

  {/* BUTTON OUTSIDE */}
  <button
    disabled={!isAvailable}

    className={`w-full py-3 text-sm font-medium 
                flex items-center justify-center gap-2
                rounded-b-2xl ${
      isAvailable
        ? "bg-primary hover:bg-primary text-white"
        : "bg-gray-400 text-white"
    }`}
  >
    Rent Now →
  </button>

</div>
            );
          })}



                    {exploreRides.length > 0 && (
<div className="lg:col-span-3 mt-8">
  <h2 className="text-lg font-semibold mb-4 px-2">
    Explore More Rides
  </h2>

  {/* 👇 FIXED CONTAINER */}
  <div className="relative -mx-4 md:-mx-6">
    <div className="flex gap-4 overflow-x-auto px-4 md:px-6 pb-2 scrollbar-hide">
      
      {exploreRides.map((v) => {
        const isAvailable =
          v.pickup_options?.some((p: any) => p.vehicle_count > 0);

        const attrs = v.attributes || {};

        return (
          <div
            key={v.submodel_id}
            className={`min-w-[260px] max-w-[260px] flex-shrink-0
              bg-white rounded-2xl shadow-sm hover:shadow-xl 
              transition-all duration-300 flex flex-col h-full overflow-hidden ${
                isAvailable ? "cursor-pointer" : "opacity-70"
              }`}
              onClick={() => {
  if (!isAvailable) return;

  // ✅ NORMALIZE STRUCTURE
  const normalizedSubmodel = {
    submodel_id: v.submodel_id,
    submodel_name: v.submodel_name,
    make_name: v.make_name,
    model_name: v.model_name,

    // ✅ FIX IMAGE
    image_url: v.image,

    // ✅ MATCH STRUCTURE
    submodel: {
      attributes: v.attributes,
    },
  };

  const normalizedPartners = v.pickup_options.map((p: any) => ({
    partner_name: p.partner_name,
    pickup_point_id: p.pickup_point_id,
    pickup_point_name: p.pickup_point_name,
    vehicle_id: p.vehicle_id,
    image_url: p.image_url,
    plans: p.plans,
    vehicle_count: p.vehicle_count,
  }));

  router.push(
    `/partner-pricing?submodel=${encodeURIComponent(
      JSON.stringify(normalizedSubmodel)
    )}&partners=${encodeURIComponent(
      JSON.stringify(normalizedPartners)
    )}&booking=${encodeURIComponent(
      JSON.stringify({ ...booking, range })
    )}`
  );
}}
          >
          
            {/* CONTENT */}
            <div className="p-3 sm:p-4 flex flex-col h-full">

              {/* IMAGE */}
              <div className="h-28 sm:h-32 flex items-center justify-center">
                <Image
  alt="Image"
  src={`${API_BASE}${v.image}`}
  width={300}
  height={200}
  className="object-contain max-h-full max-w-full"
/>
              </div>

              {/* TITLE */}
              <h3 className="text-sm font-semibold text-gray-800 text-center mt-2">
                {v.make_name} {v.submodel_name}
              </h3>

              {/* AVAILABILITY */}
              <div className="text-center text-xs mt-1">
                {isAvailable ? (
                  <span className="text-green-600 font-medium">
                    Available
                  </span>
                ) : (
                  <span className="text-red-500 font-medium">
                    Not Available
                  </span>
                )}
              </div>

              {/* RATING */}
              <div className="flex items-center justify-center gap-1 mt-1 text-xs text-gray-500">
                <Star
                  className="text-yellow-400 fill-yellow-400"
                  size={14}
                />
                <span className="font-medium text-gray-700">
                  4.5
                </span>
              </div>

              {/* SPECS */}
              <div className="grid grid-cols-2 gap-y-3 gap-x-4 mt-4 text-xs text-gray-600 justify-items-center">

                <Spec icon={<Fuel size={14} />} text={attrs.fueltype} />
                <Spec icon={<Gauge size={14} />} text={`${attrs.mileage} KMPL`} />
                <Spec icon={<Zap size={14} />} text={`${attrs.power} BHP`} />
                <Spec icon={<Settings size={14} />} text={`${attrs.torque} Nm`} />
                <Spec icon={<Weight size={14} />} text={`${attrs.weight} Kg`} />
                <Spec icon={<Cog size={14} />} text={attrs.transmission} />

              </div>

              {/* PRICE */}
              <div className="mt-auto pt-4 flex justify-between ml-3 mr-3">
                <p className="text-2xs text-gray-400 text-center">
                  Price starting @
                </p>

                <p className="text-center font-semibold text-gray-900 mt-1">
                  ₹ {getExploreMinPrice(v)}
                </p>
              </div>
            </div>

            {/* BUTTON */}
            <button
  disabled={!isAvailable}

  className={`w-full py-3 text-sm font-medium 
    flex items-center justify-center gap-2
    rounded-b-2xl ${
      isAvailable
        ? "bg-primary text-white"
        : "bg-gray-400 text-white"
    }`}
>
  Rent Now →
</button>
          </div>
        );
      })}
    </div>
    </div>
  </div>
)}
        </div>


        






</div>
  
{/* \\ kkk */}
  


      

    </div>

    
  );
}

/* SPEC */
function Spec({ icon, text }: any) {
  return (
    <div className="flex items-center gap-2">
      <span className="text-primary">{icon}</span>
      <span className="text-xs">{text || "--"}</span>
    </div>
  );
}



