"use client";

import { useEffect, useId, useRef, useState } from "react";
import { Bold, Italic, Link2 } from "lucide-react";
import { cn } from "@/shared/lib/utils";
import { useT } from "@/shared/i18n/client";
import { isInternalPath, plainText, sanitizeRichText, type ValidationIssue } from "@/shared/lib/announcements";
import { Input } from "@/presentation/components/ui/input";
import { Label } from "@/presentation/components/ui/label";
import type { AnnouncementFieldErrors, LocalizedText } from "@/domain/entities/announcement";

/** Translates a client-side validation issue the way the API words it. */
export function useIssueMessage() {
  const t = useT();
  const v = t.announcements.validation;
  return (issue: ValidationIssue): string => {
    switch (issue.code) {
      case "tooLong": return v.tooLong(issue.max ?? 0);
      case "stepsMin": return v.stepsMin(issue.min ?? 0);
      case "stepsMax": return v.stepsMax(issue.max ?? 0);
      default: return v[issue.code];
    }
  };
}

export function FieldErrors({ errors, path }: { errors: AnnouncementFieldErrors; path: string | string[] }) {
  const paths = Array.isArray(path) ? path : [path];
  const messages = paths.flatMap((p) => errors[p] ?? []);
  if (!messages.length) return null;
  return (
    <div className="space-y-0.5" role="alert">
      {messages.map((msg, i) => (
        <p key={i} className="text-xs font-medium text-destructive">{msg}</p>
      ))}
    </div>
  );
}

export function FieldLabel({
  htmlFor,
  children,
  hint,
  required,
}: {
  htmlFor?: string;
  children: React.ReactNode;
  hint?: React.ReactNode;
  required?: boolean;
}) {
  return (
    <div className="flex items-baseline justify-between gap-2">
      <Label htmlFor={htmlFor} className="text-sm font-medium">
        {children}
        {required && <span className="ml-0.5 text-destructive" aria-hidden="true">*</span>}
      </Label>
      {hint && <span className="text-[11px] text-muted-foreground">{hint}</span>}
    </div>
  );
}

export function Help({ children }: { children: React.ReactNode }) {
  return <p className="text-xs text-muted-foreground">{children}</p>;
}

function Counter({ value, max }: { value: number; max: number }) {
  const t = useT();
  return (
    <span className={cn("text-[11px] tabular-nums", value > max ? "font-semibold text-destructive" : "text-muted-foreground")}>
      {t.announcements.editor.chars(value, max)}
    </span>
  );
}

function LangTag({ lang, required, empty }: { lang: "fr" | "en"; required?: boolean; empty?: boolean }) {
  const t = useT();
  const e = t.announcements.editor;
  return (
    <span className="flex items-center gap-1.5">
      <span className="rounded bg-muted px-1.5 py-0.5 text-[10px] font-bold tracking-wide text-muted-foreground">{e[lang]}</span>
      {lang === "fr" && required && <span className="text-[10px] text-muted-foreground">{e.frRequired}</span>}
      {lang === "en" && empty && <span className="text-[10px] italic text-muted-foreground">{e.enFallback}</span>}
    </span>
  );
}

interface LocalizedProps {
  label: string;
  path: string;
  value: LocalizedText;
  onChange: (value: LocalizedText) => void;
  errors: AnnouncementFieldErrors;
  max: number;
  required?: boolean;
  placeholder?: LocalizedText;
  help?: React.ReactNode;
  disabled?: boolean;
}

/** One text in FR and EN, each with its length counter. */
export function LocalizedInput({ label, path, value, onChange, errors, max, required, placeholder, help, disabled }: LocalizedProps) {
  const id = useId();
  return (
    <div className="space-y-1.5">
      <FieldLabel htmlFor={`${id}-fr`} required={required}>{label}</FieldLabel>
      <div className="grid gap-2 md:grid-cols-2">
        {(["fr", "en"] as const).map((lang) => (
          <div key={lang} className="space-y-1">
            <div className="flex items-center justify-between">
              <LangTag lang={lang} required={required} empty={!value.en.trim()} />
              <Counter value={value[lang].length} max={max} />
            </div>
            <Input
              id={`${id}-${lang}`}
              value={value[lang]}
              disabled={disabled}
              onChange={(e) => onChange({ ...value, [lang]: e.target.value })}
              placeholder={placeholder?.[lang] || (lang === "en" ? value.fr : undefined)}
              aria-invalid={!!errors[`${path}.${lang}`]}
              lang={lang}
            />
            <FieldErrors errors={errors} path={`${path}.${lang}`} />
          </div>
        ))}
      </div>
      {help && <Help>{help}</Help>}
    </div>
  );
}

