import {
  ActionIcon,
  Alert,
  Anchor,
  Badge,
  Card,
  Center,
  Collapse,
  Grid,
  Group,
  Loader,
  SimpleGrid,
  ScrollArea,
  Stack,
  Switch,
  Table,
  Text,
  TextInput,
  Title,
} from "@mantine/core";
import {
  IconAlertTriangle,
  IconArrowLeft,
  IconSearch,
  IconUserQuestion,
  IconChevronDown,
  IconChevronRight,
} from "@tabler/icons-react";
import { Fragment, useEffect, useMemo, useState } from "react";
import { Link, useLoaderData, useSearchParams } from "react-router";
import {
  PageArrival,
  PageSection,
} from "@/routes/promo-code-campaigns/_components/motion";
import { PromoThemeShell } from "@/routes/promo-code-campaigns/_components/PromoThemeShell";
import { usePromoTheme } from "@/routes/promo-code-campaigns/_components/appearance";
import {
  StatTiles,
  type StatTileSpec,
} from "@/routes/promo-code-campaigns/_components/StatTiles";
import styles from "@/routes/promo-code-campaigns/_components/promo.module.css";
import JourneyStrip, {
  buildJourneyIndex,
} from "@/routes/event-analytics/_components/JourneyStrip";
import TablePaginationFooter from "@/components/TablePaginationFooter";
import { formatRevenue } from "@/lib/export/eventAnalyticsSheets";
import EventExportButton from "../../_components/EventExportButton";
import { buildEventAnalyticsSheets } from "@/lib/export/eventAnalyticsSheets";
import { getMemberDetail } from "@/lib/features/event-analytics/query";
import {
  experienceOrOffer,
  formatDateParam,
  moduleLabel,
  FUNNEL_ORDER,
  eventTypeLabel,
  type MemberDetailResponse,
} from "@/lib/features/event-analytics/types";
import { useSessionStorageState } from "@/hooks/useSessionStorageState";
import { useEventFilters } from "../../_hooks/useEventFilters";
import MemberTimeline from "./_components/MemberTimeline";
import type { loader } from "./page";


const funnelRank = (eventType: string) => {
  const i = FUNNEL_ORDER.indexOf(eventType);
  return i === -1 ? FUNNEL_ORDER.length : i;
};

const RECORDS_PAGE_SIZE = 25;

const fmtDateTime = (record: {
  occurredAt: string | null;
  createdAtRaw: string | null;
}): { date: string; time: string | null } => {
  if (record.occurredAt) {
    const [date, time = ""] = record.occurredAt.split("T");
    return {
      date: formatDateParam(date) ?? date,
      time: time.slice(0, 5) || null,
    };
  }
  return { date: record.createdAtRaw ?? "—", time: null };
};

const BREAKDOWN_MAX_HEIGHT = 260;

const fmtDate = (iso: string | null) =>
  iso ? (formatDateParam(iso.slice(0, 10)) ?? iso.slice(0, 10)) : "—";

const fmtIsoDateTime = (iso: string | null) =>
  iso ? iso.replace("T", " ").slice(0, 19) : "—";

const fmtMoney = (revenue: number | null, currency: string | null) => {
  if (revenue === null) return "—";
  const amount = revenue.toLocaleString("en-US", {
    minimumFractionDigits: 2,
    maximumFractionDigits: 2,
  });
  return currency ? `${currency} ${amount}` : amount;
};

function Field({ label, value }: { label: string; value: string | null }) {
  return (
    <Stack gap={0}>
      <Text size="xs" c="dimmed" tt="uppercase" fw={600}>
        {label}
      </Text>
      <Text size="sm" c={value ? undefined : "dimmed"}>
        {value || "—"}
      </Text>
    </Stack>
  );
}

