"use client";

import { useMemo, useState } from "react";
import { Check, Loader2, RefreshCw, Sparkles } from "lucide-react";
import { useRepositories } from "@/di/repository-provider";
import { useT } from "@/shared/i18n/client";
import { useApiQuery } from "@/presentation/hooks/use-api-query";
import { useApiMutation } from "@/presentation/hooks/use-api-mutation";
import { Button } from "@/presentation/components/ui/button";
import { Input } from "@/presentation/components/ui/input";
import { Badge } from "@/presentation/components/ui/badge";
import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from "@/presentation/components/ui/sheet";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/presentation/components/ui/select";
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/presentation/components/ui/table";
import ConfirmationDialog from "@/presentation/components/shared/confirmation-dialog";
import type { CompanyFuelTanks, CompanyFuelTankVehicle } from "@/domain/entities/fuel-tank";

const SOURCE_CLASS = {
  manual: "bg-green-100 text-green-800",
  estimated: "bg-amber-100 text-amber-800",
  older: "bg-slate-100 text-slate-600",
};

const ALL_SITES = "all";
const NO_SITE = "none";

/**
 * A client's fuel tanks, for the whole company or one site: the size of each fuel vehicle and who set
 * it, the estimate from make and model for the missing ones or for one vehicle, and the size typed by hand.
 */
