import { useEffect, useRef, useState } from "react";
import { AlertCircle, Loader2 } from "lucide-react";
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
} from "../../../components/ui/dialog.tsx";
import { Alert, AlertDescription } from "../../../components/ui/alert.tsx";
import { Button } from "../../../components/ui/button.tsx";
import { EmptyState } from "../../../components/ui/empty-state.tsx";
import { Input } from "../../../components/ui/input.tsx";
import { Label } from "../../../components/ui/label.tsx";
import { RadioControl } from "../../../components/ui/radio-control.tsx";
import { formatDate, formatDateTime } from "../../../utils/dateUtils";
import { relayServerFailure } from "../../../utils/fetchFailureMessage";
import {
  newOperationId,
  type HeldLabResult,
  type HeldResultCandidates,
  type ResolvedHeldResult,
} from "../../../hooks/useHeldLabResults.ts";
import { heldReasonWords, labStatusWords } from "./heldLabResultWords.ts";

// Saying which order a lab result answers. Only the orders the server offers are shown, exactly the ones it will
// accept: this practice's, sent to that laboratory at that address, for the patient the laboratory names. Nothing is
// searched for or suggested. Filed is not released: the outcome says it reaches no patient until someone releases it.

interface Props {
  item?: HeldLabResult;
  onClose: () => void;
  onDone: () => void;
  candidates: (id: string) => Promise<HeldResultCandidates>;
  resolve: (id: string, orderId: string, operationId: string) => Promise<ResolvedHeldResult | undefined>;
}

/**
 * An order named by its page address (`…/diagnostic-orders/<id>/…`) or its bare id, for an order the server could not
 * offer: one sent before laboratories confirmed patients. The server checks it exactly as it checks an offered one.
 */