/** One rich text in FR and EN (bold, italic, internal link, line break). */
export function LocalizedRichText({ label, path, value, onChange, errors, max, required, help, disabled }: LocalizedProps) {
  return (
    <div className="space-y-1.5">
      <FieldLabel required={required}>{label}</FieldLabel>
      <div className="grid gap-2 md:grid-cols-2">
        {(["fr", "en"] as const).map((lang) => (
          <div key={lang} className="space-y-1">
            <div className="flex items-center justify-between">
              <LangTag lang={lang} required={required} empty={!plainText(value.en).trim()} />
              <Counter value={plainText(value[lang]).length} max={max} />
            </div>
            <MiniRichText
              value={value[lang]}
              onChange={(html) => onChange({ ...value, [lang]: html })}
              invalid={!!errors[`${path}.${lang}`]}
              disabled={disabled}
              lang={lang}
              ariaLabel={`${label} (${lang.toUpperCase()})`}
            />
            <FieldErrors errors={errors} path={`${path}.${lang}`} />
          </div>
        ))}
      </div>
      {help && <Help>{help}</Help>}
    </div>
  );
}

/**
 * A tiny contentEditable editor restricted to the whitelist of the spec (§5). The HTML it emits
 * is sanitised on every change, so pasted content keeps only what Fleet renders.
 */
export function MiniRichText({
  value,
  onChange,
  invalid,
  disabled,
  lang,
  ariaLabel,
}: {
  value: string;
  onChange: (html: string) => void;
  invalid?: boolean;
  disabled?: boolean;
  lang: string;
  ariaLabel: string;
}) {
  const t = useT();
  const e = t.announcements.editor;
  const ref = useRef<HTMLDivElement>(null);
  const [linkError, setLinkError] = useState(false);

  // Only push the value into the DOM when it changed from outside (format switch, restore).
  useEffect(() => {
    const el = ref.current;
    if (el && sanitizeRichText(el.innerHTML) !== value) el.innerHTML = value;
  }, [value]);

  const emit = () => {
    if (ref.current) onChange(sanitizeRichText(ref.current.innerHTML));
  };

  const command = (cmd: "bold" | "italic") => {
    ref.current?.focus();
    document.execCommand(cmd);
    emit();
  };

  const link = () => {
    const href = window.prompt(e.richLinkPrompt, "/fleet/");
    if (href === null) return;
    if (!isInternalPath(href.trim())) {
      setLinkError(true);
      return;
    }
    setLinkError(false);
    ref.current?.focus();
    document.execCommand("createLink", false, href.trim());
    emit();
  };

  return (
    <div className={cn("rounded-md border bg-background shadow-xs", invalid && "border-destructive", disabled && "opacity-60")}>
      <div className="flex items-center gap-0.5 border-b px-1 py-0.5">
        <ToolButton label={e.richBold} disabled={disabled} onClick={() => command("bold")}>
          <Bold className="h-3.5 w-3.5" />
        </ToolButton>
        <ToolButton label={e.richItalic} disabled={disabled} onClick={() => command("italic")}>
          <Italic className="h-3.5 w-3.5" />
        </ToolButton>
        <ToolButton label={e.richLink} disabled={disabled} onClick={link}>
          <Link2 className="h-3.5 w-3.5" />
        </ToolButton>
      </div>
      <div
        ref={ref}
        role="textbox"
        aria-multiline="true"
        aria-label={ariaLabel}
        aria-invalid={invalid}
        lang={lang}
        contentEditable={!disabled}
        suppressContentEditableWarning
        onInput={emit}
        onBlur={emit}
        className="min-h-[72px] px-3 py-2 text-sm outline-none [&_a]:text-blue-600 [&_a]:underline"
      />
      {linkError && <p className="px-3 pb-1.5 text-xs font-medium text-destructive">{e.richLinkInvalid}</p>}
    </div>
  );
}

function ToolButton({ label, disabled, onClick, children }: { label: string; disabled?: boolean; onClick: () => void; children: React.ReactNode }) {
  return (
    <button
      type="button"
      title={label}
      aria-label={label}
      disabled={disabled}
      onMouseDown={(ev) => ev.preventDefault()}
      onClick={onClick}
      className="rounded p-1 text-muted-foreground hover:bg-muted hover:text-foreground disabled:pointer-events-none"
    >
      {children}
    </button>
  );
}

/** Rendered rich text (already restricted to the whitelist). */
export function RichTextView({ html, className }: { html: string; className?: string }) {
  return <span className={cn("[&_a]:underline", className)} dangerouslySetInnerHTML={{ __html: sanitizeRichText(html) }} />;
}
