import { useState } from "react";
import { AlertCircle, Loader2 } from "lucide-react";
import { Alert, AlertDescription } from "../../../components/ui/alert.tsx";
import { Button } from "../../../components/ui/button.tsx";
import { Input } from "../../../components/ui/input.tsx";
import { Label } from "../../../components/ui/label.tsx";
import { priorityWord } from "../../../components/ui/row-meta.tsx";
import { useStaffPermissionServiceContext } from "../../../services";
import { useCapabilityServiceContext } from "../../../services/CapabilityService.tsx";
import { useAdmission } from "../../../hooks/useAdmission.ts";
import { relayServerFailure } from "../../../utils/fetchFailureMessage";
import { reserveReceiptForSend, confirmReceiptAttempt } from "../../../utils/unconfirmedReceipts";
import { useBench, type BenchRow, type RejectionInput } from "../../../hooks/useBench.ts";
import ReleaseResultDialog from "../DiagnosticOrdersPage/ReleaseResultDialog.tsx";
import RecordRefusalDialog from "../DiagnosticOrdersPage/RecordRefusalDialog.tsx";
import { QualityControlStrip } from "./QualityControlStrip.tsx";
import { CollectDialog } from "./CollectDialog.tsx";
import { RejectSpecimenDialog } from "./RejectSpecimenDialog.tsx";
import { OrderDetailsDialog } from "./OrderDetailsDialog.tsx";
import EnterTestResultDialog from "../DiagnosticOrdersPage/EnterTestResultDialog.tsx";
import { benchTime, dayAndTime } from "./benchTime.ts";
import "./BenchPage.css";

// Worked by specimen rather than by order: the queue next door answers what is outstanding, this
// answers what is in hand. Each act opens over the worklist from the row it names.

const isUrgent = (row: BenchRow) => Boolean(row.priority && row.priority !== "routine");

const joined = (...parts: (string | undefined)[]) => parts.filter(Boolean).join(" · ");

// Names the person behind the step as well as its time, so the technician knows whom to ask.
const who = (row: BenchRow, verb: string, iso?: string, by?: string) => {
    const step = [verb, benchTime(iso), by ? `by ${by}` : undefined].filter(Boolean);
    return joined(row.patientDisplay ?? "Patient not recorded", step.length > 1 ? step.join(" ") : undefined);
};

const matches = (row: BenchRow, query: string) =>
    [row.patientDisplay, row.test, row.accession].some((value) => value?.toLowerCase().includes(query));

/** What to draw it into, led by the priority when the order is not routine. */
const tubeLine = (row: BenchRow) =>
    joined(isUrgent(row) ? priorityWord(row.priority) : undefined, row.container, row.volume);

const Row = ({ row, action, children }: { row: BenchRow; action?: React.ReactNode; children?: React.ReactNode }) => (
    <div className={`ahr-list-card bench-row${isUrgent(row) ? " bench-row-urgent" : ""}`}>
        <div className="bench-row-main">
            {row.accession ? <small className="ak-card__meta bench-accession">{row.accession}</small> : null}
            <strong className="ak-card__title">{row.test ?? "Test not recorded"}</strong>
            {children}
        </div>
        {action}
    </div>
);

/** A section always states its count, so a zero reads as settled rather than as a failed load. */
const Group = ({ title, rows, empty, searching, children }: {
    title: string;
    rows: BenchRow[];
    empty: string;
    searching: boolean;
    children: (row: BenchRow) => React.ReactNode;
}) => (
    <section className="bench-group" aria-label={title}>
        <div className="ak-section-head">
            <h2 className="ak-section-title">{title}</h2>
            <span className="ak-section-head__count">{`· ${rows.length}`}</span>
        </div>
        {rows.length ? <div className="ak-card-list">{rows.map(children)}</div> : searching ? null : <p className="ahr-list-card bench-empty">{empty}</p>}
    </section>
);

