import { useEffect, useRef, useState, useSyncExternalStore } from "react";
import { formatDateTime } from "../../../utils/dateUtils";
import type { Attachment } from "fhir/r4";
import { AlertCircle, Loader2 } from "lucide-react";
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogHeader,
  DialogTitle,
} from "../../../components/ui/dialog.tsx";
import { Alert, AlertDescription } from "../../../components/ui/alert.tsx";
import { Button } from "../../../components/ui/button.tsx";
import { LabReports } from "../../../components/LabReports/LabReports";
import { ReportAddenda } from "../../../components/LabReports/ReportAddenda";
import type { DiagnosticOrderQueueRow } from "../../../hooks/useDiagnosticOrderQueue.ts";
import { useLabReportsOnOrder } from "../../../hooks/useLabReportsOnOrder.ts";
import { REFUSAL_NEXT_STEPS } from "../../../hooks/useRecordOrderRefusal.ts";
import { useDiagnosticResult, type EnteredResult } from "../../../hooks/useDiagnosticResult.ts";
import { useReturnDiagnosticResult } from "../../../hooks/useReturnDiagnosticResult.ts";
import { openPdfInTab } from "../../../hooks/useSendOutDiagnosticOrder.ts";
import { useOrderResultRead } from "../../../hooks/useOrderResultRead.ts";
import { onViewerChange, viewerEpoch } from "../../../utils/writeThroughHold";
import { relayServerFailure } from "../../../utils/fetchFailureMessage";
import {
  DIAGNOSTIC_ORDER_STATE_LABELS,
  nextStatesFor,
  type DiagnosticOrderState,
} from "../../../utils/diagnosticOrderQueue.ts";
import { awaitsSpecimen, deliveryLine, isAwaitingResult, returnLine, stateLabel } from "./queueLines.ts";
import { useStaffPermissionServiceContext } from "../../../services";
import { controlRunLine, qualityControlAtRelease } from "../../../utils/qualityControlNotice";
import { labStatusWords } from "../HeldLabResultsPage/heldLabResultWords.ts";
import "../BenchPage/BenchPage.css";
import "./ReleaseResultDialog.css";
import "./RecordRefusalDialog.css";

const CRITICAL_CHANNEL: Record<string, string> = { telephone: "by telephone", "in-person": "in person", "secure-message": "by secure message" };

const refusalNextStep = (id?: string) => REFUSAL_NEXT_STEPS.find((step) => step.id === id)?.label;

// The queue lists each order once with one next step; everything else that can be done to an
// order lives here, with the order it belongs to.

const identity = (row: DiagnosticOrderQueueRow) =>
  `${row.patientDisplay ?? "Patient not named"} · ${row.test ?? "Test not named"}`;

export const Identity = ({ row, detail }: { row: DiagnosticOrderQueueRow; detail?: string }) => (
  <div className="bench-identity">
    <strong>{identity(row)}</strong>
    {detail ? <span>{detail}</span> : null}
  </div>
);

export const Fact = ({ term, children, hint }: { term: string; children: React.ReactNode; hint?: string }) => (
  <div className="ak-facts__item">
    <dt>{term}</dt>
    <dd>{children}</dd>
    {hint ? <dd className="ak-field-help">{hint}</dd> : null}
  </div>
);

const fromLine = (row: DiagnosticOrderQueueRow) =>
  row.fromAkashic
    ? [`From ${row.fromOutside ?? "the sending practice"}`, row.fromAkashic.orderedBy, `Sender’s order ${row.fromAkashic.theirOrderId}`]
        .filter(Boolean)
        .join(" · ")
    : row.fromOutside && row.theirOrderNumber
      ? `From ${row.fromOutside} · Sender’s order ${row.theirOrderNumber}`
      : undefined;

