import { useEffect, useRef, useState } from "react";
import { AlertCircle, Loader2 } from "lucide-react";
import { Alert, AlertDescription } from "../../../components/ui/alert.tsx";
import { Button } from "../../../components/ui/button.tsx";
import { useAuthServiceContext } from "../../../services";
import {
  RETRIEVABLE_TYPES, grantedTypes, useRecordsConnectionsService,
  type ExternalPatientMatch, type RecordsConnection, type RetrievableType, type RetrievalChoice,
} from "../../../services/RecordsConnectionsService.tsx";
import { relayServerFailure } from "../../../utils/fetchFailureMessage";
import type { ReferralRequestScope } from "../../../utils/referralRequestScope";
import { connectionStateLabel, replacedInUse, systemName } from "./connectionWords.ts";
import { RETRIEVABLE_WORDS, retrievableWords } from "./retrievalWords.ts";

interface Props {
  /** The local patient this request is matched to; only their own connection may read into it. */
  patientId?: string;
  /** Runs one read for this panel's request, practice and viewer; undefined when it was retired before it answered. */
  read: <T>(work: (scope: ReferralRequestScope) => Promise<T>) => Promise<T | undefined>;
  /** A retrieval is running: the panel says how long it may take, and starts nothing else. */
  retrieving: boolean;
  busy: boolean;
  onRetrieve: (choice: RetrievalChoice) => void;
}

const describe = (patient: ExternalPatientMatch): string =>
  [patient.name ?? "No name given", patient.birthDate ? "born " + patient.birthDate : undefined, patient.gender].filter(Boolean).join(", ");

