import {
  Box,
  Card,
  Grid,
  Group,
  SegmentedControl,
  Skeleton,
  Stack,
  Table,
  Text,
  Title,
  Badge,
  Tooltip as MantineTooltip,
} from "@mantine/core";
import { useMemo, useState, type ReactNode } from "react";
import {
  Area,
  AreaChart,
  CartesianGrid,
  LabelList,
  Line,
  LineChart,
  ResponsiveContainer,
  Tooltip as RechartsTooltip,
  XAxis,
  YAxis,
} from "recharts";
import { usePromoTheme } from "@/routes/promo-code-campaigns/_components/appearance";
import styles from "@/routes/promo-code-campaigns/_components/promo.module.css";
import { CountryCampaignBars } from "@/routes/promo-code-campaigns/_components/charts/CountryCampaignBars";
import ConversionTable from "./ConversionTable";
import {
  eventTypeShortLabel,
  moduleLabel,
  FUNNEL_ORDER,
  eventTypeLabel,
  memberDisplayName,
  type DayActivity,
  type EventSummary,
  type FunnelSummary,
  type MemberAnalyticsRow,
  type PropertyActivity,
  type SourceActivity,
  type SourceFunnel,
} from "@/lib/features/event-analytics/types";

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

const fmtInt = (n: number) => n.toLocaleString("en-US");

function formatElapsed(hours: number): string {
  if (hours < 1) return `${Math.round(hours * 60)}m`;
  if (hours < 48) {
    const h = Math.floor(hours);
    const m = Math.round((hours - h) * 60);
    return m ? `${h}h ${m}m` : `${h}h`;
  }
  return `${(hours / 24).toFixed(1)} days`;
}

type TimeMetric = "points" | "events" | "members";

type FunnelView = "funnel" | "line" | "steps";

type UtmDimension = "source" | "medium";

const TIME_METRIC_LABEL: Record<TimeMetric, string> = {
  points: "Points",
  events: "Events",
  members: "Members",
};

type Props = {
  summary: EventSummary | null;
  byDay: DayActivity[];
  byProperty: PropertyActivity[];
  bySource: SourceActivity[];
  funnelByUtmSource: SourceFunnel[];
  funnelByUtmMedium: SourceFunnel[];
  funnelBySection: SourceFunnel[];
  funnel: FunnelSummary;
  topMembers: MemberAnalyticsRow[];
  loading: boolean;
  onSelectMember: (memberId: string) => void;
};

function DashSection({
  title,
  children,
}: {
  title: string;
  children: ReactNode;
}) {
  return (
    <Stack gap="xs">
      <Title order={4} fw={600}>
        {title}
      </Title>
      {children}
    </Stack>
  );
}

