"use client";

import { useState } from "react";
import type { AxiosError } from "axios";
import { CheckCircle2, Loader2, Plus, X } from "lucide-react";
import { useRepositories } from "@/di/repository-provider";
import { useApiMutation } from "@/presentation/hooks/use-api-mutation";
import { useT, useLocale } from "@/shared/i18n/client";
import { formatDate, formatDateTime } from "@/shared/lib/format-date";
import { Button } from "@/presentation/components/ui/button";
import { Input } from "@/presentation/components/ui/input";
import { Textarea } from "@/presentation/components/ui/textarea";
import { Card, CardAction, CardContent, CardDescription, CardHeader, CardTitle } from "@/presentation/components/ui/card";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/presentation/components/ui/select";
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/presentation/components/ui/table";
import { DataQualityEffectBadge, DataQualityStatusBadge } from "./data-quality-badges";
import type {
  AddDataQualityVehiclePayload,
  DataQualityEffect,
  DataQualityIssue,
  DataQualityMakeNotScored,
  DataQualityStatus,
} from "@/domain/entities/data-quality";

const STATUSES: DataQualityStatus[] = ["open", "analysing", "field", "accepted", "resolved"];
const EFFECTS: DataQualityEffect[] = ["provisional", "low"];

const formatKm = (km: number | null, locale: string) =>
  km === null ? "—" : km.toLocaleString(locale === "fr" ? "fr-FR" : "en-US");

