import { useEffect, useRef, useState } from "react";
import { Loader2, Search } from "lucide-react";
import { Checkbox } from "../../../components/ui/checkbox";
import { Input } from "../../../components/ui/input";
import {
  useReferralWorkbenchService,
  type ReferralConfirmedFaxDetails,
  type ReferralFaxReadField,
  type ReferralFaxReadResult,
} from "../../../services/ReferralWorkbenchService";
import { eitherAborted, stillOpen, type ReferralRequestScope } from "../../../utils/referralRequestScope";
import { relayServerFailure } from "../../../utils/fetchFailureMessage";
import { isSaveRetired, useSaveScope } from "../../../utils/saveOperation";
import { citedLine, FAX_FIELD_LABEL, SEARCHABLE, senderRead, SHOWN_ONLY } from "./referralFaxWords";

const ASK_AGAIN_MS = 4000;
/** One ask may take this long before it is stopped and offered again. */
const ASK_DEADLINE_MS = 30_000;
const ASKS_BEFORE_PAUSE = 45;

type Ready = Extract<ReferralFaxReadResult, { state: "ready" }>["reading"];
type Phase = { at: "idle" } | { at: "reading" } | { at: "paused" } | { at: "failed"; message: string } | { at: "ready"; reading: Ready };

export type ReferralFaxReadingProps = {
  referralId: string;
  scope?: ReferralRequestScope;
  disabled?: boolean;
  onSearch: (term: string) => void;
  onConfirmedChange: (details: ReferralConfirmedFaxDetails | undefined) => void;
};

const Cited = ({ field }: { field: ReferralFaxReadField }) => (
  <>
    {field.lines.map((line) => (
      <small key={line.page + "-" + line.line} className="referral-faxread__line">{citedLine(line)}</small>
    ))}
    {field.unassigned
      ? <small className="referral-faxread__warn">The fax does not say whose this is. Read it from the fax.</small>
      : field.uncertain && <small className="referral-faxread__warn">Hard to read. Check it against the fax.</small>}
  </>
);