export default function MemberDetailClientPage() {
  const { memberId, accessScope } = useLoaderData<typeof loader>();
  const { filters, filterRows } = useEventFilters();
  const { series } = usePromoTheme();
  const [searchParams] = useSearchParams();

  const [showCharts] = useSessionStorageState(
    "event-analytics:show-charts",
    true,
  );

  const backTo = `/admin/event-analytics${
    searchParams.toString() ? `?${searchParams}` : ""
  }`;

  const [data, setData] = useState<MemberDetailResponse | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  const [recordSearch, setRecordSearch] = useState("");
  const [foldJourneys, setFoldJourneys] = useState(true);
  const [openJourneys, setOpenJourneys] = useState<Set<string>>(new Set());
  const [recordPage, setRecordPage] = useState(1);
  const [recordPageSize, setRecordPageSize] = useState(RECORDS_PAGE_SIZE);

  const filterKey = JSON.stringify(filters);

  useEffect(() => {
    const controller = new AbortController();
    setLoading(true);
    setError(null);
    void (async () => {
      const res = await getMemberDetail(memberId, filters, {
        signal: controller.signal,
      });
      if (controller.signal.aborted) return;
      if (res?.success) setData(res.data);
      else setError(res?.message || "Could not load this member.");
      setLoading(false);
    })();
    return () => controller.abort();
  }, [memberId, filterKey]);

  const eventTypes = useMemo(
    () =>
      [...(data?.eventTypes ?? [])].sort(
        (a, b) => funnelRank(a.eventType) - funnelRank(b.eventType),
      ),
    [data?.eventTypes],
  );

  const tiles = useMemo<StatTileSpec[]>(() => {
    const palette = series(6);
    const summary = data?.summary;
    const bySource = data?.bySource ?? [];

    const RESORT_SOURCES = ["properties", "hot_deals", "destination"];
    const EXPERIENCE_SOURCES = ["experience"];
    const sumSources = (wanted: string[]) =>
      bySource
        .filter((row) => wanted.includes(row.source))
        .reduce((total, row) => total + row.events, 0);

    const resortEvents = sumSources(RESORT_SOURCES);
    const experienceEvents = sumSources(EXPERIENCE_SOURCES);

    const stepEvents = (eventType: string) =>
      eventTypes.find((row) => row.eventType === eventType)?.events ?? 0;

    const totalEvents = summary?.totalEvents ?? 0;
    const share = (value: number) =>
      totalEvents ? (value / totalEvents) * 100 : 0;

    return [
      {
        key: "all",
        label: "All events",
        value: totalEvents,
        color: palette[0].from,
        colorTo: palette[0].to,
        icon: <Text fw={700}>Σ</Text>,
        hint: `${(summary?.totalPoints ?? 0).toLocaleString("en-US")} points earned`,
      },
      {
        key: "add_to_cart",
        label: eventTypeLabel("add_to_cart"),
        value: stepEvents("add_to_cart"),
        color: palette[1].from,
        colorTo: palette[1].to,
        icon: <Text fw={700}>1</Text>,
        percent: share(stepEvents("add_to_cart")),
      },
      {
        key: "booking_hold_initiated",
        label: eventTypeLabel("booking_hold_initiated"),
        value: stepEvents("booking_hold_initiated"),
        color: palette[2].from,
        colorTo: palette[2].to,
        icon: <Text fw={700}>2</Text>,
        percent: share(stepEvents("booking_hold_initiated")),
      },
      {
        key: "purchase",
        label: eventTypeLabel("purchase"),
        value: stepEvents("purchase"),
        color: palette[3].from,
        colorTo: palette[3].to,
        icon: <Text fw={700}>3</Text>,
        percent: share(stepEvents("purchase")),
      },
      {
        key: "resort",
        label: "Resort",
        value: resortEvents,
        color: palette[4].from,
        colorTo: palette[4].to,
        icon: <Text fw={700}>⌂</Text>,
        percent: share(resortEvents),
        hint: "Properties, hot deals and destinations",
      },
      {
        key: "experience",
        label: "Experience",
        value: experienceEvents,
        color: palette[5].from,
        colorTo: palette[5].to,
        icon: <Text fw={700}>✦</Text>,
        percent: share(experienceEvents),
        hint: "Curated experiences",
      },
    ];
  }, [data, eventTypes, series]);

  const funnelTiles = useMemo(
    () =>
      tiles.filter((tile) =>
        ["all", "add_to_cart", "booking_hold_initiated", "purchase"].includes(
          tile.key,
        ),
      ),
    [tiles],
  );
  const bookedTiles = useMemo(
    () => tiles.filter((tile) => ["resort", "experience"].includes(tile.key)),
    [tiles],
  );

  const filteredRecords = useMemo(() => {
    const all = data?.records ?? [];
    const needle = recordSearch.trim().toLowerCase();
    if (!needle) return all;
    return all.filter((r) =>
      [
        r.eventType,
        r.source,
        r.propertyName,
        r.experienceName,
        r.memberOffer,
        r.occurredAt,
      ].some((v) => v?.toLowerCase().includes(needle)),
    );
  }, [data?.records, recordSearch]);

  useEffect(() => setRecordPage(1), [recordSearch, filterKey, foldJourneys]);

  const supersededBy = useMemo(
    () => buildJourneyIndex(filteredRecords),
    [filteredRecords],
  );

  const visibleRecords = foldJourneys
    ? filteredRecords.filter((record) => !supersededBy.has(record.id))
    : filteredRecords;
  const foldedCount = filteredRecords.length - visibleRecords.length;

  const pagedRecords = visibleRecords.slice(
    (recordPage - 1) * recordPageSize,
    recordPage * recordPageSize,
  );

  const profile = data?.profile ?? null;
  const displayName = profile?.fullName ?? `Member ${memberId}`;
  const filterNote = filterRows
    .filter((r) => r.label !== "Member ID")
    .map((r) => `${r.label}: ${r.value}`)
    .join(" · ");

  const getExportData = async () => {
    const current = data;
    if (!current) throw new Error("Nothing to export yet");
    return buildEventAnalyticsSheets({
      records: current.records,
      members: current.member ? [current.member] : [],
      eventTypes: current.eventTypes,
      summary: current.summary,
      filterRows: [
        { label: "Member", value: `${displayName} (${memberId})` },
        ...filterRows,
      ],
      eventTypeColumns: eventTypes.map((t) => t.eventType),
    });
  };

  return (
    <PromoThemeShell>
      <PageArrival>
        <Stack px={28} py={20} gap="lg">
          <Anchor
            component={Link}
            to={backTo}
            size="sm"
            w="fit-content"
            underline="never"
          >
            <Group gap={4} wrap="nowrap">
              <IconArrowLeft size={15} />
              <span>Back to Event Analytics</span>
            </Group>
          </Anchor>

          <Group justify="space-between" align="flex-start" wrap="wrap">
            <Stack gap={2}>
              <Title order={2}>{displayName}</Title>
              <Text size="sm" c="dimmed">
                Membership number {memberId}
                {filterNote ? ` · ${filterNote}` : ""}
              </Text>
            </Stack>
            <Group gap="sm">
              {data && (
                <EventExportButton
                  label="Export member"
                  filename={`event-analytics-member-${memberId}`}
                  filtersSummary={`Member ${memberId}${filterNote ? ` · ${filterNote}` : ""}`}
                  getData={getExportData}
                  canExport={accessScope.update}
                />
              )}
            </Group>
          </Group>

          {error && (
            <Alert color="red" icon={<IconAlertTriangle size={18} />}>
              {error}
            </Alert>
          )}

          {loading && !data ? (
            <Center py="xl">
              <Loader />
            </Center>
          ) : (
            <>
              {!profile && !loading && (
                <Alert color="yellow" icon={<IconUserQuestion size={18} />}>
                  No member record matched membership number {memberId} in the
                  member database. The event figures below are still accurate.
                </Alert>
              )}

              {data?.recordsTruncated && (
                <Alert color="yellow" icon={<IconAlertTriangle size={18} />}>
                  This member has more events than the page reads. The figures
                  below cover the {data.records.length.toLocaleString("en-US")}{" "}
                  most recent.
                </Alert>
              )}

              {profile && (
                <PageSection>
                  <Card className={styles.sectionCard} p="md">
                    <Stack gap="sm">
                      <Group gap="sm" align="center">
                        <Title order={5}>Member details</Title>
                        {profile.accountStatus && (
                          <Badge
                            variant="light"
                            color={
                              profile.accountStatus.toLowerCase() === "active"
                                ? "teal"
                                : "gray"
                            }
                          >
                            {profile.accountStatus}
                          </Badge>
                        )}
                        {profile.accountType && (
                          <Badge variant="outline">{profile.accountType}</Badge>
                        )}
                      </Group>
                      <SimpleGrid cols={{ base: 1, sm: 2, lg: 4 }} spacing="md">
                        <Field label="Full name" value={profile.fullName} />
                        <Field
                          label="Membership number"
                          value={profile.membershipNumber}
                        />
                        <Field label="Email" value={profile.email} />
                        <Field label="Mobile" value={profile.mobile} />
                        <Field label="Country" value={profile.country} />
                        <Field
                          label="Nationality"
                          value={profile.nationality}
                        />
                        <Field
                          label="Date of birth"
                          value={fmtDate(profile.dateOfBirth)}
                        />
                        <Field
                          label="Member since"
                          value={fmtDate(profile.memberSince)}
                        />
                        <Field
                          label="Signup promo code"
                          value={profile.signupPromoCode}
                        />
                      </SimpleGrid>
                      <Anchor
                        component={Link}
                        to={`/admin/members/${encodeURIComponent(memberId)}?${new URLSearchParams(
                          {
                            from: `/admin/event-analytics/members/${memberId}${
                              searchParams.toString() ? `?${searchParams}` : ""
                            }`,
                            fromLabel: "Event Analytics",
                          },
                        )}`}
                        size="sm"
                      >
                        Open full member record →
                      </Anchor>
                    </Stack>
                  </Card>
                </PageSection>
              )}

              <PageSection>
                <Stack gap="xs">
                  <Text size="xs" c="dimmed" tt="uppercase" fw={700}>
                    Funnel
                  </Text>
                  <StatTiles
                    tiles={funnelTiles}
                    loading={loading && !data}
                    maxCols={4}
                  />
                </Stack>
              </PageSection>

              <PageSection>
                <Stack gap="xs">
                  <Text size="xs" c="dimmed" tt="uppercase" fw={700}>
                    By category
                  </Text>
                  <StatTiles
                    tiles={bookedTiles}
                    loading={loading && !data}
                    maxCols={2}
                  />
                </Stack>
              </PageSection>

              {showCharts && (
                <PageSection>
                  <MemberTimeline byDay={data?.byDay ?? []} />
                </PageSection>
              )}

              <PageSection>
                <Grid gutter="md">
                  <Grid.Col span={{ base: 12, lg: 4 }}>
                    <Card className={styles.sectionCard} p="md" h="100%">
                      <Stack gap="sm">
                        <Title order={5}>By event type</Title>
                        {eventTypes.length === 0 ? (
                          <Text c="dimmed" size="sm">
                            No events in this range.
                          </Text>
                        ) : (
                          <ScrollArea.Autosize mah={BREAKDOWN_MAX_HEIGHT} type="auto">
                            <Table verticalSpacing="xs" stickyHeader>
                              <Table.Thead>
                                <Table.Tr>
                                  <Table.Th>Event</Table.Th>
                                  <Table.Th ta="right">Events</Table.Th>
                                  <Table.Th ta="right">Points</Table.Th>
                                </Table.Tr>
                              </Table.Thead>
                              <Table.Tbody>
                                {eventTypes.map((row) => (
                                  <Table.Tr key={row.eventType}>
                                    <Table.Td>
                                      {eventTypeLabel(row.eventType)}
                                    </Table.Td>
                                    <Table.Td ta="right" className={styles.num}>
                                      {row.events.toLocaleString("en-US")}
                                    </Table.Td>
                                    <Table.Td ta="right" className={styles.num}>
                                      {row.points.toLocaleString("en-US")}
                                    </Table.Td>
                                  </Table.Tr>
                                ))}
                              </Table.Tbody>
                            </Table>
                          </ScrollArea.Autosize>
                        )}
                        <Stack gap={0}>
                          <Text size="xs" c="dimmed" tt="uppercase" fw={600}>
                            Seen
                          </Text>
                          <Text size="sm">
                            {fmtIsoDateTime(data?.summary.firstEventAt ?? null)}{" "}
                            →{" "}
                            {fmtIsoDateTime(data?.summary.lastEventAt ?? null)}
                          </Text>
                        </Stack>
                      </Stack>
                    </Card>
                  </Grid.Col>

                  <Grid.Col span={{ base: 12, lg: 4 }}>
                    <Card className={styles.sectionCard} p="md" h="100%">
                      <Stack gap="sm">
                        <Title order={5}>By property</Title>
                        {(data?.byProperty ?? []).length === 0 ? (
                          <Text c="dimmed" size="sm">
                            No property recorded on these events.
                          </Text>
                        ) : (
                          <ScrollArea.Autosize mah={BREAKDOWN_MAX_HEIGHT} type="auto">
                            <Table verticalSpacing="xs" stickyHeader>
                              <Table.Thead>
                                <Table.Tr>
                                  <Table.Th>Property</Table.Th>
                                  <Table.Th ta="right">Events</Table.Th>
                                  <Table.Th ta="right">Points</Table.Th>
                                </Table.Tr>
                              </Table.Thead>
                              <Table.Tbody>
                                {(data?.byProperty ?? []).map((row) => (
                                  <Table.Tr key={row.property}>
                                    <Table.Td>{row.property}</Table.Td>
                                    <Table.Td ta="right" className={styles.num}>
                                      {row.events.toLocaleString("en-US")}
                                    </Table.Td>
                                    <Table.Td ta="right" className={styles.num}>
                                      {row.points.toLocaleString("en-US")}
                                    </Table.Td>
                                  </Table.Tr>
                                ))}
                              </Table.Tbody>
                            </Table>
                          </ScrollArea.Autosize>
                        )}
                      </Stack>
                    </Card>
                  </Grid.Col>

                  <Grid.Col span={{ base: 12, lg: 4 }}>
                    <Card className={styles.sectionCard} p="md" h="100%">
                      <Stack gap="sm">
                        <Title order={5}>By source</Title>
                        {(data?.bySource ?? []).length === 0 ? (
                          <Text c="dimmed" size="sm">
                            No source recorded on these events.
                          </Text>
                        ) : (
                          <ScrollArea.Autosize mah={BREAKDOWN_MAX_HEIGHT} type="auto">
                            <Table verticalSpacing="xs" stickyHeader>
                              <Table.Thead>
                                <Table.Tr>
                                  <Table.Th>Source</Table.Th>
                                  <Table.Th ta="right">Events</Table.Th>
                                  <Table.Th ta="right">Points</Table.Th>
                                </Table.Tr>
                              </Table.Thead>
                              <Table.Tbody>
                                {(data?.bySource ?? []).map((row) => (
                                  <Table.Tr key={row.source}>
                                    <Table.Td>{moduleLabel(row.source)}</Table.Td>
                                    <Table.Td ta="right" className={styles.num}>
                                      {row.events.toLocaleString("en-US")}
                                    </Table.Td>
                                    <Table.Td ta="right" className={styles.num}>
                                      {row.points.toLocaleString("en-US")}
                                    </Table.Td>
                                  </Table.Tr>
                                ))}
                              </Table.Tbody>
                            </Table>
                          </ScrollArea.Autosize>
                        )}
                        <Stack gap={0}>
                          <Text size="xs" c="dimmed" tt="uppercase" fw={600}>
                            Revenue
                          </Text>
                          <Text size="sm">
                            {formatRevenue(
                              data?.summary.revenueByCurrency ?? [],
                            )}
                          </Text>
                        </Stack>
                      </Stack>
                    </Card>
                  </Grid.Col>
                </Grid>
              </PageSection>

              <PageSection>
                <Stack gap="sm">
                  <Group justify="space-between" align="center" wrap="wrap">
                    <Title order={5}>
                      All events (
                      {visibleRecords.length.toLocaleString("en-US")})
                    </Title>
                    <Group gap="md" align="center">
                      <Switch
                        size="xs"
                        checked={foldJourneys}
                        onChange={(e) =>
                          setFoldJourneys(e.currentTarget.checked)
                        }
                        label="One row per journey"
                      />
                      <TextInput
                        placeholder="Filter these events"
                        leftSection={<IconSearch size={16} />}
                        w={280}
                        value={recordSearch}
                        onChange={(e) => setRecordSearch(e.currentTarget.value)}
                      />
                    </Group>
                  </Group>

                  <Card className={styles.tableCard} p={0}>
                    <Table.ScrollContainer minWidth={860}>
                      <Table
                        highlightOnHover
                        verticalSpacing="sm"
                        horizontalSpacing="md"
                      >
                        <Table.Thead className={styles.tableHead}>
                          <Table.Tr>
                            <Table.Th w={40} />
                            <Table.Th>Created at</Table.Th>
                            <Table.Th>Event</Table.Th>
                            <Table.Th>Journey</Table.Th>
                            <Table.Th>Source</Table.Th>
                            <Table.Th>Channel</Table.Th>
                            <Table.Th>Property</Table.Th>
                            <Table.Th>Experience / offer</Table.Th>
                            <Table.Th ta="right">Points</Table.Th>
                            <Table.Th ta="right">Revenue</Table.Th>
                          </Table.Tr>
                        </Table.Thead>
                        <Table.Tbody>
                          {pagedRecords.map((record) => {
                            const open = openJourneys.has(record.id);
                            return (
                              <Fragment key={record.id}>
                                <Table.Tr>
                                  <Table.Td>
                                    <ActionIcon
                                      variant="subtle"
                                      color="gray"
                                      size="sm"
                                      aria-label={
                                        open ? "Hide journey" : "Show journey"
                                      }
                                      onClick={() =>
                                        setOpenJourneys((prev) => {
                                          const next = new Set(prev);
                                          if (next.has(record.id))
                                            next.delete(record.id);
                                          else next.add(record.id);
                                          return next;
                                        })
                                      }
                                    >
                                      {open ? (
                                        <IconChevronDown size={16} />
                                      ) : (
                                        <IconChevronRight size={16} />
                                      )}
                                    </ActionIcon>
                                  </Table.Td>
                                  <Table.Td style={{ whiteSpace: "nowrap" }}>
                                    {(() => {
                                      const { date, time } =
                                        fmtDateTime(record);
                                      return (
                                        <Stack gap={0}>
                                          <Text size="sm">{date}</Text>
                                          {time && (
                                            <Text size="xs" c="dimmed">
                                              {time}
                                            </Text>
                                          )}
                                        </Stack>
                                      );
                                    })()}
                                  </Table.Td>
                                  <Table.Td>
                                    <Badge variant="light" color="gray">
                                      {eventTypeLabel(record.eventType)}
                                    </Badge>
                                  </Table.Td>
                                  <Table.Td>
                                    <JourneyStrip
                                      record={record}
                                      variant="inline"
                                    />
                                  </Table.Td>
                                  <Table.Td>{moduleLabel(record.source)}</Table.Td>
                                  <Table.Td>
                                    <Text
                                      size="sm"
                                      c={
                                        record.utmSource ? undefined : "dimmed"
                                      }
                                    >
                                      {record.utmSource
                                        ? `${record.utmSource}${record.utmMedium ? ` / ${record.utmMedium}` : ""}`
                                        : "Direct"}
                                    </Text>
                                  </Table.Td>
                                  <Table.Td>
                                    {record.propertyName ?? "—"}
                                  </Table.Td>
                                  <Table.Td>
                                    {experienceOrOffer(record) ?? "—"}
                                  </Table.Td>
                                  <Table.Td ta="right" className={styles.num}>
                                    {record.points === null
                                      ? "—"
                                      : record.points.toLocaleString("en-US")}
                                  </Table.Td>
                                  <Table.Td ta="right">
                                    {fmtMoney(record.revenue, record.currency)}
                                  </Table.Td>
                                </Table.Tr>
                                <Table.Tr>
                                  <Table.Td
                                    colSpan={11}
                                    p={0}
                                    style={{
                                      borderBottom: open ? undefined : "none",
                                    }}
                                  >
                                    <Collapse in={open}>
                                      <JourneyStrip
                                        record={record}
                                        supersededBy={supersededBy.get(
                                          record.id,
                                        )}
                                      />
                                    </Collapse>
                                  </Table.Td>
                                </Table.Tr>
                              </Fragment>
                            );
                          })}
                          {pagedRecords.length === 0 && (
                            <Table.Tr>
                              <Table.Td colSpan={11}>
                                <Text c="dimmed" ta="center" py="md">
                                  {recordSearch
                                    ? "No events match that search."
                                    : "No events for this member in the selected range."}
                                </Text>
                              </Table.Td>
                            </Table.Tr>
                          )}
                        </Table.Tbody>
                      </Table>
                    </Table.ScrollContainer>
                  </Card>

                  <TablePaginationFooter
                    total={visibleRecords.length}
                    page={recordPage}
                    totalPages={Math.max(
                      1,
                      Math.ceil(visibleRecords.length / recordPageSize),
                    )}
                    pageSize={recordPageSize}
                    onPageChange={setRecordPage}
                    onPageSizeChange={(size) => {
                      setRecordPageSize(size);
                      setRecordPage(1);
                    }}
                  />
                </Stack>
              </PageSection>
            </>
          )}
        </Stack>
      </PageArrival>
    </PromoThemeShell>
  );
}
