import { useEffect, useState } from "react";
import type { RelatedPerson } from "fhir/r4";
import { ScanEye, ShieldUser, UserRoundX } from "lucide-react";
import { toast } from "sonner";
import {
  AlertDialog,
  AlertDialogCancel,
  AlertDialogContent,
  AlertDialogDescription,
  AlertDialogFooter,
  AlertDialogHeader,
  AlertDialogTitle,
} from "../../../components/ui/alert-dialog";
import { useRelatedPersonServiceContext } from "../../../services";
import { TIER_LABELS, type AuthorityGrant } from "../../../services/relatedPersonAuthority";
import { describeCurrentAccess } from "../../../components/FhirRelatedPersonDisplay/tierWords";
import { inviteAnswerOf } from "../../../config/relatedPersonInviteStatus";
import { relayServerFailure } from "../../../utils/fetchFailureMessage";
import { GUARDIAN_KEEPS_GRANT_MESSAGE, guardianKeepsGrant } from "../../../utils/guardianKeepsGrant";
import { PersonAction } from "./FamilyPerson";
import "./RelatedPersonsPage.css";

interface InboundAccessActionsProps {
  relatedPerson: RelatedPerson;
  displayName: string;
  grant?: AuthorityGrant;
  onUpdatePermissions?: () => void;
  /** Opens what this person has opened or changed on the record. */
  onShowActivity?: () => void;
  onRevoked: () => void;
  /** Rows in the phone overlay; beside Save, the ending is a red button. */
  variant?: "rows" | "button";
  /** The server says this guardianship has ended: nothing is left to change or revoke. */
  ended?: boolean;
}

// Someone who can access me: change what they may do, or end it. Revoking is its own action, not a tier.
export const InboundAccessActions = ({
  relatedPerson,
  displayName,
  grant,
  onUpdatePermissions,
  onShowActivity,
  onRevoked,
  variant = "rows",
  ended = false,
}: InboundAccessActionsProps) => {
  const { deleteRelatedPerson } = useRelatedPersonServiceContext();
  const [confirming, setConfirming] = useState(false);
  const [revoking, setRevoking] = useState(false);
  const [error, setError] = useState<string | null>(null);

  // An unanswered invitation has granted nothing yet, so ending it is withdrawing it.
  const invited = inviteAnswerOf(relatedPerson) !== "accepted";
  const kept = guardianKeepsGrant(relatedPerson);
  const keptNote = <p className="care-access-sub">{GUARDIAN_KEEPS_GRANT_MESSAGE}</p>;
  // Nothing can be revoked here once the grant is the guardian's to keep, or the guardianship has ended.
  const unrevocable = kept || ended;
  // A confirmation already open when that turns out to be so closes, and does not reopen.
  useEffect(() => {
    if (unrevocable) setConfirming(false);
  }, [unrevocable]);
  const endLabel = invited ? "Withdraw the invitation" : "Revoke access";
  // Ending access removes authority, not history: what they did on the record stays readable.
  const endEffect = invited
    ? "The invitation ends immediately. Its history is kept."
    : "Their access ends immediately. The history of their access is kept.";

  const revoke = async () => {
    if (unrevocable) return;
    setRevoking(true);
    setError(null);
    try {
      await deleteRelatedPerson(relatedPerson);
      setConfirming(false);
      toast.success(
        invited
          ? `The invitation to ${displayName} was withdrawn.`
          : `Access revoked. ${displayName} no longer has access to your record.`,
        { position: "top-right" },
      );
      window.dispatchEvent(new CustomEvent("relatedPersonDeleted"));
      onRevoked();
    } catch (err) {
      setError(relayServerFailure(err, "That could not be completed."));
    } finally {
      setRevoking(false);
    }
  };

  const confirm = (
    <AlertDialog
      open={confirming && !unrevocable}
      onOpenChange={(open) => {
        if (!revoking) setConfirming(open);
      }}
    >
      <AlertDialogContent>
        <AlertDialogHeader>
          <AlertDialogTitle>
            {invited ? `Withdraw the invitation to ${displayName}?` : `Revoke ${displayName}'s access?`}
          </AlertDialogTitle>
          <AlertDialogDescription>{endEffect}</AlertDialogDescription>
        </AlertDialogHeader>
        {error && <p role="alert" className="access-action-error">{error}</p>}
        <AlertDialogFooter>
          <AlertDialogCancel className="btn btn-amber" disabled={revoking}>
            {invited ? "Keep the invitation" : "Keep their access"}
          </AlertDialogCancel>
          <button
            type="button"
            className={`btn btn-red ${revoking ? "btn-busy" : ""}`}
            disabled={revoking}
            onClick={() => void revoke()}
            data-testid="confirm-revoke"
          >
            {revoking ? "Revoking…" : endLabel}
          </button>
        </AlertDialogFooter>
      </AlertDialogContent>
    </AlertDialog>
  );

  // An ended guardianship already gives them nothing; the card beside this says so.
  if (variant === "button") {
    if (ended) return null;
    if (kept) return keptNote;
    return (
      <>
        <button
          type="button"
          className="btn btn-red"
          onClick={() => setConfirming(true)}
          disabled={revoking}
          data-testid="revoke-access"
        >
          {endLabel}
        </button>
        {confirm}
      </>
    );
  }

  return (
    <div className="access-actions">
      {ended && (
        <p className="care-access-sub">
          {displayName}&rsquo;s guardianship has ended, so it no longer gives them access. What they did while it
          lasted stays in the record.
        </p>
      )}
      {kept && !ended && keptNote}
      {onUpdatePermissions && !kept && !ended && (
        <PersonAction
          icon={ShieldUser}
          label="Update permissions"
          sub={grant ? describeCurrentAccess(TIER_LABELS[grant.tier], grant.allowBillingView) : "What they may do on your behalf."}
          onClick={onUpdatePermissions}
          disabled={revoking}
        />
      )}
      {onShowActivity && (
        <PersonAction
          icon={ScanEye}
          label="Their activity on your record"
          sub="Every time they opened or changed something, and when."
          onClick={onShowActivity}
          disabled={revoking}
        />
      )}
      {!kept && !ended && (
        <PersonAction
          icon={UserRoundX}
          label={endLabel}
          sub={endEffect}
          onClick={() => setConfirming(true)}
          danger
          disabled={revoking}
          testId="revoke-access"
        />
      )}
      {confirm}
    </div>
  );
};

export default InboundAccessActions;