import { useCallback, useEffect, useRef, useState } from "react";
import { Button } from "../../../components/ui/button";
import { Checkbox } from "../../../components/ui/checkbox";
import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "../../../components/ui/dialog";
import { QrCode } from "../../../components/QrCode/QrCode";
import { HttpError } from "../../../services/HttpService";
import {
  useShareAccessService,
  type ShareAccessService,
  type ShareStatus,
  type ShownCode,
  type SignedAuthorization,
} from "../../../services/shareAccessService";
import "./ShareAccessDialog.css";

const POLL_MS = 3000;
const DOT = " \u00b7 ";

type Phase =
  | { kind: "intro" }
  | { kind: "showing"; shown: ShownCode }
  | { kind: "deciding"; status: ShareStatus }
  | { kind: "finishing"; status: ShareStatus }
  | { kind: "approved"; teamId?: string; name: string; offerRef: string }
  | { kind: "ended"; message: string };

const ENDED: Record<string, string> = {
  declined: "You declined. Nothing was shared.",
  cancelled: "The code was withdrawn. Nothing was shared.",
  expired: "The code expired before anyone used it. Nothing was shared.",
  none: "That code is no longer waiting. Nothing was shared.",
};

const refusalOf = (error: unknown, fallback: string) =>
  error instanceof HttpError && typeof (error.body as { message?: unknown })?.message === "string"
    ? (error.body as { message: string }).message
    : fallback;

// Where the practitioner types the code is wherever the server's own claim link points, per environment.
export const claimHost = (claimUrl: string): string | undefined => {
  try {
    return new URL(claimUrl).host || undefined;
  } catch {
    return undefined;
  }
};

export const remainingLabel = (expiresAt: string, now: number) => {
  const seconds = Math.max(0, Math.ceil((Date.parse(expiresAt) - now) / 1000));
  return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
};

interface ShareAccessDialogProps {
  open: boolean;
  onOpenChange: (open: boolean) => void;
  service: ShareAccessService;
  onOpenTeam: (teamId: string) => void;
}

