import { useEffect, useRef, useState } from "react";
import { Copy, Phone, Printer, Send } from "lucide-react";
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
} from "../../../components/ui/dialog.tsx";
import { Button } from "../../../components/ui/button.tsx";
import { Input } from "../../../components/ui/input.tsx";
import { Textarea } from "../../../components/ui/textarea.tsx";
import { Alert, AlertDescription } from "../../../components/ui/alert.tsx";
import { actionAttempt, stillOpen, type ActionAttempt, type ReferralRequestScope } from "../../../utils/referralRequestScope";
import {
  useReferralWorkbenchService,
  type ReferralClaimCode,
  type ReferralContact,
  type ReferralContactAttempt,
  type ReferralFaxResult,
} from "../../../services/ReferralWorkbenchService.tsx";
import { useAuthServiceContext } from "../../../services";
import { canSendFax } from "../../../utils/organizationFaxSettings.ts";
import { relayServerFailure } from "../../../utils/fetchFailureMessage";
import { HttpError } from "../../../services/HttpService";
import type { ReferralQueueRow } from "../../../hooks/useReferralQueue.ts";
import { patientBookedLine, referralClosureReasonLabel } from "../../../utils/referralQueue.ts";
import "./referralDialog.css";
import { ReferralContactHistory } from "./ReferralContactHistory";
import { useReferralContactRecovery } from "../../../hooks/useReferralContactRecovery";
import { ReferralContactRecovery } from "./ReferralContactRecovery";
import { outcomeUnknown } from "../../../utils/saveOperation";

// - THE SEND WORKBENCH. Three ways to send a referral, and a phone call is one of them.
//
// Spencer: *"however they want to do it as long as it's all logged/documented in our system."*
//
// PHONE IS THE MAJORITY OF REAL-WORLD REFERRAL TRAFFIC, and it is fully buildable today - the fax
// vendor is the only part still held on a BAA. A referral worked by phone must leave **as complete a
// record as one we faxed**; if the call path records less, the coordinator keeps a private notebook for
// the parts that did not fit and we have rebuilt the paper tray this feature replaced.
//
// AND NOTHING HERE CLAIMS THE SPECIALIST RECEIVED IT. The record says what WE did. A coordinator who
// reads "sent" as "they have it" stops chasing - and a referral nobody is chasing is a patient who does
// not reach a specialist.
//
// ZERO WordPress: Tailwind + lucide + the shared ui primitives.

type Method = "phone" | "portal" | "fax";

interface Props {
  row: ReferralQueueRow | null;
  onOpenChange: (open: boolean) => void;
  /** Fired after a contact is recorded, so the queue can re-read the row's state. */
  onRecorded: () => void;
  /** Which writes this person may make now, read live: an open form loses a control the moment its authority goes. */
  may?: ReferralWorkbenchWrites;
  /** The opening this dialog belongs to: every request is admitted by it, and nothing is shown or started once it retires. */
  scope?: ReferralRequestScope;
}

export interface ReferralWorkbenchWrites {
  contact: boolean;
  state: boolean;
  claimCode: boolean;
  fax: boolean;
  /** The shared contact book a used number is corrected in. */
  contactBook: boolean;
}

const ALL_WRITES: ReferralWorkbenchWrites = { contact: true, state: true, claimCode: true, fax: true, contactBook: true };

const TABS: { key: Method; label: string; icon: typeof Phone }[] = [
  { key: "phone", label: "Phone", icon: Phone },
  { key: "portal", label: "Akashic", icon: Send },
  { key: "fax", label: "Fax", icon: Printer },
];