/** The laboratory's attached files are fetched when somebody asks for them, not with the order. */
const useReportOnDemand = (orderId?: string) => {
  const readLabReports = useLabReportsOnOrder();
  // Each opening is its own: a new order, or this one closed and opened again. A read answers only the opening
  // that asked, so files read for one are never shown in the next.
  const opening = useRef(0);
  const openFor = useRef<string | undefined>();
  if (openFor.current !== orderId) {
    openFor.current = orderId;
    opening.current += 1;
  }
  const [shown, setShown] = useState<{ opening: number; reports: Attachment[]; withheld?: string }>();
  const [failed, setFailed] = useState<{ opening: number; message: string }>();
  const [readingFor, setReadingFor] = useState<number>();
  const mine = shown?.opening === opening.current ? shown : undefined;
  const reports = mine && !mine.withheld ? mine.reports : undefined;
  const withheld = mine?.withheld;
  const error = failed?.opening === opening.current ? failed.message : undefined;
  const reading = readingFor === opening.current;

  const toggle = async () => {
    if (!orderId) return;
    if (mine) { setShown(undefined); return; }
    const asked = opening.current;
    setReadingFor(asked);
    setFailed(undefined);
    try {
      const found = await readLabReports(orderId);
      if (opening.current !== asked) return;
      setShown({ opening: asked, reports: found.reports ?? [],
        ...(found.withheld ? { withheld: found.message || "These files are not available to you yet." } : {}) });
    } catch (failure) {
      if (opening.current !== asked) return;
      console.error("Error reading the attached laboratory files on an order:", failure);
      setFailed({ opening: asked, message: relayServerFailure(failure, "Could not open the attached files just now.") });
    } finally {
      setReadingFor((current) => (current === asked ? undefined : current));
    }
  };

  return { reports, withheld, error, reading, toggle, open: Boolean(mine) };
};

type ReportOnDemand = ReturnType<typeof useReportOnDemand>;

const ReportButton = ({ report }: { report: ReportOnDemand }) => (
  <Button className="btn btn-blue-ghost" disabled={report.reading} onClick={() => void report.toggle()}>
    {report.reading ? "Opening…" : report.open ? "Hide attached files" : "View attached laboratory files"}
  </Button>
);

const ReportShown = ({ report }: { report: ReportOnDemand }) => (
  <>
    {report.error && (
      <Alert variant="destructive">
        <AlertCircle className="h-4 w-4" />
        <AlertDescription>{report.error}</AlertDescription>
      </Alert>
    )}
    {/* Withheld, none attached and could not ask are three different answers, and none says the result is missing. */}
    {report.withheld ? (
      <p className="ak-field-help" role="status">The attached laboratory files can’t be shown here: {report.withheld}</p>
    ) : null}
    {report.reports && (report.reports.length ? (
      <LabReports reports={report.reports} />
    ) : (
      <p className="ak-field-help">No laboratory files are attached to this result.</p>
    ))}
  </>
);

const ASKED = "Asked. What the laboratory sends back is filed on this order, or held for a person to match. Nothing reaches the patient until it is released.";

/**
 * Asking the laboratory that confirmed this order for its results now, offered only with its receipt and diagnostics
 * manage; a refusal is shown in the server's words. An ask belongs to the opening it was made in (this order, this
 * viewer): once that ends nothing more is sent or shown for it, and an older ask's answer never clears a newer one.
 */
const useAskForResults = (row?: DiagnosticOrderQueueRow) => {
  const { canManage } = useStaffPermissionServiceContext();
  const { askForResults } = useOrderResultRead();
  const viewer = useSyncExternalStore(onViewerChange, viewerEpoch);
  const opening = useRef(0);
  const openFor = useRef<{ orderId?: string; viewer?: number }>({});
  if (openFor.current.orderId !== row?.orderId || openFor.current.viewer !== viewer) {
    openFor.current = { orderId: row?.orderId, viewer };
    opening.current += 1;
  }
  useEffect(() => () => { opening.current += 1; }, []);
  const latest = useRef(0);
  const [asked, setAsked] = useState<{ id: number; opening: number; busy?: boolean; said?: string; failed?: boolean }>();
  const ask = async () => {
    const orderId = row?.orderId;
    if (!orderId) return;
    const mine = { id: ++latest.current, opening: opening.current };
    // The viewer is read live, not through the last render, so a change just before sending retires the ask.
    const viewerAt = viewerEpoch();
    const owns = () => opening.current === mine.opening && viewerEpoch() === viewerAt;
    const settle = (next: { said?: string; failed?: boolean }) => setAsked((now) => (now?.id === mine.id ? { ...mine, ...next } : now));
    setAsked({ ...mine, busy: true });
    try {
      settle(await askForResults(orderId, owns)
        ? { said: ASKED }
        : { said: "The laboratory was not asked for results.", failed: true });
    } catch (failure) {
      settle({ said: relayServerFailure(failure, "Could not ask the laboratory for results. Try again."), failed: true });
    }
  };
  const current = asked?.opening === opening.current ? asked : undefined;
  return { offered: Boolean(row?.labConfirmed && row.orderId && canManage("diagnostics")), ask, ...current };
};