export const orderIdFrom = (text: string): string | undefined => {
  const written = text.trim();
  return (/\/diagnostic-orders\/([A-Za-z0-9.-]{1,64})(?:[/?#]|$)/.exec(written) ?? /^([A-Za-z0-9.-]{1,64})$/.exec(written))?.[1];
};

const outcomeWords = (result: ResolvedHeldResult | undefined): { done: boolean; words: string } => {
  if (result?.outcome === "filed") return { done: true, words: "Filed onto the order. It reaches the patient only when someone releases it." };
  if (result?.outcome === "superseded") return { done: true, words: "A newer edition of this result was already filed on the order, so this one is kept as received." };
  if (result?.outcome === "held") return { done: false, words: `Matched, but it could not be filed: ${heldReasonWords(result.reason)}` };
  return { done: false, words: "Someone else acted on this result meanwhile. Look at the list again." };
};

const MatchHeldResultDialog = ({ item, onClose, onDone, candidates, resolve }: Props) => {
  const [found, setFound] = useState<HeldResultCandidates>();
  const [loadError, setLoadError] = useState<string>();
  const [chosen, setChosen] = useState<string>("");
  // An order named by hand stands in for the offered ones while anything is typed.
  const [typed, setTyped] = useState("");
  const target = typed.trim() ? orderIdFrom(typed) : chosen;
  const [busy, setBusy] = useState(false);
  const [error, setError] = useState<string>();
  const [result, setResult] = useState<{ done: boolean; words: string }>();
  // One attempt, one id: a resend after an unclear answer is recognised by the server, never applied twice.
  const operation = useRef(newOperationId());

  useEffect(() => {
    setFound(undefined);
    setLoadError(undefined);
    setChosen("");
    setTyped("");
    setError(undefined);
    setResult(undefined);
    operation.current = newOperationId();
    if (!item) return;
    let current = true;
    candidates(item.id)
      .then((answer) => { if (current) setFound(answer); })
      .catch((failure) => { if (current) setLoadError(relayServerFailure(failure, "Could not find the orders this result may answer.")); });
    return () => { current = false; };
  }, [item, candidates]);

  const match = async () => {
    if (!item || !target) return;
    setBusy(true);
    setError(undefined);
    try {
      const said = outcomeWords(await resolve(item.id, target, operation.current));
      setResult(said);
    } catch (failure) {
      setError(relayServerFailure(failure, "The match was not confirmed. Try again; a repeat is recognised."));
    } finally {
      setBusy(false);
    }
  };

  const report = item?.report;
  return (
    <Dialog open={Boolean(item)} onOpenChange={(open) => { if (!open) (result ? onDone : onClose)(); }}>
      <DialogContent className="held-lab-result-dialog">
        <DialogHeader>
          <DialogTitle>Match this laboratory result to an order</DialogTitle>
          <DialogDescription>{heldReasonWords(item?.heldReason)}</DialogDescription>
        </DialogHeader>

        <dl className="held-lab-result-sent" aria-label="What the laboratory sent">
          <dt>Test</dt><dd>{report?.code ?? "Not named"}</dd>
          {labStatusWords(report?.status) ? <><dt>Status</dt><dd>{labStatusWords(report?.status)}</dd></> : null}
          {report?.issued ? <><dt>Issued</dt><dd>{formatDateTime(report.issued)}</dd></> : null}
          <dt>Patient at the laboratory</dt>
          <dd>{report?.subject?.display ?? "Not named"}{report?.subject?.reference ? ` (${report.subject.reference})` : ""}</dd>
        </dl>

        {result ? (
          <Alert variant={result.done ? "default" : "destructive"} role="status">
            <AlertDescription>{result.words}</AlertDescription>
          </Alert>
        ) : loadError ? (
          <Alert variant="destructive"><AlertCircle className="size-4" /><AlertDescription>{loadError}</AlertDescription></Alert>
        ) : !found ? (
          <p className="held-lab-result-loading"><Loader2 className="size-4 animate-spin" aria-hidden /> Finding the orders it may answer…</p>
        ) : found.orders.length === 0 && !found.complete ? (
          <p className="held-lab-result-note">
            {found.reason ? `${found.reason} ` : ""}Not every order could be looked at just now, so one may be missing. Try
            again shortly.
          </p>
        ) : found.orders.length === 0 ? (
          <EmptyState size="compact" title={found.reason ?? "No order this practice sent to that laboratory for this patient is waiting for it."} />
        ) : (
          <>
            <RadioControl
              label="The order it answers"
              selected={chosen}
              options={found.orders.map((each) => ({
                value: each.orderId,
                label: [each.test ?? "Order", each.patient?.name, each.requested ? `requested ${formatDate(each.requested)}` : undefined]
                  .filter(Boolean).join(" · "),
              }))}
              onChange={(value: string) => setChosen(value)}
            />
            {!found.complete ? <p className="held-lab-result-note">Not every order could be looked at just now, so one may be missing. Try again shortly.</p> : null}
          </>
        )}

        {!result && found ? (
          <div className="held-lab-result-by-hand">
            <Label htmlFor="held-lab-result-order">Not listed? The order&apos;s page address</Label>
            <Input
              id="held-lab-result-order"
              autoComplete="off"
              value={typed}
              onChange={(event) => setTyped(event.target.value)}
            />
            <p className="held-lab-result-note">
              An order sent before laboratories confirmed their patients is not listed. Paste the address of its page; it
              is checked exactly as a listed one is.
            </p>
            {typed.trim() && !orderIdFrom(typed) ? <p className="held-lab-result-note" role="alert">That is not an order&apos;s page address.</p> : null}
          </div>
        ) : null}

        {error ? <Alert variant="destructive"><AlertCircle className="size-4" /><AlertDescription>{error}</AlertDescription></Alert> : null}

        <DialogFooter>
          {result ? (
            <Button onClick={onDone}>Done</Button>
          ) : (
            <>
              <Button variant="outline" onClick={onClose} disabled={busy}>Cancel</Button>
              <Button onClick={match} disabled={!target || busy}>
                {busy ? <Loader2 className="size-4 animate-spin" aria-hidden /> : null}
                Match
              </Button>
            </>
          )}
        </DialogFooter>
      </DialogContent>
    </Dialog>
  );
};

export default MatchHeldResultDialog;