"use client";

import {
  Card,
  Group,
  Loader,
  MultiSelect,
  Pagination,
  Stack,
  Table,
  Text,
  TextInput,
  Title,
  Tooltip,
} from "@mantine/core";
import { useDebouncedValue } from "@mantine/hooks";
import {
  IconClockCheck,
  IconFlag,
  IconFlagExclamation,
  IconSearch,
  IconSend,
} from "@tabler/icons-react";
import { useCallback, useEffect, useMemo, useState } from "react";
import { useNavigate } from "react-router";
import { BarChart } from "@mantine/charts";
import {
  ActiveFilterChips,
  FilterDrawer,
  FilterSection,
  FilterTrigger,
  type FilterChip,
} from "@/routes/promo-code-campaigns/_components/FilterDrawer";
import {
  StatTiles,
  type StatTileSpec,
} from "@/routes/promo-code-campaigns/_components/StatTiles";
import { listFlags, getFlagStats } from "@/lib/features/kevo/query";
import type {
  KevoFlag,
  KevoFlagCategory,
  KevoFlagSource,
  KevoFlagStatus,
  KevoStats,
} from "@/lib/features/kevo/types";
import {
  CATEGORY_COLOR,
  CATEGORY_LABEL,
  CategoryBadge,
  KARMA,
  SOURCE_LABEL,
  STATUS_LABEL,
  StatusBadge,
  timeAgo,
} from "../_components/kevo.constants";

const PAGE_SIZE = 25;

const CATEGORY_OPTIONS = Object.entries(CATEGORY_LABEL).map(([value, label]) => ({
  value,
  label,
}));
const STATUS_OPTIONS = Object.entries(STATUS_LABEL).map(([value, label]) => ({
  value,
  label,
}));
const SOURCE_OPTIONS = Object.entries(SOURCE_LABEL).map(([value, label]) => ({
  value,
  label,
}));

