"use client";

import { useEffect, useState } from "react";
import { CheckCircle2, ExternalLink, FlaskConical, Loader2, TriangleAlert } from "lucide-react";
import { useT, useLocale } from "@/shared/i18n/client";
import { useRepositories } from "@/di/repository-provider";
import { env } from "@/infrastructure/config/env";
import { formatParis, isFuture, issuesToFieldErrors, validateAnnouncement } from "@/shared/lib/announcements";
import { Button } from "@/presentation/components/ui/button";
import { Checkbox } from "@/presentation/components/ui/checkbox";
import { Label } from "@/presentation/components/ui/label";
import { SearchableSelect } from "@/presentation/components/ui/searchable-select";
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
} from "@/presentation/components/ui/dialog";
import { useIssueMessage } from "@/presentation/components/announcements/form-controls";
import type {
  Announcement,
  AnnouncementCatalogs,
  AnnouncementExampleVehicle,
  AnnouncementFieldErrors,
  AnnouncementInput,
  AnnouncementPreviewToken,
  AudienceCount,
} from "@/domain/entities/announcement";

/** "Aperçu dans Fleet": token, example vehicle when the page needs one, new tab (spec §7.1). */
export function PreviewDialog({
  open,
  onOpenChange,
  announcement,
  dirty,
  catalogs,
  exampleVehicles,
  exampleVehicleId,
  onExampleVehicle,
}: {
  open: boolean;
  onOpenChange: (open: boolean) => void;
  announcement: Announcement | null;
  dirty: boolean;
  catalogs: AnnouncementCatalogs;
  exampleVehicles: AnnouncementExampleVehicle[];
  exampleVehicleId: number | null;
  onExampleVehicle: (id: number | null) => void;
}) {
  const t = useT();
  const locale = useLocale();
  const p = t.announcements.preview;
  const { announcementRepository } = useRepositories();
  const [token, setToken] = useState<AnnouncementPreviewToken | null>(null);
  const [loading, setLoading] = useState(false);
  const page = catalogs.pages.find((x) => x.key === announcement?.page_key);
  const needsVehicle = !!page?.needs_vehicle;

  const generate = async () => {
    if (!announcement) return;
    setLoading(true);
    try {
      const result = await announcementRepository.previewToken(announcement.id, exampleVehicleId ?? undefined);
      setToken(result);
      if (!env.announcementsMock) window.open(result.preview_url, "_blank", "noopener,noreferrer");
    } finally {
      setLoading(false);
    }
  };

  return (
    <Dialog
      open={open}
      onOpenChange={(o) => {
        onOpenChange(o);
        if (!o) setToken(null);
      }}
    >
      <DialogContent className="sm:max-w-lg">
        <DialogHeader>
          <DialogTitle>{p.title}</DialogTitle>
          <DialogDescription>{p.body}</DialogDescription>
        </DialogHeader>
        {!announcement || dirty ? (
          <p className="rounded-lg border border-amber-200 bg-amber-50 px-3 py-2 text-sm text-amber-900">{p.needsSave}</p>
        ) : (
          <div className="space-y-3">
            {needsVehicle && (
              <SearchableSelect
                label={p.vehicle}
                triggerClassName="w-full"
                value={exampleVehicleId ? String(exampleVehicleId) : ""}
                onValueChange={(v) => onExampleVehicle(v ? Number(v) : null)}
                placeholder={t.announcements.editor.exampleVehiclePlaceholder}
                options={exampleVehicles.map((v) => ({ value: String(v.id), label: `${v.numberplate} · ${v.make_model}` }))}
              />
            )}
            {token && (
              <div className="space-y-1.5 rounded-lg border bg-muted/40 p-3 text-xs">
                <a href={token.preview_url} target="_blank" rel="noreferrer" className="flex items-center gap-1.5 break-all font-mono text-blue-700 underline">
                  <ExternalLink className="h-3.5 w-3.5 shrink-0" />
                  {token.preview_url}
                </a>
                <p className="text-muted-foreground">{p.expires(formatParis(token.expires_at, locale))}</p>
                {env.announcementsMock && (
                  <p className="flex items-center gap-1.5 text-purple-700">
                    <FlaskConical className="h-3.5 w-3.5" />
                    {p.mockNote}
                  </p>
                )}
              </div>
            )}
          </div>
        )}
        <DialogFooter>
          <Button type="button" onClick={generate} disabled={!announcement || dirty || loading || (needsVehicle && !exampleVehicleId)}>
            {loading ? <Loader2 className="mr-1.5 h-4 w-4 animate-spin" /> : <ExternalLink className="mr-1.5 h-4 w-4" />}
            {p.open}
          </Button>
        </DialogFooter>
      </DialogContent>
    </Dialog>
  );
}

/**
 * Publish / schedule: the blocking errors of §6.4, the warnings (nobody / everybody, overlapping
 * modals) and the explicit confirmation of the notification recipients (§8.3).
 */
