import { useState } from "react";
import { AlertCircle, Loader2 } from "lucide-react";
import {
  Dialog,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogTitle,
} from "../../../components/ui/dialog";
import { Alert, AlertDescription } from "../../../components/ui/alert";
import { Button } from "../../../components/ui/button";
import { Input } from "../../../components/ui/input";
import { Label } from "../../../components/ui/label";
import { Textarea } from "../../../components/ui/textarea";
import { useReferralWorkbenchService } from "../../../services/ReferralWorkbenchService";
import { stillOpen, type ReferralRequestScope } from "../../../utils/referralRequestScope";
import { describeWriteFailure } from "../../../utils/fetchFailureMessage";
import "./referralDialog.css";

/**
 * - TYPE IN A REFERRAL THAT ARRIVED BY FAX OR PHONE.
 *
 * THE GAP THIS CLOSES IS THE WRONG WAY ROUND WITHOUT IT. Every arrival path built so far starts with
 * another Akashic practice minting a claim code, so **the referrals that most need tracking - the ones on
 * paper, from a practice that is not on the system - had no way into the queue at all.**
 *
 * Spencer, 2026-08-23: *"a way for referral coordinators to manually add a new referral into their
 * queue before it's been handled."*
 *
 * THERE IS NO PATIENT FIELD, AND THAT IS THE WHOLE DESIGN. Spencer's ruling puts the patient at the
 * point of **contact** - *"they would either try to find the patient in our system or if they don't exist
 * yet register the new patient"* - which happens when somebody rings them, not while a coordinator is
 * holding a fax. **A required field nobody can fill at the moment of typing is how a queue stays empty
 * and the paper tray survives.**
 *
 * ONE REQUIRED FIELD: WHO SENT IT. It is on the letterhead of the thing in their hand, and it is what
 * tells two rows apart in a queue where every row is a referral.
 */

export type LogInboundReferralDialogProps = {
  open: boolean;
  onOpenChange: (open: boolean) => void;
  /** Re-read the queue rather than patch a row in: the server minted the id and composed the notice. */
  onLogged: () => void;
  /** The opening this dialog belongs to: its requests are admitted by it, and nothing is shown once it retires. */
  scope?: ReferralRequestScope;
};

export const LogInboundReferralDialog = ({
  open,
  onOpenChange,
  onLogged,
  scope,
}: LogInboundReferralDialogProps) => {
  const { logInboundReferral } = useReferralWorkbenchService();
  const [from, setFrom] = useState("");
  const [reason, setReason] = useState("");
  const [note, setNote] = useState("");
  const [saving, setSaving] = useState(false);
  const [error, setError] = useState<string | undefined>(undefined);

  const reset = () => {
    setFrom("");
    setReason("");
    setNote("");
    setError(undefined);
  };

  const close = (next: boolean) => {
    if (!next) reset();
    onOpenChange(next);
  };

  const submit = async () => {
    setSaving(true);
    setError(undefined);

    try {
      await logInboundReferral({
        from: from.trim(),
        ...(reason.trim() ? { reason: reason.trim() } : {}),
        ...(note.trim() ? { note: note.trim() } : {}),
      }, scope);
      if (!stillOpen(scope)) return;
      // Reported before closing: closing retires this opening, and its completion belongs to it.
      onLogged();
      reset();
      onOpenChange(false);
    } catch (failure: unknown) {
      // Never closes on failure. A coordinator who watched the dialog vanish would believe the
      // referral is tracked, and the piece of paper is usually already in the shredder pile.
      if (!stillOpen(scope)) return;
      setError(describeWriteFailure(failure, "That referral could not be added"));
    } finally {
      setSaving(false);
    }
  };

  return (
    <Dialog open={open} onOpenChange={close}>
      <DialogContent className="ak-dialog referral-rfdlg max-w-none gap-0 p-0">
        <DialogHeader className="ak-overlay__header">
          <DialogTitle>Add a referral that came in</DialogTitle>
          <DialogDescription className="ak-overlay__description">
            Record referrals received by fax or phone. They join the referral queue for staff to work.
          </DialogDescription>
        </DialogHeader>

        <div className="ak-overlay__body space-y-4">
          <div className="space-y-1.5">
            <Label htmlFor="inbound-referral-from">Who sent it</Label>
            <Input
              id="inbound-referral-from"
              value={from}
              onChange={(event) => setFrom(event.target.value)}
              placeholder="The practice or clinic on the fax"
              maxLength={200}
            />
          </div>

          <div className="space-y-1.5">
            <Label htmlFor="inbound-referral-reason">Reason for referral</Label>
            <Input
              id="inbound-referral-reason"
              value={reason}
              onChange={(event) => setReason(event.target.value)}
              placeholder="Optional"
              maxLength={2000}
            />
          </div>

          <div className="space-y-1.5">
            <Label htmlFor="inbound-referral-note">Anything else</Label>
            <Textarea
              id="inbound-referral-note"
              value={note}
              onChange={(event) => setNote(event.target.value)}
              placeholder="Optional — anything on the fax the next person should see"
              rows={3}
              maxLength={2000}
            />
          </div>

          {/* ⚠️ SAYS WHAT HAPPENS NEXT, because the missing patient is the thing a coordinator will look
              for and not find. Without this the absence reads as a form that forgot a field. */}
          <p className="ak-field-help">
            You will match this to a patient when you contact them — either finding them here or
            registering them then.
          </p>

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

        <DialogFooter className="ak-overlay__footer">
          <Button variant="ghost" onClick={() => close(false)} disabled={saving}>
            Cancel
          </Button>
          {/* ⛔ Disabled on an empty sender rather than refused after a round trip: the server refuses it
              too, and being told what is missing before pressing anything is the cheaper of the two. */}
          <Button onClick={() => void submit()} disabled={saving || from.trim().length === 0}>
            {saving && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
            {saving ? "Adding…" : "Add to the queue"}
          </Button>
        </DialogFooter>
      </DialogContent>
    </Dialog>
  );
};

export default LogInboundReferralDialog;