import {
  Alert,
  Badge,
  Card,
  Group,
  Loader,
  MultiSelect,
  Select,
  Stack,
  Switch,
  Text,
  TextInput,
  Title,
} from "@mantine/core";
import { DatePickerInput } from "@mantine/dates";
import { notifications } from "@mantine/notifications";
import { IconSearch } from "@tabler/icons-react";
import { InfoHint } from "@/lib/components/InfoHint";
import { useEffect, useMemo, useState } from "react";
import { useNavigate } from "react-router";
import {
  getCodeCampaignMap,
  getMemberReferralAnalytics,
  getReportFilterOptions,
  getReportUsers,
  listCountriesFromDB,
  type CodeCampaignMapRow,
} from "@/lib/features/promo-code-campaigns/query";
import type {
  PromoCodeUserRow,
  PromoCodeUsersResult,
} from "@/lib/features/promo-code-campaigns/types";
import { listPromoCodes } from "@/lib/features/promo-codes/query";
import type { PromoCode } from "@/lib/features/promo-codes/types";
import { ExportButton } from "@/lib/export/ExportButton";
import {
  ActiveFilterChips,
  type FilterChip,
  FilterDrawer,
  FilterSection,
  FilterTrigger,
} from "@/routes/promo-code-campaigns/_components/FilterDrawer";
import {
  StatTiles,
  type StatTileSpec,
} from "@/routes/promo-code-campaigns/_components/StatTiles";
import {
  AnimatedNumber,
  PageSection,
} from "@/routes/promo-code-campaigns/_components/motion";
import { useAccountStatusFilter } from "@/routes/promo-code-campaigns/_components/useAccountStatusFilter";
import { usePromoTheme } from "@/routes/promo-code-campaigns/_components/appearance";
import promoStyles from "@/routes/promo-code-campaigns/_components/promo.module.css";
import {
  IconCake,
  IconCalendarStats,
  IconLogin,
  IconUsers,
  IconWorld,
} from "@tabler/icons-react";
import {
  ExportLimitError,
  MAX_EXPORT_ROWS,
  withTimeout,
} from "@/lib/export/exportLimits";
import { useSessionStorageState } from "@/hooks/useSessionStorageState";
import {
  buildExportSheet,
  ColumnArranger,
  CountryMultiSelect,
  DEFAULT_SIGNUP_WINDOW,
  defaultColumnKeys,
  FilterPanel,
  isWindowActive,
  ReportPreview,
  resolveColumns,
  resolveSignupWindow,
  SelectAllMultiSelect,
  SignupWindowControl,
  type ReportColumn,
  type SignupWindowState,
} from "../_shared";

const PAGE_SIZE_OPTIONS = ["10", "25", "50", "100"];

const fmtDate = (value: unknown) => {
  if (!value) return "";
  const d = new Date(value as string);
  return Number.isFinite(d.getTime()) ? d.toLocaleDateString() : "";
};

const toYMD = (d: Date | null): string | undefined => {
  if (!d) return undefined;
  const dt = new Date(d);
  if (!Number.isFinite(dt.getTime())) return undefined;
  const y = dt.getFullYear();
  const m = String(dt.getMonth() + 1).padStart(2, "0");
  const day = String(dt.getDate()).padStart(2, "0");
  return `${y}-${m}-${day}`;
};

const isLoggedIn = (u: PromoCodeUserRow) => {
  const v = u.first_access_attempt;
  if (typeof v === "boolean") return v;
  if (typeof v === "string") {
    const s = v.trim().toLowerCase();
    return s === "true" || s === "t" || s === "1";
  }
  return Boolean(v);
};

