import { useEffect, 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, SelectItem, SelectTrigger, SelectValue } from "../../../components/ui/select.tsx";
import type { InboundRequisition, RefusalResult, RequisitionContact } from "../../../hooks/useInboundRequisitions.ts";
import {
    BLANK_CONTACT,
    ContactFields,
    contactFrom,
    contactReady,
    describeContact,
    failureWording,
    newStamp,
    type AttemptStamp,
    type ContactDraft,
} from "./RequisitionContactDialog.tsx";

// The server's refusal codes, worded from the laboratory's side; the server checks them.
export const REASONS = [
    { code: "unknown-test", label: "We do not offer that test" },
    { code: "retired-test", label: "That test is retired" },
    { code: "unknown-account", label: "We do not recognise the account" },
    { code: "missing-field", label: "The order is missing something we require" },
    { code: "not-authorised", label: "The account may not order that test" },
    { code: "other", label: "Something else" },
] as const;

interface Props {
    requisition?: InboundRequisition;
    onClose: () => void;
    refuse: (
        requisitionId: string,
        refusal: { reasonCode: string; message: string; contact?: Omit<RequisitionContact, "recordedBy"> },
    ) => Promise<RefusalResult>;
}

const RefuseRequisitionDialog = ({ requisition, onClose, refuse }: Props) => {
    const [reasonCode, setReasonCode] = useState<string>();
    const [message, setMessage] = useState("");
    const [busy, setBusy] = useState(false);
    const [error, setError] = useState<string>();
    const [recording, setRecording] = useState(false);
    const [contact, setContact] = useState<ContactDraft>(BLANK_CONTACT);
    const [stamp, setStamp] = useState<AttemptStamp>(newStamp);
    const [done, setDone] = useState<RefusalResult>();

    useEffect(() => {
        setReasonCode(undefined);
        setMessage("");
        setError(undefined);
        setRecording(false);
        setContact(BLANK_CONTACT);
        setStamp(newStamp());
        setDone(undefined);
    }, [requisition?.requisitionId]);

    if (!requisition?.requisitionId) return null;

    // Paper has no Akashic channel back: staff tell the sender, and may record that they did.
    const paper = !requisition.akashic;
    const from = requisition.from ?? "the sender";

    const submit = async () => {
        setBusy(true);
        setError(undefined);
        try {
            const result = await refuse(requisition.requisitionId as string, {
                reasonCode: reasonCode as string,
                message: message.trim(),
                ...(paper && recording ? { contact: contactFrom(contact, stamp) } : {}),
            });
            if (paper) setDone(result);
            else onClose();
        } catch (failure) {
            console.error("Error refusing an inbound requisition:", failure);
            setError(failureWording(failure, "refusal"));
        } finally {
            setBusy(false);
        }
    };

    if (done) {
        return (
            <Dialog open onOpenChange={(open) => { if (!open) onClose(); }}>
                <DialogContent>
                    <DialogHeader>
                        <DialogTitle>Order refused</DialogTitle>
                        <DialogDescription>{`Refused. ${from} has not been told through Akashic.`}</DialogDescription>
                    </DialogHeader>
                    {(done.contacts ?? []).length === 0 ? (
                        <p className="ak-field-help">No contact attempt recorded yet.</p>
                    ) : (done.contacts ?? []).map((attempt) => (
                        <p key={attempt.id} className="ak-field-help">{`Contact attempt recorded: ${describeContact(attempt)}`}</p>
                    ))}
                    <DialogFooter>
                        <Button className="btn btn-blue" onClick={onClose}>Done</Button>
                    </DialogFooter>
                </DialogContent>
            </Dialog>
        );
    }

    return (
        <Dialog open onOpenChange={(open) => { if (!open && !busy) onClose(); }}>
            <DialogContent>
                <DialogHeader>
                    <DialogTitle>Refuse order</DialogTitle>
                    <DialogDescription>
                        {[requisition.patientName, requisition.test ?? "Test not named"].filter(Boolean).join(" · ")}
                    </DialogDescription>
                </DialogHeader>

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

                <div className="grid gap-3">
                    <div className="grid gap-1">
                        <Label htmlFor="refuse-reason">Reason</Label>
                        <Select value={reasonCode ?? ""} onValueChange={setReasonCode}>
                            <SelectTrigger id="refuse-reason" aria-label="Reason">
                                <SelectValue placeholder="Choose reason" />
                            </SelectTrigger>
                            <SelectContent>
                                {REASONS.map((reason) => (
                                    <SelectItem key={reason.code} value={reason.code}>{reason.label}</SelectItem>
                                ))}
                            </SelectContent>
                        </Select>
                    </div>
                    <div className="grid gap-1">
                        <Label htmlFor="refuse-message">{paper ? "Reason in your words" : `Message to ${from}`}</Label>
                        <Textarea
                            id="refuse-message"
                            value={message}
                            rows={3}
                            maxLength={500}
                            disabled={busy}
                            onChange={(event) => setMessage(event.target.value)}
                        />
                    </div>
                    <p className="ak-field-help">
                        {paper
                            ? `This records the refusal here. Akashic cannot tell ${from}; contact them the way you normally would.`
                            : "An order refusal goes back to the sender with its reason. Specimen rejection is separate and follows the redraw workflow."}
                    </p>
                    {paper && !recording ? (
                        <Button className="btn btn-blue-ghost" disabled={busy} onClick={() => setRecording(true)}>
                            Record the contact attempt
                        </Button>
                    ) : null}
                    {paper && recording ? (
                        <>
                            <ContactFields draft={contact} onChange={setContact} disabled={busy} idPrefix="refuse-contact" />
                            <Button className="btn btn-blue-ghost" disabled={busy} onClick={() => { setRecording(false); setContact(BLANK_CONTACT); }}>
                                Not now
                            </Button>
                        </>
                    ) : null}
                </div>

                <DialogFooter>
                    <Button
                        className="btn btn-red"
                        disabled={!reasonCode || !message.trim() || busy || (paper && recording && !contactReady(contact))}
                        onClick={() => void submit()}
                    >
                        {busy ? "Refusing…" : "Refuse order"}
                    </Button>
                </DialogFooter>
            </DialogContent>
        </Dialog>
    );
};

export default RefuseRequisitionDialog;