export default function MemberDashboard({
  summary,
  byDay,
  byProperty,
  bySource,
  funnelByUtmSource,
  funnelByUtmMedium,
  funnelBySection,
  funnel,
  topMembers,
  loading,
  onSelectMember,
}: Props) {
  const { series } = usePromoTheme();
  const [timeMetric, setTimeMetric] = useState<TimeMetric>("points");
  const [utmDimension, setUtmDimension] = useState<UtmDimension>("source");
  const [funnelView, setFunnelView] = useState<FunnelView>("line");
  const [hoveredResort, setHoveredResort] = useState<number | null>(null);

  const funnelSteps = useMemo(
    () =>
      funnel.steps.filter(
        (step, i) =>
          i === 0 || step.membersAnyOrder > 0 || step.members > 0,
      ),
    [funnel.steps],
  );

  const colors = useMemo(
    () =>
      series(
        Math.max(3, funnelSteps.length, byProperty.length, bySource.length),
      ),
    [funnelSteps.length, byProperty.length, bySource.length, series],
  );

  const leaderboard = useMemo(
    () =>
      topMembers.slice(0, 8).map((m) => ({
        name: memberDisplayName(m),
        memberId: m.memberId,
        points: m.points,
        events: m.events,
      })),
    [topMembers],
  );

  const properties = useMemo(() => byProperty.slice(0, 8), [byProperty]);

  const lineData = useMemo(
    () =>
      funnelSteps.map((step) => ({
        step: eventTypeShortLabel(step.eventType),
        fullStep: eventTypeLabel(step.eventType),
        members: step.members,
        anyOrder: step.membersAnyOrder,
      })),
    [funnelSteps],
  );

  const resortBarData = useMemo(
    () =>
      properties.map((row) => ({
        resort: row.property.replace(/^karma\s+/i, "") || row.property,
        Members: row.members,
        events: row.events,
      })),
    [properties],
  );

  const resortSeries = useMemo(() => {
    const [paint] = series(1);
    return [
      {
        key: "members",
        name: "Members",
        color: paint.from,
        colorTo: paint.to,
      },
    ];
  }, [series]);

  const busiestMember = useMemo(
    () => Math.max(0, ...topMembers.map((m) => m.events)),
    [topMembers],
  );

  const moduleRows = useMemo(() => {
    const byKey = new Map(funnelBySection.map((row) => [row.key, row]));

    for (const item of bySource) {
      if (byKey.has(item.source)) continue;
      byKey.set(item.source, {
        key: item.source,
        journeys: 0,
        stoppedAtCart: 0,
        stoppedAtHold: 0,
        purchased: 0,
        conversionPct: 0,
        members: item.members,
        events: item.events,
        points: item.points,
        revenueByCurrency: [],
        medianHoursToPurchase: null,
      });
    }

    return [...byKey.values()].sort(
      (a, b) => b.purchased - a.purchased || b.events - a.events,
    );
  }, [funnelBySection, bySource]);

  if (loading && !summary) {
    return (
      <Grid gutter="md">
        {[0, 1, 2, 3].map((i) => (
          <Grid.Col key={i} span={{ base: 12, lg: 6 }}>
            <Skeleton h={260} radius="md" />
          </Grid.Col>
        ))}
      </Grid>
    );
  }

  const basisNoun = funnel.basis === "journey" ? "journeys" : "members";
  const membersInRange = summary?.uniqueMembers ?? 0;
  const smallSample = funnel.entered < 10;
  const completed = funnelSteps.length
    ? (funnelSteps[funnelSteps.length - 1]?.members ?? 0)
    : 0;
  const endToEndAccent =
    colors[Math.max(0, funnelSteps.length - 1)]?.from ??
    "var(--mantine-color-teal-6)";

  return (
    <Stack gap="xl">
      <DashSection title="">
        <Grid gutter="md">
          <Grid.Col span={{ base: 12, lg: 6 }}>
            <Card className={styles.sectionCard} p="md" h="100%">
              <Stack gap="sm">
                <Stack gap={0}>
                  <Group
                    gap="xs"
                    align="center"
                    justify="space-between"
                    wrap="nowrap"
                  >
                    <Group gap="xs" align="center" wrap="nowrap">
                      <Title order={5}>
                        {funnel.basis === "journey"
                          ? "Conversion funnel"
                          : "Member funnel"}
                      </Title>
                      <MantineTooltip
                        withArrow
                        multiline
                        w={300}
                        label={
                          funnel.basis === "journey"
                            ? "One row per booking attempt, correlated by journeyId. A cart and a purchase count as a conversion only if they belong to the same attempt."
                            : "One row per member who did both steps in order. The app does not yet send a journeyId, so two separate attempts by one person cannot be told apart and any later purchase redeems any earlier cart — this over-counts."
                        }
                      >
                        <Badge
                          size="xs"
                          variant="light"
                          color={funnel.basis === "journey" ? "teal" : "yellow"}
                          style={{ cursor: "help" }}
                        >
                          {funnel.basis === "journey"
                            ? "by journey"
                            : "by member"}
                        </Badge>
                      </MantineTooltip>
                    </Group>
                    <SegmentedControl
                      size="xs"
                      value={funnelView}
                      onChange={(v) => setFunnelView(v as FunnelView)}
                      data={[
                        { value: "funnel", label: "Funnel" },
                        { value: "line", label: "Line" },
                        { value: "steps", label: "Steps" },
                      ]}
                    />
                  </Group>
                </Stack>

                {funnelSteps.length === 0 ? (
                  <Text c="dimmed" size="sm">
                    No events in this range.
                  </Text>
                ) : funnelView === "steps" ? (
                  <Table.ScrollContainer minWidth={560}>
                    <Table verticalSpacing="sm" horizontalSpacing="md">
                      <Table.Thead className={styles.tableHead}>
                        <Table.Tr>
                          <Table.Th>Step</Table.Th>
                          <Table.Th ta="right">Reached</Table.Th>
                          <Table.Th ta="right">Entered here</Table.Th>
                          <Table.Th ta="right">Dropped</Table.Th>
                          <Table.Th ta="right">Conversion</Table.Th>
                          <Table.Th ta="right">Median</Table.Th>
                        </Table.Tr>
                      </Table.Thead>
                      <Table.Tbody>
                        {funnelSteps.map((step, i) => {
                          const previous = i > 0 ? funnelSteps[i - 1] : null;
                          const enteredHere = Math.max(
                            0,
                            step.membersAnyOrder - step.members,
                          );
                          const dropped = previous
                            ? Math.max(0, previous.members - step.members)
                            : 0;
                          return (
                            <Table.Tr key={step.eventType}>
                              <Table.Td>
                                {eventTypeLabel(step.eventType)}
                              </Table.Td>
                              <Table.Td ta="right" className={styles.num}>
                                {fmtInt(step.members)}
                              </Table.Td>
                              <Table.Td
                                ta="right"
                                className={styles.num}
                                c={enteredHere ? undefined : "dimmed"}
                              >
                                {enteredHere ? `+${fmtInt(enteredHere)}` : "—"}
                              </Table.Td>
                              <Table.Td
                                ta="right"
                                className={styles.num}
                                c={dropped ? undefined : "dimmed"}
                              >
                                {previous ? fmtInt(dropped) : "—"}
                              </Table.Td>
                              <Table.Td ta="right" className={styles.num}>
                                {step.conversionPct === null
                                  ? "—"
                                  : smallSample && previous
                                    ? `${fmtInt(step.members)}/${fmtInt(previous.members)}`
                                    : `${step.conversionPct.toFixed(1)}%`}
                              </Table.Td>
                              <Table.Td ta="right" className={styles.num}>
                                {step.medianHoursFromPrevious === null
                                  ? "—"
                                  : formatElapsed(step.medianHoursFromPrevious)}
                              </Table.Td>
                            </Table.Tr>
                          );
                        })}
                      </Table.Tbody>
                    </Table>
                  </Table.ScrollContainer>
                ) : funnelView === "line" ? (
                  <Stack gap="xs">
                    <Box style={{ height: 248 }}>
                      <ResponsiveContainer width="100%" height="100%">
                        <LineChart
                          data={lineData}
                          margin={{ top: 18, right: 16, bottom: 12, left: 0 }}
                        >
                          <CartesianGrid
                            strokeDasharray="3 3"
                            vertical={false}
                            opacity={0.25}
                          />
                          <XAxis
                            dataKey="step"
                            tick={{ fontSize: 11 }}
                            interval={0}
                            tickLine={false}
                            padding={{ left: 20, right: 20 }}
                            height={42}
                            label={{
                              value: "Funnel step",
                              position: "insideBottom",
                              offset: -2,
                              fontSize: 11,
                              fill: "var(--mantine-color-dimmed)",
                            }}
                          />
                          <YAxis
                            allowDecimals={false}
                            tick={{ fontSize: 11 }}
                            tickLine={false}
                            axisLine={false}
                            width={48}
                            label={{
                              value: "Members reached",
                              angle: -90,
                              position: "insideLeft",
                              fontSize: 11,
                              fill: "var(--mantine-color-dimmed)",
                              style: { textAnchor: "middle" },
                            }}
                          />
                          <RechartsTooltip
                            contentStyle={{ fontSize: 12, borderRadius: 8 }}
                            labelFormatter={(_label, payload) =>
                              (payload?.[0]?.payload as { fullStep?: string })
                                ?.fullStep ?? String(_label)
                            }
                            formatter={(value, name) =>
                              [fmtInt(Number(value)), String(name)] as [
                                string,
                                string,
                              ]
                            }
                          />
                          <Line
                            type="monotone"
                            dataKey="anyOrder"
                            name="Any order"
                            stroke="var(--mantine-color-dimmed)"
                            strokeDasharray="5 4"
                            strokeWidth={1.5}
                            dot={{ r: 3 }}
                          />
                          <Line
                            type="monotone"
                            dataKey="members"
                            name="In sequence"
                            stroke={endToEndAccent}
                            strokeWidth={2.5}
                            dot={{ r: 5, strokeWidth: 2, fill: "#fff" }}
                            activeDot={{ r: 7 }}
                          >
                            <LabelList
                              dataKey="members"
                              position="top"
                              offset={10}
                              style={{ fontSize: 12, fontWeight: 700 }}
                            />
                          </Line>
                        </LineChart>
                      </ResponsiveContainer>
                    </Box>

                    <Group gap="lg" justify="center">
                      <Group gap={6} wrap="nowrap">
                        <Box
                          style={{
                            width: 16,
                            height: 3,
                            borderRadius: 2,
                            background: endToEndAccent,
                          }}
                        />
                        <Text size="xs" c="dimmed">
                          Reached in sequence
                        </Text>
                      </Group>
                      <Group gap={6} wrap="nowrap">
                        <Box
                          style={{
                            width: 16,
                            height: 0,
                            borderTop: "2px dashed var(--mantine-color-dimmed)",
                          }}
                        />
                        <Text size="xs" c="dimmed">
                          Any {basisNoun} with the event
                        </Text>
                      </Group>
                    </Group>

                    {funnelSteps.length > 1 && (
                      <Group
                        justify="space-between"
                        align="center"
                        p="sm"
                        style={{
                          borderRadius: "var(--mantine-radius-md)",
                          background: `color-mix(in srgb, ${endToEndAccent} 12%, transparent)`,
                          border: `1px solid color-mix(in srgb, ${endToEndAccent} 35%, transparent)`,
                        }}
                      >
                        <Stack gap={0}>
                          <Text size="xs" c="dimmed" tt="uppercase" fw={700}>
                            Completed every step
                          </Text>
                          <Text size="xs" c="dimmed">
                            {completed === 0
                              ? `None of the ${fmtInt(funnel.entered)} ${basisNoun} that entered`
                              : `${fmtInt(completed)} of ${fmtInt(
                                  funnel.entered,
                                )} ${basisNoun} that entered`}
                          </Text>
                        </Stack>
                        <Text fz={24} fw={800} lh={1} className={styles.num}>
                          {smallSample
                            ? `${fmtInt(completed)}/${fmtInt(funnel.entered)}`
                            : `${funnel.completionPct.toFixed(1)}%`}
                        </Text>
                      </Group>
                    )}
                  </Stack>
                ) : (
                  <Stack gap={2}>
                    {funnelSteps.map((row, i) => {
                      const share = funnel.entered
                        ? (row.members / funnel.entered) * 100
                        : 0;
                      const accent =
                        colors[i]?.from ?? "var(--mantine-color-teal-6)";
                      const accentTo = colors[i]?.to ?? accent;
                      const previous = i > 0 ? funnelSteps[i - 1] : null;
                      const dropped = previous
                        ? Math.max(0, previous.members - row.members)
                        : 0;
                      const width = row.members > 0 ? Math.max(share, 18) : 0;

                      return (
                        <Box key={row.eventType}>
                          {previous && (
                            <Group
                              justify="center"
                              gap={6}
                              wrap="nowrap"
                              py={6}
                            >
                              <Text
                                size="xs"
                                fw={700}
                                c={dropped ? "red.6" : "teal.6"}
                              >
                                {dropped === 0
                                  ? `all ${fmtInt(previous.members)} continued`
                                  : row.members === 0
                                    ? `all ${fmtInt(previous.members)} stopped here`
                                    : `${fmtInt(row.members)} of ${fmtInt(
                                        previous.members,
                                      )} continued · ${fmtInt(dropped)} stopped`}
                              </Text>
                              {!smallSample && row.conversionPct !== null && (
                                <Text size="xs" c="dimmed">
                                  ({row.conversionPct.toFixed(1)}%)
                                </Text>
                              )}
                              {row.medianHoursFromPrevious !== null && (
                                <Text size="xs" c="dimmed">
                                  · {formatElapsed(row.medianHoursFromPrevious)}
                                </Text>
                              )}
                            </Group>
                          )}

                          <MantineTooltip
                            withArrow
                            label={
                              row.members === row.membersAnyOrder
                                ? `${fmtInt(row.members)} ${basisNoun}`
                                : `${fmtInt(row.members)} in sequence · ${fmtInt(
                                    row.membersAnyOrder,
                                  )} with any ${eventTypeLabel(row.eventType)} event`
                            }
                          >
                            <Box
                              style={{
                                height: 54,
                                display: "flex",
                                alignItems: "center",
                                justifyContent: "center",
                                borderRadius: "var(--mantine-radius-md)",
                                border:
                                  "1px dashed var(--mantine-color-default-border)",
                                cursor: "help",
                              }}
                            >
                              {width > 0 ? (
                                <Group
                                  justify="space-between"
                                  wrap="nowrap"
                                  px={14}
                                  style={{
                                    width: `${width}%`,
                                    height: "100%",
                                    minWidth: 0,
                                    color: "#fff",
                                    borderRadius: "var(--mantine-radius-md)",
                                    background: `linear-gradient(135deg, ${accent}, ${accentTo})`,
                                    transition: "width 320ms ease",
                                  }}
                                >
                                  <Stack gap={0} style={{ minWidth: 0 }}>
                                    <Text size="sm" fw={700} lineClamp={1}>
                                      {eventTypeLabel(row.eventType)}
                                    </Text>
                                    <Text
                                      size="xs"
                                      style={{ color: "rgba(255,255,255,.8)" }}
                                    >
                                      {i === 0
                                        ? "entered here"
                                        : smallSample
                                          ? `${fmtInt(row.members)} of ${fmtInt(
                                              funnel.entered,
                                            )}`
                                          : `${share.toFixed(1)}%`}
                                    </Text>
                                  </Stack>
                                  <Text
                                    fz={24}
                                    fw={800}
                                    lh={1}
                                    className={styles.num}
                                    style={{ flexShrink: 0 }}
                                  >
                                    {fmtInt(row.members)}
                                  </Text>
                                </Group>
                              ) : (
                                <Group
                                  justify="space-between"
                                  wrap="nowrap"
                                  px={14}
                                  style={{ width: "100%" }}
                                >
                                  <Stack gap={0}>
                                    <Text size="sm" fw={700} c="dimmed">
                                      {eventTypeLabel(row.eventType)}
                                    </Text>
                                    <Text size="xs" c="dimmed">
                                      nobody reached this step
                                    </Text>
                                  </Stack>
                                  <Text fz={24} fw={800} lh={1} c="dimmed">
                                    0
                                  </Text>
                                </Group>
                              )}
                            </Box>
                          </MantineTooltip>
                        </Box>
                      );
                    })}

                    {funnelSteps.length > 1 && (
                      <Group
                        justify="space-between"
                        align="center"
                        mt="xs"
                        p="sm"
                        style={{
                          borderRadius: "var(--mantine-radius-md)",
                          background: `color-mix(in srgb, ${endToEndAccent} 12%, transparent)`,
                          border: `1px solid color-mix(in srgb, ${endToEndAccent} 35%, transparent)`,
                        }}
                      >
                        <Stack gap={0}>
                          <Text size="xs" c="dimmed" tt="uppercase" fw={700}>
                            Completed every step
                          </Text>
                          <Text size="xs" c="dimmed">
                            {completed === 0
                              ? `None of the ${fmtInt(funnel.entered)} ${basisNoun} that entered`
                              : `${fmtInt(completed)} of ${fmtInt(
                                  funnel.entered,
                                )} ${basisNoun} that entered`}
                          </Text>
                        </Stack>
                        <Text fz={24} fw={800} lh={1} className={styles.num}>
                          {smallSample
                            ? `${fmtInt(completed)}/${fmtInt(funnel.entered)}`
                            : `${funnel.completionPct.toFixed(1)}%`}
                        </Text>
                      </Group>
                    )}
                  </Stack>
                )}
              </Stack>
            </Card>
          </Grid.Col>

          <Grid.Col span={{ base: 12, lg: 6 }}>
            <Card className={styles.sectionCard} p="md" h="100%">
              <Stack gap="sm" h="100%">
                <Stack gap={0}>
                  <Title order={5}>Most active members</Title>
                  <Text size="xs" c="dimmed">
                    Ranked by events recorded in this range.
                  </Text>
                </Stack>

                <Group gap="lg" wrap="wrap">
                  <Stack gap={0}>
                    <Text size="xs" c="dimmed" tt="uppercase" fw={600}>
                      Members
                    </Text>
                    <Text fz={20} fw={700} lh={1.2} className={styles.num}>
                      {fmtInt(summary?.uniqueMembers ?? 0)}
                    </Text>
                  </Stack>
                  <Stack gap={0}>
                    <Text size="xs" c="dimmed" tt="uppercase" fw={600}>
                      Events
                    </Text>
                    <Text fz={20} fw={700} lh={1.2} className={styles.num}>
                      {fmtInt(summary?.totalEvents ?? 0)}
                    </Text>
                  </Stack>
                </Group>

                {leaderboard.length === 0 ? (
                  <Text c="dimmed" size="sm">
                    No member activity in this range.
                  </Text>
                ) : (
                  <Stack gap={8}>
                    {leaderboard.map((m, i) => {
                      const width = busiestMember
                        ? Math.max(4, (m.events / busiestMember) * 100)
                        : 0;
                      const accent = colors[i % colors.length] ?? colors[0];

                      return (
                        <Box
                          key={m.memberId ?? m.name}
                          onClick={() =>
                            m.memberId && onSelectMember?.(m.memberId)
                          }
                          style={{
                            cursor: m.memberId ? "pointer" : "default",
                            borderRadius: "var(--mantine-radius-sm)",
                            padding: "2px 4px",
                          }}
                        >
                          <Group
                            justify="space-between"
                            wrap="nowrap"
                            gap="xs"
                            mb={4}
                          >
                            <Group
                              gap={8}
                              wrap="nowrap"
                              style={{ minWidth: 0 }}
                            >
                              <Text
                                size="xs"
                                fw={700}
                                c="dimmed"
                                w={14}
                                ta="right"
                                style={{ flexShrink: 0 }}
                              >
                                {i + 1}
                              </Text>
                              <Text size="sm" fw={600} lineClamp={1}>
                                {m.name}
                              </Text>
                            </Group>
                            <Group
                              gap="xs"
                              wrap="nowrap"
                              style={{ flexShrink: 0 }}
                            >
                              <Text size="xs" c="dimmed">
                                {fmtInt(m.points)} pts
                              </Text>
                              <Text size="sm" fw={700} className={styles.num}>
                                {fmtInt(m.events)}
                              </Text>
                            </Group>
                          </Group>

                          <Box
                            ml={22}
                            style={{
                              height: 6,
                              borderRadius: 999,
                              overflow: "hidden",
                              background: "var(--mantine-color-default-border)",
                            }}
                          >
                            <Box
                              style={{
                                height: "100%",
                                width: `${width}%`,
                                borderRadius: 999,
                                background: `linear-gradient(90deg, ${accent.from}, ${accent.to})`,
                                transition: "width 300ms ease",
                              }}
                            />
                          </Box>
                        </Box>
                      );
                    })}
                  </Stack>
                )}

                {leaderboard.length > 0 && (
                  <Text size="xs" c="dimmed" mt="auto">
                    Select a member to filter the whole page to them.
                  </Text>
                )}
              </Stack>
            </Card>
          </Grid.Col>
        </Grid>
      </DashSection>

      <DashSection title="">
        <Grid gutter="md">
          <Grid.Col span={{ base: 12, lg: 6 }}>
            <Card className={styles.sectionCard} p="md" h="100%">
              <Stack gap="sm">
                <Group justify="space-between" align="center" wrap="wrap">
                  <Stack gap={0}>
                    <Title order={5}>Activity by UTM</Title>
                    <Text size="xs" c="dimmed">
                      {utmDimension === "source"
                        ? "The campaign that brought the member in."
                        : "The medium of that campaign."}
                    </Text>
                  </Stack>
                  <SegmentedControl
                    size="xs"
                    value={utmDimension}
                    onChange={(v) => setUtmDimension(v as UtmDimension)}
                    data={[
                      { value: "source", label: "Source" },
                      { value: "medium", label: "Medium" },
                    ]}
                  />
                </Group>

                <ConversionTable
                  rows={
                    utmDimension === "source"
                      ? funnelByUtmSource
                      : funnelByUtmMedium
                  }
                  label={utmDimension === "source" ? "Source" : "Medium"}
                  emptyMessage="No tagged journeys in this range."
                />
              </Stack>
            </Card>
          </Grid.Col>
          <Grid.Col span={{ base: 12, lg: 6 }}>
            <Card className={styles.sectionCard} p="md" h="100%">
              <Stack gap="sm">
                <Stack gap={0}>
                  <Title order={5}>Activity by module</Title>
                  <Text size="xs" c="dimmed">
                    The module the journey started in.
                  </Text>
                </Stack>

                <ConversionTable
                      rows={moduleRows}
                      label="Module"
                      formatKey={moduleLabel}
                    />
              </Stack>
            </Card>
          </Grid.Col>
        </Grid>
      </DashSection>

      <DashSection title="">
        <Grid gutter="md">
          <Grid.Col span={{ base: 12, lg: 6 }}>
            <Card className={styles.sectionCard} p="md" h="100%">
              <Stack gap="sm">
                <Group justify="space-between" align="center" wrap="wrap">
                  <Stack gap={0}>
                    <Title order={5}>Activity over time</Title>
                    <Text size="xs" c="dimmed">
                      {byDay.length} day{byDay.length === 1 ? "" : "s"} with
                      activity
                    </Text>
                  </Stack>
                  <SegmentedControl
                    size="xs"
                    value={timeMetric}
                    onChange={(value) => setTimeMetric(value as TimeMetric)}
                    data={[
                      { value: "points", label: "Points" },
                      { value: "events", label: "Events" },
                      { value: "members", label: "Members" },
                    ]}
                  />
                </Group>

                {byDay.length === 0 ? (
                  <Text c="dimmed" size="sm">
                    No dated events in this range.
                  </Text>
                ) : (
                  <ResponsiveContainer width="100%" height={240}>
                    <AreaChart
                      data={byDay}
                      margin={{ left: 4, right: 12, top: 8, bottom: 12 }}
                    >
                      <defs>
                        <linearGradient
                          id="memberActivityFill"
                          x1="0"
                          y1="0"
                          x2="0"
                          y2="1"
                        >
                          <stop
                            offset="0%"
                            stopColor={colors[0].from}
                            stopOpacity={0.45}
                          />
                          <stop
                            offset="100%"
                            stopColor={colors[0].to}
                            stopOpacity={0.04}
                          />
                        </linearGradient>
                      </defs>
                      <CartesianGrid
                        strokeDasharray="3 3"
                        vertical={false}
                        opacity={0.4}
                      />
                      <XAxis
                        dataKey="day"
                        fontSize={11}
                        tickLine={false}
                        tickFormatter={(day: string) => day.slice(5)}
                        minTickGap={24}
                        height={38}
                        padding={{ left: 14, right: 14 }}
                        label={{
                          value: "Date",
                          position: "insideBottom",
                          offset: -2,
                          fontSize: 11,
                          fill: "var(--mantine-color-dimmed)",
                        }}
                      />
                      <YAxis
                        fontSize={11}
                        tickLine={false}
                        axisLine={false}
                        allowDecimals={false}
                        width={52}
                        label={{
                          value: TIME_METRIC_LABEL[timeMetric],
                          angle: -90,
                          position: "insideLeft",
                          fontSize: 11,
                          fill: "var(--mantine-color-dimmed)",
                          style: { textAnchor: "middle" },
                        }}
                      />
                      <RechartsTooltip
                        contentStyle={{ fontSize: 12, borderRadius: 8 }}
                        formatter={(value) => [
                          Number(value).toLocaleString("en-US"),
                          TIME_METRIC_LABEL[timeMetric],
                        ]}
                      />
                      <Area
                        type="monotone"
                        dataKey={timeMetric}
                        stroke={colors[0].from}
                        strokeWidth={2}
                        dot={{ r: 3, strokeWidth: 2, fill: "#fff" }}
                        activeDot={{ r: 6 }}
                        fill="url(#memberActivityFill)"
                      />
                    </AreaChart>
                  </ResponsiveContainer>
                )}
              </Stack>
            </Card>
          </Grid.Col>
          <Grid.Col span={{ base: 12, lg: 6 }}>
            <Card className={styles.sectionCard} p="md" h="100%">
              <Stack gap="sm" h="100%">
                <Stack gap={0}>
                  <Title order={5}>Resort Bookings</Title>
                  <Text size="xs" c="dimmed">
                    Distinct members per resort, across every event type.
                  </Text>
                </Stack>

                {properties.length === 0 ? (
                  <Text c="dimmed" size="sm">
                    No property recorded on these events.
                  </Text>
                ) : (
                  <Box style={{ flex: 1 }}>
                    <CountryCampaignBars
                      data={resortBarData}
                      series={resortSeries}
                      xKey="resort"
                      xLabel="Resort"
                      yLabel="Members"
                      height={300}
                      hoveredIndex={hoveredResort}
                      onHoverIndex={setHoveredResort}
                      maxColumns={10}
                    />
                  </Box>
                )}
              </Stack>
            </Card>
          </Grid.Col>
        </Grid>
      </DashSection>
    </Stack>
  );
}
