import { useState } from "react";
import { AlertCircle } from "lucide-react";
import {
    Dialog,
    DialogContent,
    DialogDescription,
    DialogFooter,
    DialogHeader,
    DialogTitle,
} from "../../../components/ui/dialog.tsx";
import { Alert, AlertDescription } from "../../../components/ui/alert.tsx";
import { Button } from "../../../components/ui/button.tsx";
import { Label } from "../../../components/ui/label.tsx";
import { Textarea } from "../../../components/ui/textarea.tsx";
import {
    Select,
    SelectContent,
    SelectGroup,
    SelectItem,
    SelectTrigger,
    SelectValue,
} from "../../../components/ui/select.tsx";
import type { BenchRow, RejectionInput, RejectionOutcome } from "../../../hooks/useBench.ts";
import { ActWithdrawn } from "../DiagnosticOrdersPage/ActWithdrawn.tsx";

interface Props {
    row?: BenchRow;
    onClose: () => void;
    /** Rejects with the words to show when the refusal could not be confirmed. */
    onReject: (row: BenchRow, input: RejectionInput) => Promise<RejectionOutcome>;
    /** The caller may no longer make this write: the dialog stays readable and closable, and cannot send. */
    withdrawn?: boolean;
}

// Each line is what the server confirmed, so a task or a message that failed says so.
const outcomeLines = (outcome: RejectionOutcome, reason: string): string[] => [
    outcome.alreadyRecorded ? "This rejection was already recorded: " + reason + "." : "Specimen rejected: " + reason + ".",
    "The order stays open. Record receipt only when the replacement specimen arrives.",
    ...(outcome.senderNotified === "delivered"
        ? ["The ordering practice has been told and arranges recollection."]
        : outcome.senderNotified === "failed"
            ? ["The ordering practice could not be told. Contact them directly."]
            : outcome.patientTaskRaised
                ? ["The patient has a task to give another sample."]
                : ["The patient’s redraw task could not be raised. Ask them to return another way."]),
];

export const RejectSpecimenDialog = ({ row, onClose, onReject, withdrawn }: Props) => {
    // One refusal, one attempt: a retry after a lost answer finishes it instead of starting another.
    const [attemptId] = useState(() => crypto.randomUUID());
    const [reasonCode, setReasonCode] = useState("");
    const [note, setNote] = useState("");
    const [busy, setBusy] = useState(false);
    const [error, setError] = useState<string>();
    const [outcome, setOutcome] = useState<RejectionOutcome>();

    if (!row) return null;

    const reasons = (row.rejectionReasons ?? []).filter((each) => each.code);
    const displayOf = (code: string) => reasons.find((each) => each.code === code)?.display ?? code;
    const identity = [row.patientDisplay ?? "Patient not recorded", row.test ?? "Test not recorded"].join(" · ");
    const detail = [row.orderedBy, row.accession].filter(Boolean).join(" · ");

    const submit = async () => {
        if (!reasonCode) return;
        setBusy(true);
        setError(undefined);
        try {
            setOutcome(await onReject(row, { attemptId, reasonCode, note }));
        } catch (failure) {
            setError(failure instanceof Error ? failure.message : String(failure));
        } finally {
            setBusy(false);
        }
    };

    return (
        <Dialog open onOpenChange={(open) => { if (!open && !busy) onClose(); }}>
            <DialogContent className="bench-dialog">
                <DialogHeader>
                    <DialogTitle>{outcome ? "Recollection needed" : "Reject specimen"}</DialogTitle>
                </DialogHeader>

                <div className="bench-identity">
                    <strong>{identity}</strong>
                    {detail ? <span>{detail}</span> : null}
                </div>

                {outcome ? (
                    <div role="status" className="bench-reject-outcome">
                        {outcomeLines(outcome, displayOf(outcome.reason ?? reasonCode)).map((line) => (
                            <p key={line}>{line}</p>
                        ))}
                    </div>
                ) : (
                    <>
                        <div className="bench-reject-field">
                            <Label htmlFor="bench-reject-reason">Reason</Label>
                            <Select value={reasonCode} onValueChange={setReasonCode} disabled={busy}>
                                <SelectTrigger id="bench-reject-reason" className="w-full">
                                    <SelectValue placeholder="Choose laboratory reason" />
                                </SelectTrigger>
                                <SelectContent>
                                    <SelectGroup>
                                        {reasons.map((each) => (
                                            <SelectItem key={each.code} value={each.code as string}>
                                                {each.display ?? each.code}
                                            </SelectItem>
                                        ))}
                                    </SelectGroup>
                                </SelectContent>
                            </Select>
                        </div>
                        <div className="bench-reject-field">
                            <Label htmlFor="bench-reject-note">Details (optional)</Label>
                            <Textarea
                                id="bench-reject-note"
                                rows={2}
                                value={note}
                                disabled={busy}
                                onChange={(event) => setNote(event.target.value)}
                            />
                        </div>
                        <DialogDescription className="ak-field-help">
                            Notify the ordering practice and raise the redraw task. This rejects the specimen,
                            not the order, and is not a clinical result.
                        </DialogDescription>
                    </>
                )}

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

                {withdrawn && !outcome ? <ActWithdrawn /> : null}

                {outcome ? null : (
                    <DialogFooter>
                        <Button className="btn btn-red" disabled={busy || !reasonCode || withdrawn} onClick={() => void submit()}>
                            {busy ? "Rejecting…" : "Reject specimen"}
                        </Button>
                    </DialogFooter>
                )}
            </DialogContent>
        </Dialog>
    );
};