/** A received fax read into suggestions. Only the sender and reason a person ticks are saved, and only with the match. */
export const ReferralFaxReading = ({ referralId, scope, disabled, onSearch, onConfirmedChange }: ReferralFaxReadingProps) => {
  const { readReferralFax } = useReferralWorkbenchService();
  const [phase, setPhase] = useState<Phase>({ at: "idle" });
  const [from, setFrom] = useState({ value: "", checked: false });
  const [reason, setReason] = useState({ value: "", checked: false });
  const timer = useRef<ReturnType<typeof setTimeout>>();
  // This referral's own lifetime inside the dialog's: a change of viewer, or this panel going away, retires its asks
  // and conceals what they read.
  const lives = useSaveScope(referralId, () => {
    clearTimeout(timer.current);
    setPhase({ at: "idle" });
    setFrom({ value: "", checked: false });
    setReason({ value: "", checked: false });
  });

  useEffect(() => () => {
    clearTimeout(timer.current);
    onConfirmedChange(undefined);
  // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  useEffect(() => {
    const details: ReferralConfirmedFaxDetails = {
      ...(from.checked && from.value.trim() ? { from: from.value.trim() } : {}),
      ...(reason.checked && reason.value.trim() ? { reason: reason.value.trim() } : {}),
    };
    onConfirmedChange(Object.keys(details).length > 0 ? details : undefined);
  }, [from, reason, onConfirmedChange]);

  const ask = async (asked: number) => {
    if (!stillOpen(scope)) return;
    setPhase({ at: "reading" });
    const operation = lives.start(ASK_DEADLINE_MS);
    const owned: ReferralRequestScope = {
      admit: () => { operation.admit(); scope?.admit(); },
      signal: scope ? eitherAborted(operation.transport.signal, scope.signal) : operation.transport.signal,
      organizationId: scope?.organizationId,
    };
    try {
      const result = await operation.step(() => readReferralFax(referralId, owned));
      if (!operation.belongs() || !stillOpen(scope)) return;
      if (result.state === "reading") {
        if (asked + 1 >= ASKS_BEFORE_PAUSE) { setPhase({ at: "paused" }); return; }
        timer.current = setTimeout(() => void ask(asked + 1), ASK_AGAIN_MS);
        return;
      }
      if (result.state === "failed") { setPhase({ at: "failed", message: result.message }); return; }
      const sender = senderRead(result.reading.fields);
      setFrom({ value: sender?.value ?? "", checked: false });
      setReason({ value: result.reading.fields.reason?.value ?? "", checked: false });
      setPhase({ at: "ready", reading: result.reading });
    } catch (failure: unknown) {
      if (isSaveRetired(failure) || !operation.belongs() || !stillOpen(scope)) return;
      setPhase({ at: "failed", message: relayServerFailure(failure, "We could not read the fax just now. Try again in a moment.") });
    } finally {
      operation.retire();
    }
  };

  if (phase.at === "idle" || phase.at === "failed" || phase.at === "paused") {
    return (
      <div className="referral-faxread">
        <p className="ak-field-help">
          {phase.at === "failed" ? phase.message
            : phase.at === "paused" ? "The fax is still being read. Try again in a minute."
            : "This referral came by fax. Read it to suggest the patient, the sender and the reason; you check each one."}
        </p>
        <button type="button" className="btn btn-blue-ghost-sm" disabled={disabled} onClick={() => void ask(0)}>
          {phase.at === "idle" ? "Read the fax" : "Try again"}
        </button>
      </div>
    );
  }

  if (phase.at === "reading") {
    return (
      <p className="referral-faxread ak-field-help" role="status">
        <Loader2 className="h-4 w-4 animate-spin" /> Reading the fax. This can take a minute.
      </p>
    );
  }

  const { fields, droppedUngrounded, truncated } = phase.reading;
  const sender = senderRead(fields);
  const searchable = SEARCHABLE.filter((name) => fields[name]);
  const shown = SHOWN_ONLY.filter((name) => fields[name]);
  const editable = [
    { key: "from", label: "Sender", read: sender, state: from, set: setFrom },
    { key: "reason", label: FAX_FIELD_LABEL.reason, read: fields.reason, state: reason, set: setReason },
  ].filter((item) => item.read);

  return (
    <section className="referral-faxread" aria-label="Read from the fax">
      <p className="referral-faxread__title">Read from the fax</p>
      {searchable.length === 0 && editable.length === 0 && shown.length === 0 && (
        <p className="ak-field-help">Nothing on the fax could be read with confidence. Work from the fax itself.</p>
      )}
      {searchable.map((name) => (
        <div key={name} className="referral-faxread__item">
          <span className="referral-faxread__label">{FAX_FIELD_LABEL[name]}</span>
          <span className="referral-faxread__value">{fields[name]!.value}</span>
          <Cited field={fields[name]!} />
          {!fields[name]!.unassigned && <button type="button" className="btn btn-blue-ghost-sm" disabled={disabled} onClick={() => onSearch(fields[name]!.value)}>
            <Search className="h-4 w-4" /> Search for this
          </button>}
        </div>
      ))}
      {editable.map((item) => (
        <div key={item.key} className="referral-faxread__item">
          <label className="referral-faxread__label" htmlFor={"faxread-" + item.key}>{item.label}</label>
          <Input id={"faxread-" + item.key} value={item.state.value} disabled={disabled}
            onChange={(event) => item.set({ ...item.state, value: event.target.value })} />
          <Cited field={item.read!} />
          <label className="referral-faxread__check" htmlFor={"faxread-" + item.key + "-check"}>
            <Checkbox id={"faxread-" + item.key + "-check"} checked={item.state.checked} disabled={disabled || !item.state.value.trim()}
              onCheckedChange={(checked) => item.set({ ...item.state, checked: checked === true })} />
            <span>I checked the {item.label.toLowerCase()} against the fax; save it on the referral</span>
          </label>
        </div>
      ))}
      {shown.length > 0 && (
        <dl className="referral-faxread__shown">
          {shown.map((name) => (
            <div key={name} className="referral-faxread__item">
              <dt className="referral-faxread__label">{FAX_FIELD_LABEL[name]}</dt>
              <dd className="referral-faxread__value">{fields[name]!.value}<Cited field={fields[name]!} /></dd>
            </div>
          ))}
        </dl>
      )}
      {(droppedUngrounded > 0 || truncated) && (
        <p className="ak-field-help">
          {truncated ? "Only the first part of a long fax was read. " : ""}
          {droppedUngrounded > 0 ? "Some values were left out because the fax text did not carry them." : ""}
        </p>
      )}
    </section>
  );
};

export default ReferralFaxReading;