export function PublishDialog({
  open,
  onOpenChange,
  announcement,
  input,
  count,
  onConfirm,
  onFix,
  publishing,
}: {
  open: boolean;
  onOpenChange: (open: boolean) => void;
  announcement: Announcement | null;
  input: AnnouncementInput;
  count: AudienceCount | null;
  onConfirm: () => void;
  /** Close and highlight the fields to fix in the form. */
  onFix: (errors: AnnouncementFieldErrors) => void;
  publishing: boolean;
}) {
  const t = useT();
  const locale = useLocale();
  const pub = t.announcements.publish;
  const issueMessage = useIssueMessage();
  const { announcementRepository } = useRepositories();
  const [notifyOk, setNotifyOk] = useState(false);
  const [overlaps, setOverlaps] = useState<Announcement[]>([]);

  const issues = validateAnnouncement(input, "publish");
  const names = t.announcements.validation.fieldNames;
  const fieldName = (field: string) => {
    const [head, index, sub] = field.split(".");
    if (head === "steps" && index !== undefined && sub) return `${t.announcements.steps.step(Number(index) + 1)} · ${names[sub.replace(/_(label|path|alt)$/, "")] ?? sub}`;
    return names[head.replace(/_(label|path|alt)$/, "")] ?? head;
  };

  useEffect(() => {
    if (!open || input.format !== "modal") return;
    let cancelled = false;
    announcementRepository
      .overlappingModals({ id: announcement?.id, starts_at: input.starts_at, ends_at: input.ends_at, audience: input.audience })
      .then((items) => !cancelled && setOverlaps(items))
      .catch(() => undefined);
    return () => {
      cancelled = true;
    };
  }, [open, input.format, input.starts_at, input.ends_at, input.audience, announcement?.id, announcementRepository]);

  const warnings: string[] = [];
  if (count && count.count === 0) warnings.push(t.announcements.audience.warnZero);
  if (count && count.total > 0 && count.count === count.total) warnings.push(t.announcements.audience.warnEveryone);
  if (input.format === "modal" && overlaps.length) {
    warnings.push(`${t.announcements.schedule.overlapTitle} : ${overlaps.map((o) => o.title.fr).join(", ")}. ${t.announcements.schedule.overlapBody}`);
  }

  const scheduled = isFuture(input.starts_at);
  const needsNotifyOk = input.notify.enabled && !announcement?.first_published_at;
  const canConfirm = issues.length === 0 && (!needsNotifyOk || notifyOk) && !publishing;

  return (
    <Dialog
      open={open}
      onOpenChange={(o) => {
        onOpenChange(o);
        if (!o) setNotifyOk(false);
      }}
    >
      <DialogContent className="sm:max-w-lg">
        <DialogHeader>
          <DialogTitle>{scheduled ? pub.scheduleTitle : pub.title}</DialogTitle>
          <DialogDescription>{scheduled ? pub.starts(formatParis(input.starts_at, locale)) : pub.startsNow}</DialogDescription>
        </DialogHeader>

        {issues.length > 0 ? (
          <div className="space-y-1.5 rounded-lg border border-red-200 bg-red-50 p-3 text-sm text-red-800" role="alert">
            <p className="font-semibold">{pub.errorsTitle}</p>
            <ul className="list-disc space-y-0.5 pl-5 text-xs">
              {issues.map((issue, i) => (
                <li key={i}>
                  <b>{fieldName(issue.field)}</b> — {issueMessage(issue)}
                </li>
              ))}
            </ul>
          </div>
        ) : (
          <p className="flex items-center gap-1.5 text-sm text-emerald-700">
            <CheckCircle2 className="h-4 w-4" />
            {pub.ready}
          </p>
        )}

        {warnings.length > 0 && (
          <div className="space-y-1.5 rounded-lg border border-amber-200 bg-amber-50 p-3 text-xs text-amber-900">
            <p className="flex items-center gap-1.5 text-sm font-semibold">
              <TriangleAlert className="h-4 w-4" />
              {pub.warningsTitle}
            </p>
            <ul className="list-disc space-y-0.5 pl-5">
              {warnings.map((w) => (
                <li key={w}>{w}</li>
              ))}
            </ul>
          </div>
        )}

        {needsNotifyOk && issues.length === 0 && (
          <div className="flex items-start gap-2 rounded-lg border p-3">
            <Checkbox id="notify-ok" checked={notifyOk} onCheckedChange={(v) => setNotifyOk(v === true)} />
            <Label htmlFor="notify-ok" className="text-sm font-normal leading-snug">{pub.notifyConfirm(count?.count ?? 0)}</Label>
          </div>
        )}

        <DialogFooter>
          <Button type="button" variant="outline" onClick={() => onOpenChange(false)} disabled={publishing}>
            {t.announcements.confirm.cancel}
          </Button>
          {issues.length > 0 && (
            <Button type="button" variant="secondary" onClick={() => onFix(issuesToFieldErrors(issues, issueMessage))}>
              {pub.fixFields}
            </Button>
          )}
          <Button type="button" onClick={onConfirm} disabled={!canConfirm}>
            {publishing && <Loader2 className="mr-1.5 h-4 w-4 animate-spin" />}
            {scheduled ? pub.confirmSchedule : pub.confirm}
          </Button>
        </DialogFooter>
      </DialogContent>
    </Dialog>
  );
}
