import { useRef, useState } from "react";
import { AlertCircle, Inbox, Loader2, Plus } from "lucide-react";
import { Alert, AlertDescription } from "../../../components/ui/alert.tsx";
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 { Label } from "../../../components/ui/label.tsx";
import { Textarea } from "../../../components/ui/textarea.tsx";
import { ToggleGroupControl, ToggleGroupControlOption } from "../../../components/ui/toggle-group-control.tsx";
import { EmptyState } from "../../../components/ui/empty-state.tsx";
import { useStaffPermissionServiceContext } from "../../../services";
import {
  useInboundRequisitions,
  type InboundRequisition,
  type RefusedRequisition,
} from "../../../hooks/useInboundRequisitions.ts";
import { formatDate, formatDateTime } from "../../../utils/dateUtils";
import { mayHaveBeenWritten, relayServerFailure } from "../../../utils/fetchFailureMessage";
import { newOperationId } from "../../../hooks/useHeldLabResults";
import MatchRequisitionDialog from "./MatchRequisitionDialog.tsx";
import ReviewOrderDialog from "./ReviewOrderDialog.tsx";
import { testTermsOf } from "./requisitionTestTerms.ts";
import RefuseRequisitionDialog, { REASONS } from "./RefuseRequisitionDialog.tsx";
import RequisitionContactDialog, { describeContact, failureWording } from "./RequisitionContactDialog.tsx";
import "./InboundRequisitionsPage.css";

// WHAT ARRIVED ON PAPER FROM SOMEBODY WHO IS NOT ON THIS SYSTEM.
//
// EVERY OTHER INBOUND PATH STARTS WITH ANOTHER AKASHIC PRACTICE, so the requisitions that most need
// tracking - faxed by a clinician who will never have a login - had no way in at all.
//
// THE PATIENT IS NAMED BY A PERSON AND NEVER BY THIS SCREEN. What is typed here is what the sender
// wrote, and it stays that way until somebody opens the row and chooses a record. Nothing on this
// page searches for a patient, suggests one, or highlights a likely one.
//
// TYPING IN AND MATCHING BOTH NEED `manage`; READING THE LIST NEEDS ONLY `view`. That is the split
// the API makes, and the screen makes the same one rather than a different one: a tech the practice
// has not yet trusted to write to a record can still see that a fax arrived, which is how somebody
// knows to fetch the person who can.

const BLANK = {
  from: "",
  npi: "",
  test: "",
  patientName: "",
  patientBirthDate: "",
  theirOrderCode: "",
  note: "",
};