const BenchPage = () => {
    const { canManage, permissionsSettled } = useStaffPermissionServiceContext();
    // Every act here writes through a diagnostics route the server gates at manage.
    const mayWork = canManage("diagnostics");
    const { mayCall } = useCapabilityServiceContext();
    // The practice's permissions decide whether the bench is worked here at all; the server's own answer for the route
    // each act calls can still say no, and then the act is not offered. An unanswered capability read narrows nothing.
    const mayAct = (method: string, route: string) => mayWork && mayCall(method, route) !== false;
    const mayCollect = mayAct("PUT", "/diagnostic-order/*/state");
    const mayReceive = mayAct("POST", "/Specimen");
    const mayReject = mayAct("POST", "/diagnostic-order/*/rejection");
    const mayEnterResult = permissionsSettled && mayAct("POST", "/diagnostic-order/*/result");
    const mayRefuse = mayAct("POST", "/diagnostic-order/*/refusal");
    const mayRelease = mayAct("POST", "/diagnostic-order/*/release");
    // An act already open follows its route's answer too: withdrawn, its dialog cannot send, and a write still
    // waiting on its token when the answer changes is stopped before it leaves.
    const admitCollect = useAdmission(mayCollect);
    const admitReceive = useAdmission(mayReceive);
    const admitReject = useAdmission(mayReject);
    const { bench, loading, error, reload, markCollected, receive, rejectAtReceipt, markReleased } = useBench();

    const [query, setQuery] = useState("");
    const [collecting, setCollecting] = useState<BenchRow>();
    const [viewing, setViewing] = useState<BenchRow>();
    const [refusing, setRefusing] = useState<BenchRow>();
    const [releasing, setReleasing] = useState<BenchRow>();
    const [receiving, setReceiving] = useState<BenchRow>();
    const [entering, setEntering] = useState<BenchRow>();
    const [rejecting, setRejecting] = useState<BenchRow>();

    const searching = query.trim().toLowerCase();
    const shown = (rows: BenchRow[]) => (searching ? rows.filter((row) => matches(row, searching)) : rows);
    const sections = {
        toCollect: shown(bench.toCollect),
        onTheBench: shown(bench.onTheBench),
        awaitingRelease: shown(bench.awaitingRelease),
        rejectedToday: shown(bench.rejectedToday),
    };
    const nothingMatches = Boolean(searching) && Object.values(sections).every((rows) => rows.length === 0);

    const enterResult = (row: BenchRow) => {
        if (row.orderId && permissionsSettled && canManage("diagnostics") && mayCall("POST", "/diagnostic-order/*/result") !== false) setEntering(row);
    };

    // Collection only moves the order; a failure keeps the dialog open with the words.
    const take = async (row: BenchRow) => {
        try {
            await markCollected(row.orderId as string, admitCollect);
        } catch (failure) {
            console.error("Error marking a sample collected:", failure);
            throw new Error(relayServerFailure(failure, "That sample was not marked collected. Nothing changed."));
        }
        setCollecting(undefined);
    };

    // Receipt mints the accession from the test specimen requirements. An order keeps one attempt until its receipt is
    // confirmed or definitely refused, across leaving the bench and reloading, so trying again after an unanswered
    // receipt is answered with the tube it wrote, not a second one.
    const takeIn = async (row: BenchRow) => {
        const orderId = row.orderId as string;
        const attemptId = await reserveReceiptForSend(orderId);
        try {
            await receive(orderId, admitReceive, attemptId);
        } catch (failure) {
            console.error("Error receiving a specimen:", failure);
            const status = (failure as { status?: unknown } | null)?.status;
            if (typeof status === "number" && status >= 400 && status < 500) {
                try { await confirmReceiptAttempt(orderId, attemptId); } catch { /* Keep the refusal and its recovery identity. */ }
            }
            throw new Error(relayServerFailure(failure, "That specimen could not be confirmed as received. Try again; it will not be received twice."));
        }
        await confirmReceiptAttempt(orderId, attemptId);
        setReceiving(undefined);
    };

    // A refusal whose answer was lost is retried as the same attempt, so the words say to try again.
    const turnAway = async (row: BenchRow, input: RejectionInput) => {
        try {
            return await rejectAtReceipt(row, input, admitReject);
        } catch (failure) {
            console.error("Error rejecting a specimen:", failure);
            throw new Error(relayServerFailure(failure, "The rejection could not be confirmed. Try again; it will not be recorded twice."));
        }
    };

    return (
        <div className="bench-page">
            <div className="bench-head">
                <h1 className="ak-page-title">Bench</h1>
                <p className="ak-page-title__sub">Specimens and the next step for each.</p>
            </div>

            <div className="ak-page-body">
            {/* Its own request, so a quality record that cannot be read never takes the worklist with it. */}
            <QualityControlStrip />

            {error && !loading ? (
                <Alert variant="destructive">
                    <AlertCircle className="h-4 w-4" />
                    <AlertDescription>
                        <span>{error}</span> <span>No counts are shown until the bench can be read.</span>
                    </AlertDescription>
                    <Button className="btn btn-blue-ghost bench-retry" onClick={() => void reload()}>
                        Try again
                    </Button>
                </Alert>
            ) : null}

            {loading ? (
                <p className="ak-status-line bench-loading">
                    <Loader2 className="h-4 w-4 animate-spin" />
                    Loading the bench…
                </p>
            ) : error ? null : (
                <>
                    <div className="bench-toolbar">
                        <Label className="bench-find items-stretch">
                            Find work
                            <Input
                                type="search"
                                value={query}
                                placeholder="Patient, test or accession"
                                onChange={(event) => setQuery(event.target.value)}
                            />
                        </Label>
                    </div>

                    <div className="bench-grid">
                        <Group title="To collect" rows={sections.toCollect} empty="Nothing in this section." searching={Boolean(searching)}>
                            {(row) => (
                                <Row
                                    key={row.orderId}
                                    row={row}
                                    action={mayCollect && row.orderId ? (
                                        <Button className="btn btn-blue-ghost" onClick={() => setCollecting(row)}>
                                            Mark collected
                                        </Button>
                                    ) : undefined}
                                >
                                    <small className="ak-card__meta">{who(row, "Ordered", row.authoredOn, row.orderedBy)}</small>
                                    {tubeLine(row) ? (
                                        <small className={isUrgent(row) ? "ak-card__meta bench-urgent" : "ak-card__meta"}>{tubeLine(row)}</small>
                                    ) : null}
                                </Row>
                            )}
                        </Group>

                        <Group title="On the bench" rows={sections.onTheBench} empty="Nothing in this section." searching={Boolean(searching)}>
                            {(row) => (
                                <Row
                                    key={row.specimenId ?? row.orderId}
                                    row={row}
                                    action={mayWork && row.orderId ? (
                                        row.awaitingReceipt ? (
                                            mayReceive
                                                ? <Button className="btn btn-blue-ghost" onClick={() => setReceiving(row)}>Receive specimen</Button>
                                                : undefined
                                        ) : row.sentOut ? (
                                            <Button className="btn btn-blue-ghost" onClick={() => setViewing(row)}>View order</Button>
                                        ) : mayEnterResult ? (
                                            <Button className="btn btn-blue-ghost" onClick={() => enterResult(row)}>Enter result</Button>
                                        ) : undefined
                                    ) : undefined}
                                >
                                    <small className="ak-card__meta">{who(row, "Collected", row.collectedAt, row.collectedBy)}</small>
                                    {row.awaitingReceipt ? (
                                        <small className="ak-card__meta">
                                            {row.acceptedFromNetwork ? "Accepted · awaiting specimen" : "Awaiting receipt · no accession yet"}
                                        </small>
                                    ) : null}
                                    {row.recollectionFor ? (
                                        <small className="ak-card__meta bench-urgent">{"Recollection needed · last specimen rejected: " + row.recollectionFor}</small>
                                    ) : null}
                                    {row.sentOut ? (
                                        <small className="ak-card__meta">{`Sent out · ${row.sentOut.laboratory ?? "laboratory not named"}`}</small>
                                    ) : null}
                                </Row>
                            )}
                        </Group>

                        <Group title="Awaiting release" rows={sections.awaitingRelease} empty="Nothing in this section." searching={Boolean(searching)}>
                            {(row) => (
                                <Row
                                    key={row.orderId}
                                    row={row}
                                    action={mayRelease && row.orderId ? (
                                        <Button className="btn btn-blue-ghost" onClick={() => setReleasing(row)}>Review &amp; release</Button>
                                    ) : undefined}
                                >
                                    <small className="ak-card__meta">{who(row, "Entered", row.enteredAt)}</small>
                                    <small className="ak-card__meta">Entered · Not released</small>
                                </Row>
                            )}
                        </Group>

                        <Group title="Rejected today" rows={sections.rejectedToday} empty="No specimens rejected today." searching={Boolean(searching)}>
                            {(row) => (
                                <Row key={row.specimenId} row={row}>
                                    <small className="ak-card__meta">{row.patientDisplay ?? "Patient not recorded"}</small>
                                    <small className="ak-card__meta">{row.rejectedFor ?? "Rejected · reason not recorded"}</small>
                                </Row>
                            )}
                        </Group>
                    </div>

                    {nothingMatches ? (
                        <p className="ak-empty ak-empty--compact">No work matches your search. Clear it to see this worklist.</p>
                    ) : null}
                </>
            )}
            </div>

            <CollectDialog key={collecting?.orderId} mode="collect" row={collecting} onClose={() => setCollecting(undefined)} onConfirm={take} withdrawn={!mayCollect} />
            <CollectDialog
                key={"receive-" + receiving?.orderId}
                mode="receive"
                row={receiving}
                onClose={() => setReceiving(undefined)}
                onConfirm={takeIn}
                withdrawn={!mayReceive}
                onReject={mayReject ? (row) => { setReceiving(undefined); setRejecting(row); } : undefined}
            />
            <RejectSpecimenDialog
                key={"reject-" + rejecting?.orderId}
                row={rejecting}
                onClose={() => setRejecting(undefined)}
                onReject={turnAway}
                withdrawn={!mayReject}
            />

            <OrderDetailsDialog
                row={viewing}
                onClose={() => setViewing(undefined)}
                onEnterResult={mayEnterResult ? (row) => { setViewing(undefined); enterResult(row); } : undefined}
                onRecordRefusal={mayRefuse ? (row) => { setViewing(undefined); setRefusing(row); } : undefined}
            />

            <EnterTestResultDialog
                key={entering?.orderId}
                order={entering?.orderId ? { orderId: entering.orderId, test: entering.test, testCode: entering.testCode, testCodeSystem: entering.testCodeSystem, patient: entering.patientDisplay, detail: entering.accession } : undefined}
                onClose={() => setEntering(undefined)}
                onSaved={() => void reload()}
                withdrawn={!mayEnterResult}
            />

            <RecordRefusalDialog row={refusing} onClose={() => setRefusing(undefined)} onRecorded={() => void reload()} withdrawn={!mayRefuse} />

            <ReleaseResultDialog
                orderId={releasing?.orderId}
                test={releasing?.test}
                testCode={releasing?.testCode}
                testCodeSystem={releasing?.testCodeSystem}
                patient={releasing?.patientDisplay}
                detail={releasing ? joined(releasing.accession, dayAndTime(releasing.enteredAt) ? `Entered ${dayAndTime(releasing.enteredAt)}` : undefined) : undefined}
                onClose={() => setReleasing(undefined)}
                onReleased={() => { if (releasing?.orderId) markReleased(releasing.orderId); }}
                withdrawn={!mayRelease}
                // The control records are this page's own strip, at its top.
                onOpenControls={() => window.scrollTo({ top: 0, behavior: "smooth" })}
            />
        </div>
    );
};

export default BenchPage;