const REPORT_COLUMNS: ReportColumn<PromoCodeUserRow>[] = [
  {
    key: "promo_code",
    label: "Promo Code",
    width: 22,
    defaultOn: true,
    get: (u) => String(u.signup_promo_code ?? ""),
  },
  {
    key: "campaign",
    label: "Campaign",
    width: 22,
    defaultOn: true,
    get: (u) => String(u.campaign ?? ""),
  },
  {
    key: "membership_number",
    label: "Account ID",
    width: 16,
    defaultOn: true,
    get: (u) => String(u.membership_number ?? ""),
  },
  {
    key: "member_number",
    label: "Member ID",
    width: 16,
    defaultOn: false,
    get: (u) => String(u.member_number ?? ""),
  },
  {
    key: "first_name",
    label: "First Name",
    width: 18,
    defaultOn: true,
    get: (u) => String(u.first_name ?? ""),
  },
  {
    key: "last_name",
    label: "Last Name",
    width: 18,
    defaultOn: true,
    get: (u) => String(u.last_name ?? ""),
  },
  {
    key: "email",
    label: "Email",
    width: 30,
    defaultOn: true,
    get: (u) => String(u.email ?? ""),
  },
  {
    key: "phone",
    label: "Phone",
    width: 18,
    defaultOn: true,
    get: (u) => String(u.phone ?? ""),
  },
  {
    key: "nationality",
    label: "Nationality",
    width: 16,
    defaultOn: true,
    get: (u) => String(u.nationality ?? ""),
  },
  {
    key: "country",
    label: "Country",
    width: 16,
    defaultOn: true,
    get: (u) => String(u.country ?? ""),
  },
  {
    key: "date_of_birth",
    label: "Date of Birth",
    width: 16,
    defaultOn: false,
    get: (u) => fmtDate(u.date_of_birth),
  },
  {
    key: "account_type_name",
    label: "Account Type",
    width: 18,
    defaultOn: false,
    get: (u) => String(u.account_type_name ?? ""),
  },
  {
    key: "account_status_name",
    label: "Account Status",
    width: 16,
    defaultOn: false,
    get: (u) => String(u.account_status_name ?? ""),
  },
  {
    key: "logged_in",
    label: "Logged In",
    width: 12,
    defaultOn: false,
    get: (u) => (isLoggedIn(u) ? "Yes" : "No"),
  },
  {
    key: "commence_date",
    label: "Date of Acquisition",
    width: 18,
    defaultOn: true,
    get: (u) => fmtDate(u.commence_date),
  },
];

const DEFAULT_COLUMN_KEYS = defaultColumnKeys(REPORT_COLUMNS);

const codeOf = (p: PromoCode): string => String(p.code ?? p.name ?? "").trim();

const GROUP_PREFIX = "group:";
const GROUP_REFERRAL = `${GROUP_PREFIX}member-referrals`;