export function CompanyFuelTanksSheet({ companyId, companyName, open, onOpenChange }: {
  companyId: number | null;
  companyName: string;
  open: boolean;
  onOpenChange: (open: boolean) => void;
}) {
  const t = useT();
  const container = useRepositories();
  const [site, setSite] = useState<string>(ALL_SITES);
  const [confirmOpen, setConfirmOpen] = useState(false);
  const [drafts, setDrafts] = useState<Record<number, string>>({});
  const [queuedMessage, setQueuedMessage] = useState<string | null>(null);

  const { data, loading, refetch } = useApiQuery<CompanyFuelTanks | null>(
    () => (companyId ? container.companyRepository.getFuelTanks(companyId) : Promise.resolve(null)),
    { deps: [companyId, open], enabled: open && !!companyId }
  );

  const estimate = useApiMutation(
    ({ ids, missingOnly }: { ids: number[]; missingOnly: boolean }) =>
      container.companyRepository.estimateFuelTanks(companyId!, missingOnly ? "missing" : "all", ids),
    {
      onSuccess: (result) => {
        setConfirmOpen(false);
        refetch();
        if (result) setQueuedMessage(t.fuelTanks.queued(result.queued));
      },
    }
  );
  const save = useApiMutation(
    ({ id, litres }: { id: number; litres: number | null }) => container.vehicleRepository.update(id, { fuel_tank_capacity: litres }),
    {
      successMessage: t.fuelTanks.saved,
      onSuccess: (vehicle) => {
        setDrafts((current) => {
          const next = { ...current };
          delete next[vehicle.id];
          return next;
        });
        refetch();
      },
    }
  );

  const sites = useMemo(() => {
    const byId = new Map<number, string>();
    (data?.vehicles ?? []).forEach((v) => v.site && byId.set(v.site.id, v.site.name));
    return [...byId.entries()].sort((a, b) => a[1].localeCompare(b[1]));
  }, [data]);
  const hasNoSite = (data?.vehicles ?? []).some((v) => !v.site);

  const vehicles = (data?.vehicles ?? []).filter((v) =>
    site === ALL_SITES ? true : site === NO_SITE ? !v.site : v.site?.id === Number(site)
  );
  const missing = vehicles.filter((v) => v.fuel_tank_capacity === null);
  const summary = {
    vehicles: vehicles.length,
    missing: missing.length,
    manual: vehicles.filter((v) => v.fuel_tank_capacity_source === "manual").length,
    estimated: vehicles.filter((v) => v.fuel_tank_capacity_source === "estimated").length,
  };

  const sourceBadge = (vehicle: CompanyFuelTankVehicle) => {
    if (vehicle.fuel_tank_capacity === null) return <span className="text-muted-foreground">—</span>;
    const key = vehicle.fuel_tank_capacity_source ?? "older";
    return <Badge className={SOURCE_CLASS[key]}>{t.fuelTanks.source[key]}</Badge>;
  };

  const draftOf = (vehicle: CompanyFuelTankVehicle) =>
    drafts[vehicle.id] ?? (vehicle.fuel_tank_capacity !== null ? String(vehicle.fuel_tank_capacity) : "");
  const changed = (vehicle: CompanyFuelTankVehicle) =>
    drafts[vehicle.id] !== undefined && drafts[vehicle.id] !== (vehicle.fuel_tank_capacity !== null ? String(vehicle.fuel_tank_capacity) : "");

  return (
    <Sheet open={open} onOpenChange={(value) => { setQueuedMessage(null); setDrafts({}); setSite(ALL_SITES); onOpenChange(value); }}>
      <SheetContent className="w-full sm:max-w-3xl overflow-y-auto">
        <SheetHeader className="shrink-0">
          <SheetTitle>{t.fuelTanks.title(companyName)}</SheetTitle>
          <SheetDescription>{t.fuelTanks.description}</SheetDescription>
        </SheetHeader>

        {loading && !data ? (
          <div className="flex justify-center py-10"><Loader2 className="w-6 h-6 animate-spin" /></div>
        ) : (
          <div className="shrink-0 space-y-4 px-4 pb-6">
            <div className="flex items-center gap-2">
              <span className="text-sm text-muted-foreground">{t.fuelTanks.site}</span>
              <Select value={site} onValueChange={setSite}>
                <SelectTrigger className="w-64"><SelectValue /></SelectTrigger>
                <SelectContent>
                  <SelectItem value={ALL_SITES}>{t.fuelTanks.allSites}</SelectItem>
                  {sites.map(([id, name]) => <SelectItem key={id} value={String(id)}>{name}</SelectItem>)}
                  {hasNoSite && <SelectItem value={NO_SITE}>{t.fuelTanks.noSite}</SelectItem>}
                </SelectContent>
              </Select>
            </div>

            <div className="grid grid-cols-4 gap-2">
              {(["vehicles", "missing", "manual", "estimated"] as const).map((key) => (
                <div key={key} className="rounded-lg border p-3">
                  <div className="text-xs text-muted-foreground">{t.fuelTanks.summary[key]}</div>
                  <div className="text-xl font-semibold">{summary[key]}</div>
                </div>
              ))}
            </div>

            <div className="flex flex-wrap items-center gap-2">
              <Button size="sm" disabled={missing.length === 0 || estimate.loading} onClick={() => setConfirmOpen(true)}>
                {t.fuelTanks.estimateMissing(missing.length)}
              </Button>
              <Button size="sm" variant="ghost" onClick={() => refetch()} disabled={loading}>
                <RefreshCw className={`w-4 h-4 mr-2 ${loading ? "animate-spin" : ""}`} />
                {t.fuelTanks.refresh}
              </Button>
            </div>
            {queuedMessage && <p className="text-sm text-muted-foreground">{queuedMessage}</p>}

            {vehicles.length === 0 ? (
              <p className="py-6 text-center text-sm text-muted-foreground">{t.fuelTanks.empty}</p>
            ) : (
              <Table>
                <TableHeader>
                  <TableRow>
                    <TableHead>{t.fuelTanks.columns.vehicle}</TableHead>
                    <TableHead className="w-48">{t.fuelTanks.columns.tank}</TableHead>
                    <TableHead>{t.fuelTanks.columns.source}</TableHead>
                    <TableHead>{t.fuelTanks.columns.box}</TableHead>
                  </TableRow>
                </TableHeader>
                <TableBody>
                  {vehicles.map((vehicle) => (
                    <TableRow key={vehicle.id}>
                      <TableCell>
                        <div className="font-medium">{vehicle.numberplate}</div>
                        <div className="text-xs text-muted-foreground">
                          {[vehicle.mark, vehicle.model].filter(Boolean).join(" ")}
                          {site === ALL_SITES && vehicle.site ? ` · ${vehicle.site.name}` : ""}
                        </div>
                      </TableCell>
                      <TableCell>
                        <div className="flex items-center gap-1">
                          <Input
                            type="number"
                            className="h-8 w-24"
                            value={draftOf(vehicle)}
                            onChange={(event) => setDrafts((current) => ({ ...current, [vehicle.id]: event.target.value }))}
                          />
                          {changed(vehicle) ? (
                            <Button
                              size="icon"
                              variant="ghost"
                              className="h-8 w-8"
                              title={t.fuelTanks.saveRow}
                              disabled={save.loading}
                              onClick={() => save.mutate({ id: vehicle.id, litres: draftOf(vehicle) === "" ? null : Number(draftOf(vehicle)) })}
                            >
                              <Check className="w-4 h-4" />
                            </Button>
                          ) : vehicle.fuel_tank_capacity_source !== "manual" && (
                            <Button
                              size="icon"
                              variant="ghost"
                              className="h-8 w-8"
                              title={t.fuelTanks.estimateRow}
                              disabled={estimate.loading}
                              onClick={() => estimate.mutate({ ids: [vehicle.id], missingOnly: false })}
                            >
                              <Sparkles className="w-4 h-4" />
                            </Button>
                          )}
                        </div>
                      </TableCell>
                      <TableCell>{sourceBadge(vehicle)}</TableCell>
                      <TableCell>{vehicle.has_box ? "✓" : "—"}</TableCell>
                    </TableRow>
                  ))}
                </TableBody>
              </Table>
            )}
          </div>
        )}

        <ConfirmationDialog
          open={confirmOpen}
          onOpenChange={setConfirmOpen}
          title={t.fuelTanks.confirmTitle}
          description={t.fuelTanks.confirmMissing(missing.length)}
          confirmLabel={t.fuelTanks.confirm}
          loading={estimate.loading}
          onConfirm={() => estimate.mutate({ ids: missing.map((v) => v.id), missingOnly: true })}
        />
      </SheetContent>
    </Sheet>
  );
}