export const QueueOrderDialog = ({
  row,
  panelOf = 1,
  busy,
  onClose,
  onAdvance,
  onSendOut,
  onSendToRead,
  onRefused,
  onWithdraw,
  onRefusalDealtWith,
  onRelease,
  onEnter,
  onRetryTransmission,
}: {
  row?: DiagnosticOrderQueueRow;
  panelOf?: number;
  busy: boolean;
  onClose: () => void;
  onAdvance: (row: DiagnosticOrderQueueRow, state: DiagnosticOrderState) => void;
  onSendOut: (row: DiagnosticOrderQueueRow) => void;
  /** A performed, unreported study, to a reader on Akashic or not; absent when it cannot go. */
  onSendToRead?: (row: DiagnosticOrderQueueRow) => void;
  onRefused: (row: DiagnosticOrderQueueRow) => void;
  /** The ordering clinician takes the order back; offered only where the server says it would admit it. */
  onWithdraw?: (row: DiagnosticOrderQueueRow) => void;
  onRefusalDealtWith: (row: DiagnosticOrderQueueRow) => void;
  onRelease: (row: DiagnosticOrderQueueRow) => void;
  onEnter: (row: DiagnosticOrderQueueRow) => void;
  /** An electronic send saved but not confirmed queued, handed on again under the same send-out. */
  onRetryTransmission?: (row: DiagnosticOrderQueueRow) => void;
}) => {
  const report = useReportOnDemand(row?.orderId);
  const asking = useAskForResults(row);
  const { canManage, permissionsSettled } = useStaffPermissionServiceContext();
  const mayWork = row?.kind !== "laboratory" || (permissionsSettled && canManage("diagnostics"));
  if (!row) return null;

  // Offered moves come from the state, so a button whose only outcome is a refusal is never shown.
  const moves = nextStatesFor(row.kind, row.state);
  const laboratory = row.sentOut?.laboratory ?? row.akashicRoute?.laboratory;
  const delivery = deliveryLine(row);
  const from = fromLine(row);

  return (
    <Dialog open onOpenChange={(open) => { if (!open) onClose(); }}>
      <DialogContent className="bench-dialog">
        <DialogHeader>
          <DialogTitle>Order details</DialogTitle>
        </DialogHeader>

        <Identity row={row} detail={[row.accession, stateLabel(row.state)].filter(Boolean).join(" · ")} />
        <DialogDescription className="sr-only">Where this order stands and what can be done with it.</DialogDescription>

        <dl className="ak-facts">
          <Fact term="Status">{stateLabel(row.state)}</Fact>
          {laboratory ? <Fact term="Performing laboratory">{laboratory}</Fact> : null}
          {delivery ? <Fact term="Delivery">{delivery}</Fact> : null}
          {from ? <Fact term="Ordered">{from}</Fact> : null}
          {panelOf > 1 ? (
            <Fact term="Panel">{`Ordered with ${panelOf - 1} other ${panelOf === 2 ? "test" : "tests"} — one draw`}</Fact>
          ) : null}
        </dl>

        {/* Still sent, because it genuinely was sent; the refusal is what says the work stopped. */}
        {row.refusal && (
          <div className="refusal-standing">
            <span className="refusal-standing-reason">
              {row.refusal.reason ?? "The laboratory refused this order"}
            </span>
            {row.refusal.theirMessage && (
              <span className="refusal-standing-said">{row.refusal.theirMessage}</span>
            )}
            {row.refusal.theirCode && <span>Their reference: {row.refusal.theirCode}</span>}
            {refusalNextStep(row.refusal.nextStep) && <span>Next: {refusalNextStep(row.refusal.nextStep)}</span>}
            {mayWork && row.orderId && (
              <Button className="btn btn-blue-ghost" disabled={busy} onClick={() => onRefusalDealtWith(row)}>
                Dealt with
              </Button>
            )}
          </div>
        )}

        {/* Dealing with a refusal ends it as work; the order still shows it happened. */}
        {row.pastRefusal && !row.refusal && (
          <section className="refusal-history" aria-labelledby="refusal-history-title">
            <h3 id="refusal-history-title" className="refusal-history-title">Order history</h3>
            <span>
              {["Laboratory refused the order", row.pastRefusal.recorded ? formatDateTime(row.pastRefusal.recorded) : undefined]
                .filter(Boolean).join(" · ")}
            </span>
            {row.pastRefusal.reason && <span className="refusal-history-reason">{row.pastRefusal.reason}</span>}
            {row.pastRefusal.theirMessage && (
              <span className="refusal-standing-said">{row.pastRefusal.theirMessage}</span>
            )}
            {row.pastRefusal.theirCode && <span>Their reference: {row.pastRefusal.theirCode}</span>}
            <span>{row.pastRefusal.resolved ? `Dealt with ${formatDateTime(row.pastRefusal.resolved)}` : "Dealt with"}</span>
          </section>
        )}

        <div className="bench-actions">
          {mayWork && moves.map((state) =>
            // Sending asks where rather than just stamping; marking it without a laboratory left orders sent to nobody.
            state === "sent" ? (
              <Button key={state} className="btn btn-blue-ghost" disabled={busy || !row.orderId} onClick={() => onSendOut(row)}>
                Send out
              </Button>
            ) : (
              <Button key={state} className="btn btn-blue-ghost" disabled={busy || !row.orderId} onClick={() => onAdvance(row, state)}>
                {`Mark ${DIAGNOSTIC_ORDER_STATE_LABELS[state].toLowerCase()}`}
              </Button>
            ),
          )}
          {onRetryTransmission && row.transmissionOwed && row.orderId && (
            <Button className="btn btn-blue-ghost" disabled={busy} onClick={() => onRetryTransmission(row)}>
              Retry electronic send
            </Button>
          )}
          {onRetryTransmission && row.deliveryOwed && row.orderId && (
            <Button className="btn btn-blue-ghost" disabled={busy} onClick={() => onRetryTransmission(row)}>
              Deliver to laboratory
            </Button>
          )}
          {mayWork && onSendToRead && row.orderId && (
            <Button className="btn btn-blue-ghost" disabled={busy} onClick={() => onSendToRead(row)}>
              Send out to be read
            </Button>
          )}
          {/* A result reaches nobody until somebody releases it. */}
          {mayWork && row.awaitingRelease && row.orderId && (
            <Button className="btn btn-blue-ghost" disabled={busy} onClick={() => onRelease(row)}>
              Review &amp; release
            </Button>
          )}
          {/* A refused order waits on the refusal being dealt with, not on a result. A test performed
              here waits for its specimen to be received; one sent out is entered from the other
              laboratory's report. */}
          {mayWork && isAwaitingResult(row.state) && row.orderId && !row.refusal
            && !awaitsSpecimen(row) && (
            <Button className="btn btn-blue" disabled={busy} onClick={() => onEnter(row)}>
              Enter result
            </Button>
          )}
          {row.resultOnFile && row.orderId && <ReportButton report={report} />}
          {asking.offered && (!asking.said || asking.failed) && (
            <Button className="btn btn-blue-ghost" disabled={busy || asking.busy} onClick={() => void asking.ask()}>
              {asking.busy ? <Loader2 className="size-4 animate-spin" aria-hidden /> : null}
              Ask the laboratory for results
            </Button>
          )}
          {onWithdraw && row.withdrawable && row.orderId && (
            <Button className="btn btn-red-ghost" disabled={busy} onClick={() => onWithdraw(row)}>
              Withdraw order
            </Button>
          )}
          {/* The laboratory would not take it, which is not the sample being refused. */}
          {mayWork && row.orderId && !row.refusal && !row.awaitingRelease && (
            <Button className="btn btn-red-ghost" disabled={busy} onClick={() => onRefused(row)}>
              Record order refusal
            </Button>
          )}
        </div>
        {asking.said ? <p className="release-note" role={asking.failed ? "alert" : "status"}>{asking.said}</p> : null}
        <ReportShown report={report} />
      </DialogContent>
    </Dialog>
  );
};