export default function KevoFlagsClientPage() {
  const navigate = useNavigate();
  const [flags, setFlags] = useState<KevoFlag[]>([]);
  const [total, setTotal] = useState(0);
  const [page, setPage] = useState(1);
  const [loading, setLoading] = useState(true);
  const [stats, setStats] = useState<KevoStats | null>(null);

  const [search, setSearch] = useState("");
  const [debouncedSearch] = useDebouncedValue(search, 350);
  const [categories, setCategories] = useState<string[]>([]);
  const [statuses, setStatuses] = useState<string[]>([]);
  const [sources, setSources] = useState<string[]>([]);
  const [drawerOpen, setDrawerOpen] = useState(false);

  const load = useCallback(async () => {
    setLoading(true);
    const res = await listFlags({
      categories: categories as KevoFlagCategory[],
      statuses: statuses as KevoFlagStatus[],
      sources: sources as KevoFlagSource[],
      search: debouncedSearch || undefined,
      page,
      limit: PAGE_SIZE,
    });
    if (res.success) {
      setFlags(res.data.flags);
      setTotal(res.data.total);
    }
    setLoading(false);
  }, [categories, statuses, sources, debouncedSearch, page]);

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

  useEffect(() => {
    void getFlagStats().then((res) => res.success && setStats(res.data));
  }, []);

  const statusCount = (s: KevoFlagStatus) =>
    stats?.by_status.find((r) => r.status === s)?.count ?? 0;

  const tiles: StatTileSpec[] = [
    {
      key: "new",
      label: "Needs review",
      value: stats ? statusCount("NEW") : null,
      icon: <IconFlagExclamation size={20} />,
      color: statusCount("NEW") > 0 ? KARMA.crit : KARMA.bronze,
      hint: "New flags nobody has looked at",
    },
    {
      key: "in_review",
      label: "In review",
      value: stats ? statusCount("IN_REVIEW") : null,
      icon: <IconFlag size={20} />,
      color: KARMA.bronze,
    },
    {
      key: "routed",
      label: "Routed to ClickUp",
      value: stats ? statusCount("ROUTED") : null,
      icon: <IconSend size={20} />,
      color: KARMA.black,
    },
    {
      key: "resolution",
      label: "Avg resolution (hours)",
      value: stats?.avg_resolution_hours ?? null,
      icon: <IconClockCheck size={20} />,
      color: KARMA.good,
      hint: "From flag creation to a final state",
    },
  ];

  // Weekly stacked bars, one series per category, Karma palette.
  const weeklyData = useMemo(() => {
    if (!stats) return [];
    const byWeek = new Map<string, Record<string, number | string>>();
    for (const row of stats.weekly) {
      const bucket = byWeek.get(row.week) ?? { week: row.week };
      bucket[CATEGORY_LABEL[row.category]] = row.count;
      byWeek.set(row.week, bucket);
    }
    return [...byWeek.values()];
  }, [stats]);

  const chips: FilterChip[] = [
    ...categories.map((v) => ({
      key: `c-${v}`,
      label: CATEGORY_LABEL[v as KevoFlagCategory],
      onRemove: () => setCategories((cur) => cur.filter((x) => x !== v)),
    })),
    ...statuses.map((v) => ({
      key: `s-${v}`,
      label: STATUS_LABEL[v as KevoFlagStatus],
      onRemove: () => setStatuses((cur) => cur.filter((x) => x !== v)),
    })),
    ...sources.map((v) => ({
      key: `src-${v}`,
      label: SOURCE_LABEL[v as KevoFlagSource],
      onRemove: () => setSources((cur) => cur.filter((x) => x !== v)),
    })),
  ];
  const resetFilters = () => {
    setCategories([]);
    setStatuses([]);
    setSources([]);
  };

  return (
    <Stack gap="lg">
      <div>
        <Title order={2}>Kevo flags</Title>
        <Text c="dimmed" size="sm">
          Issues raised in Live Help conversations — by Kevo itself, post-call
          analysis, or the team.
        </Text>
      </div>

      <StatTiles tiles={tiles} loading={!stats} maxCols={4} />

      {weeklyData.length > 0 && (
        <Card radius="lg" withBorder>
          <Text fw={600} size="sm" mb={2}>
            Flags per week
          </Text>
          <Text c="dimmed" size="xs" mb="md">
            Last 12 weeks, by category
          </Text>
          <BarChart
            h={180}
            data={weeklyData}
            dataKey="week"
            type="stacked"
            withLegend
            series={Object.entries(CATEGORY_LABEL).map(([key, label]) => ({
              name: label,
              color: CATEGORY_COLOR[key as KevoFlagCategory],
            }))}
          />
        </Card>
      )}

      <Group justify="space-between" wrap="wrap">
        <TextInput
          placeholder="Search question, entity, reference or conversation id…"
          leftSection={<IconSearch size={16} />}
          value={search}
          onChange={(e) => {
            setSearch(e.currentTarget.value);
            setPage(1);
          }}
          w={{ base: "100%", sm: 360 }}
          radius="xl"
        />
        <FilterTrigger
          activeCount={chips.length}
          onClick={() => setDrawerOpen(true)}
        />
      </Group>
      <ActiveFilterChips chips={chips} onReset={resetFilters} />

      <FilterDrawer
        opened={drawerOpen}
        onClose={() => setDrawerOpen(false)}
        activeCount={chips.length}
        onReset={resetFilters}
      >
        <FilterSection icon={<IconFlag size={15} />} title="Category">
          <MultiSelect
            data={CATEGORY_OPTIONS}
            value={categories}
            onChange={(v) => {
              setCategories(v);
              setPage(1);
            }}
            placeholder="All categories"
            clearable
          />
        </FilterSection>
        <FilterSection icon={<IconFlagExclamation size={15} />} title="Status">
          <MultiSelect
            data={STATUS_OPTIONS}
            value={statuses}
            onChange={(v) => {
              setStatuses(v);
              setPage(1);
            }}
            placeholder="All statuses"
            clearable
          />
        </FilterSection>
        <FilterSection icon={<IconSend size={15} />} title="Source">
          <MultiSelect
            data={SOURCE_OPTIONS}
            value={sources}
            onChange={(v) => {
              setSources(v);
              setPage(1);
            }}
            placeholder="All sources"
            clearable
          />
        </FilterSection>
      </FilterDrawer>

      <Card radius="lg" withBorder p={0}>
        {loading ? (
          <Group justify="center" py={60}>
            <Loader size="sm" color={KARMA.bronze} />
            <Text c="dimmed" size="sm">
              Loading flags…
            </Text>
          </Group>
        ) : flags.length === 0 ? (
          <Stack align="center" py={60} gap={4}>
            <Text fw={600}>No flags match</Text>
            <Text c="dimmed" size="sm">
              Nothing needs attention here right now.
            </Text>
          </Stack>
        ) : (
          <Table.ScrollContainer minWidth={760}>
            <Table highlightOnHover verticalSpacing="sm">
              <Table.Thead>
                <Table.Tr>
                  <Table.Th>Reference</Table.Th>
                  <Table.Th>Category</Table.Th>
                  <Table.Th>Entity</Table.Th>
                  <Table.Th>Member question</Table.Th>
                  <Table.Th>Source</Table.Th>
                  <Table.Th>Status</Table.Th>
                  <Table.Th>Age</Table.Th>
                </Table.Tr>
              </Table.Thead>
              <Table.Tbody>
                {flags.map((flag) => (
                  <Table.Tr
                    key={flag.id}
                    style={{ cursor: "pointer" }}
                    onClick={() => navigate(`/admin/kevo/flags/${flag.reference}`)}
                  >
                    <Table.Td>
                      <Text size="sm" ff="monospace">
                        {flag.reference}
                      </Text>
                    </Table.Td>
                    <Table.Td>
                      <CategoryBadge category={flag.category} />
                    </Table.Td>
                    <Table.Td>
                      <Text size="sm">{flag.entity ?? "–"}</Text>
                    </Table.Td>
                    <Table.Td maw={340}>
                      <Tooltip
                        label={flag.member_question ?? ""}
                        multiline
                        maw={420}
                        disabled={!flag.member_question}
                      >
                        <Text size="sm" lineClamp={1}>
                          {flag.member_question ?? "–"}
                        </Text>
                      </Tooltip>
                    </Table.Td>
                    <Table.Td>
                      <Text size="xs" c="dimmed">
                        {SOURCE_LABEL[flag.source]}
                      </Text>
                    </Table.Td>
                    <Table.Td>
                      <StatusBadge status={flag.status} />
                    </Table.Td>
                    <Table.Td>
                      <Text size="xs" c="dimmed">
                        {timeAgo(flag.created_at)}
                      </Text>
                    </Table.Td>
                  </Table.Tr>
                ))}
              </Table.Tbody>
            </Table>
          </Table.ScrollContainer>
        )}
      </Card>

      {total > PAGE_SIZE && (
        <Group justify="center">
          <Pagination
            value={page}
            onChange={setPage}
            total={Math.ceil(total / PAGE_SIZE)}
            color={KARMA.bronze}
          />
        </Group>
      )}
    </Stack>
  );
}
