import {
  Anchor,
  Badge,
  Card,
  Center,
  Checkbox,
  Group,
  Loader,
  Progress,
  SegmentedControl,
  Stack,
  Table,
  Text,
  TextInput,
  Title,
  UnstyledButton,
} from "@mantine/core";
import { IconSearch, IconX } from "@tabler/icons-react";
import { useMemo, useState } from "react";
import {
  Bar,
  BarChart,
  CartesianGrid,
  Cell,
  LabelList,
  ResponsiveContainer,
  Tooltip,
  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 { formatRevenue } from "@/lib/export/eventAnalyticsSheets";
import {
  FUNNEL_ORDER,
  eventTypeLabel,
  type EventTypeAnalyticsResponse,
} from "@/lib/features/event-analytics/types";

const MAX_CHART_BARS = 12;

type Metric = "events" | "uniqueMembers" | "points";

const BAR_ROW_HEIGHT = 42;
const BAR_CHART_CHROME = 56;

const METRIC_LABEL: Record<Metric, string> = {
  events: "Events",
  uniqueMembers: "Members",
  points: "Points",
};

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

type Props = {
  data: EventTypeAnalyticsResponse | null;
  loading: boolean;
  activeEventTypes: string[];
  onToggleEventType: (eventType: string) => void;
  showCharts: boolean;
  selected: string[];
  onSelectedChange: (next: string[]) => void;
  onOpenEvent: (eventType: string) => void;
};

export default function EventAnalytics({
  data,
  loading,
  activeEventTypes,
  onToggleEventType,
  showCharts,
  selected,
  onSelectedChange,
  onOpenEvent,
}: Props) {
  const { series } = usePromoTheme();
  const [search, setSearch] = useState("");
  const [metric, setMetric] = useState<Metric>("events");

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

  const colorByType = useMemo(() => {
    const palette = series(Math.max(1, ordered.length));
    return new Map(ordered.map((row, i) => [row.eventType, palette[i]]));
  }, [ordered, series]);

  const visible = useMemo(() => {
    const needle = search.trim().toLowerCase();
    if (!needle) return ordered;
    return ordered.filter((row) =>
      row.eventType.toLowerCase().includes(needle),
    );
  }, [ordered, search]);

  const selectedSet = new Set(selected);
  const visibleIds = visible.map((r) => r.eventType);
  const allVisibleSelected =
    visibleIds.length > 0 && visibleIds.every((id) => selectedSet.has(id));
  const someVisibleSelected = visibleIds.some((id) => selectedSet.has(id));

  const toggleRow = (eventType: string) =>
    onSelectedChange(
      selectedSet.has(eventType)
        ? selected.filter((id) => id !== eventType)
        : [...selected, eventType],
    );

  const toggleAll = () =>
    onSelectedChange(
      allVisibleSelected
        ? selected.filter((id) => !visibleIds.includes(id))
        : [...new Set([...selected, ...visibleIds])],
    );

  const toolbar = (
    <Group justify="space-between" align="center" wrap="wrap" gap="sm">
      <TextInput
        placeholder="Search by event type"
        leftSection={<IconSearch size={16} />}
        w={280}
        value={search}
        onChange={(e) => setSearch(e.currentTarget.value)}
      />
      {selected.length > 0 && (
        <Group gap="xs">
          <Text size="sm" c="dimmed">
            {selected.length} selected for export
          </Text>
          <UnstyledButton
            onClick={() => onSelectedChange([])}
            aria-label="Clear selection"
          >
            <Group gap={2}>
              <IconX size={13} />
              <Text size="sm">Clear</Text>
            </Group>
          </UnstyledButton>
        </Group>
      )}
    </Group>
  );

  if (loading && !data) {
    return (
      <Center py="xl">
        <Loader size="sm" />
      </Center>
    );
  }

  if (!data || ordered.length === 0) {
    return (
      <Stack gap="sm">
        {toolbar}
        <Card className={styles.sectionCard} p="xl">
          <Text c="dimmed" ta="center">
            No events for these filters.
          </Text>
        </Card>
      </Stack>
    );
  }

  const chartRows = ordered.slice(0, MAX_CHART_BARS).map((r) => ({
    eventType: eventTypeLabel(r.eventType),
    rawType: r.eventType,
    events: r.events,
    uniqueMembers: r.uniqueMembers,
    points: r.points,
  }));
  const hiddenFromChart = ordered.length - chartRows.length;

  const funnelSteps = ordered.filter(
    (r) => funnelRank(r.eventType) < FUNNEL_ORDER.length,
  );
  const showConversion =
    activeEventTypes.length === 0 && funnelSteps.length > 1;

  return (
    <Stack gap="md">
      {toolbar}

      {showCharts && (
        <Card className={styles.sectionCard} p="md">
          <Stack gap="sm">
            <Group justify="space-between" align="center" wrap="wrap">
              <Stack gap={0}>
                <Title order={5}>Events by type</Title>
                {hiddenFromChart > 0 ? (
                  <Text size="xs" c="dimmed">
                    Top {chartRows.length} of {ordered.length} shown — all types
                    are listed in the table.
                  </Text>
                ) : (
                  <Text size="xs" c="dimmed">
                    In funnel order, so the drop-off between steps is visible.
                  </Text>
                )}
              </Stack>
              <SegmentedControl
                size="xs"
                value={metric}
                onChange={(value) => setMetric(value as Metric)}
                data={[
                  { value: "events", label: "Events" },
                  { value: "uniqueMembers", label: "Members" },
                  { value: "points", label: "Points" },
                ]}
              />
            </Group>

            <ResponsiveContainer
              width="100%"
              height={chartRows.length * BAR_ROW_HEIGHT + BAR_CHART_CHROME}
            >
              <BarChart
                data={chartRows}
                layout="vertical"
                margin={{ left: 12, right: 32, top: 4, bottom: 18 }}
                barCategoryGap="28%"
              >
                <CartesianGrid
                  strokeDasharray="3 3"
                  horizontal={false}
                  opacity={0.4}
                />
                <XAxis
                  type="number"
                  allowDecimals={false}
                  fontSize={12}
                  height={38}
                  label={{
                    value: METRIC_LABEL[metric],
                    position: "insideBottom",
                    offset: -2,
                    fontSize: 11,
                    fill: "var(--mantine-color-dimmed)",
                  }}
                />
                <YAxis
                  label={{
                    value: "Event type",
                    angle: -90,
                    position: "insideLeft",
                    fontSize: 11,
                    fill: "var(--mantine-color-dimmed)",
                    style: { textAnchor: "middle" },
                  }}
                  type="category"
                  dataKey="eventType"
                  width={160}
                  fontSize={12}
                  tickLine={false}
                />
                <Tooltip
                  cursor={{ fillOpacity: 0.06 }}
                  formatter={(value) => [
                    Number(value).toLocaleString("en-US"),
                    METRIC_LABEL[metric],
                  ]}
                />
                <Bar dataKey={metric} radius={[0, 6, 6, 0]} maxBarSize={30}>
                  {chartRows.map((row) => (
                    <Cell
                      key={row.rawType}
                      fill={colorByType.get(row.rawType)?.from ?? "#c2a154"}
                      cursor="pointer"
                      onClick={() => onOpenEvent(row.rawType)}
                    />
                  ))}
                  <LabelList
                    dataKey={metric}
                    position="right"
                    fontSize={12}
                    formatter={(v) => Number(v).toLocaleString("en-US")}
                  />
                </Bar>
              </BarChart>
            </ResponsiveContainer>

            {showConversion && (
              <Group gap="lg" wrap="wrap">
                {funnelSteps.slice(1).map((step, i) => {
                  const prev = funnelSteps[i];
                  const from = prev[metric];
                  const pct = from
                    ? Number(((step[metric] / from) * 100).toFixed(1))
                    : 0;
                  return (
                    <Stack key={step.eventType} gap={0}>
                      <Text size="xs" c="dimmed">
                        {eventTypeLabel(prev.eventType)} →{" "}
                        {eventTypeLabel(step.eventType)}
                      </Text>
                      <Text size="sm" fw={700} className={styles.num}>
                        {pct}%
                      </Text>
                    </Stack>
                  );
                })}
              </Group>
            )}
          </Stack>
        </Card>
      )}

      <Card className={styles.tableCard} p={0}>
        <Table.ScrollContainer minWidth={720}>
          <Table highlightOnHover verticalSpacing="sm" horizontalSpacing="md">
            <Table.Thead className={styles.tableHead}>
              <Table.Tr>
                <Table.Th w={40}>
                  <Checkbox
                    size="xs"
                    aria-label="Select every event type shown"
                    checked={allVisibleSelected}
                    indeterminate={someVisibleSelected && !allVisibleSelected}
                    onChange={toggleAll}
                  />
                </Table.Th>
                <Table.Th>Event type</Table.Th>
                <Table.Th ta="right">Events</Table.Th>
                <Table.Th ta="right">Members</Table.Th>
                <Table.Th w={160} />
                <Table.Th w={150}>Share</Table.Th>
                <Table.Th ta="right">Points</Table.Th>
                <Table.Th ta="right">Revenue</Table.Th>
              </Table.Tr>
            </Table.Thead>
            <Table.Tbody>
              {visible.map((row) => {
                const active = activeEventTypes.includes(row.eventType);
                const color = colorByType.get(row.eventType);
                return (
                  <Table.Tr
                    key={row.eventType}
                    bg={
                      selectedSet.has(row.eventType)
                        ? "var(--mantine-primary-color-light)"
                        : undefined
                    }
                  >
                    <Table.Td>
                      <Checkbox
                        size="xs"
                        aria-label={`Select event type ${row.eventType}`}
                        checked={selectedSet.has(row.eventType)}
                        onChange={() => toggleRow(row.eventType)}
                      />
                    </Table.Td>
                    <Table.Td>
                      <Badge
                        variant={active ? "filled" : "light"}
                        style={{
                          cursor: "pointer",
                          backgroundColor: active
                            ? color?.from
                            : `color-mix(in srgb, ${color?.from ?? "#c2a154"} 14%, transparent)`,
                          color: active ? "#fff" : undefined,
                        }}
                        onClick={() => onToggleEventType(row.eventType)}
                      >
                        {eventTypeLabel(row.eventType)}
                      </Badge>
                    </Table.Td>
                    <Table.Td ta="right" className={styles.num}>
                      {row.events.toLocaleString("en-US")}
                    </Table.Td>
                    <Table.Td ta="right" className={styles.num}>
                      {row.uniqueMembers.toLocaleString("en-US")}
                    </Table.Td>
                    <Table.Td style={{ whiteSpace: "nowrap" }}>
                      <Anchor
                        component="button"
                        type="button"
                        size="sm"
                        onClick={() => onOpenEvent(row.eventType)}
                      >
                        View members →
                      </Anchor>
                    </Table.Td>
                    <Table.Td>
                      <Stack gap={2}>
                        <Progress
                          value={row.sharePct}
                          size="sm"
                          color={color?.from ?? "teal"}
                        />
                        <Text size="xs" c="dimmed">
                          {row.sharePct}%
                        </Text>
                      </Stack>
                    </Table.Td>
                    <Table.Td ta="right" className={styles.num}>
                      {row.points.toLocaleString("en-US")}
                    </Table.Td>
                    <Table.Td ta="right">
                      <Text size="sm">
                        {formatRevenue(row.revenueByCurrency)}
                      </Text>
                    </Table.Td>
                  </Table.Tr>
                );
              })}
              {visible.length === 0 && (
                <Table.Tr>
                  <Table.Td colSpan={8}>
                    <Text c="dimmed" ta="center" py="md">
                      No event type matches "{search}".
                    </Text>
                  </Table.Td>
                </Table.Tr>
              )}
            </Table.Tbody>
          </Table>
        </Table.ScrollContainer>
      </Card>
    </Stack>
  );
}
