"use client";

import { useCallback, useEffect, useState } from "react";
import { useRouter } from "next/navigation";
import Link from "next/link";
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
import { Button } from "@/components/ui/button";
import { Plus } from "lucide-react";
import { VehicleTable } from "./vehicle-table";
import { DeleteVehicleDialog } from "./delete-vehicle-dialog";
import {
  changeVehicleStatusAction,
  deleteVehicleAction,
  getVehiclesAction,
  type PaginationLink,
  type VehicleListData,
  type VehicleListItem,
} from "@/features/vehicles/actions/vehicles-actions";
import { useToastEnhanced } from "@/hooks/use-toast-enhanced";

interface VehicleCategoryOption {
  id: number;
  name: string;
}

interface VehiclesClientProps {
  categories: VehicleCategoryOption[];
  initialData?: VehicleListData;
}

export function VehiclesClient({ initialData }: VehiclesClientProps) {
  const toast = useToastEnhanced();
  const router = useRouter();
  const [currentTab, setCurrentTab] = useState<"all" | "active" | "inactive">(
    "all"
  );
  const [vehicles, setVehicles] = useState<VehicleListItem[]>(
    initialData?.data ?? []
  );
  const [isLoading, setIsLoading] = useState(false);
  const [searchQuery, setSearchQuery] = useState("");
  const [debouncedSearch, setDebouncedSearch] = useState("");
  const [currentPage, setCurrentPage] = useState(
    initialData?.current_page ?? 1
  );
  const [itemsPerPage, setItemsPerPage] = useState(10);
  const [totalPages, setTotalPages] = useState(initialData?.last_page ?? 1);
  const [totalItems, setTotalItems] = useState(initialData?.total ?? 0);
  const [paginationLinks, setPaginationLinks] = useState<PaginationLink[]>(
    initialData?.links ?? []
  );
  const [hasNextPage, setHasNextPage] = useState(
    Boolean(initialData?.next_page_url)
  );
  const [hasPrevPage, setHasPrevPage] = useState(
    Boolean(initialData?.prev_page_url)
  );
  const [tabCounts, setTabCounts] = useState({
    all: initialData?.total ?? 0,
    active: 0,
    inactive: 0,
  });
  const [selectedVehicleForDelete, setSelectedVehicleForDelete] =
    useState<VehicleListItem | null>(null);
  const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);

  // Starts at 0 so the fetch effect skips the initial mount (data comes from server).
  // User actions increment this to trigger subsequent fetches.
  const [fetchGeneration, setFetchGeneration] = useState(0);

  const loadVehicles = useCallback(
    async (
      tab: "all" | "active" | "inactive",
      page: number,
      perPage: number,
      search: string
    ) => {
      setIsLoading(true);
      try {
        const status = tab === "all" ? undefined : tab;
        const result = await getVehiclesAction(page, perPage, status, search);
        if (!result.success || !result.data) {
          throw new Error(result.error || "Failed to load vehicles");
        }

        setVehicles(result.data.data);
        setCurrentPage(result.data.current_page);
        setTotalPages(result.data.last_page || 1);
        setTotalItems(result.data.total || 0);
        setPaginationLinks(result.data.links || []);
        setHasNextPage(Boolean(result.data.next_page_url));
        setHasPrevPage(Boolean(result.data.prev_page_url));
        setTabCounts((prev) => ({
          ...prev,
          [tab]: result.data?.total || 0,
        }));
      } catch (error) {
        toast.error({
          title: "Failed to Load Vehicles",
          description:
            error instanceof Error
              ? error.message
              : "Could not load vehicle list.",
        });
      } finally {
        setIsLoading(false);
      }
    },
    [toast]
  );

  // Debounce search: only trigger a fetch when the value actually changes to avoid
  // firing on the initial mount where both trimmed and debouncedSearch are "".
  useEffect(() => {
    const timer = setTimeout(() => {
      const trimmed = searchQuery.trim();
      // debouncedSearch is intentionally captured as a stale closure here —
      // we only want to compare against the value that was current when searchQuery changed.
      if (trimmed !== debouncedSearch) {
        setDebouncedSearch(trimmed);
        setCurrentPage(1);
        setFetchGeneration((g) => g + 1);
      }
    }, 400);
    return () => clearTimeout(timer);
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [searchQuery]);

  // Main fetch effect. fetchGeneration === 0 means initial mount with server data — skip.
  // All state changes are batched with setFetchGeneration so the closure always has
  // the latest tab/page/search values when this effect runs.
  useEffect(() => {
    if (fetchGeneration === 0) return;
    loadVehicles(currentTab, currentPage, itemsPerPage, debouncedSearch);
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [fetchGeneration]);

  const handleToggleStatus = useCallback(
    async (vehicle: VehicleListItem) => {
      const nextStatus = vehicle.status === "active" ? "inactive" : "active";
      const result = await changeVehicleStatusAction(
        vehicle.id,
        nextStatus as "active" | "inactive"
      );
      if (!result.success) {
        toast.error({
          title: "Failed to Update Status",
          description: result.error || "Could not update vehicle status.",
        });
        return;
      }
      toast.success({
        title: "Status Updated",
        description: `${vehicle.name} is now ${nextStatus}.`,
      });
      setFetchGeneration((g) => g + 1);
    },
    [toast]
  );

  const handleDeleteVehicle = useCallback((vehicle: VehicleListItem) => {
    setSelectedVehicleForDelete(vehicle);
    setIsDeleteDialogOpen(true);
  }, []);

  const handleConfirmDelete = useCallback(async () => {
    if (!selectedVehicleForDelete) return;

    const result = await deleteVehicleAction(selectedVehicleForDelete.id);
    if (!result.success) {
      toast.error({
        title: "Failed to Delete Vehicle",
        description: result.error || "Could not delete vehicle.",
      });
      return;
    }

    toast.success({
      title: "Vehicle Deleted",
      description: `${selectedVehicleForDelete.name} has been deleted.`,
    });
    setIsDeleteDialogOpen(false);
    setSelectedVehicleForDelete(null);
    setFetchGeneration((g) => g + 1);
  }, [selectedVehicleForDelete, toast]);

  const handleEditVehicle = useCallback(
    (vehicle: VehicleListItem) => {
      const vehicleId = String(vehicle.id ?? vehicle.vehicle_id ?? "");
      if (!vehicleId) {
        toast.error({
          title: "Missing Vehicle ID",
          description: "Unable to edit because the vehicle ID is missing.",
        });
        return;
      }
      router.push(
        `/admin/vehicle-listing/edit/${encodeURIComponent(vehicleId)}`
      );
    },
    [router, toast]
  );

  const sharedTableProps = {
    vehicles,
    isLoading,
    currentPage,
    totalPages,
    totalItems,
    itemsPerPage,
    paginationLinks,
    hasNextPage,
    hasPrevPage,
    searchQuery,
    onSearchQueryChange: (value: string) => {
      setSearchQuery(value);
    },
    onPageChange: (page: number) => {
      setCurrentPage(page);
      setFetchGeneration((g) => g + 1);
    },
    onItemsPerPageChange: (value: number) => {
      setCurrentPage(1);
      setItemsPerPage(value);
      setFetchGeneration((g) => g + 1);
    },
    onEdit: handleEditVehicle,
    onDelete: handleDeleteVehicle,
    onToggleStatus: handleToggleStatus,
  };

  return (
    <section aria-labelledby="vehicles-heading" className="admin-section">
      <header className="admin-page-header flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
        <div>
          <h1 id="vehicles-heading" className="admin-page-title">
            Vehicle Listing
          </h1>
          <p className="admin-page-description">
            Manage all vehicles available for booking.
          </p>
        </div>
        <Link
          href="/admin/vehicle-listing/add-new"
          className="w-full sm:w-auto"
        >
          <Button className="w-full sm:w-auto">
            <Plus className="mr-2 h-4 w-4" aria-hidden="true" />
            Add Vehicle
          </Button>
        </Link>
      </header>

      <Tabs
        value={currentTab}
        onValueChange={(value) => {
          const newTab = value as "all" | "active" | "inactive";
          setCurrentTab(newTab);
          setCurrentPage(1);
          setFetchGeneration((g) => g + 1);
        }}
        className="w-full"
      >
        <TabsList className="mb-6 h-auto p-1.5 bg-muted/50 rounded-xl border border-border/50">
          <TabsTrigger
            value="all"
            className="rounded-lg data-[state=active]:bg-background data-[state=active]:shadow-sm px-4 py-2"
          >
            All ({tabCounts.all})
          </TabsTrigger>
          <TabsTrigger
            value="active"
            className="rounded-lg data-[state=active]:bg-background data-[state=active]:shadow-sm px-4 py-2"
          >
            Active ({tabCounts.active})
          </TabsTrigger>
          <TabsTrigger
            value="inactive"
            className="rounded-lg data-[state=active]:bg-background data-[state=active]:shadow-sm px-4 py-2"
          >
            Inactive ({tabCounts.inactive})
          </TabsTrigger>
        </TabsList>

        <TabsContent value="all" className="mt-0">
          <VehicleTable {...sharedTableProps} />
        </TabsContent>

        <TabsContent value="active" className="mt-0">
          <VehicleTable {...sharedTableProps} />
        </TabsContent>

        <TabsContent value="inactive" className="mt-0">
          <VehicleTable {...sharedTableProps} />
        </TabsContent>
      </Tabs>

      <DeleteVehicleDialog
        vehicle={selectedVehicleForDelete}
        open={isDeleteDialogOpen}
        onOpenChange={(open) => {
          setIsDeleteDialogOpen(open);
          if (!open) {
            setSelectedVehicleForDelete(null);
          }
        }}
        onConfirm={handleConfirmDelete}
      />
    </section>
  );
}