// Share ongoing access by code: show a code, wait for a practitioner to claim it, then approve or
// decline the claimant the server describes. Approval signs the release document shown here.
export const ShareAccessDialog = ({ open, onOpenChange, service, onOpenTeam }: ShareAccessDialogProps) => {
  const { showCode, readStatus, decide, readAuthorizations } = service;
  const [phase, setPhase] = useState<Phase>({ kind: "intro" });
  const [busy, setBusy] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [agreed, setAgreed] = useState(false);
  const [showDocument, setShowDocument] = useState(false);
  const [signedCopy, setSignedCopy] = useState<string | null>(null);
  const [copies, setCopies] = useState<SignedAuthorization[]>([]);
  const [openCopy, setOpenCopy] = useState<string | null>(null);
  const [copiesFailed, setCopiesFailed] = useState(false);
  const [availability, setAvailability] = useState<string | null>(null);
  const [showCopies, setShowCopies] = useState(false);

  const loadCopies = useCallback(() => {
    readAuthorizations()
      .then((signed) => { setCopies(signed.authorizations); setAvailability(typeof signed.availability === 'string' ? signed.availability : null); setCopiesFailed(false); })
      .catch(() => setCopiesFailed(true));
  }, [readAuthorizations]);
  const [now, setNow] = useState(() => Date.now());
  const phaseRef = useRef(phase);
  phaseRef.current = phase;

  // Reopening picks up a claim already waiting for the patient; anything else starts from the start.
  useEffect(() => {
    if (!open) return;
    setPhase({ kind: "intro" });
    setError(null);
    setAgreed(false);
    setShowDocument(false);
    setSignedCopy(null);
    setOpenCopy(null);
    setShowCopies(false);
    loadCopies();
    readStatus()
      .then((status) => {
        if (phaseRef.current.kind !== "intro") return;
        if (status.state === "claimed") setPhase({ kind: "deciding", status });
        if (status.state === "approving") setPhase({ kind: "finishing", status });
      })
      .catch(() => undefined);
  }, [open, readStatus, loadCopies]);

  const showing = phase.kind === "showing";
  useEffect(() => {
    if (!open || !showing) return;
    const tick = window.setInterval(() => setNow(Date.now()), 1000);
    const poll = window.setInterval(async () => {
      try {
        const status = await readStatus();
        if (phaseRef.current.kind !== "showing") return;
        if (status.state === "claimed") setPhase({ kind: "deciding", status });
        else if (status.state !== "minted") setPhase({ kind: "ended", message: ENDED[status.state] ?? ENDED.none });
      } catch {
        // A missed poll is retried on the next tick; the countdown still runs.
      }
    }, POLL_MS);
    return () => {
      window.clearInterval(tick);
      window.clearInterval(poll);
    };
  }, [open, showing, readStatus]);

  useEffect(() => {
    if (phase.kind === "showing" && Date.parse(phase.shown.expiresAt) <= now) {
      setPhase({ kind: "ended", message: ENDED.expired });
    }
  }, [phase, now]);

  const start = useCallback(async () => {
    setBusy(true);
    setError(null);
    try {
      const shown = await showCode();
      setNow(Date.now());
      setPhase({ kind: "showing", shown });
    } catch (failure) {
      setError(refusalOf(failure, "The code could not be shown. Try again."));
    } finally {
      setBusy(false);
    }
  }, [showCode]);

  const act = useCallback(async (run: () => Promise<{ state: string; teamId?: string }>, name = "", offerRef = "") => {
    setBusy(true);
    setError(null);
    try {
      const result = await run();
      setPhase(result.state === "approved"
        ? { kind: "approved", teamId: result.teamId, name, offerRef }
        : { kind: "ended", message: ENDED[result.state] ?? ENDED.none });
      if (result.state === "approved") loadCopies();
    } catch (failure) {
      // This offer has moved on elsewhere: its controls go, and nothing is retried against a newer one.
      if (failure instanceof HttpError && failure.status === 409) {
        setAgreed(false);
        setPhase({ kind: "ended", message: refusalOf(failure, ENDED.none) });
        loadCopies();
        return;
      }
      setError(refusalOf(failure, "That did not go through. Try again."));
    } finally {
      setBusy(false);
    }
  }, [loadCopies]);

  // A code nobody has claimed is withdrawn when the screen closes, so it cannot be used unseen.
  const close = (next: boolean) => {
    const current = phaseRef.current;
    if (!next && current.kind === "showing") decide({ decision: "cancel", offerRef: current.shown.offerRef }).catch(() => undefined);
    onOpenChange(next);
  };

  const claimant = phase.kind === "deciding" ? phase.status.claimant : undefined;
  const document = phase.kind === "deciding" ? phase.status.document : undefined;
  const refs = phase.kind === "deciding" || phase.kind === "finishing"
    ? { offerRef: phase.status.offerRef ?? "", claimRef: phase.status.claimRef ?? "" }
    : undefined;

  const toggleSignedCopy = async (offerRef: string) => {
    if (signedCopy !== null) return setSignedCopy(null);
    try {
      const copy = (await readAuthorizations()).authorizations.find((signed) => signed.offerRef === offerRef);
      setSignedCopy(copy ? copy.signedText : "Your signed copy could not be found. Try again in a moment.");
    } catch (failure) {
      setError(refusalOf(failure, "Your signed copy could not be opened. Try again."));
    }
  };

  return (
    <Dialog open={open} onOpenChange={close}>
      <DialogContent className="share-access max-w-md">
        <DialogHeader>
          <DialogTitle>Share access with a practitioner</DialogTitle>
          <DialogDescription>
            {phase.kind === "deciding"
              ? "Someone used your code. Check who they are before you decide."
              : "For a practitioner outside your practices who should follow your care."}
          </DialogDescription>
        </DialogHeader>

        {phase.kind === "intro" && (
          <ul className="share-access-terms">
            <li>They see your name and can reach you straight away. They see a structured summary of your clinical information, including what is added later, until you stop sharing. Notes, documents, images and attachments are not shared.</li>
            <li>They can message you and join case conferences about your care. They cannot book or start visits.</li>
            <li>Substance use treatment records, psychotherapy notes and other specially protected records are not shared.</li>
            <li>Nothing is shared until you see who used the code and approve them.</li>
          </ul>
        )}

        {/* Every signed copy stays reachable whatever the current offer is doing; only a code on screen hides them. */}
        {phase.kind !== "showing" && (copies.length > 0 || copiesFailed) && (
          <div className="share-access-history">
            <button type="button" className="btn btn-stripped share-access-history-title" onClick={() => setShowCopies((shown) => !shown)}>
              {`Your signed authorizations${copies.length ? ` (${copies.length})` : ""}`}
            </button>
            {availability && <p className="share-access-note">{availability}</p>}
            {copiesFailed && (
              <p className="share-access-note" role="alert">
                Your signed authorizations could not be loaded.{" "}
                <button type="button" className="btn btn-stripped" onClick={loadCopies}>Try again</button>
              </p>
            )}
            {showCopies && <ul>
              {copies.map((copy) => (
                <li key={copy.offerRef}>
                  <span>
                    {[copy.recipient.registryName, `NPI ${copy.recipient.npi}`, `signed ${copy.signedAt.slice(0, 10)}`].join(DOT)}
                    {copy.state === "approving" && " (not finished)"}
                  </span>
                  <span className="share-access-history-actions">
                    <button type="button" className="btn btn-stripped" onClick={() => setOpenCopy(openCopy === copy.offerRef ? null : copy.offerRef)}>
                      {openCopy === copy.offerRef ? "Hide" : "Read"}
                    </button>
                    {copy.state === "approved" && (
                      <button type="button" className="btn btn-stripped" onClick={() => onOpenTeam(copy.teamId)}>
                        Open the team
                      </button>
                    )}
                  </span>
                  {openCopy === copy.offerRef && <pre className="share-access-document">{copy.signedText}</pre>}
                </li>
              ))}
            </ul>}
          </div>
        )}

        {phase.kind === "showing" && (
          <div className="share-access-showing">
            <QrCode value={phase.shown.claimUrl} label="Code for the practitioner to scan" className="share-access-qr" />
            <p className="share-access-code">{phase.shown.code}</p>
            <p className="share-access-hint">
              The practitioner scans this or types the code{claimHost(phase.shown.claimUrl) ? ` at ${claimHost(phase.shown.claimUrl)}` : ""}. It expires in{" "}
              <span data-testid="share-countdown">{remainingLabel(phase.shown.expiresAt, now)}</span>.
            </p>
          </div>
        )}

        {phase.kind === "deciding" && claimant && document && (
          <div className="share-access-deciding">
            <dl className="share-access-claimant">
              <dt>National NPI registry</dt>
              <dd>{[[claimant.registryName, claimant.registryTaxonomy].filter(Boolean).join(", "), `NPI ${claimant.npi}`].join(DOT)}</dd>
              <dt>Signed in as</dt>
              <dd>{[claimant.accountName || "No name given", claimant.accountEmail].join(DOT)}</dd>
            </dl>
            {!claimant.namesAgree && (
              <p className="share-access-warning" role="alert">
                The name on this account does not match the registry. Make sure this is the person you meant.
              </p>
            )}
            <p className="share-access-note">
              Akashic checked that this NPI belongs to an active individual practitioner and that this email belongs to the
              account. It cannot confirm that the person in front of you is that practitioner.
            </p>
            <button type="button" className="btn btn-stripped share-access-doc-toggle" onClick={() => setShowDocument((shown) => !shown)}>
              {showDocument ? "Hide the authorization" : "Read the full authorization"}
            </button>
            {showDocument && <pre className="share-access-document">{document.text}</pre>}
            <label className="share-access-agree">
              <Checkbox checked={agreed} onCheckedChange={(checked) => setAgreed(checked === true)} />
              <span>I have read the authorization and agree to share my record with {claimant.registryName}.</span>
            </label>
          </div>
        )}

        {phase.kind === "deciding" && !document && (
          <p className="share-access-note">This claim cannot be shown, so it cannot be approved. Decline it and show a new code.</p>
        )}

        {phase.kind === "finishing" && (
          <p className="share-access-note" role="status">
            You approved sharing with {phase.status.claimant?.registryName ?? "this practitioner"}, but it did not finish. Finish it
            with the authorization you already signed.
          </p>
        )}

        {phase.kind === "approved" && (
          <div className="share-access-deciding">
            <p className="share-access-note" role="status">
              {phase.name} can now message you and join case conferences about your care. You can stop sharing from the team at any time.
            </p>
            {availability && <p className="share-access-note">{availability}</p>}
            <button type="button" className="btn btn-stripped share-access-doc-toggle" onClick={() => void toggleSignedCopy(phase.offerRef)}>
              {signedCopy !== null ? "Hide your signed authorization" : "Read your signed authorization"}
            </button>
            {signedCopy !== null && <pre className="share-access-document">{signedCopy}</pre>}
          </div>
        )}

        {phase.kind === "ended" && <p className="share-access-note" role="status">{phase.message}</p>}

        {error && <p className="text-sm text-destructive" role="alert">{error}</p>}

        <DialogFooter>
          {(phase.kind === "intro" || phase.kind === "ended") && (
            <Button className="btn btn-blue" disabled={busy} onClick={start}>
              {busy ? "Getting a code..." : phase.kind === "ended" ? "Show a new code" : "Show a code"}
            </Button>
          )}
          {phase.kind === "showing" && (
            <Button variant="outline" disabled={busy} onClick={() => act(() => decide({ decision: "cancel", offerRef: phase.shown.offerRef }))}>
              Withdraw this code
            </Button>
          )}
          {phase.kind === "finishing" && refs && phase.status.version !== undefined && phase.status.documentHash && (
            <Button
              className="btn btn-green"
              disabled={busy}
              onClick={() =>
                act(
                  () => decide({ decision: "approve", ...refs, version: phase.status.version!, documentHash: phase.status.documentHash! }),
                  phase.status.claimant?.registryName ?? "The practitioner",
                  refs.offerRef,
                )
              }
            >
              {busy ? "Finishing..." : "Finish sharing"}
            </Button>
          )}
          {phase.kind === "deciding" && refs && phase.status.version !== undefined && (
            <>
              <Button
                variant="outline"
                disabled={busy}
                onClick={() => act(() => decide({ decision: "decline", ...refs, version: phase.status.version! }))}
              >
                Decline
              </Button>
              {claimant && document && (
                <Button
                  className="btn btn-green"
                  disabled={busy || !agreed}
                  onClick={() =>
                    act(
                      () => decide({ decision: "approve", ...refs, version: phase.status.version!, documentHash: document.hash }),
                      claimant.registryName,
                      refs.offerRef,
                    )
                  }
                >
                  {busy ? "Approving..." : "Approve"}
                </Button>
              )}
            </>
          )}
          {phase.kind === "approved" && phase.teamId && (
            <Button className="btn btn-blue" onClick={() => onOpenTeam(phase.teamId!)}>
              Open the team
            </Button>
          )}
        </DialogFooter>
      </DialogContent>
    </Dialog>
  );
};

/** The dialog with its service, mounted only while open so a closed dialog costs the page nothing. */
export const ConnectedShareAccessDialog = (props: Omit<ShareAccessDialogProps, "service">) => {
  const service = useShareAccessService();
  return <ShareAccessDialog {...props} service={service} />;
};

export default ShareAccessDialog;