import { useEffect, useState } from "react";
import { AlertCircle } 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 { Label } from "../../../components/ui/label.tsx";
import { Textarea } from "../../../components/ui/textarea.tsx";
import { Alert, AlertDescription } from "../../../components/ui/alert.tsx";
import {
    ReferralDirectorySearch,
    type ReferralTarget,
} from "../../../components/ReferralDirectorySearch/ReferralDirectorySearch.tsx";
import { useReferralWorkbenchService } from "../../../services/ReferralWorkbenchService";
import { relayServerFailure } from "../../../utils/fetchFailureMessage";
import {
    openPdfInTab,
    useSendOutDiagnosticOrder,
    type SendMethod,
    type SentOut,
} from "../../../hooks/useSendOutDiagnosticOrder.ts";
import { useLabConnections, type LabConnection } from "../../../hooks/useLabConnections.ts";
import SendMethodField, { reviewedPairing } from "./SendMethodField.tsx";
import "./SendOutDialog.css";

// Sending a test out to a laboratory the practice does not run.
//
// THE LABORATORY COMES FROM THE ADDRESS BOOK EVERY REFERRAL ALREADY USES, keyed on NPI. A send-out
// laboratory is the same animal as a referral recipient -- an outside organization with a fax number
// and a desk things go to -- and a second directory would duplicate the registry client, the
// shared-and-private split and the fax number one coordinator learned on a phone call.
//
// THE ACCOUNT NUMBER IS WHAT MAKES THE PAPER WORK and it is refused when empty: it is what the
// laboratory files and bills against, so a requisition without one comes straight back.

interface Props {
    orderId?: string;
    test?: string;
    /** The order's code; electronic sending needs a reviewed pairing for it. */
    testCode?: string;
    testCodeSystem?: string;
    patient?: string;
    orderedBy?: string;
    onClose: () => void;
    onSent: (sent: SentOut) => void;
}