// Retrieving records for an outgoing request through the staff member's own connection to another system. Each step
// opens only once the one before it is answered, and changing an answer clears every step after it. The patient found
// there is that system's, pinned for this retrieval only; the request's own patient match is never made from it.
// Once the request is matched, the patient's own connection is offered too: its grant is already pinned to them, so
// there is nobody to look up, and the server decides whether this staff member may read it.
const RecordsRetrievePanel = ({ patientId, read, retrieving, busy, onRetrieve }: Props) => {
  const { currentUser } = useAuthServiceContext();
  const { listConnections, searchExternalPatients } = useRecordsConnectionsService();
  const me = currentUser?.fhir?.id ? "Practitioner/" + currentUser.fhir.id : undefined;

  const [connections, setConnections] = useState<RecordsConnection[]>();
  const [loadError, setLoadError] = useState<string>();
  const [connectionId, setConnectionId] = useState<string>();
  const [name, setName] = useState("");
  const [birthDate, setBirthDate] = useState("");
  const [searching, setSearching] = useState(false);
  const [found, setFound] = useState<{ patients: ExternalPatientMatch[]; more: boolean; withBirthDate: boolean }>();
  const [searchError, setSearchError] = useState<string>();
  const [externalId, setExternalId] = useState<string>();
  const [types, setTypes] = useState<Set<RetrievableType>>(new Set());
  // Only the latest search answers: an earlier one that lands late never replaces it.
  const searches = useRef(0);
  // A changed name, date or connection retires the search under way, settles it, and withdraws what it offered; a new
  // viewer, request, practice or local patient is a new panel altogether.
  const retireSearch = () => {
    searches.current += 1;
    setSearching(false);
    setSearchError(undefined);
    setFound(undefined);
    setExternalId(undefined);
  };

  useEffect(() => {
    let live = true;
    read((scope) => listConnections(scope))
      .then((listed) => { if (live && listed) setConnections(listed); })
      .catch((failure) => { if (live) setLoadError(relayServerFailure(failure, "Your connections could not be read.")); });
    return () => { live = false; };
  }, [listConnections, read]);

  // One replaced by a connection in use is not another choice: the new one is offered instead.
  const current = (connections ?? []).filter((c) => c.status !== "disconnected" && !replacedInUse(c, connections ?? []));
  // A staff member's own connections only: one made with someone else's login at the other system is theirs alone.
  const own = current.filter((c) => c.audience === "staff-delegated" && c.owner === me);
  // The request's own patient's connections only, never another patient's.
  const theirs = patientId ? current.filter((c) => c.audience === "patient" && c.localPatient === patientId) : [];
  const usable = (c: RecordsConnection) => connectionStateLabel(c) === "Connected";
  const chosen = [...own, ...theirs].find((c) => c.connectionId === connectionId && usable(c));
  const pinned = chosen?.audience === "patient";
  const granted = chosen ? grantedTypes(chosen.grantedScopes) : [];
  // The connection's own lookup rule, as the server registered it; one stored before the rule was told is optional.
  const dateRequired = chosen?.lookup?.birthDate === "required";
  const notGranted = RETRIEVABLE_TYPES.filter((type) => !granted.includes(type));

  const choose = (id: string) => {
    setConnectionId(id);
    retireSearch();
    // A patient's own grant has no lookup step: what it reads is chosen at once.
    const patients = theirs.find((c) => c.connectionId === id);
    if (patients) setTypes(new Set(grantedTypes(patients.grantedScopes)));
  };

  const search = async () => {
    if (!chosen) return;
    // The same rule the button holds to, so no other way in sends a name alone where a birth date is needed.
    if (dateRequired && !birthDate) {
      setSearchError("Enter the patient's birth date to search " + systemName(chosen) + ".");
      return;
    }
    const mine = ++searches.current;
    setSearching(true);
    setSearchError(undefined);
    setFound(undefined);
    setExternalId(undefined);
    try {
      const answer = await read((scope) => searchExternalPatients(chosen.connectionId, name.trim(), birthDate || undefined, scope));
      if (mine === searches.current && answer) setFound({ ...answer, withBirthDate: Boolean(birthDate) });
    } catch (failure) {
      if (mine === searches.current) setSearchError(relayServerFailure(failure, "The other system could not be searched."));
    } finally {
      if (mine === searches.current) setSearching(false);
    }
  };

  const pick = (id: string) => {
    setExternalId(id);
    setTypes(new Set(granted));
  };
  const toggle = (type: RetrievableType) => setTypes((now) => {
    const next = new Set(now);
    if (next.has(type)) next.delete(type); else next.add(type);
    return next;
  });

  const patient = found?.patients.find((p) => p.id === externalId);
  // Ready to retrieve: a patient found through a staff login, or the patient's own grant, which names its patient.
  const ready = !!chosen && (pinned || !!patient);
  const asked = RETRIEVABLE_TYPES.filter((type) => types.has(type) && granted.includes(type));

  return (
    <section className="records-form" aria-label="Retrieve from a connection">
      <h3 className="records-history-title">Retrieve from a connection</h3>
      {loadError && (
        <Alert variant="destructive">
          <AlertCircle className="h-4 w-4" />
          <AlertDescription>{loadError}</AlertDescription>
        </Alert>
      )}
      {!connections && !loadError && <p className="records-loading"><Loader2 className="h-4 w-4 animate-spin" aria-hidden="true" /> Loading your connections</p>}
      {connections && own.length === 0 && theirs.length === 0 && (
        <>
          <p className="records-note">You have no connection of your own to another system.</p>
          <div className="records-actions">
            <a className="btn btn-blue-ghost" href="#/dashboard/records/connections">Make one in Connections</a>
          </div>
        </>
      )}

      {own.length > 0 && (
        <fieldset className="records-field">
          <legend>Your connection</legend>
          {own.map((c) => (
            <label key={c.connectionId}>
              <input type="radio" name="retrieve-connection" value={c.connectionId} checked={connectionId === c.connectionId}
                disabled={!usable(c) || busy} onChange={() => choose(c.connectionId)} />{" "}
              {systemName(c) + (usable(c) ? "" : " - " + connectionStateLabel(c))}
            </label>
          ))}
        </fieldset>
      )}

      {theirs.length > 0 && (
        <fieldset className="records-field">
          <legend>The patient's own connection</legend>
          {theirs.map((c) => (
            <label key={c.connectionId}>
              <input type="radio" name="retrieve-connection" value={c.connectionId} checked={connectionId === c.connectionId}
                disabled={!usable(c) || busy} onChange={() => choose(c.connectionId)} />{" "}
              {systemName(c) + (usable(c) ? "" : " - " + connectionStateLabel(c))}
            </label>
          ))}
        </fieldset>
      )}

      {chosen && !pinned && (
        <div className="records-field">
          <label>
            Name at the other system
            <input type="text" value={name} maxLength={100} disabled={busy}
              onChange={(event) => { setName(event.target.value); retireSearch(); }} />
          </label>
          <label>
            {dateRequired ? "Birth date" : "Birth date (optional)"}
            <input type="date" value={birthDate} disabled={busy} required={dateRequired}
              onChange={(event) => { setBirthDate(event.target.value); retireSearch(); }} />
          </label>
          {dateRequired && <p className="records-note">Enter the patient's name and birth date to search {systemName(chosen)}.</p>}
          <Button className="btn btn-blue-ghost" disabled={name.trim().length < 2 || (dateRequired && !birthDate) || searching || busy} onClick={() => void search()}>
            {searching ? "Searching" : "Search"}
          </Button>
        </div>
      )}

      {chosen && searchError && (
        <Alert variant="destructive">
          <AlertCircle className="h-4 w-4" />
          <AlertDescription>{searchError}</AlertDescription>
        </Alert>
      )}
      {chosen && found && found.patients.length === 0 && (
        <p className="records-note">{systemName(chosen)} found no one with that name{found.withBirthDate ? " and birth date" : ""}.</p>
      )}
      {chosen && found && found.patients.length > 0 && (
        <fieldset className="records-field">
          <legend>At {systemName(chosen)}</legend>
          {found.patients.map((p) => (
            <label key={p.id}>
              <input type="radio" name="retrieve-patient" value={p.id} checked={externalId === p.id} disabled={busy} onChange={() => pick(p.id)} />{" "}
              {describe(p)}
            </label>
          ))}
          {found.more && <p className="records-note">There are more matches at {systemName(chosen)}; add the birth date or more of the name.</p>}
        </fieldset>
      )}

      {chosen && ready && (
        <fieldset className="records-field">
          <legend>What to retrieve</legend>
          {granted.map((type) => (
            <label key={type}>
              <input type="checkbox" checked={types.has(type)} disabled={busy} onChange={() => toggle(type)} />{" "}
              {retrievableWords(type, chosen?.grantedScopes ?? [])}
            </label>
          ))}
          {notGranted.length > 0 && (
            <p className="records-note">Not granted on this connection: {notGranted.map((type) => RETRIEVABLE_WORDS[type]).join(", ")}</p>
          )}
        </fieldset>
      )}

      {chosen && ready && (
        <div className="records-field">
          <p className="records-note">
            Retrieve {asked.map((type) => RETRIEVABLE_WORDS[type].toLowerCase()).join(", ") || "nothing"}{" "}
            {patient ? "for " + describe(patient) : "for this request's patient"} from {systemName(chosen)} into this request
            {pinned ? ", through the connection the patient made" : ""}. Nothing is added to the chart until each item is checked.
          </p>
          <p className="records-note">If not everything can be read, nothing is kept: untick a kind of record and retrieve again.</p>
          {retrieving && (
            <p className="records-loading">
              <Loader2 className="h-4 w-4 animate-spin" aria-hidden="true" /> Retrieving from {systemName(chosen)}. This can take up to half a minute.
            </p>
          )}
          <div className="records-actions">
            <Button className="btn btn-blue" disabled={busy || asked.length === 0}
              onClick={() => onRetrieve({ connectionId: chosen.connectionId, ...(patient && !pinned ? { externalPatient: patient.id } : {}), types: asked })}>
              Retrieve
            </Button>
          </div>
        </div>
      )}
    </section>
  );
};

export default RecordsRetrievePanel;