import { Badge, Button, Loader, Tooltip } from "@mantine/core";
import { notifications } from "@mantine/notifications";
import { IconClock, IconUserOff } from "@tabler/icons-react";
import { useCallback, useEffect, useState } from "react";
import {
  applyAccountDeletion,
  getDeletionConfig,
  listDeletionRecords,
  listDeletionStatuses,
  searchAccounts,
  type AccountSearchResult,
  type DeletionConfig,
  type DeletionRecord,
  type DeletionStatus,
} from "@/lib/features/account-deletion/query";
import { listEDMTemplates } from "@/lib/features/edm/query";
import DeleteAccountModal, {
  type DeletionRequest,
  type TemplateOption,
} from "@/routes/account-deletion/_components/DeleteAccountModal";

const daysUntil = (iso: string | null): number | null => {
  if (!iso) return null;
  const due = new Date(iso).getTime();
  if (!Number.isFinite(due)) return null;
  return Math.max(0, Math.ceil((due - Date.now()) / (24 * 60 * 60 * 1000)));
};

const formatDay = (value: string | null): string => {
  if (!value) return "—";
  const parsed = new Date(value);
  return Number.isFinite(parsed.getTime()) ? parsed.toLocaleDateString() : "—";
};

const DeleteAccountControl: React.FC<{ membershipNumber?: string }> = ({
  membershipNumber,
}) => {
  const [record, setRecord] = useState<DeletionRecord | null>(null);
  const [loading, setLoading] = useState(true);

  const [account, setAccount] = useState<AccountSearchResult | null>(null);
  const [opening, setOpening] = useState(false);
  const [submitting, setSubmitting] = useState(false);

  const [statuses, setStatuses] = useState<DeletionStatus[]>([]);
  const [missingStatusIDs, setMissingStatusIDs] = useState<string[]>([]);
  const [templates, setTemplates] = useState<TemplateOption[]>([]);
  const [config, setConfig] = useState<DeletionConfig | null>(null);

  const loadRecord = useCallback(async () => {
    if (!membershipNumber) {
      setLoading(false);
      return;
    }
    const response = await listDeletionRecords({
      page: 1,
      pageSize: 1,
      search: membershipNumber,
    });
    if (response.success && response.data) {
      const latest = response.data.items[0] ?? null;
      setRecord(
        latest?.accountNumber === membershipNumber ? latest : null,
      );
    }
    setLoading(false);
  }, [membershipNumber]);

  useEffect(() => {
    void loadRecord();
  }, [loadRecord]);

  const openDialog = useCallback(async () => {
    if (!membershipNumber) return;
    setOpening(true);
    const [accountResponse, statusResponse, templateResponse, configResponse] =
      await Promise.all([
        searchAccounts({ accountNumber: membershipNumber }),
        listDeletionStatuses(),
        listEDMTemplates(),
        getDeletionConfig(),
      ]);
    setOpening(false);

    if (!accountResponse.success || !accountResponse.data?.items.length) {
      notifications.show({
        color: "red",
        message: accountResponse.message || "Could not load the account",
      });
      return;
    }

    if (statusResponse.success && statusResponse.data) {
      setStatuses(statusResponse.data.items);
      setMissingStatusIDs(statusResponse.data.missingExtStatusIDs ?? []);
    }
    if (templateResponse.success && Array.isArray(templateResponse.data)) {
      setTemplates(
        templateResponse.data.map((template) => ({
          id: template.id,
          name: template.name,
        })),
      );
    }
    if (configResponse.success && configResponse.data) {
      setConfig(configResponse.data);
    }
    setAccount(accountResponse.data.items[0] ?? null);
  }, [membershipNumber]);

  const confirmDeletion = useCallback(
    async (request: DeletionRequest) => {
      if (!account) return;
      setSubmitting(true);
      const response = await applyAccountDeletion({
        accountNumber: account.accountNumber,
        ...request,
      });
      setSubmitting(false);

      const partial = response.data?.localError;
      if (partial) {
        notifications.show({
          color: "orange",
          autoClose: false,
          title: "Partly applied",
          message: `Viewpoint was updated. The member database was not: ${partial}`,
        });
      } else if (!response.success) {
        notifications.show({
          color: "red",
          message: response.message || "Failed to delete the account",
        });
        return;
      } else {
        notifications.show({
          color: "green",
          message: response.data?.updatedExisting
            ? `Account ${account.accountNumber} corrected to ${response.data?.appliedStatus.name} — existing closure updated, no new email sent`
            : `Account ${account.accountNumber} moved to ${response.data?.appliedStatus.name}`,
        });
      }

      if (response.data?.viewpointLogError) {
        notifications.show({
          color: "orange",
          autoClose: false,
          title: "Viewpoint log note not written",
          message: response.data.viewpointLogError,
        });
      }

      setAccount(null);
      await loadRecord();
    },
    [account, loadRecord],
  );

  if (!membershipNumber) return null;
  if (loading) return <Loader size="xs" />;

  const active = record && !record.reactivatedAt;
  const remaining =
    active && record.followupEdmStatus === "pending"
      ? daysUntil(record.followupDueAt)
      : null;
  return (
    <>
      {active ? (
        <Tooltip
          label={
            remaining === null
              ? `Retired on ${formatDay(record.createdAt)} — see the Deletion tab`
              : `Data-deletion email due ${formatDay(record.followupDueAt)} — see the Deletion tab`
          }
          multiline
          w={260}
        >
          <Badge
            color="red"
            variant="light"
            leftSection={<IconClock size={12} />}
          >
            {remaining === null
              ? "Deleted"
              : `Deleted — data email in ${remaining}d`}
          </Badge>
        </Tooltip>
      ) : (
        <Button
          size="compact-sm"
          color="red"
          variant="light"
          leftSection={<IconUserOff size={14} />}
          loading={opening}
          onClick={() => void openDialog()}
        >
          Delete account
        </Button>
      )}

      <DeleteAccountModal
        opened={Boolean(account)}
        account={account}
        statuses={statuses}
        missingStatusIDs={missingStatusIDs}
        statusesLoading={false}
        submitting={submitting}
        templates={templates}
        templatesLoading={false}
        config={config}
        onClose={() => setAccount(null)}
        onConfirm={confirmDeletion}
      />
    </>
  );
};

export default DeleteAccountControl;