export function IssueDetail({
  issue,
  onChanged,
  onClose,
}: {
  issue: DataQualityIssue;
  onChanged: () => void;
  onClose: () => void;
}) {
  const t = useT();
  const locale = useLocale();
  const copy = t.dataQuality;
  const { dataQualityRepository } = useRepositories();
  const [nextStep, setNextStep] = useState(issue.next_step ?? "");
  const [note, setNote] = useState("");
  const [plate, setPlate] = useState("");
  const [measure, setMeasure] = useState("");

  const updateMutation = useApiMutation(
    (payload: { status?: DataQualityStatus; effect?: DataQualityEffect; next_step?: string | null }) =>
      dataQualityRepository.updateIssue(issue.id, payload),
    { successMessage: copy.toasts.updated, onSuccess: onChanged }
  );

  const noteMutation = useApiMutation(
    (text: string) => dataQualityRepository.addNote(issue.id, text),
    { successMessage: copy.toasts.noteAdded, onSuccess: () => { setNote(""); onChanged(); } }
  );

  const addVehicleMutation = useApiMutation(
    async (payload: AddDataQualityVehiclePayload) => {
      try {
        return await dataQualityRepository.addVehicle(issue.id, payload);
      } catch (err) {
        if ((err as AxiosError).response?.status === 404) throw new Error(copy.detail.vehicleNotFound);
        throw err;
      }
    },
    { successMessage: copy.toasts.vehicleAdded, onSuccess: () => { setPlate(""); setMeasure(""); onChanged(); } }
  );

  const resolveMutation = useApiMutation(
    (linkId: number) => dataQualityRepository.resolveVehicle(linkId),
    { successMessage: copy.toasts.vehicleResolved, onSuccess: onChanged }
  );

  const nextStepChanged = nextStep.trim() !== (issue.next_step ?? "");

  return (
    <Card className="gap-4">
      <CardHeader>
        <CardTitle>{copy.detail.title(issue.title)}</CardTitle>
        <CardDescription>
          {copy.detail.subtitle(issue.vehicles_count, issue.clients_count)}
          {issue.detail && <span className="block mt-1">{issue.detail}</span>}
        </CardDescription>
        <CardAction>
          <Button variant="ghost" size="icon-sm" onClick={onClose} aria-label={copy.detail.close}>
            <X className="w-4 h-4" />
          </Button>
        </CardAction>
      </CardHeader>
      <CardContent className="space-y-6">
        <div className="grid gap-4 md:grid-cols-[auto_auto_1fr] md:items-end">
          <div className="space-y-1.5">
            <p className="text-xs font-medium text-muted-foreground">{copy.issues.columns.status}</p>
            <Select
              value={issue.status}
              onValueChange={(value) => updateMutation.mutate({ status: value as DataQualityStatus })}
              disabled={updateMutation.loading}
            >
              <SelectTrigger size="sm" className="w-44"><SelectValue /></SelectTrigger>
              <SelectContent>
                {STATUSES.map((s) => <SelectItem key={s} value={s}>{copy.status[s]}</SelectItem>)}
              </SelectContent>
            </Select>
          </div>
          <div className="space-y-1.5">
            <p className="text-xs font-medium text-muted-foreground">{copy.detail.effect}</p>
            <Select
              value={issue.effect}
              onValueChange={(value) => updateMutation.mutate({ effect: value as DataQualityEffect })}
              disabled={updateMutation.loading}
            >
              <SelectTrigger size="sm" className="w-44"><SelectValue /></SelectTrigger>
              <SelectContent>
                {EFFECTS.map((e) => <SelectItem key={e} value={e}>{copy.effect[e]}</SelectItem>)}
              </SelectContent>
            </Select>
          </div>
          <form
            className="space-y-1.5"
            onSubmit={(e) => {
              e.preventDefault();
              updateMutation.mutate({ next_step: nextStep.trim() || null });
            }}
          >
            <p className="text-xs font-medium text-muted-foreground">{copy.detail.nextStep}</p>
            <div className="flex gap-2">
              <Input
                className="h-8"
                value={nextStep}
                placeholder={copy.detail.nextStepPlaceholder}
                onChange={(e) => setNextStep(e.target.value)}
              />
              <Button type="submit" size="sm" variant="outline" disabled={!nextStepChanged || updateMutation.loading}>
                {copy.detail.save}
              </Button>
            </div>
          </form>
        </div>

        <div className="grid gap-6 lg:grid-cols-[2fr_1fr]">
          <div className="space-y-3">
            <div>
              <p className="text-sm font-semibold">{copy.detail.vehicles}</p>
              <p className="text-xs text-muted-foreground">{copy.detail.vehiclesSubtitle}</p>
            </div>
            <div className="rounded-lg border">
              <Table>
                <TableHeader>
                  <TableRow>
                    <TableHead>{copy.detail.columns.plate}</TableHead>
                    <TableHead>{copy.detail.columns.client}</TableHead>
                    <TableHead>{copy.detail.columns.box}</TableHead>
                    <TableHead>{copy.detail.columns.measure}</TableHead>
                    <TableHead>{copy.detail.columns.since}</TableHead>
                    <TableHead className="text-right">{copy.detail.columns.km}</TableHead>
                    <TableHead className="w-10" />
                  </TableRow>
                </TableHeader>
                <TableBody>
                  {issue.vehicles.length === 0 ? (
                    <TableRow>
                      <TableCell colSpan={7} className="py-6 text-center text-sm text-muted-foreground">{copy.detail.noVehicles}</TableCell>
                    </TableRow>
                  ) : issue.vehicles.map((v) => (
                    <TableRow key={v.link_id}>
                      <TableCell>
                        <span className="font-medium">{v.plate}</span>
                        {v.model && <span className="block text-xs text-muted-foreground">{v.model}</span>}
                      </TableCell>
                      <TableCell>{v.client ?? "—"}</TableCell>
                      <TableCell>{v.box ?? "—"}</TableCell>
                      <TableCell className="whitespace-normal">{v.measure ?? "—"}</TableCell>
                      <TableCell>{v.since ? formatDate(v.since, locale) : "—"}</TableCell>
                      <TableCell className="text-right font-mono">{formatKm(v.km_30d, locale)}</TableCell>
                      <TableCell>
                        <Button
                          variant="ghost"
                          size="sm"
                          disabled={resolveMutation.loading}
                          onClick={() => resolveMutation.mutate(v.link_id)}
                        >
                          <CheckCircle2 className="w-4 h-4 mr-1.5" />
                          {copy.detail.resolve}
                        </Button>
                      </TableCell>
                    </TableRow>
                  ))}
                </TableBody>
              </Table>
            </div>
            <form
              className="flex flex-wrap items-center gap-2"
              onSubmit={(e) => {
                e.preventDefault();
                if (!plate.trim()) return;
                addVehicleMutation.mutate({ plate: plate.trim(), ...(measure.trim() ? { measure: measure.trim() } : {}) });
              }}
            >
              <Input className="h-8 w-36" value={plate} placeholder={copy.detail.platePlaceholder} onChange={(e) => setPlate(e.target.value)} />
              <Input className="h-8 flex-1 min-w-48" value={measure} placeholder={copy.detail.measurePlaceholder} onChange={(e) => setMeasure(e.target.value)} />
              <Button type="submit" size="sm" variant="outline" disabled={!plate.trim() || addVehicleMutation.loading}>
                {addVehicleMutation.loading ? <Loader2 className="w-4 h-4 mr-1.5 animate-spin" /> : <Plus className="w-4 h-4 mr-1.5" />}
                {copy.detail.addVehicle}
              </Button>
            </form>
          </div>

          <div className="space-y-3">
            <p className="text-sm font-semibold">{copy.detail.notes}</p>
            {issue.notes.length === 0 ? (
              <p className="text-sm text-muted-foreground">{copy.detail.noNotes}</p>
            ) : (
              <ul className="space-y-2">
                {issue.notes.map((n, i) => (
                  <li key={`${n.at}-${i}`} className="rounded-lg bg-muted/50 px-3 py-2 text-sm">
                    <span className="block text-xs text-muted-foreground">
                      {formatDateTime(n.at, locale)}{n.by ? ` · ${n.by}` : ""}
                    </span>
                    <span className="whitespace-pre-line">{n.text}</span>
                  </li>
                ))}
              </ul>
            )}
            <form
              className="space-y-2"
              onSubmit={(e) => {
                e.preventDefault();
                if (note.trim()) noteMutation.mutate(note.trim());
              }}
            >
              <Textarea rows={3} value={note} placeholder={copy.detail.notePlaceholder} onChange={(e) => setNote(e.target.value)} />
              <Button type="submit" size="sm" variant="outline" disabled={!note.trim() || noteMutation.loading}>
                {noteMutation.loading && <Loader2 className="w-4 h-4 mr-1.5 animate-spin" />}
                {copy.detail.addNote}
              </Button>
            </form>
          </div>
        </div>
      </CardContent>
    </Card>
  );
}