const SendOutDialog = ({ orderId, test, testCode, testCodeSystem, patient, orderedBy, onClose, onSent }: Props) => {
    const { sendOut, requisition } = useSendOutDiagnosticOrder();
    const { readReferralContact } = useReferralWorkbenchService();
    const { connections, loading: labsLoading } = useLabConnections();
    const ours = connections.filter((lab) => lab.active !== false && lab.npi);

    const [target, setTarget] = useState<ReferralTarget>();
    const [manual, setManual] = useState(false);
    const [ourLabId, setOurLabId] = useState("");
    const [npi, setNpi] = useState("");
    const [name, setName] = useState("");
    const [accountNumber, setAccountNumber] = useState("");
    const [theirOrderCode, setTheirOrderCode] = useState("");
    const [note, setNote] = useState("");
    const [fax, setFax] = useState<string>();
    const [method, setMethod] = useState<SendMethod>("paper");
    const [busy, setBusy] = useState(false);
    // Once sent it cannot be sent again from here, whether or not its requisition opened.
    const [sent, setSent] = useState<SentOut>();
    const [error, setError] = useState<string>();

    useEffect(() => {
        setTarget(undefined);
        setManual(false);
        setNpi("");
        setName("");
        setAccountNumber("");
        setNote("");
        setFax(undefined);
        setMethod("paper");
        setSent(undefined);
        setError(undefined);
    }, [orderId]);

    // Their order code follows the laboratory: one the practice set up brings its reviewed pairing for this test,
    // and any other laboratory starts empty, so one laboratory's code is never sent to the next.
    const chosenNpi = npi.trim();
    const configured = ours.find((lab) => lab.npi === chosenNpi);
    const pairedCode = reviewedPairing(configured, { system: testCodeSystem, code: testCode })?.theirCode ?? "";
    useEffect(() => {
        setTheirOrderCode(pairedCode);
    }, [orderId, chosenNpi, pairedCode]);

    // What one coordinator learned about reaching this laboratory, so the next one does not phone to
    // find out. Best effort: a registry that will not answer must not stop a specimen leaving.
    const choose = async (chosen: ReferralTarget) => {
        setTarget(chosen);
        setOurLabId("");
        setNpi(chosen.organization.npi);
        setName(chosen.organization.name);
        try {
            const contact = await readReferralContact(chosen.organization.npi);
            setFax(contact?.shared?.fax ?? chosen.location?.fax);
        } catch {
            setFax(chosen.location?.fax);
        }
    };

    // Most send-outs go to a laboratory the practice has set up, whose account number is already on file.
    const chooseOurs = async (lab: LabConnection) => {
        setTarget(undefined);
        setManual(true);
        setOurLabId(lab.id ?? lab.npi ?? "");
        setNpi(lab.npi ?? "");
        setName(lab.name ?? "");
        setAccountNumber(lab.accountNumber ?? "");
        if (!lab.npi) return;
        try {
            setFax((await readReferralContact(lab.npi))?.shared?.fax);
        } catch {
            setFax(undefined);
        }
    };

    // labs.html opens on the practice's own laboratory, already chosen, with the form showing.
    const firstOurs = ours[0];
    useEffect(() => {
        if (firstOurs && !target && !manual && !sent) void chooseOurs(firstOurs);
        // eslint-disable-next-line react-hooks/exhaustive-deps
    }, [firstOurs?.id, firstOurs?.npi, target, manual, sent]);

    if (!orderId) return null;

    // The page re-reads only once this closes: re-reading remounts the dialog, which would drop the outcome
    // and offer the same order for sending again.
    const close = () => {
        if (sent) onSent(sent);
        onClose();
    };

    const chosen = Boolean(target) || manual;
    const submittable = /^\d{10}$/.test(npi.trim()) && accountNumber.trim().length > 0;

    const submit = async () => {
        // Opened BEFORE the await, while the click's activation is still alive, or the blocker eats it.
        const tab = window.open("", "_blank");
        if (tab) tab.opener = null;

        setBusy(true);
        setError(undefined);
        let outcome: SentOut | undefined;
        try {
            outcome = await sendOut(orderId, {
                npi: npi.trim(),
                display: name,
                accountNumber,
                theirOrderCode,
                note,
                method,
            });
        } catch (err) {
            tab?.close();
            console.error("Error sending the order out:", err);
            setError(relayServerFailure(err, "Could not send this out. Please try again."));
            setBusy(false);
            return;
        }

        setSent(outcome ?? {});
        try {
            openPdfInTab(tab, await requisition(orderId));
        } catch (err) {
            tab?.close();
            console.error("Sent out, but the requisition did not open:", err);
            setError("Sent out. The requisition could not be opened, so print it from the order.");
        } finally {
            setBusy(false);
        }
    };

    return (
        <Dialog open onOpenChange={(open) => { if (!open && !busy) close(); }}>
            <DialogContent className="send-out-dialog">
                <DialogHeader>
                    <DialogTitle>Prepare send-out</DialogTitle>
                    <DialogDescription className="send-out-identity">
                        <strong>{[patient, test ?? "This test"].filter(Boolean).join(" · ")}</strong>
                        {orderedBy ? <span className="send-out-sub">{"Ordered by " + orderedBy}</span> : null}
                    </DialogDescription>
                </DialogHeader>

                {error ? (
                    <Alert variant="destructive">
                        <AlertCircle className="h-4 w-4" />
                        <AlertDescription>{error}</AlertDescription>
                    </Alert>
                ) : null}

                {sent ? (
                    <p className="send-out-note" role="status">
                        {sent.akashic
                            ? `Delivered to ${name || "the laboratory"} through Akashic. Awaiting their acceptance; acceptance does not mean the specimen was received.`
                            : sent.transmission === "refused" || sent.transmission === "unconfirmed"
                            ? `Saved, but the electronic send to ${name || "the laboratory"} was not confirmed. Retry it from the order, or send the requisition with the specimen.`
                            : sent.transmitting
                            ? `Queued for electronic delivery to ${name || "the laboratory"}. Delivery has not been confirmed, and delivery does not prove the laboratory accepted the order or received the specimen.`
                            : `Requisition prepared for ${name || "the laboratory"}. Printing it does not confirm delivery; send it with the specimen.`}
                    </p>
                ) : chosen ? (
                    <div className="send-out-form">
                        {ours.length ? (
                            <>
                                <div className="send-out-field">
                                    <Label htmlFor="send-out-lab">Performing laboratory</Label>
                                    <select
                                        id="send-out-lab"
                                        className="ak-field"
                                        value={ourLabId}
                                        disabled={busy}
                                        onChange={(e) => {
                                            const lab = ours.find((each) => (each.id ?? each.npi) === e.target.value);
                                            if (lab) void chooseOurs(lab);
                                        }}
                                    >
                                        {ourLabId ? null : <option value="">{name || "Another laboratory"}</option>}
                                        {ours.map((lab) => (
                                            <option key={lab.id ?? lab.npi} value={lab.id ?? lab.npi}>
                                                {(lab.name ?? lab.npi) + " · configured"}
                                            </option>
                                        ))}
                                    </select>
                                </div>
                                <details className="send-out-other">
                                    <summary>Use another laboratory / enter manually</summary>
                                    <ReferralDirectorySearch
                                        onSelect={(chosenTarget) => void choose(chosenTarget)}
                                        onEnterManually={() => setOurLabId("")}
                                        chooseLabel="Send to this laboratory"
                                    />
                                    <div className="send-out-field">
                                        <Label htmlFor="send-out-name">Laboratory name</Label>
                                        <Input
                                            id="send-out-name"
                                            value={name}
                                            onChange={(e) => setName(e.target.value)}
                                            placeholder="Riverbend Reference Laboratory"
                                        />
                                    </div>

                                    <div className="send-out-field">
                                        <Label htmlFor="send-out-npi">Laboratory NPI</Label>
                                        <Input
                                            id="send-out-npi"
                                            value={npi}
                                            onChange={(e) => setNpi(e.target.value)}
                                            placeholder="1548273901"
                                        />
                                    </div>
                                </details>
                                <div className="send-out-field">
                                    <Label htmlFor="send-out-account">Our account number</Label>
                                    <Input
                                        id="send-out-account"
                                        value={accountNumber}
                                        onChange={(e) => setAccountNumber(e.target.value)}
                                        placeholder="GRF-88213"
                                    />
                                </div>
                            </>
                        ) : (
                            <>
                            <div className="send-out-field">
                                <Label htmlFor="send-out-name">Laboratory name</Label>
                                <Input
                                    id="send-out-name"
                                    value={name}
                                    onChange={(e) => setName(e.target.value)}
                                    placeholder="Riverbend Reference Laboratory"
                                />
                            </div>

                            <div className="send-out-field-row">
                                <div className="send-out-field">
                                    <Label htmlFor="send-out-npi">Laboratory NPI</Label>
                                    <Input
                                        id="send-out-npi"
                                        value={npi}
                                        onChange={(e) => setNpi(e.target.value)}
                                        placeholder="1548273901"
                                    />
                                </div>
                                <div className="send-out-field">
                                    <Label htmlFor="send-out-account">Our account number</Label>
                                    <Input
                                        id="send-out-account"
                                        value={accountNumber}
                                        onChange={(e) => setAccountNumber(e.target.value)}
                                        placeholder="GRF-88213"
                                    />
                                </div>
                            </div>

                            </>
                        )}

                        {fax ? <p className="send-out-note">Results come back by fax to {fax}</p> : null}

                        <div className="send-out-field">
                            <Label htmlFor="send-out-code">Their order code</Label>
                            <Input
                                id="send-out-code"
                                value={theirOrderCode}
                                onChange={(e) => setTheirOrderCode(e.target.value)}
                                placeholder="RB-4471"
                            />
                        </div>

                        <div className="send-out-field">
                            <Label htmlFor="send-out-note">Note for the laboratory (optional)</Label>
                            <Textarea
                                id="send-out-note"
                                value={note}
                                onChange={(e) => setNote(e.target.value)}
                                rows={2}
                                placeholder="Patient fasting since 8pm"
                            />
                        </div>

                        <SendMethodField npi={npi} test={{ system: testCodeSystem, code: testCode }} method={method} onChange={setMethod} disabled={busy} />

                        <p className="send-out-note send-out-note--box">
                            Review patient identity, requested test, destination and account before continuing.
                            Laboratory configuration is managed in Platform Manager.
                        </p>
                    </div>
                ) : labsLoading || (firstOurs && !manual) ? null : (
                    <div className="send-out-results">
                        <ReferralDirectorySearch
                            onSelect={(chosenTarget) => void choose(chosenTarget)}
                            onEnterManually={() => setManual(true)}
                            manualOnNoMatch
                            chooseLabel="Send to this laboratory"
                        />
                    </div>
                )}

                {/* Only once a laboratory is chosen. While the registry list is up there is nothing
                    to submit, and the footer sat over the results and swallowed the click on the
                    very row somebody was reaching for. */}
                {sent ? (
                    <DialogFooter>
                        <Button className="btn btn-blue" onClick={close}>Close</Button>
                    </DialogFooter>
                ) : chosen ? (
                    <DialogFooter>
                        <Button
                            className="btn btn-green"
                            disabled={!submittable || busy}
                            onClick={() => void submit()}
                        >
                            Confirm send-out
                        </Button>
                    </DialogFooter>
                ) : null}
            </DialogContent>
        </Dialog>
    );
};

export default SendOutDialog;