/**
 * Who released the result and when, as the report records it. Never the viewer, the ordering practitioner or an
 * addendum's author, and never inferred: a result not released says so, and a missing signer says it was not recorded.
 */
/**
 * Where a report filed from a laboratory came from, and the laboratory's own status and time. Said apart from the
 * release line, because the laboratory finishing a report is not anyone here releasing it.
 */
const LaboratorySource = ({ from }: { from: NonNullable<EnteredResult["fromLaboratory"]> }) => (
  <p className="release-note" data-testid="result-from-laboratory">
    {[`From ${from.laboratory ?? "the laboratory"}: their report ${from.theirReport}, version ${from.version}`,
      labStatusWords(from.laboratoryStatus), from.issued ? `issued ${formatDateTime(from.issued)}` : undefined]
      .filter(Boolean).join(" · ")}
  </p>
);

const ReleaseAttribution = ({ result }: { result: EnteredResult }) => {
  const at = result.status === "final" ? result.released?.at : undefined;
  return (
    <p className="release-note" data-testid="result-release">
      {!at
        ? "Not released yet."
        : result.released?.by
          ? `Signed by ${result.released.by} · ${formatDateTime(at)}`
          : `Signed ${formatDateTime(at)} · signer not recorded`}
    </p>
  );
};

/**
 * Where quality control stood when the result went out, from the position stamped on it, never today's. Said only
 * when the server sent the stamped position, so a missing answer is not mistaken for one released before stamping.
 */