const InboundRequisitionsPage = () => {
  const { canManage } = useStaffPermissionServiceContext();
  const {
    requisitions, requisitionsPartial, refused, refusedUnreadable, refusedPartial, refusedWindowDays, loading, error, reload, log, match, accept, refuse, recordContact, findCandidates,
  } = useInboundRequisitions();

  const mayWrite = canManage("diagnostics");

  const [typing, setTyping] = useState(false);
  const [paper, setPaper] = useState(BLANK);
  // Which worklist the accepted order joins; the paper says, and most paper is laboratory work.
  const [kind, setKind] = useState<"laboratory" | "imaging">("laboratory");
  const [busy, setBusy] = useState(false);
  const [logError, setLogError] = useState<string>();
  // An entry whose answer was lost keeps its operation, so logging the same paper again cannot store it twice.
  const unsettled = useRef<{ operationId: string; request: string }>();
  const [matching, setMatching] = useState<InboundRequisition>();
  const [reviewing, setReviewing] = useState<InboundRequisition>();
  const [refusing, setRefusing] = useState<InboundRequisition>();
  const [contacting, setContacting] = useState<RefusedRequisition>();
  const [resending, setResending] = useState<string>();
  const [resendError, setResendError] = useState<string>();

  // The server keeps the refusal as first recorded; a resend only retries updating the sender's order.
  const resend = async (row: RefusedRequisition) => {
    setResending(row.requisitionId);
    setResendError(undefined);
    try {
      await refuse(row.requisitionId as string, { reasonCode: row.refusal?.reasonCode ?? "other", message: row.refusal?.message ?? "Refused." });
    } catch (failure) {
      console.error("Error resending a refusal:", failure);
      setResendError(failureWording(failure, "refusal"));
    } finally {
      setResending(undefined);
    }
  };

  const field = (key: keyof typeof BLANK) => (
    event: { target: { value: string } },
  ) => setPaper((held) => ({ ...held, [key]: event.target.value }));

  // The two facts a row is unreadable without. Everything else on a fax is optional, because a fax
  // that omits it is a bad requisition and a real one.
  const submittable = paper.from.trim().length > 0 && paper.patientName.trim().length > 0;

  const close = () => { setPaper(BLANK); setKind("laboratory"); setTyping(false); setLogError(undefined); };

  const submit = async () => {
    setBusy(true);
    setLogError(undefined);
    const requisition = {
      from: paper.from.trim(),
      patientName: paper.patientName.trim(),
      ...(paper.npi.trim() ? { npi: paper.npi.trim() } : {}),
      ...(paper.test.trim() ? { test: paper.test.trim() } : {}),
      ...(kind === "imaging" ? { kind: "imaging" as const } : {}),
      ...(paper.patientBirthDate.trim() ? { patientBirthDate: paper.patientBirthDate.trim() } : {}),
      ...(paper.theirOrderCode.trim() ? { theirOrderCode: paper.theirOrderCode.trim() } : {}),
      ...(paper.note.trim() ? { note: paper.note.trim() } : {}),
    };
    const request = JSON.stringify(requisition);
    const attempt = unsettled.current?.request === request ? unsettled.current : { operationId: newOperationId(), request };
    unsettled.current = attempt;
    try {
      await log(requisition, attempt.operationId);
      unsettled.current = undefined;
      close();
      await reload();
    } catch (failure) {
      console.error("Error logging an inbound requisition:", failure);
      // Only a server's definite refusal settles the entry; any other failure may have stored it.
      const refused = typeof (failure as { status?: unknown } | null)?.status === "number" && !mayHaveBeenWritten(failure);
      if (!refused) {
        setLogError("This may have been saved; the answer was lost. Log it again unchanged to finish; it will not be stored twice.");
      } else {
        unsettled.current = undefined;
        setLogError(relayServerFailure(failure, "That could not be saved. Nothing was recorded."));
      }
    } finally {
      setBusy(false);
    }
  };

  return (
    <div>
      <div className="inbound-head">
        <div className="min-w-0">
          <h1 className="ak-page-title">Requisitions received</h1>
          <p className="ak-page-title__sub">
            Outside orders waiting for patient matching.
          </p>
        </div>
        {mayWrite && (
          <Button className="btn btn-blue" onClick={() => setTyping(true)}>
            <Plus className="mr-2 h-4 w-4" aria-hidden="true" />
            Add requisition
          </Button>
        )}
      </div>

      <div className="ak-page-body">
      {error && !loading && (
        <Alert variant="destructive">
          <AlertCircle className="h-4 w-4" />
          <AlertDescription>{error}</AlertDescription>
          <Button className="btn btn-blue-ghost inbound-retry" onClick={() => void reload()}>
            Try again
          </Button>
        </Alert>
      )}

      <Dialog open={typing} onOpenChange={(open) => { if (!open && !busy) close(); }}>
        <DialogContent>
          <DialogHeader>
            <DialogTitle>Add requisition</DialogTitle>
            <DialogDescription>Enter what arrived from the outside practice.</DialogDescription>
          </DialogHeader>
          <div className="inbound-form">
            {logError && (
              <Alert variant="destructive">
                <AlertCircle className="h-4 w-4" />
                <AlertDescription>{logError}</AlertDescription>
              </Alert>
            )}

            <div className="inbound-row">
              <div className="inbound-field">
                <Label htmlFor="inbound-from">Sending practice *</Label>
                <Input
                  id="inbound-from"
                  value={paper.from}
                  disabled={busy}
                  placeholder="Riverbend Family Practice"
                  onChange={field("from")}
                />
              </div>
              <div className="inbound-field">
                <Label htmlFor="inbound-npi">Ordering NPI (optional)</Label>
                <Input
                  id="inbound-npi"
                  value={paper.npi}
                  disabled={busy}
                  placeholder="1548273901"
                  onChange={field("npi")}
                />
              </div>
            </div>

            {/* AS THE PAGE HAS IT, and the label says so. Somebody correcting a spelling here is
                editing the evidence the match will later be judged against. */}
            <div className="inbound-row">
              <div className="inbound-field">
                <Label htmlFor="inbound-patient">Patient name as written *</Label>
                <Input
                  id="inbound-patient"
                  value={paper.patientName}
                  disabled={busy}
                  placeholder="H. Potter"
                  onChange={field("patientName")}
                />
              </div>
              <div className="inbound-field">
                <Label htmlFor="inbound-dob">Date of birth (optional)</Label>
                <Input
                  id="inbound-dob"
                  type="date"
                  value={paper.patientBirthDate}
                  disabled={busy}
                  onChange={field("patientBirthDate")}
                />
              </div>
            </div>

            <div className="inbound-row">
              <div className="inbound-field">
                <ToggleGroupControl label="It asks for" value={kind} disabled={busy} isBlock className="mb-3 whitespace-nowrap"
                  onChange={(value) => setKind(value === "imaging" ? "imaging" : "laboratory")}>
                  <ToggleGroupControlOption value="laboratory" label="Lab test" />
                  <ToggleGroupControlOption value="imaging" label="Imaging study" />
                </ToggleGroupControl>
                <Label htmlFor="inbound-test">Requested test</Label>
                <Input
                  id="inbound-test"
                  value={paper.test}
                  disabled={busy}
                  placeholder={kind === "imaging" ? "XR Knee 2 views" : "Hemoglobin A1c"}
                  onChange={field("test")}
                />
              </div>
              <div className="inbound-field">
                <Label htmlFor="inbound-code">Sender&apos;s order number (optional)</Label>
                <Input
                  id="inbound-code"
                  value={paper.theirOrderCode}
                  disabled={busy}
                  placeholder="RB-4471"
                  onChange={field("theirOrderCode")}
                />
              </div>
            </div>

            <div className="inbound-field">
              <Label htmlFor="inbound-note">Additional information (optional)</Label>
              <Textarea
                id="inbound-note"
                value={paper.note}
                rows={2}
                disabled={busy}
                placeholder="Fasting since 8pm"
                onChange={field("note")}
              />
            </div>

            <p className="ak-field-help">
              Save first, then match the patient. This does not automatically create a patient account.
            </p>
          </div>
          <DialogFooter>
            <Button className="btn btn-green" disabled={!submittable || busy} onClick={() => void submit()}>
              {busy ? "Saving…" : "Save requisition"}
            </Button>
          </DialogFooter>
        </DialogContent>
      </Dialog>

      {loading ? (
        <p className="ak-status-line flex items-center gap-2">
          <Loader2 className="h-4 w-4 animate-spin" />
          Loading what has arrived…
        </p>
      ) : error ? null : requisitions.length === 0 && !requisitionsPartial ? (
        <EmptyState
          icon={Inbox}
          title="Nothing waiting"
          description="Fax and phone requisitions wait here until someone identifies the patient."
        />
      ) : (
        <>
        {/* A partial list never reads as everything waiting: some requisitions may not be shown. */}
        {requisitionsPartial ? (
          <p className="ak-field-help" role="status">
            {requisitions.length === 0
              ? "What is waiting could not all be read; requisitions may be waiting that are not shown. Try again shortly."
              : `Showing ${requisitions.length} requisitions; this list is incomplete. Requisitions not shown are still waiting.`}
          </p>
        ) : null}
        <div className="ak-card-list">
        {requisitions.map((requisition) => (
          <div key={requisition.requisitionId} className="ak-card inbound-card">
              <div className="inbound-card__main">
                <p className="ak-card__title">{requisition.test ?? "Test not named"}</p>
                {/* The patient as written, said plainly as written. This is not a record yet. */}
                <p className="ak-card__meta">
                  {`Patient as written: ${requisition.patientName}`}
                  {requisition.patientBirthDate
                    ? ` · DOB: ${formatDate(requisition.patientBirthDate)}`
                    : " · Date of birth not provided"}
                </p>
                {requisition.akashic ? (
                  <>
                    <p className="ak-card__meta">
                      {[`From ${requisition.from}`, requisition.akashic.orderedBy, requisition.theirOrderCode ? `Sender’s order ${requisition.theirOrderCode}` : undefined]
                        .filter(Boolean)
                        .join(" · ")}
                    </p>
                    {testTermsOf(requisition) ? (
                      <p className="ak-card__meta">{testTermsOf(requisition)}</p>
                    ) : null}
                    <p className="ak-card__meta">
                      {`Order received from ${requisition.from} · Akashic organization`}
                      {requisition.receivedAt ? ` · Received ${formatDateTime(requisition.receivedAt)}` : ""}
                    </p>
                  </>
                ) : (
                  <p className="ak-card__meta">
                    {`From ${requisition.from}`}
                    {requisition.theirOrderCode ? ` · ${requisition.theirOrderCode}` : ""}
                    {requisition.receivedAt ? ` · Received ${formatDateTime(requisition.receivedAt)}` : ""}
                  </p>
                )}
                {requisition.note ? (
                  <p className="ak-card__meta">{requisition.note}</p>
                ) : null}
                {requisition.matchedPatient ? (
                  <p className="ak-card__meta">
                    {`Matched to ${requisition.matchedPatient.display ?? "the chosen record"} · order acceptance needed`}
                  </p>
                ) : null}
              </div>

              {mayWrite && (
                <div className="inbound-card__actions">
                  {requisition.matchedPatient ? (
                    <Button className="btn btn-blue-ghost" onClick={() => setReviewing(requisition)}>
                      Review order
                    </Button>
                  ) : (
                    <Button className="btn btn-blue-ghost" onClick={() => setMatching(requisition)}>
                      Match patient
                    </Button>
                  )}
                  <Button className="btn btn-red-ghost" onClick={() => setRefusing(requisition)}>
                    Refuse order
                  </Button>
                </div>
              )}
          </div>
        ))}
        <p className="ak-card ak-card--muted ak-field-help">
          Patient matching is a deliberate staff decision. Logging a requisition alone does not select or create a patient record.
        </p>
        </div>
        </>
      )}
      {!loading && refusedUnreadable ? (
        <Alert variant="destructive">
          <AlertCircle className="h-4 w-4" />
          <AlertDescription>Refused requisitions could not be loaded, so none are shown.</AlertDescription>
        </Alert>
      ) : null}
      {resendError ? (
        <Alert variant="destructive">
          <AlertCircle className="h-4 w-4" />
          <AlertDescription>{resendError}</AlertDescription>
        </Alert>
      ) : null}
      {!loading && refused.length > 0 ? (
        <section aria-labelledby="refused-requisitions" className="inbound-refused">
          <h2 id="refused-requisitions" className="ak-section-title">
            {refusedWindowDays ? `Refused in the last ${refusedWindowDays} days` : "Refused"}
          </h2>
          {refusedPartial ? (
            <p className="ak-field-help">Showing {refused.length} refusals; this list is incomplete. Refusals not shown are kept.</p>
          ) : null}
          <div className="ak-card-list">
            {refused.map((row) => (
              <div key={row.requisitionId} className="ak-card inbound-card">
                <div className="inbound-card__main">
                  <p className="ak-card__title">{row.test ?? "Test not named"}</p>
                  <p className="ak-card__meta">{`Patient as written: ${row.patientName ?? "not given"}`}</p>
                  <p className="ak-card__meta">
                    {`From ${row.from}`}
                    {row.refusal?.at ? ` · Refused ${formatDateTime(row.refusal.at)}` : ""}
                  </p>
                  <p className="ak-card__meta">
                    {[REASONS.find((reason) => reason.code === row.refusal?.reasonCode)?.label, row.refusal?.message]
                      .filter(Boolean)
                      .join(": ")}
                  </p>
                  {row.akashic ? (
                    <p className="ak-card__meta">
                      {row.senderRecordUpdated
                        ? `Refusal recorded on ${row.from}’s order through Akashic.`
                        : `Not yet confirmed on ${row.from}’s order.`}
                    </p>
                  ) : (
                    <>
                      <p className="ak-card__meta">{`${row.from} has not been told through Akashic.`}</p>
                      {(row.contacts ?? []).length === 0 ? (
                        <p className="ak-card__meta">No contact attempt recorded yet.</p>
                      ) : (row.contacts ?? []).map((attempt) => (
                        <p key={attempt.id} className="ak-card__meta">
                          {`Contact attempt recorded: ${describeContact(attempt)}`}
                        </p>
                      ))}
                    </>
                  )}
                </div>
                {mayWrite && !row.akashic ? (
                  <div className="inbound-card__actions">
                    <Button className="btn btn-blue-ghost" onClick={() => setContacting(row)}>
                      Record contact attempt
                    </Button>
                  </div>
                ) : null}
                {mayWrite && row.akashic && !row.senderRecordUpdated ? (
                  <div className="inbound-card__actions">
                    <Button className="btn btn-blue-ghost" disabled={resending === row.requisitionId} onClick={() => void resend(row)}>
                      {resending === row.requisitionId ? "Sending…" : "Send the refusal again"}
                    </Button>
                  </div>
                ) : null}
              </div>
            ))}
          </div>
        </section>
      ) : null}
      </div>
      <RequisitionContactDialog requisition={contacting} recordContact={recordContact} onClose={() => setContacting(undefined)} />
      <ReviewOrderDialog requisition={reviewing} accept={accept} onClose={() => setReviewing(undefined)} />

      <RefuseRequisitionDialog requisition={refusing} refuse={refuse} onClose={() => setRefusing(undefined)} />

      <MatchRequisitionDialog
        requisition={matching}
        match={match}
        findCandidates={findCandidates}
        onClose={() => setMatching(undefined)}
        onMatched={() => void reload()}
      />
    </div>
  );
};

export default InboundRequisitionsPage;