export function MakesNotScoredDetail({
  makes,
  onClose,
}: {
  makes: DataQualityMakeNotScored[];
  onClose: () => void;
}) {
  const t = useT();
  const copy = t.dataQuality;
  const vehicles = makes.reduce((sum, m) => sum + m.vehicles, 0);

  return (
    <Card className="gap-4">
      <CardHeader>
        <CardTitle className="flex items-center gap-2">
          {copy.detail.title(copy.makes.title)}
          <DataQualityStatusBadge status="analysing" />
          <DataQualityEffectBadge effect="none" />
        </CardTitle>
        <CardDescription>{copy.makes.subtitle(vehicles)}</CardDescription>
        <CardAction>
          <Button variant="ghost" size="icon-sm" onClick={onClose} aria-label={copy.detail.close}>
            <X className="w-4 h-4" />
          </Button>
        </CardAction>
      </CardHeader>
      <CardContent>
        <div className="rounded-lg border">
          <Table>
            <TableHeader>
              <TableRow>
                <TableHead>{copy.makes.columns.make}</TableHead>
                <TableHead className="text-right">{copy.makes.columns.vehicles}</TableHead>
                <TableHead className="text-right">{copy.makes.columns.clients}</TableHead>
                <TableHead>{copy.makes.columns.clientNames}</TableHead>
              </TableRow>
            </TableHeader>
            <TableBody>
              {makes.map((m) => (
                <TableRow key={m.make}>
                  <TableCell className="font-medium">{m.make}</TableCell>
                  <TableCell className="text-right font-mono">{m.vehicles}</TableCell>
                  <TableCell className="text-right font-mono">{m.clients}</TableCell>
                  <TableCell className="whitespace-normal text-muted-foreground">{m.client_names.join(", ") || "—"}</TableCell>
                </TableRow>
              ))}
            </TableBody>
          </Table>
        </div>
      </CardContent>
    </Card>
  );
}