const QualityControlAtRelease = ({ result, test }: { result: EnteredResult; test?: string }) => {
  if (result.status !== "final" || result.qualityControlAtRelease === undefined) return null;
  const run = controlRunLine(result.qualityControlAtRelease ?? undefined);
  return (
    <p className="release-note" data-testid="result-quality-control">
      {qualityControlAtRelease(result.qualityControlAtRelease, test)}
      {run ? <><br />{run}</> : null}
    </p>
  );
};

export const QueueResultDialog = ({
  row,
  panelOf = 1,
  busy,
  onClose,
  onAddendum,
  onReturn,
  onFaxBack,
}: {
  row?: DiagnosticOrderQueueRow;
  panelOf?: number;
  busy: boolean;
  onClose: () => void;
  onAddendum: (row: DiagnosticOrderQueueRow) => void;
  onReturn: (row: DiagnosticOrderQueueRow) => void;
  onFaxBack: (row: DiagnosticOrderQueueRow) => void;
}) => {
  const { result, error: readError, loading } = useDiagnosticResult(row?.orderId);
  const report = useReportOnDemand(row?.orderId);
  const { resultPage } = useReturnDiagnosticResult();
  // The server takes an addendum only from diagnostics manage; nobody else is offered one. The Admin
  // workspace reads as manage here, so a result the server just refused to show also offers none.
  const { canManage } = useStaffPermissionServiceContext();
  const mayAddend = canManage("diagnostics") && !readError;

  const [printError, setPrintError] = useState<string>();

  if (!row) return null;

  const printResult = async () => {
    if (!row.orderId) return;
    // Opened before the await, while the click still counts as the user acting.
    const tab = window.open("", "_blank");
    if (tab) tab.opener = null;
    setPrintError(undefined);
    try {
      openPdfInTab(tab, await resultPage(row.orderId));
    } catch (failure) {
      tab?.close();
      setPrintError(relayServerFailure(failure, "The result page could not be made."));
    }
  };

  const returned = returnLine(row);
  const signed = Boolean(row.resultOnFile && !row.awaitingRelease && row.orderId);
  const from = fromLine(row);

  return (
    <Dialog open onOpenChange={(open) => { if (!open) onClose(); }}>
      <DialogContent className="bench-dialog">
        <DialogHeader>
          <DialogTitle>Result details</DialogTitle>
        </DialogHeader>

        <Identity row={row} detail={[row.accession, stateLabel(row.state)].filter(Boolean).join(" · ")} />
        <DialogDescription className="sr-only">The result on file for this order.</DialogDescription>
        {/* The sender files what comes back against their own number, so the result names it. */}
        {from ? <dl className="ak-facts"><Fact term="Ordered">{from}</Fact></dl> : null}

        {loading ? (
          <p className="ak-status-line">
            <Loader2 className="h-4 w-4 animate-spin" />
            Reading the result…
          </p>
        ) : null}
        {readError ? (
          <Alert variant="destructive">
            <AlertCircle className="h-4 w-4" />
            <AlertDescription>{readError}</AlertDescription>
          </Alert>
        ) : null}
        {/* An imaging read is findings and impression; its measurements are optional and not missed. */}
        {result && (result.measurements.length || row.kind !== "imaging") ? (result.measurements.length ? (
          <table className="release-table">
            <thead>
              <tr><th>Measurement</th><th>Value</th><th>Unit</th></tr>
            </thead>
            <tbody>
              {result.measurements.map((measurement, index) => (
                <tr key={`${measurement.name ?? "measurement"}-${index}`}>
                  <td>{measurement.name ?? "Not named"}</td>
                  <td>{[measurement.value ?? "Not recorded", measurement.flag].filter(Boolean).join(" ")}</td>
                  <td>{measurement.unit ?? ""}</td>
                </tr>
              ))}
            </tbody>
          </table>
        ) : (
          <p className="release-note">No measurement was entered on this result.</p>
        )) : null}
        {result?.findings ? <p className="release-findings">{result.findings}</p> : null}
        {result?.impression ? <p className="release-findings"><strong>Impression </strong>{result.impression}</p> : null}
        {/* The order the report answers carries what was added since signing, beside the signed words. */}
        {result?.criticalFinding?.told ? (
          <p className="release-note">
            {[`Critical result told to ${result.criticalFinding.told}`,
              result.criticalFinding.how ? CRITICAL_CHANNEL[result.criticalFinding.how] ?? result.criticalFinding.how : undefined,
              result.criticalFinding.at ? formatDateTime(result.criticalFinding.at) : undefined].filter(Boolean).join(" ")}
          </p>
        ) : null}
        {result?.fromLaboratory ? <LaboratorySource from={result.fromLaboratory} /> : null}
        {result ? <ReleaseAttribution result={result} /> : null}
        {result && row.kind !== "imaging" ? <QualityControlAtRelease result={result} test={row.test} /> : null}
        {result?.addenda?.length ? <ReportAddenda addenda={result.addenda} /> : null}
        {panelOf > 1 ? <p className="release-note">Other tests in this panel keep their own status.</p> : null}

        {/* Released is not reviewed; the queue never implies the clinician has seen it. */}
        <p className="ak-field-help">
          {row.state === "reviewed"
            ? "The ordering clinician has reviewed this result."
            : "Ordering clinician has not reviewed this result."}
        </p>
        {returned ? <p className="ak-field-help">{returned}</p> : null}

        <div className="bench-actions">
          {/* A laboratory's paperwork; an imaging read is its own report and has none. */}
          {row.resultOnFile && row.orderId && row.kind !== "imaging" && <ReportButton report={report} />}
          {/* Only once the result is out; before release the words belong in the report itself. */}
          {signed && mayAddend && (
            <Button className="btn btn-blue-ghost" disabled={busy} onClick={() => onAddendum(row)}>
              Add addendum
            </Button>
          )}
          {/* The signed page the server renders for any order here, on the permission it asks for; an
              in-house imaging read has no laboratory paperwork to print instead. */}
          {signed && mayAddend && (row.fromOutside || row.kind === "imaging") && (
            <Button className="btn btn-blue-ghost" onClick={() => void printResult()}>
              Print the result
            </Button>
          )}
          {/* Back the way it came, for a practice that ordered on paper and has no login here. */}
          {signed && row.fromOutside && (
            <>
              <Button className="btn btn-blue" disabled={busy} onClick={() => onReturn(row)}>
                {row.returned?.outcome === "delivered" ? "View delivery" : "Return report"}
              </Button>
              {/* Fax is for a practice that ordered on paper; an Akashic return lands on their own order. */}
              {!row.fromAkashic && !row.readFor && (
                <Button className="btn btn-blue-ghost" disabled={busy} onClick={() => onFaxBack(row)}>
                  Fax it back
                </Button>
              )}
            </>
          )}
        </div>

        {printError && (
          <Alert variant="destructive">
            <AlertCircle className="h-4 w-4" />
            <AlertDescription>{printError}</AlertDescription>
          </Alert>
        )}
        <ReportShown report={report} />
      </DialogContent>
    </Dialog>
  );
};