const ReferralWorkbenchDialog = ({ row, onOpenChange, onRecorded, may = ALL_WRITES, scope }: Props) => {
  // The authority as it stands now, not as it stood when a request was sent: a correction is only started under it.
  const mayNow = useRef(may);
  mayNow.current = may;
  // Each write is its own attempt: admitted while the opening holds and that action is still allowed, and retired
  // for good the first time either fails.
  const liveAttempts = useRef(new Set<{ action: keyof ReferralWorkbenchWrites; attempt: ActionAttempt }>());
  const attempt = (action: keyof ReferralWorkbenchWrites) => {
    const started = actionAttempt(scope, () => mayNow.current[action]);
    const entry = { action, attempt: started };
    liveAttempts.current.add(entry);
    started.signal.addEventListener("abort", () => liveAttempts.current.delete(entry), { once: true });
    return started;
  };
  // A permission seen to go retires its attempts at once, so its return does not revive them.
  useEffect(() => {
    liveAttempts.current.forEach((entry) => { if (!may[entry.action]) entry.attempt.retire(); });
  }, [may.contact, may.state, may.claimCode, may.fax, may.contactBook]);
  const { readContactHistory, recordContact, mintClaimCode, faxReferral, previewReferralPacket, readReferralContact, saveReferralContact, markReferralAccepted, markReferralScheduled } =
    useReferralWorkbenchService();
  /**
 * WHETHER THIS PRACTICE CAN ACTUALLY SEND, read off the Organization we already hold.
 *
 * CHOSEN IS NOT READY. A practice can pick a vendor and never save the account details - the
 * settings screen writes those in two steps - and offering a button to a half-configured practice
 * produces exactly the click-and-stop-chasing this tab was built to prevent.
 */
  const { currentOrganization } = useAuthServiceContext();
  const faxConfigured = canSendFax(currentOrganization);

  const [method, setMethod] = useState<Method>("phone");
  const [recipient, setRecipient] = useState("");
  const [spokeWith, setSpokeWith] = useState("");
  const [outcome, setOutcome] = useState("");
  const [busy, setBusy] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [saved, setSaved] = useState(false);
  const recovery = useReferralContactRecovery(row, scope, may.contact);
  const contactUnconfirmed = recovery.held;
  const [recordedContacts, setRecordedContacts] = useState<{ taskId: string; contacts?: ReferralContactAttempt[] }>();
  const contacts = recovery.contacts ?? (recordedContacts && recordedContacts.taskId === row?.taskId ? recordedContacts.contacts : row?.contacts);
  const [claim, setClaim] = useState<ReferralClaimCode | null>(null);
  const [faxNumber, setFaxNumber] = useState("");
  const [faxResult, setFaxResult] = useState<ReferralFaxResult | null>(null);
  /** A transition the server confirmed, for the referral it was made on and no other. */
  const [recorded, setRecorded] = useState<{ orderId: string; state: "claimed" | "scheduled" } | null>(null);
  const openOrderId = useRef(row?.orderId);
  const bodyRef = useRef<HTMLDivElement>(null);
  openOrderId.current = row?.orderId;
  useEffect(() => setBusy(false), [row?.orderId]);

  /**
 * WHAT SOMEBODY ALREADY LEARNED ABOUT REACHING THIS PRACTICE.
 *
 * BEST-EFFORT AND NEVER A GATE. A specialist with nothing recorded is the ordinary case on day one,
 * and the coordinator must still be able to type a number and send. So a failure here is silent: it
 * costs a prefilled field, not the ability to send a referral.
 */
  const [contact, setContact] = useState<ReferralContact | null>(null);
  const [contactRefusal, setContactRefusal] = useState<string | null>(null);
  /** The numbers as the book had them, so an edit can be told from a prefill. */
  const [knownFax, setKnownFax] = useState("");
  /** Why the packet could not be sent as it stands, learned from a preview rather than a refusal. */
  const [previewNote, setPreviewNote] = useState<string | null>(null);
  const [knownPhone, setKnownPhone] = useState("");
  const [shareCorrection, setShareCorrection] = useState(true);
  const [sharePhoneCorrection, setSharePhoneCorrection] = useState(true);

  useEffect(() => {
    if (!row?.performerNpi) {
      setContact(null);
      setKnownFax("");
      setKnownPhone("");
      return;
    }

    let cancelled = false;
    setContactRefusal(null);
    void readReferralContact(row.performerNpi, scope)
      .then((found) => {
        if (cancelled || !stillOpen(scope)) return;
        setContact(found);
        const fax = found.shared?.fax ?? "";
        const phone = found.shared?.phone ?? "";
        setKnownFax(fax);
        setKnownPhone(phone);
        // Prefills only an EMPTY box. A coordinator who has already typed something is mid-thought,
        // and overwriting them would be the worse failure of the two.
        setFaxNumber((current) => (current.trim() === "" ? fax : current));
        setRecipient((current) => (current.trim() === "" ? phone : current));
      })
      .catch((err) => {
        if (cancelled || !stillOpen(scope)) return;
        // A REFUSAL IS NOT AN EMPTY ADDRESS BOOK. Swallowing this left three blank fields and no
        // sentence, and a coordinator reads blank as "no contact on file" rather than as "you were
        // not allowed to look" - empty data standing in for a denial, which is the one thing the
        // denial rule forbids. A 404 IS a true emptiness and stays silent: every first referral to a
        // new recipient is one, and crying denial there would teach the desk to ignore the sentence.
        if (err instanceof HttpError && err.status === 404) return;
        setContactRefusal(relayServerFailure(err, "We could not read this recipient's saved contact details."));
      });

    return () => { cancelled = true; };
  }, [row?.performerNpi, readReferralContact]);

  const reset = () => {
    setMethod("phone");
    setRecipient("");
    setSpokeWith("");
    setOutcome("");
    setError(null);
    setSaved(false);
    setRecordedContacts(undefined);
    setClaim(null);
    setFaxNumber("");
    setFaxResult(null);
    setRecorded(null);
    setBusy(false);
  };

  const close = (open: boolean) => {
    if (!open) reset();
    onOpenChange(open);
  };

  const logPhoneCall = async () => {
    if (!row?.taskId || busy || contactUnconfirmed) return;
    setBusy(true);
    setError(null);
    const call = attempt("contact");
    // The correction is part of this press: opted into now, and retired for good if its permission goes meanwhile.
    const correctedPhone = recipient.trim();
    const correction = row.performerNpi && sharePhoneCorrection && correctedPhone !== "" && correctedPhone !== knownPhone
      ? attempt("contactBook")
      : undefined;
    try {
      const contacts = await recovery.record({
        method: "phone",
        recipient: recipient.trim() || undefined,
        spokeWith: spokeWith.trim() || undefined,
        outcome: outcome.trim() || undefined,
        // A FULL ISO INSTANT WITH AN OFFSET. FHIR's dateTime grammar allows a naked local time and the
        // resource INVARIANT does not, so HealthLake 400s it - `toISOString` is always UTC-qualified
        //.
        occurredAt: new Date().toISOString(),
      }, call, recordContact);
      if (!stillOpen(call)) return;
      setRecordedContacts({ taskId: row.taskId, contacts });
      setSaved(true);
      onRecorded();

      /*
       * THE PHONE IS WHERE THE CORRECTION IS ACTUALLY LEARNED, which is why this belongs here and
       * not only on the fax tab. The server's own note for the book describes this exact moment:
       * they called, they found out the number was wrong and referrals go to the referral
       * department, and they type it once so every practice that ever refers here inherits it.
       *
       * Best-effort and after the fact, on the same terms as the fax path: the call IS recorded,
       * and failing the whole action now would tell a coordinator their record did not save when it
       * did. Only the shared field is written - the private note has its own control and its own
       * audience.
       */
      if (row.performerNpi && correction && stillOpen(correction)) {
        try {
          await saveReferralContact(row.performerNpi, { shared: { phone: correctedPhone } }, correction);
          if (!stillOpen(correction)) return;
          setKnownPhone(correctedPhone);
        } catch {
          // Deliberately silent - see above. The recorded call is what the coordinator is watching.
        }
      }
    } catch (err) {
      if (!stillOpen(call)) return;
      setError(outcomeUnknown(err)
        ? null
        : relayServerFailure(err, "That call could not be recorded. Please try again."));
    } finally {
      // Done with this press either way: an unused correction is not left waiting.
      correction?.retire();
      setBusy(false);
    }
  };

/*
   * WHO MAY STATE RECEIPT HERE. A recipient with no Akashic reference cannot claim the referral
   * itself, so the practice that placed it says so instead - Spencer, 2026-09-16. Terminal states are
   * excluded because terminal means terminal.
   */
  const acknowledged = recorded && recorded.orderId === row?.orderId ? recorded.state : undefined;
  const referralState = acknowledged ?? row?.state;
  const canCloseAsSender =
    !!row?.orderId && !row?.performerReference && referralState !== "scheduled" && referralState !== "expired";

  /*
   * A FINISHED REFERRAL OPENS AS IT STANDS. Scheduled and closed are terminal, and on staging both
   * still opened "Send …" with a claim code and a fax, saying neither where they stood nor why one
   * was closed. What stays on a scheduled one is recording a call, which the server still accepts;
   * a closed one offers no call form under "Nothing more is sent from here".
   */
  const finished = referralState === "scheduled" || referralState === "expired";
  const closed = referralState === "expired";
  const closedWith = referralClosureReasonLabel(row?.closureReason);
  const whereItStands = !finished || acknowledged
    ? undefined
    : referralState === "scheduled"
      ? "Scheduled: they booked the patient. Nothing more is sent from here."
      : `Closed${closedWith ? `: ${closedWith}` : ""}. Nothing more is sent from here.`;
  useEffect(() => { if (finished) setMethod("phone"); }, [finished]);

  // A result that lands after the dialog moved to another referral touches only the queue.
  const recordOnBehalf = async (state: "claimed" | "scheduled") => {
    const orderId = row?.orderId;
    if (!orderId) return;
    setBusy(true);
    setError(null);
    const change = attempt("state");
    try {
      await (state === "claimed" ? markReferralAccepted(orderId, change) : markReferralScheduled(orderId, change));
      if (!stillOpen(change)) return;
      if (openOrderId.current === orderId) setRecorded({ orderId, state });
      onRecorded();
    } catch (err) {
      if (openOrderId.current === orderId && stillOpen(change)) {
        setError(relayServerFailure(err, "That referral could not be updated. Please try again."));
      }
    } finally {
      if (openOrderId.current === orderId) setBusy(false);
    }
  };

  const getClaimCode = async () => {
    if (!row?.orderId) return;
    setBusy(true);
    setError(null);
    const mint = attempt("claimCode");
    try {
      const minted = await mintClaimCode(row.orderId, mint);
      if (!stillOpen(mint)) return;
      setClaim(minted);
    } catch (err) {
      if (!stillOpen(mint)) return;
      setError(relayServerFailure(err, "A code could not be created. Please try again."));
    } finally {
      setBusy(false);
    }
  };

  /**
 * SEND THE PACKET.
 *
 * IT REPORTS WHAT THE VENDOR ACCEPTED, NEVER THAT THE SPECIALIST HAS IT - the same fence the phone
 * tab carries. A coordinator who reads "sent" as "they have it" stops chasing, and a referral nobody
 * is chasing is a patient who does not reach a specialist.
 */
  /**
 * Look at the packet before sending it.
 *
 * Ruled 2026-09-14: there was no way to see the page without sending it, so a coordinator faxed a
 * patient's demographics, insurance and reason for referral to an outside practice without ever
 * being able to check what was on it. A send cannot be recalled.
 *
 * The PDF is opened in a new tab from a blob rather than drawn here. The server composes the same
 * page the send transmits; a second renderer in the client would be a preview of something else.
 */
  const previewPacket = async () => {
    if (!row?.orderId) return;

    // THE TAB IS OPENED IN THE GESTURE, BEFORE ANY AWAIT. A popup blocker allows window.open only
    // while the click's transient user activation is alive, and awaiting the packet first spends it -
    // so an ordinary blocker discarded the PDF and the coordinator saw nothing happen.
    // `noopener` is deliberately absent: passing it makes window.open return NULL, and the handle is
    // what the blob URL is assigned to below. The opener is severed by hand instead.
    const tab = window.open('', '_blank');
    if (tab) tab.opener = null;
    // The blank tab belongs to this opening: if it retires before the packet arrives, the tab is closed, not filled.
    const closeOwnedTab = () => tab?.close();
    scope?.signal.addEventListener('abort', closeOwnedTab, { once: true });
    setBusy(true);
    setError(null);
    try {
      const preview = await previewReferralPacket(row.orderId, scope);
      if (!stillOpen(scope)) {
        tab?.close();
        return;
      }

      // The reason it could not be sent, said BEFORE the coordinator types a number and presses
      // Send - the server returns the page either way, so they can see what is missing on it.
      setPreviewNote(preview.actionable ? null : preview.notActionableReason ?? null);

      const bytes = Uint8Array.from(atob(preview.pdfBase64), (character) => character.charCodeAt(0));
      const url = URL.createObjectURL(new Blob([bytes], { type: preview.contentType }));

      // The tab already exists; this only points it at the packet. If it was blocked outright there
      // is no handle, and opening again here would be blocked for the same reason.
      if (tab) tab.location.href = url;
      // Released on the next turn rather than immediately: revoking synchronously races the tab that
      // is still opening and lands it on a blank page.
      setTimeout(() => URL.revokeObjectURL(url), 60_000);
    } catch (err) {
      // The blank tab was opened on the press and the packet never arrived, so it is closed rather
      // than left as an empty window the coordinator has to tidy up.
      tab?.close();
      if (!stillOpen(scope)) return;
      setError(relayServerFailure(err, 'That packet could not be prepared. Try again.'));
    } finally {
      scope?.signal.removeEventListener('abort', closeOwnedTab);
      setBusy(false);
    }
  };

  const sendFax = async () => {
    if (!row?.orderId || faxNumber.trim() === "") return;
    setBusy(true);
    setError(null);
    const send = attempt("fax");
    // The correction is part of this press: opted into now, and retired for good if its permission goes meanwhile.
    const correctedFax = faxNumber.trim();
    const correction = row.performerNpi && shareCorrection && correctedFax !== knownFax ? attempt("contactBook") : undefined;
    try {
      // The task id rides along so the SERVER writes the contact entry. It verifies the task is ours,
      // focuses this referral and is a referral task before touching it.
      const sent = await faxReferral(row.orderId, { toNumber: faxNumber.trim(), taskId: row.taskId }, send);
      if (!stillOpen(send)) return;
      setFaxResult(sent);
      onRecorded();

      /*
 * SAVE WHAT WAS LEARNED, AFTER THE SEND AND NEVER BEFORE IT.
 *
 * Order matters: the number is worth sharing because it was just USED, and recording one that
 * the vendor then refused would publish a bad number to every practice. So this runs only past
 * a send the vendor accepted.
 *
 * It is also best-effort. The fax has gone; failing the whole action now would tell a
 * coordinator their referral did not send when it did. Only the shared field is written - the
 * private note has its own control and its own audience.
 */
      if (row.performerNpi && correction && stillOpen(correction)) {
        try {
          await saveReferralContact(row.performerNpi, { shared: { fax: correctedFax } }, correction);
          if (!stillOpen(correction)) return;
          setKnownFax(correctedFax);
        } catch {
          // Deliberately silent - see above. The send is what the coordinator is watching.
        }
      }
    } catch (err) {
      /*
       * A 502 ON THIS ROUTE IS THE FAX VENDOR TALKING, AND ITS WORDS ARE NOT FIT FOR A COORDINATOR.
       *
       * MEASURED on journey G4: pressing Send the packet put this on a receptionist's screen -
       * "The number you set as from does not belong to you, Please use a number that you have in
       * project <a uuid>". A sentence about an API project, naming an identifier out of somebody
       * else's system, in front of somebody holding a patient's referral.
       *
       * NARROWED TO 502 ON PURPOSE. `relayServerFailure` is right for every other failure here,
       * because those come from our own handler and are written for a person to read - "This
       * practice has not saved its account details yet." is the sentence a coordinator needs, and
       * a blanket rule would swallow it. 502 is the one status that means the proxy could not get
       * a good answer out of the third party, so it is the one whose body was never ours.
       *
       * IT DOES NOT SAY NOTHING WAS SENT. A 502 is our side failing to hear a clear answer, not a
       * confirmed refusal, and telling a coordinator their referral definitely did not go is the
       * same class of mistake in the other direction.
       */
      if (!stillOpen(send)) return;
      const status = (err as { status?: unknown } | null | undefined)?.status;
      setError(
        status === 502
          ? "We could not reach the fax service and cannot confirm whether this fax was sent. Try again in a moment."
          : relayServerFailure(err, "That fax could not be sent. Please try again."),
      );
    } finally {
      correction?.retire();
      setBusy(false);
    }
  };

  return (
    <Dialog open={Boolean(row)} onOpenChange={close}>
      <DialogContent
        className="ak-dialog referral-rfdlg max-w-none gap-0 p-0"
        onOpenAutoFocus={(event) => {
          if (contacts?.length) {
            event.preventDefault();
            bodyRef.current?.querySelector<HTMLElement>('[data-contact-history-heading]')?.focus();
            return;
          }
          // Open on the first field. Focus landing on the Phone tab drew its focus ring over the underline.
          const field = bodyRef.current?.querySelector<HTMLElement>("input, textarea");
          if (field) { event.preventDefault(); field.focus(); }
        }}
      >
        <DialogHeader className="ak-overlay__header text-left">
          {/* 🔑 THE PATIENT IS IN THE TITLE, and this is the half of the card with the consequence.
              The dialog named the DESTINATION and nothing else, so a coordinator was about to phone a
              hospital without being told who they were calling about — carrying it from the row they
              clicked, which is worse than not knowing, because it is exactly the kind of thing people
              are certain they remembered.
              ⚠️ Falls back to the old wording when the name is absent rather than printing an empty gap
              or the word "patient": a row whose subject could not be resolved is the one case where a
              confident-looking name would be a guess. */}
          {/* RESERVES THE CLOSE BUTTON'S FOOTPRINT. The dialog is sized by `width: max-content`
              (index.css:3511), so when the title is the longest line the dialog grows to exactly the
              title's ink — and the close is `absolute right-4`, drawn on top of it. Measured at
              1400x950: "Send Zzcard461 Crossorgfixture's referral to State University Of Iowa" ended
              8px UNDER the close, while a shorter title cleared it by 1px. The padding travels into
              the max-content width, so the clearance holds at any title length. */}
          <DialogTitle className="pr-8">
            {finished
              ? (row?.patientDisplay
                  ? `${row.patientDisplay}'s referral${row.performerDisplay ? ` to ${row.performerDisplay}` : ""}`
                  : `This referral${row?.performerDisplay ? ` to ${row.performerDisplay}` : ""}`)
              : row?.patientDisplay
              ? (row.performerDisplay
                  ? `Send ${row.patientDisplay}'s referral to ${row.performerDisplay}`
                  : `Send ${row.patientDisplay}'s referral`)
              : (row?.performerDisplay
                  ? `Send this referral to ${row.performerDisplay}`
                  : "Send this referral")}
          </DialogTitle>
          {/* 🚨 THE SENTENCE THAT STOPS A COORDINATOR BELIEVING THE REFERRAL LANDED. Everything on this
              screen is an account of what WE did. */}
          {/* A closed sheet sends nothing, so its description is where it stands, below. */}
          {!closed && (
            <DialogDescription className="ak-overlay__description">
              Recording a send is a note of what you did — it does not confirm the specialist received it.
            </DialogDescription>
          )}
          {/* 📞 THE REASON, because relaying WHY is most of what the call is. It sits under the
              description rather than in the title: the title says who and where, and a reason long
              enough to matter would push those off a narrow dialog. */}
          {row?.reasonText && (
            <p className="ak-overlay__description">{row.reasonText}</p>
          )}
          {whereItStands && (closed
            ? <DialogDescription className="ak-overlay__description" data-testid="referral-where-it-stands">{whereItStands}</DialogDescription>
            : <p className="ak-overlay__description" data-testid="referral-where-it-stands">{whereItStands}</p>
          )}
          {patientBookedLine(row?.patientBookedAt) && (
            <p className="ak-overlay__description" data-testid="referral-patient-booked">
              {patientBookedLine(row?.patientBookedAt)}
            </p>
          )}
        </DialogHeader>

        <div ref={bodyRef} className="ak-overlay__body grid gap-4">
        <ReferralContactHistory contacts={contacts} />
          <ReferralContactRecovery recovery={recovery} read={readContactHistory} onReconciled={(contacts) => {
            if (!row?.taskId) return;
            setRecordedContacts({ taskId: row.taskId, contacts });
            setRecipient(""); setSpokeWith(""); setOutcome(""); setError(null); setSaved(false);
            onRecorded();
          }} />
        {!finished && (
        <div className="ak-tabs ak-tabs--line">
          {TABS.map(({ key, label, icon: Icon }) => (
            <button
              key={key}
              type="button"
              onClick={() => { setMethod(key); setError(null); }}
              className="ak-tab"
              data-state={method === key ? "active" : "inactive"}
            >
              <Icon className="h-4 w-4" />
              {label}
            </button>
          ))}
        </div>
        )}


        {/* THE REFUSAL, NEXT TO THE FIELDS IT EXPLAINS. Deliberately not the  Alert above:
            that one belongs to an ACTION the coordinator just took, and is cleared by the next one.
            This is a passive lookup that failed before anybody pressed anything, and it has to
            survive long enough to be read. It never blocks the form - a denial that takes the screen
            away is the same defect wearing the other hat. */}
        {contactRefusal && (
          <Alert data-testid="referral-contact-refused">
            <AlertDescription>{contactRefusal}</AlertDescription>
          </Alert>
        )}
        {error && (
          <Alert variant="destructive">
            <AlertDescription>{error}</AlertDescription>
          </Alert>
        )}

        {/* ── PHONE ───────────────────────────────────────────────────────────────────────────────
            🔬 THE CARD'S FIRST CONTROL: *"a logged call is a real record, not a note. Who called, who
            was called, when, and the outcome — enough that somebody reading it later can tell whether
            the referral was accepted, declined or is still open. ⛔ A free-text box is not this."*
            ⇒ Separate fields, so the next coordinator can read them rather than parse a paragraph. */}
        {!may.contact && !may.state && !may.claimCode && !may.fax && (
          <p className="ak-notice" role="status" data-testid="referral-read-only">
            Your role at this practice can see this referral but not work it.
          </p>
        )}
        {method === "phone" && !saved && !closed && may.contact && (
          <div className="space-y-3">
            <div>
              <label className="ak-label block" htmlFor="referral-call-number">
                Number called
              </label>
              <Input
                id="referral-call-number"
                value={recipient}
                onChange={(e) => setRecipient(e.target.value)}
                placeholder="(555) 555-0123"
              />
              {/* WHERE THE NUMBER CAME FROM. A prefilled box with no provenance is a number the
                  coordinator cannot judge, and judging it is what makes a correction possible. */}
              {knownPhone !== "" && recipient.trim() === knownPhone && (
                <p className="ak-field-help">
                  From the shared referral book, recorded by a practice that referred here before.
                </p>
              )}
              {contact?.shared?.routeTo && (
                <p className="ak-field-help">Ask for {contact.shared.routeTo}.</p>
              )}
              {contact?.shared?.hours && (
                <p className="ak-field-help">Reachable {contact.shared.hours}.</p>
              )}
            </div>

            {/* THE CORRECTION, AT THE MOMENT IT IS LEARNED. Opt-out rather than automatic, on the
                same reasoning as the fax tab: the number dialled for one call may be a direct line
                somebody was given once, and publishing that to every practice would be wrong. */}
            {row?.performerNpi && recipient.trim() !== "" && recipient.trim() !== knownPhone && (
              <label className="flex items-start gap-2">
                <input
                  type="checkbox"
                  className="mt-1"
                  checked={sharePhoneCorrection}
                  onChange={(event) => setSharePhoneCorrection(event.target.checked)}
                />
                <span>
                  {knownPhone === ""
                    ? "Record this number for this practice, so nobody has to find it again."
                    : "Update the number for this practice — the one on file did not work."}
                </span>
              </label>
            )}
            <div>
              <label className="ak-label block" htmlFor="referral-call-person">
                Who you spoke with
              </label>
              {/* ⭐ A PERSON, and the server's own note calls this the single most valuable thing on a
                  phone record — it is who the next coordinator rings back and asks for. */}
              <Input
                id="referral-call-person"
                value={spokeWith}
                onChange={(e) => setSpokeWith(e.target.value)}
                placeholder="Name and role, if they gave one"
              />
            </div>
            <div>
              <label className="ak-label block" htmlFor="referral-call-outcome">
                What was agreed
              </label>
              <Textarea
                id="referral-call-outcome"
                value={outcome}
                onChange={(e) => setOutcome(e.target.value)}
                placeholder="Accepted, declined, asked for records, call back Tuesday…"
                rows={3}
              />
            </div>
            <div className="flex justify-end">
              {/* Plain <button> for the blue: on the shared <Button>, rule 3A strips the primitive's
                  fill, border and shadow, so a house class on it is a silent no-op and the action
                  renders as prose. Same remedy as UnbookableSaveDialog. */}
              <button type="button" className="btn btn-blue" disabled={busy || contactUnconfirmed} onClick={() => void logPhoneCall()}>
                Record this call
              </button>
            </div>
          </div>
        )}

        {method === "phone" && saved && (
          <Alert variant="success">
            <AlertDescription>
              Call recorded against this referral. It is on the referral&apos;s history for whoever picks it
              up next.
            </AlertDescription>
          </Alert>
        )}
        {/* THE SENDER STATES RECEIPT - Spencer, 2026-09-16. Offered ONLY for a recipient who cannot
            sign in, because a practice on Akashic states its own receipt by claiming the referral.
            The server refuses the other cases; this decides what to OFFER. */}
        {method === "phone" && acknowledged && (
          <Alert variant="success" data-testid="referral-transition-recorded">
            <AlertDescription>
              {acknowledged === "scheduled"
                ? "Recorded that they booked the patient."
                : "Recorded that they accepted it."}
            </AlertDescription>
          </Alert>
        )}
        {method === "phone" && canCloseAsSender && may.state && (
          <div className="space-y-2 border-t border-line pt-3">
            <p className="ak-field-help">
              {referralState !== "claimed" && (
                <>
                  {row?.performerDisplay ?? "This practice"} is not on Akashic, so nothing here can tell you
                  they accepted it. If they did, say so.{" "}
                </>
              )}
              If they booked the patient, record that and this referral leaves the open queue.
            </p>
            {/* The dialog footer's stacking, so both answers fit on a phone. */}
            <DialogFooter>
              {referralState !== "claimed" && (
                <button type="button" className="btn btn-blue-ghost" disabled={busy} onClick={() => void recordOnBehalf("claimed")}>
                  They accepted it
                </button>
              )}
              <button type="button" className="btn btn-blue" disabled={busy} onClick={() => void recordOnBehalf("scheduled")}>
                They booked the patient
              </button>
            </DialogFooter>
          </div>
        )}


        {/* ── AKASHIC / CLAIM CODE ────────────────────────────────────────────────────────────────── */}
        {method === "portal" && (
          <div className="space-y-3">
            <p className="ak-field-help">
              Give the receiving practice this code. They enter it when they sign in to Akashic, and the
              referral opens on their side.
            </p>
            {claim ? (
              <div className="ak-empty ak-empty--boxed">
                <p className="font-mono text-lg font-bold tracking-widest">{claim.printed}</p>
                {/*
                  * WHAT THE CODE ACTUALLY GUARANTEES, because the old sentence described a different
                  * scheme and was false on its face beside a code containing a digit.
                  *
                  * It claimed the code held no digits at all. The code is Crockford Base32 —
                  * alphanumeric, and safe for exactly the opposite reason: the digits stay and the
                  * CONFUSABLE LETTERS are the ones removed. There is no I, L, O or U in a real code, so a
                  * 0 can only ever be a zero. Entry then folds O to 0 and I/L to 1, which is safe
                  * precisely because those letters can never appear — reading a character with one
                  * possible intent, rather than guessing.
                  *
                  * So somebody who hears "Z-oh-F-B" and types an O is fine. Telling them there is no zero
                  * was the only thing that could have made them hesitate over a code that works.
                  */}
                <p className="ak-field-help">
                  Read it out or write it down. There is no I, L, O or U in a code, so a 0 is always a
                  zero and a 1 is always a one — and if the other practice types the letter, it still
                  works.
                </p>
                <Button
                  type="button"
                  variant="outline"
                  size="sm"
                  className="mt-2"
                  onClick={() => void navigator.clipboard?.writeText(claim.printed)}
                >
                  <Copy className="mr-1 h-3 w-3" /> Copy
                </Button>
              </div>
            ) : (
              <div className="flex justify-end">
                {may.claimCode && (
                  <button type="button" className="btn btn-blue" disabled={busy} onClick={() => void getClaimCode()}>
                    Get a claim code
                  </button>
                )}
              </div>
            )}
          </div>
        )}

        {/* ── FAX ─────────────────────────────────────────────────────────────────────────────────
            🚨 THE CARD'S SECOND CONTROL, AND IT IS THE SHARPEST ONE HERE: *"the fax option must be
            VISIBLY UNAVAILABLE rather than broken. A button that silently does nothing is worse than
            one that says why — a coordinator will click it, believe the referral was sent, and stop
            chasing it. That is a patient not getting to a specialist."*
            ⇒ No button at all, and the reason stated in the coordinator's terms rather than ours. */}
        {/* 🔻 THE REASON CHANGED, AND THE COPY HAD TO CHANGE WITH IT. This said *"faxing is not switched
            on yet — we will not send records to a fax service until the agreement covering it is
            signed."* That was true while cards 608/611 waited on an Akashic-held fax BAA, and **card 636
            dissolved that wait** rather than satisfying it: the practice brings its own vendor and its
            own agreement, so there is no BAA of ours to sign.
            ⇒ What remains is not our limitation but a setting THIS PRACTICE has not filled in, and
            saying otherwise would send a coordinator to ask us for something only they can do.
            🚨 Control 2 is unchanged and still governs: NO send button, and the reason on screen. */}
        {method === "fax" && !faxConfigured && (
          <Alert>
            <AlertDescription>
              <strong>This practice has not set up faxing yet.</strong> Faxing uses your own fax account —
              an administrator can add one under Faxing, beside Referrals. Until then, send this referral by
              phone or give the practice a claim code; both are recorded here the same way.
            </AlertDescription>
          </Alert>
        )}

        {/* 📠 CARD 611 — CONFIGURED, SO THE BUTTON EXISTS.
            ✅ The packet the server composes is COMPLETE ON ITS OWN: demographics, insurance, the reason
            for referral, the notes, and the referring practitioner's identity and NPI. The claim code is
            additive — an earlier design faxed a content-free "click here" sheet, and it was struck
            because an office that cannot see the reason cannot act.
            ⛔ Nothing here composes the page: a client that decided what a clinical document says would
            be a second, silently different copy of that decision. */}
        {method === "fax" && faxConfigured && !faxResult && (
          <div className="space-y-3 pt-4">
            <div className="space-y-1">
              <label className="ak-label" htmlFor="referral-fax-number">
                Their fax number
              </label>
              <Input
                id="referral-fax-number"
                value={faxNumber}
                onChange={(event) => setFaxNumber(event.target.value)}
                placeholder="319-555-0101"
              />
              {/* WHERE THE NUMBER CAME FROM, because a prefilled box with no provenance is a number
                  the coordinator cannot judge. Knowing another practice recorded it is what makes it
                  worth trusting - and worth correcting when it turns out to be wrong. */}
              {knownFax !== "" && faxNumber.trim() === knownFax && (
                <p className="ak-field-help">
                  From the shared referral book, recorded by a practice that referred here before.
                </p>
              )}
              {contact?.shared?.routeTo && (
                <p className="ak-field-help">Ask for {contact.shared.routeTo}.</p>
              )}
              {contact?.shared?.hours && (
                <p className="ak-field-help">Reachable {contact.shared.hours}.</p>
              )}
            </div>

            {/* THE CORRECTION, OFFERED ONLY WHEN THERE IS ONE. This is the half that makes the book
                worth having: a coordinator rings, learns the number is wrong, and every practice that
                ever refers here inherits what they learned.
                It is opt-out rather than automatic - the number typed for one send may be a direct
                line somebody was given once, and publishing that to every practice would be wrong. */}
            {row?.performerNpi && faxNumber.trim() !== "" && faxNumber.trim() !== knownFax && (
              <label className="flex items-start gap-2">
                <input
                  type="checkbox"
                  className="mt-1"
                  checked={shareCorrection}
                  onChange={(event) => setShareCorrection(event.target.checked)}
                />
                <span>
                  {knownFax === ""
                    ? "Record this number for this practice, so nobody has to find it again."
                    : "Update the number for this practice — the one on file did not work."}
                </span>
              </label>
            )}
            <p className="ak-field-help">
              We send the full referral packet — the patient, their insurance, the reason for referral and
              your notes — so the specialist can act on it without signing in anywhere.
            </p>
            {/* The reason it cannot go, found by looking rather than by being refused mid-send. */}
            {previewNote && (
              <span className="ahr-field-help ahr-caution block" data-testid="packet-not-actionable">{previewNote}</span>
            )}

            <div className="flex items-center gap-2">
              {/* NO FAX NUMBER REQUIRED, and that is the point: checking what would leave is not part
                  of addressing it, and a coordinator should be able to look before they have the
                  number in hand. */}
              <button
                type="button"
                className="btn btn-blue-ghost"
                disabled={busy}
                onClick={() => void previewPacket()}
              >
                See what will be sent
              </button>
              {may.fax && (
                <button
                  type="button"
                  className="btn btn-blue"
                  disabled={busy || faxNumber.trim() === ""}
                  onClick={() => void sendFax()}
                >
                  Send the packet
                </button>
              )}
            </div>
          </div>
        )}

        {/* 🚨 WHAT IT SAYS AFTERWARDS IS THE CONTROL. The vendor ACCEPTED the job — that is the only
            thing anybody knows, and the sentence says so rather than letting "sent" do the work. */}
        {method === "fax" && faxResult && (
          <Alert className="mt-4">
            <AlertDescription>
              <strong>
                {faxResult.accepted
                  ? `${faxResult.pageCount} page${faxResult.pageCount === 1 ? "" : "s"} handed to your fax service.`
                  : "Your fax service did not accept it."}
              </strong>{" "}
              {faxResult.accepted
                ? `This does not confirm the specialist received the referral. Follow up until they respond. If they call, use reference ${faxResult.printedCode}.`
                : "Nothing was sent. Check the number and try again."}
            </AlertDescription>
          </Alert>
        )}
        </div>
      </DialogContent>
    </Dialog>
  );
};

export default ReferralWorkbenchDialog;