export default function MemberReport() {
  const navigate = useNavigate();

  const openMember = (u: PromoCodeUserRow) => {
    const code = String(u.signup_promo_code ?? "").trim();
    const membership = String(u.membership_number ?? "").trim();
    if (!code || !membership) return;
    navigate(
      `/admin/reports/members/${encodeURIComponent(code)}/${encodeURIComponent(membership)}`,
    );
  };

  useEffect(() => {
    try {
      window.sessionStorage.removeItem("reports.dobRange");
      window.sessionStorage.removeItem("reports.codeType");
      window.sessionStorage.removeItem("reports.accountStatus.seeded");
      window.sessionStorage.removeItem("reports.accountStatus.seeded.v2");
    } catch {}
  }, []);

  const [codeOptions, setCodeOptions] = useState<
    { value: string; label: string }[]
  >([]);
  const [codesLoading, setCodesLoading] = useState(true);
  const [codesError, setCodesError] = useState<string | null>(null);
  const [codeSearch, setCodeSearch] = useState("");
  const [labelByValue, setLabelByValue] = useSessionStorageState<
    Record<string, string>
  >("reports.labelByValue", {});

  const [selectedCodes, setSelectedCodes] = useSessionStorageState<string[]>(
    "reports.selectedCodes",
    [],
  );
  const [selectedCampaigns, setSelectedCampaigns] = useSessionStorageState<
    string[]
  >("reports.selectedCampaigns", []);
  const [mapRows, setMapRows] = useState<CodeCampaignMapRow[]>([]);
  const [mapLoading, setMapLoading] = useState(true);
  const [selectedColumns, setSelectedColumns] = useSessionStorageState<
    string[]
  >("reports.selectedColumns", DEFAULT_COLUMN_KEYS);
  const [search, setSearch] = useSessionStorageState("reports.search", "");
  const [loggedInOnly, setLoggedInOnly] = useSessionStorageState(
    "reports.loggedInOnly",
    false,
  );
  const [pageSize, setPageSize] = useSessionStorageState(
    "reports.pageSize",
    25,
  );

  const [signupWindow, setSignupWindow] =
    useSessionStorageState<SignupWindowState>(
      "reports.window",
      DEFAULT_SIGNUP_WINDOW,
    );
  const [countrySel, setCountrySel] = useSessionStorageState<string[]>(
    "reports.country",
    [],
  );
  const windowRange = useMemo(
    () => resolveSignupWindow(signupWindow),
    [signupWindow],
  );

  const [countryOptions, setCountryOptions] = useState<string[]>([]);
  const [nationalityOptions, setNationalityOptions] = useState<string[]>([]);
  const canChooseAccountType = true;

  const [accountTypeOptions, setAccountTypeOptions] = useState<string[]>([]);
  useEffect(() => {
    let cancelled = false;
    void (async () => {
      const res = await listCountriesFromDB();
      if (cancelled || !res.success) return;
      setCountryOptions(res.data.map((c) => c.name));
    })();
    return () => {
      cancelled = true;
    };
  }, []);

  const [statusFilter, setStatusFilter] = useSessionStorageState<string | null>(
    "reports.status",
    "all",
  );
  const [nationalityFilter, setNationalityFilter] = useSessionStorageState<
    string[]
  >("reports.nationality", []);
  const [accountTypeFilter, setAccountTypeFilter] = useSessionStorageState<
    string[]
  >("reports.accountType", []);
  const accountStatus = useAccountStatusFilter();

  const accountTypeForQuery = accountTypeFilter.length
    ? accountTypeFilter
    : undefined;

  const [dobRange, setDobRange] = useState<[Date | null, Date | null]>([
    null,
    null,
  ]);
  const [sortBy, setSortBy] = useSessionStorageState<string | null>(
    "reports.sort",
    "commence-desc",
  );

  const [filtersOpen, setFiltersOpen] = useState(false);
  const { series: seriesPalette } = usePromoTheme();

  const filterChips = useMemo<FilterChip[]>(() => {
    const chips: FilterChip[] = [];

    for (const value of selectedCampaigns) {
      if (!value.startsWith(GROUP_PREFIX)) continue;
      chips.push({
        key: value,
        label: "Member referrals",
        onRemove: () =>
          setSelectedCampaigns(selectedCampaigns.filter((v) => v !== value)),
      });
    }

    if (isWindowActive(signupWindow)) {
      chips.push({
        key: "window",
        label: "Signup window",
        onRemove: () => setSignupWindow(DEFAULT_SIGNUP_WINDOW),
      });
    }
    if (statusFilter && statusFilter !== "all") {
      chips.push({
        key: "status",
        label: `Status: ${statusFilter === "active" ? "Active" : "Non-active"}`,
        onRemove: () => setStatusFilter("all"),
      });
    }
    chips.push(...accountStatus.chips);

    const multi: Array<[string, string[], (next: string[]) => void]> = [
      ["Country", countrySel, setCountrySel],
      ["Nationality", nationalityFilter, setNationalityFilter],
      ...(canChooseAccountType
        ? [
            ["Account type", accountTypeFilter, setAccountTypeFilter] as [
              string,
              string[],
              (next: string[]) => void,
            ],
          ]
        : []),
    ];
    for (const [label, values, setter] of multi) {
      for (const value of values) {
        chips.push({
          key: `${label}:${value}`,
          label: `${label}: ${value}`,
          onRemove: () => setter(values.filter((v) => v !== value)),
        });
      }
    }
    if (dobRange[0] || dobRange[1]) {
      chips.push({
        key: "dob",
        label: "Date of birth",
        onRemove: () => setDobRange([null, null]),
      });
    }
    return chips;
  }, [
    selectedCampaigns,
    setSelectedCampaigns,
    canChooseAccountType,
    signupWindow,
    statusFilter,
    countrySel,
    nationalityFilter,
    accountStatus.chips,
    accountTypeFilter,
    dobRange,
  ]);

  const resetFilters = () => {
    setSignupWindow(DEFAULT_SIGNUP_WINDOW);
    setCountrySel([]);
    setStatusFilter("all");
    setNationalityFilter([]);
    accountStatus.reset();
    setAccountTypeFilter([]);
    setDobRange([null, null]);
  };

  const [data, setData] = useState<PromoCodeUsersResult | null>(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [page, setPage] = useState(1);

  const [grandTotal, setGrandTotal] = useState<number | null>(null);
  useEffect(() => {
    let cancelled = false;
    (async () => {
      try {
        const res = await getReportUsers([], {
          page: 1,
          pageSize: 1,
          ...accountStatus.scope,
        });
        if (cancelled) return;
        if (res.success) setGrandTotal(res.data.pagination.total);
      } catch {}
    })();
    return () => {
      cancelled = true;
    };
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [accountStatus.scopeKey]);

  useEffect(() => {
    let cancelled = false;
    setCodesLoading(true);
    const timer = setTimeout(async () => {
      try {
        const res = await listPromoCodes({
          includeExpired: "true",
          searchTerm: codeSearch.trim() || undefined,
          limit: 100,
          offset: 0,
        });
        if (!res.success) {
          throw new Error(res.message || "Failed to load promo codes");
        }
        const inner = res.data;
        const items: PromoCode[] = Array.isArray(inner)
          ? inner
          : Array.isArray(inner?.data)
            ? inner.data
            : Array.isArray((inner as any)?.items)
              ? (inner as any).items
              : [];
        const seen = new Set<string>();
        const options: { value: string; label: string }[] = [];
        const labels: Record<string, string> = {};
        for (const p of items) {
          const code = codeOf(p);
          if (!code || seen.has(code.toUpperCase())) continue;
          seen.add(code.toUpperCase());
          const name = String(p.name ?? "").trim();
          const label = name && name !== code ? `${name} (${code})` : code;
          options.push({ value: code, label });
          labels[code] = label;
        }
        if (cancelled) return;
        options.sort((a, b) => a.label.localeCompare(b.label));
        setCodeOptions(options);
        setLabelByValue((prev) => ({ ...prev, ...labels }));
        setCodesError(null);
      } catch (e) {
        if (cancelled) return;
        setCodesError(
          e instanceof Error ? e.message : "Failed to load promo codes",
        );
      } finally {
        if (!cancelled) setCodesLoading(false);
      }
    }, 300);
    return () => {
      cancelled = true;
      clearTimeout(timer);
    };
  }, [codeSearch]);

  const pickerData = useMemo(() => {
    const byValue = new Map<string, string>();
    for (const o of codeOptions) byValue.set(o.value, o.label);
    for (const v of selectedCodes) {
      if (!byValue.has(v)) byValue.set(v, labelByValue[v] ?? v);
    }
    return Array.from(byValue, ([value, label]) => ({ value, label }));
  }, [codeOptions, selectedCodes, labelByValue]);

  useEffect(() => {
    let cancelled = false;
    void (async () => {
      setMapLoading(true);
      try {
        const res = await getCodeCampaignMap();
        if (!cancelled && res.success) setMapRows(res.data);
      } finally {
        if (!cancelled) setMapLoading(false);
      }
    })();
    return () => {
      cancelled = true;
    };
  }, []);

  const [codesByType, setCodesByType] = useState<{
    promo: string[];
    referral: string[];
  } | null>(null);

  useEffect(() => {
    let cancelled = false;
    void (async () => {
      const collect = async (
        flag: "onlyPromoCodes" | "onlyMemberReferralCodes",
      ) => {
        const out: string[] = [];
        const pageSize = 250;
        for (let offset = 0; offset < 10000; offset += pageSize) {
          const res = await listPromoCodes({
            [flag]: "true",
            limit: pageSize,
            offset,
          } as never);
          if (!res.success) break;
          const items = res.data?.data ?? [];
          for (const item of items) {
            const code = String(
              (item as { code?: string; name?: string }).code ??
                (item as { name?: string }).name ??
                "",
            ).trim();
            if (code) out.push(code);
          }
          if (items.length < pageSize) break;
        }
        return out;
      };

      const [promo, referral] = await Promise.all([
        collect("onlyPromoCodes"),
        collect("onlyMemberReferralCodes"),
      ]);
      if (!cancelled) setCodesByType({ promo, referral });
    })();
    return () => {
      cancelled = true;
    };
  }, []);

  const [referralSignups, setReferralSignups] = useState<number | null>(null);

  useEffect(() => {
    let cancelled = false;
    setReferralSignups(null);
    void (async () => {
      const res = await getMemberReferralAnalytics({
        from: windowRange.from,
        to: windowRange.to,
        ...accountStatus.scope,
      });
      if (cancelled || !res.success) return;
      setReferralSignups(Number(res.data.analytics.total || 0));
    })();
    return () => {
      cancelled = true;
    };
  }, [windowRange.from, windowRange.to, accountStatus.scopeKey]);

  const campaignOptions = useMemo(() => {
    const byId = new Map<string, string>();
    for (const r of mapRows) byId.set(r.campaign_id, r.campaign_name);
    return Array.from(byId, ([value, label]) => ({ value, label })).sort(
      (a, b) => a.label.localeCompare(b.label),
    );
  }, [mapRows]);

  const campaignPickerData = useMemo(
    () => [
      {
        value: GROUP_REFERRAL,
        label:
          referralSignups === null
            ? "Member referrals"
            : `Member referrals (${referralSignups.toLocaleString()})`,
      },
      ...campaignOptions,
    ],
    [campaignOptions, referralSignups],
  );

  const campaignIdToCodes = useMemo(() => {
    const m = new Map<string, string[]>();
    for (const r of mapRows) {
      const list = m.get(r.campaign_id) ?? [];
      list.push(r.promo_code_name);
      m.set(r.campaign_id, list);
    }
    return m;
  }, [mapRows]);

  const codeToCampaigns = useMemo(() => {
    const m = new Map<string, string[]>();
    for (const r of mapRows) {
      const key = r.promo_code_name.toUpperCase();
      const list = m.get(key) ?? [];
      if (!list.includes(r.campaign_name)) list.push(r.campaign_name);
      m.set(key, list);
    }
    return m;
  }, [mapRows]);

  const effectiveCodes = useMemo(() => {
    const byUpper = new Map<string, string>();
    for (const c of selectedCodes) byUpper.set(c.toUpperCase(), c);
    for (const id of selectedCampaigns) {
      if (id.startsWith(GROUP_PREFIX)) continue;
      for (const c of campaignIdToCodes.get(id) ?? []) {
        if (!byUpper.has(c.toUpperCase())) byUpper.set(c.toUpperCase(), c);
      }
    }
    const groups = selectedCampaigns.filter((v) => v.startsWith(GROUP_PREFIX));
    if (groups.length > 0) {
      if (!codesByType) return ["\u0000"];
      if (groups.includes(GROUP_REFERRAL)) {
        for (const c of codesByType.referral) {
          const key = c.trim().toUpperCase();
          if (key && !byUpper.has(key)) byUpper.set(key, c);
        }
      }
    }

    const picked = Array.from(byUpper.values());
    if (picked.length === 0 && selectedCampaigns.length > 0) return ["\u0000"];
    return picked;
  }, [selectedCodes, selectedCampaigns, campaignIdToCodes, codesByType]);

  const campaignForCode = (code: unknown) =>
    codeToCampaigns.get(String(code ?? "").toUpperCase())?.join(", ") ?? "";

  const loadPreview = async (targetPage: number) => {
    setLoading(true);
    try {
      const res = await getReportUsers(effectiveCodes, {
        page: targetPage,
        pageSize,
        search: search.trim() || undefined,
        loggedIn: loggedInOnly || undefined,
        from: windowRange.from,
        to: windowRange.to,
        country: countrySel.length ? countrySel : undefined,
        status:
          statusFilter && statusFilter !== "all"
            ? (statusFilter as "active" | "inactive")
            : undefined,
        nationality: nationalityFilter.length ? nationalityFilter : undefined,
        ...accountStatus.scope,
        accountType: accountTypeForQuery,
        dobFrom: toYMD(dobRange[0]),
        dobTo: toYMD(dobRange[1]),
      });
      if (res.success) {
        setData(res.data);
        setError(null);
        setPage(res.data.pagination.page);
      } else {
        setError(res.message || "Failed to load report");
        notifications.show({
          color: "red",
          message: res.message || "Failed to load report",
        });
      }
    } catch (e) {
      setError(e instanceof Error ? e.message : "Failed to load report");
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    const t = setTimeout(() => {
      setPage(1);
      void loadPreview(1);
    }, 350);
    return () => clearTimeout(t);
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [
    effectiveCodes,
    search,
    loggedInOnly,
    pageSize,
    windowRange.from,
    windowRange.to,
    countrySel,
    statusFilter,
    nationalityFilter,
    accountStatus.scopeKey,
    accountTypeFilter,
    dobRange,
  ]);

  useEffect(() => {
    let cancelled = false;
    void (async () => {
      const res = await getReportFilterOptions(effectiveCodes, {
        from: windowRange.from,
        to: windowRange.to,
      });
      if (cancelled || !res.success) return;
      setNationalityOptions(res.data.nationalities);
      setAccountTypeOptions(res.data.accountTypes);
    })();
    return () => {
      cancelled = true;
    };
  }, [effectiveCodes, windowRange.from, windowRange.to]);

  const activeColumns = useMemo(
    () => resolveColumns(REPORT_COLUMNS, selectedColumns),
    [selectedColumns],
  );

  const items = data?.items ?? [];

  const visibleUsers = useMemo(() => {
    const rows = [...items].sort((a, b) => {
      const aDate = a.commence_date
        ? new Date(String(a.commence_date)).getTime()
        : 0;
      const bDate = b.commence_date
        ? new Date(String(b.commence_date)).getTime()
        : 0;
      switch (sortBy) {
        case "commence-asc":
          return aDate - bDate;
        case "name-asc":
          return `${a.first_name ?? ""} ${a.last_name ?? ""}`.localeCompare(
            `${b.first_name ?? ""} ${b.last_name ?? ""}`,
          );
        case "name-desc":
          return `${b.first_name ?? ""} ${b.last_name ?? ""}`.localeCompare(
            `${a.first_name ?? ""} ${a.last_name ?? ""}`,
          );
        case "membership-asc":
          return String(a.membership_number ?? "").localeCompare(
            String(b.membership_number ?? ""),
          );
        case "membership-desc":
          return String(b.membership_number ?? "").localeCompare(
            String(a.membership_number ?? ""),
          );
        case "commence-desc":
        default:
          return bDate - aDate;
      }
    });
    return rows.map((u) => ({
      ...u,
      campaign: campaignForCode(u.signup_promo_code),
    }));
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [items, sortBy, codeToCampaigns]);

  const getExportData = async (signal: AbortSignal) => {
    const all: PromoCodeUserRow[] = [];
    const exportPageSize = 1000;
    let p = 1;
    let totalPages = 1;
    do {
      if (signal.aborted) {
        throw new DOMException("Export cancelled", "AbortError");
      }
      const res = await withTimeout(
        getReportUsers(effectiveCodes, {
          page: p,
          pageSize: exportPageSize,
          search: search.trim() || undefined,
          loggedIn: loggedInOnly || undefined,
          from: windowRange.from,
          to: windowRange.to,
          country: countrySel.length ? countrySel : undefined,
          status:
            statusFilter && statusFilter !== "all"
              ? (statusFilter as "active" | "inactive")
              : undefined,
          nationality: nationalityFilter.length ? nationalityFilter : undefined,
          ...accountStatus.scope,
          accountType: accountTypeForQuery,
          dobFrom: toYMD(dobRange[0]),
          dobTo: toYMD(dobRange[1]),
          includeTotal: p === 1,
        }),
      );
      if (!res.success) {
        throw new Error(res.message || "Failed to load report");
      }
      if (p === 1) {
        if (res.data.pagination.total > MAX_EXPORT_ROWS) {
          throw new ExportLimitError(res.data.pagination.total);
        }
        totalPages = res.data.pagination.totalPages || 1;
      }
      all.push(...res.data.items);
      p += 1;
    } while (p <= totalPages);

    const enriched = all.map((u) => ({
      ...u,
      campaign: campaignForCode(u.signup_promo_code),
    }));
    return buildExportSheet("Report", activeColumns, enriched);
  };

  const total = data?.pagination.total ?? 0;
  const totalPages = data?.pagination.totalPages ?? 1;
  const hasConfig = activeColumns.length > 0;

  const statTiles = useMemo<StatTileSpec[]>(() => {
    const paint = seriesPalette(4);
    const tiles: StatTileSpec[] = [
      {
        key: "matched",
        label: "Members matched",
        value: total,
        icon: <IconUsers size={17} />,
        color: paint[0].from,
        colorTo: paint[0].to,
        hint:
          grandTotal !== null && grandTotal !== total
            ? `of ${grandTotal.toLocaleString()} total`
            : "Current filters",
        percent:
          grandTotal !== null && grandTotal > 0
            ? (total / grandTotal) * 100
            : undefined,
      },
      {
        key: "columns",
        label: "Columns",
        value: activeColumns.length,
        icon: <IconCalendarStats size={17} />,
        color: paint[1].from,
        colorTo: paint[1].to,
        hint: hasConfig ? "Included in export" : "Pick at least one",
      },
      {
        key: "scope",
        label: "Codes in scope",
        value: selectedCodes.length,
        icon: <IconWorld size={17} />,
        color: paint[2].from,
        colorTo: paint[2].to,
        hint:
          selectedCodes.length === 0 && selectedCampaigns.length === 0
            ? "All promo codes"
            : selectedCampaigns.length > 0
              ? `plus ${selectedCampaigns.length} campaign${selectedCampaigns.length === 1 ? "" : "s"}`
              : "Picked in setup",
      },
    ];
    if (loggedInOnly) {
      tiles.push({
        key: "logged-in-only",
        label: "Logged in only",
        value: total,
        icon: <IconLogin size={17} />,
        color: paint[3].from,
        colorTo: paint[3].to,
        hint: "Restriction active",
      });
    }
    return tiles;
  }, [
    total,
    grandTotal,
    activeColumns.length,
    hasConfig,
    selectedCodes.length,
    selectedCampaigns.length,
    loggedInOnly,
    seriesPalette,
  ]);

  const displayCount = data ? total : null;

  return (
    <Stack gap="lg">
      <Group justify="space-between" align="center">
        <Group gap="sm">
          <Title order={4}>Members report</Title>
          <InfoHint
            width={340}
            ariaLabel="About the members report"
            label="Build a flexible user report: pick one or more promo codes, choose which columns to include, then export."
          />
          {grandTotal !== null && (
            <Badge variant="light" size="lg">
              <AnimatedNumber value={grandTotal} /> user
              {grandTotal === 1 ? "" : "s"}
            </Badge>
          )}
        </Group>
        <Group gap="xs" align="center">
          <FilterTrigger
            activeCount={filterChips.filter((c) => c.onRemove).length}
            onClick={() => setFiltersOpen(true)}
          />
          <ExportButton
            label="Export Report"
            filename="promo-code-report"
            getData={getExportData}
            section="reports"
          />
        </Group>
      </Group>

      {codesError && (
        <Alert color="red" variant="light">
          {codesError}
        </Alert>
      )}

      <FilterPanel title="Report setup" storageKey="reports.members.setup.open">
        <MultiSelect
          label="Campaign / Group"
          placeholder={
            selectedCampaigns.length
              ? undefined
              : "All codes — pick a campaign or group to filter"
          }
          data={campaignPickerData}
          value={selectedCampaigns}
          onChange={setSelectedCampaigns}
          searchable
          clearable
          hidePickedOptions
          rightSection={
            mapLoading || !codesByType || referralSignups === null ? (
              <Loader size="xs" />
            ) : undefined
          }
          nothingFoundMessage={
            mapLoading ? "Loading…" : "No matching campaign or group"
          }
          description="Everything selected is included, combined with any promo codes below. Leave empty for all codes."
        />

        <MultiSelect
          label="Promo codes"
          placeholder={
            selectedCodes.length
              ? undefined
              : "All members — pick codes to filter"
          }
          data={pickerData}
          value={selectedCodes}
          onChange={setSelectedCodes}
          searchable
          searchValue={codeSearch}
          onSearchChange={setCodeSearch}
          filter={({ options }) => options}
          clearable
          limit={100}
          rightSection={codesLoading ? <Loader size="xs" /> : undefined}
          nothingFoundMessage={
            codesLoading ? "Searching…" : "No matching promo code"
          }
          description="Leave empty to include all members; select one or more codes to filter."
        />

        <ColumnArranger
          columns={REPORT_COLUMNS}
          selected={selectedColumns}
          onChange={setSelectedColumns}
        />

        <Switch
          label="Logged-in users only"
          checked={loggedInOnly}
          onChange={(e) => setLoggedInOnly(e.currentTarget.checked)}
        />
      </FilterPanel>

      <ActiveFilterChips chips={filterChips} onReset={resetFilters} />

      <PageSection>
        <StatTiles tiles={statTiles} loading={loading && !data} />
      </PageSection>

      <FilterDrawer
        opened={filtersOpen}
        onClose={() => setFiltersOpen(false)}
        activeCount={filterChips.filter((c) => c.onRemove).length}
        onReset={resetFilters}
      >
        <FilterSection
          icon={<IconCalendarStats size={15} />}
          title="Acquisition window"
          description="Applies to the whole dataset, not just this page."
        >
          <SignupWindowControl
            value={signupWindow}
            onChange={setSignupWindow}
            label="Date of Acquisition"
          />
        </FilterSection>

        <FilterSection
          icon={<IconWorld size={15} />}
          title="Member"
          description="Country, status, nationality and account type."
        >
          <CountryMultiSelect
            value={countrySel}
            onChange={setCountrySel}
            options={countryOptions}
          />
          <Select
            label="Promo Code Status"
            value={statusFilter ?? "all"}
            onChange={(v) => setStatusFilter(v ?? "all")}
            allowDeselect={false}
            data={[
              { value: "all", label: "All" },
              { value: "active", label: "Active" },
              { value: "inactive", label: "Non-active" },
            ]}
          />
          {accountStatus.control}
          <SelectAllMultiSelect
            label="Nationality"
            placeholder="Any nationality"
            value={nationalityFilter}
            onChange={setNationalityFilter}
            options={nationalityOptions}
          />
          <MultiSelect
            label="Account type"
            placeholder={
              accountTypeFilter.length ? undefined : "Any account type"
            }
            value={accountTypeFilter}
            onChange={setAccountTypeFilter}
            data={accountTypeOptions.map((c) => ({ value: c, label: c }))}
            clearable
            searchable
            hidePickedOptions
            description="Leave empty to include every type the promo codes grant."
          />
        </FilterSection>

        <FilterSection
          icon={<IconCake size={15} />}
          title="Date of birth"
          description="Bounds on the member's date of birth."
          withDivider={false}
        >
          <Stack gap={4}>
            <Text size="sm" fw={500}>
              Date of birth
            </Text>
            <Group gap="xs" grow>
              <DatePickerInput
                placeholder="From"
                maxDate={dobRange[1] ? new Date(dobRange[1]) : new Date()}
                value={dobRange[0] ? new Date(dobRange[0]) : null}
                onChange={(val) =>
                  setDobRange(([_, end]) => [val as Date | null, end])
                }
                clearable
                valueFormat="DD MMM YYYY"
              />
              <DatePickerInput
                placeholder="To"
                minDate={dobRange[0] ? new Date(dobRange[0]) : undefined}
                maxDate={new Date()}
                value={dobRange[1] ? new Date(dobRange[1]) : null}
                onChange={(val) =>
                  setDobRange(([start]) => [start, val as Date | null])
                }
                clearable
                valueFormat="DD MMM YYYY"
              />
            </Group>
          </Stack>
        </FilterSection>
      </FilterDrawer>

      <Card className={promoStyles.sectionCard} p="lg">
        <Group gap="sm" align="center" mb="sm">
          <Text fw={700} size="lg">
            Members {displayCount !== null ? `(${displayCount})` : ""}
          </Text>
          {loading && <Loader size="xs" />}
        </Group>
        <Group
          gap="sm"
          align="center"
          justify="space-between"
          wrap="wrap"
          mb="md"
        >
          <TextInput
            placeholder="Name, email, membership # or phone…"
            leftSection={<IconSearch size={16} />}
            value={search}
            onChange={(e) => setSearch(e.currentTarget.value)}
            style={{ flex: 1, minWidth: 240, maxWidth: 360 }}
          />
          <Select
            size="sm"
            variant="filled"
            w={200}
            value={sortBy ?? "commence-desc"}
            onChange={(v) => setSortBy(v ?? "commence-desc")}
            allowDeselect={false}
            data={[
              { value: "commence-desc", label: "Newest joined" },
              { value: "commence-asc", label: "Oldest joined" },
              { value: "name-asc", label: "Name (A–Z)" },
              { value: "name-desc", label: "Name (Z–A)" },
              { value: "membership-asc", label: "Membership # (ascending)" },
              { value: "membership-desc", label: "Membership # (descending)" },
            ]}
          />
        </Group>

        {error && (
          <Alert color="red" variant="light" mb="md">
            {error}
          </Alert>
        )}

        {!hasConfig ? (
          <Text c="dimmed" ta="center" py="xl">
            Select at least one column to preview the report.
          </Text>
        ) : (
          <ReportPreview
            activeColumns={activeColumns}
            rows={visibleUsers}
            loading={loading}
            rowKey={(u, idx) => String(u.membership_number ?? idx)}
            onRowClick={(u) => openMember(u)}
            emptyMessage="No members match the current filters."
            total={total}
            page={page}
            totalPages={totalPages}
            pageSize={pageSize}
            onPageChange={(p) => {
              setPage(p);
              void loadPreview(p);
            }}
            onPageSizeChange={setPageSize}
            pageSizeOptions={PAGE_SIZE_OPTIONS}
            showFooter={Boolean(data)}
          />
        )}
      </Card>
    </Stack>
  );
}
