import {
  duplicateCampaignGroup,
  listCampaignGroups,
  pauseCampaignGroup,
  resumeCampaignGroup,
  type CampaignGroup,
} from "@/lib/features/notifications/action";
import { useSessionStorageState } from "@/hooks/useSessionStorageState";
import {
  ActionIcon,
  Badge,
  Box,
  Button,
  Checkbox,
  Group,
  LoadingOverlay,
  Menu,
  Pagination,
  Popover,
  Stack,
  Table,
  Text,
  TextInput,
} from "@mantine/core";
import { useDebouncedValue } from "@mantine/hooks";
import {
  IconCalendarEvent,
  IconCircleCheck,
  IconColumns3,
  IconStack2,
  IconUsersGroup,
  IconCopy,
  IconDotsVertical,
  IconEdit,
  IconExternalLink,
  IconFolderPlus,
  IconInbox,
  IconPlayerPause,
  IconPlayerPlay,
  IconSearch,
  IconTrash,
} from "@tabler/icons-react";
import type { ReactNode } from "react";
import { useCallback, useEffect, useMemo, useState } from "react";
import { useNavigate } from "react-router";
import styles from "@/routes/promo-code-campaigns/_components/promo.module.css";
import DeleteCampaignModal from "./DeleteCampaignModal";
import {
  countCampaignFilters,
  toListQuery,
  type CampaignFilters,
} from "./CampaignFilterDrawer";
import ThemedStatTiles, { type ThemedTileSpec } from "../ThemedStatTiles";
import ParentCampaignFormModal from "./ParentCampaignFormModal";
import {
  formatDateTime,
  GroupProgress,
  GroupStatusBadge,
  nextStepLabel,
  runGroupAction,
} from "./shared";

const PAGE_SIZE = 10;

type ColumnKey =
  | "tags"
  | "status"
  | "progress"
  | "nextStep"
  | "notifications"
  | "sent"
  | "seen"
  | "createdBy"
  | "created"
  | "updated";

type Column = {
  key: ColumnKey;
  label: string;
  width?: number;
  align?: "left" | "right";
  render: (group: CampaignGroup) => ReactNode;
};

const seenRate = (group: CampaignGroup) =>
  group.totals.sent > 0
    ? ((group.totals.opens / group.totals.sent) * 100).toFixed(1)
    : "0.0";

const COLUMNS: Column[] = [
  {
    key: "tags",
    label: "Tags",
    width: 200,
    render: (g) =>
      g.tags?.length ? (
        <Group gap={4}>
          {g.tags.map((tag) => (
            <Badge
              key={tag.id}
              variant="outline"
              size="sm"
              radius="sm"
              tt="none"
            >
              {tag.name}
            </Badge>
          ))}
        </Group>
      ) : (
        <Text size="xs" c="dimmed">
          —
        </Text>
      ),
  },
  {
    key: "status",
    label: "Status",
    width: 110,
    render: (g) => <GroupStatusBadge status={g.status} />,
  },
  {
    key: "progress",
    label: "Progress",
    width: 220,
    render: (g) => <GroupProgress group={g} size="sm" />,
  },
  {
    key: "nextStep",
    label: "Next step",
    width: 190,
    render: (g) => (
      <Text size="xs" fw={500}>
        {nextStepLabel(g)}
      </Text>
    ),
  },
  {
    key: "notifications",
    label: "Notifications",
    width: 120,
    align: "right",
    render: (g) => (
      <span
        className={styles.dataBadge}
        style={
          {
            "--data-badge-color": "var(--mantine-color-indigo-6)",
          } as React.CSSProperties
        }
      >
        {g.progress.total}
      </span>
    ),
  },
  {
    key: "sent",
    label: "Sent / Audience",
    width: 140,
    align: "right",
    render: (g) => (
      <Text size="sm" fw={600} className={styles.num}>
        {g.totals.sent.toLocaleString()}
        <Text span size="xs" c="dimmed" fw={400}>
          {" "}
          / {g.totals.audience.toLocaleString()}
        </Text>
      </Text>
    ),
  },
  {
    key: "seen",
    label: "Seen",
    width: 110,
    align: "right",
    render: (g) => (
      <Stack gap={0} align="flex-end">
        <Text size="sm" fw={600} className={styles.num}>
          {g.totals.opens.toLocaleString()}
        </Text>
        <Text size="xs" c="dimmed" className={styles.num}>
          {seenRate(g)}%
        </Text>
      </Stack>
    ),
  },
  {
    key: "createdBy",
    label: "Created by",
    width: 180,
    render: (g) => (
      <Text
        size="xs"
        c="dimmed"
        lineClamp={1}
        title={g.created_by ?? undefined}
      >
        {g.created_by || "—"}
      </Text>
    ),
  },
  {
    key: "created",
    label: "Created",
    width: 160,
    render: (g) => (
      <Text size="xs" c="dimmed">
        {formatDateTime(g.created_at)}
      </Text>
    ),
  },
  {
    key: "updated",
    label: "Last updated",
    width: 160,
    render: (g) => (
      <Text size="xs" c="dimmed">
        {formatDateTime(g.updated_at)}
      </Text>
    ),
  },
];

const DEFAULT_HIDDEN: ColumnKey[] = ["createdBy", "updated"];

const countByStatus = (groups: CampaignGroup[], statuses: string[]) =>
  groups.filter((g) => statuses.includes(g.status)).length;

function buildCampaignTiles(
  groups: CampaignGroup[],
  filtered: boolean,
): ThemedTileSpec[] {
  const total = groups.length;
  const notifications = groups.reduce((sum, g) => sum + g.progress.total, 0);
  const sent = groups.reduce((sum, g) => sum + g.totals.sent, 0);
  const audience = groups.reduce((sum, g) => sum + g.totals.audience, 0);
  const share = (n: number) => (total ? (n / total) * 100 : 0);
  const inProgress = countByStatus(groups, ["SENDING", "ACTIVE"]);
  const scheduled = countByStatus(groups, ["SCHEDULED"]);
  const completed = countByStatus(groups, ["COMPLETED"]);
  return [
    {
      key: "campaigns",
      label: "Campaigns",
      value: total,
      icon: <IconStack2 size={18} stroke={1.8} />,
      hint: `${notifications} notification${notifications === 1 ? "" : "s"}${filtered ? " · matching filters" : ""}`,
    },
    {
      key: "in-progress",
      label: "In Progress",
      value: inProgress,
      icon: <IconPlayerPlay size={18} stroke={1.8} />,
      percent: share(inProgress),
      hint: "Sending now or partly sent",
    },
    {
      key: "scheduled",
      label: "Scheduled",
      value: scheduled,
      icon: <IconCalendarEvent size={18} stroke={1.8} />,
      percent: share(scheduled),
      hint: "Waiting for first send",
    },
    {
      key: "completed",
      label: "Completed",
      value: completed,
      icon: <IconCircleCheck size={18} stroke={1.8} />,
      percent: share(completed),
      hint: "Every notification sent",
    },
    {
      key: "reached",
      label: "Members Reached",
      value: sent,
      icon: <IconUsersGroup size={18} stroke={1.8} />,
      percent: audience ? Math.min(100, (sent / audience) * 100) : 0,
      hint: `of ${audience.toLocaleString()} targeted`,
    },
  ];
}

const ParentCampaignTiles: React.FC<{
  refreshKey?: number;
  filters: CampaignFilters;
}> = ({ refreshKey, filters }) => {
  const navigate = useNavigate();
  const [groups, setGroups] = useState<CampaignGroup[]>([]);
  const [loading, setLoading] = useState(true);
  const [search, setSearch] = useState("");
  const [debouncedSearch] = useDebouncedValue(search, 300);
  const filterKey = JSON.stringify(filters);
  const [page, setPage] = useState(1);
  const [toDelete, setToDelete] = useState<CampaignGroup | null>(null);
  const [toEdit, setToEdit] = useState<CampaignGroup | null>(null);
  const [hiddenColumns, setHiddenColumns] = useSessionStorageState<ColumnKey[]>(
    "notifications.campaigns.hiddenColumns",
    DEFAULT_HIDDEN,
  );

  const load = useCallback(async () => {
    setLoading(true);
    try {
      const res = await listCampaignGroups({
        ...toListQuery(JSON.parse(filterKey) as CampaignFilters),
        search: debouncedSearch || undefined,
      });
      if (res.success) setGroups(res.data ?? []);
    } finally {
      setLoading(false);
    }
  }, [debouncedSearch, filterKey]);

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

  useEffect(() => setPage(1), [debouncedSearch, filterKey]);

  const totalPages = Math.max(1, Math.ceil(groups.length / PAGE_SIZE));
  const currentPage = Math.min(page, totalPages);
  const rows = useMemo(
    () => groups.slice((currentPage - 1) * PAGE_SIZE, currentPage * PAGE_SIZE),
    [groups, currentPage],
  );

  const visibleColumns = COLUMNS.filter((c) => !hiddenColumns.includes(c.key));
  const colCount = visibleColumns.length + 2;

  const toggleColumn = (key: ColumnKey) =>
    setHiddenColumns((prev) =>
      prev.includes(key) ? prev.filter((k) => k !== key) : [...prev, key],
    );

  const open = (id: string) => navigate(`groups/${id}`);

  const act = async (fn: () => Promise<any>, msg: string) => {
    if (await runGroupAction(fn, msg)) load();
  };

  const filtered =
    Boolean(debouncedSearch) || countCampaignFilters(filters) > 0;
  const tiles = useMemo(
    () => buildCampaignTiles(groups, filtered),
    [groups, filtered],
  );

  return (
    <>
      <Stack gap="md">
        <ThemedStatTiles
          tiles={tiles}
          loading={loading && groups.length === 0}
        />

        <Group justify="space-between">
          <Group gap="xs">
            <Text fw={700} size="md">
              Campaigns
            </Text>
            {!loading && (
              <Badge variant="light" size="md" radius="sm">
                {groups.length}
              </Badge>
            )}
          </Group>
          <Group gap="xs">
            <TextInput
              placeholder="Search name, description or tag"
              w={260}
              leftSection={<IconSearch size={16} />}
              value={search}
              onChange={(e) => setSearch(e.currentTarget.value)}
            />
            <Popover position="bottom-end" withArrow shadow="md" width={220}>
              <Popover.Target>
                <Button
                  variant="default"
                  leftSection={<IconColumns3 size={16} />}
                >
                  Columns
                </Button>
              </Popover.Target>
              <Popover.Dropdown>
                <Stack gap={8}>
                  <Text size="xs" fw={700} tt="uppercase" c="dimmed">
                    Visible columns
                  </Text>
                  {COLUMNS.map((column) => (
                    <Checkbox
                      key={column.key}
                      size="xs"
                      label={column.label}
                      checked={!hiddenColumns.includes(column.key)}
                      onChange={() => toggleColumn(column.key)}
                    />
                  ))}
                </Stack>
              </Popover.Dropdown>
            </Popover>
            <Button
              variant="light"
              leftSection={<IconFolderPlus size={16} />}
              onClick={() => navigate("groups/new")}
            >
              New Campaign
            </Button>
          </Group>
        </Group>

        <Box pos="relative" className={styles.tableCard}>
          <LoadingOverlay visible={loading} overlayProps={{ blur: 1 }} />
          <Table.ScrollContainer minWidth={900}>
            <Table style={{ borderCollapse: "separate", borderSpacing: 0 }}>
              <Table.Thead className={styles.tableHead}>
                <Table.Tr>
                  <Table.Th className={styles.th}>Name</Table.Th>
                  {visibleColumns.map((column) => (
                    <Table.Th
                      key={column.key}
                      className={styles.th}
                      w={column.width}
                      ta={column.align}
                    >
                      {column.label}
                    </Table.Th>
                  ))}
                  <Table.Th className={styles.th} w={50} />
                </Table.Tr>
              </Table.Thead>
              <Table.Tbody>
                {rows.length === 0 && !loading ? (
                  <Table.Tr>
                    <Table.Td colSpan={colCount} className={styles.emptyCell}>
                      <Stack align="center" gap={6}>
                        <IconInbox size={38} stroke={1.2} opacity={0.3} />
                        <Text c="dimmed" size="sm">
                          {filtered
                            ? "No campaigns match your filters."
                            : "No campaigns yet. Group related notifications under one campaign to track them together."}
                        </Text>
                      </Stack>
                    </Table.Td>
                  </Table.Tr>
                ) : (
                  rows.map((g) => (
                    <Table.Tr
                      key={g.id}
                      className={styles.row}
                      onClick={() => open(g.id)}
                    >
                      <Table.Td maw={320}>
                        <Text
                          fw={700}
                          size="sm"
                          lineClamp={1}
                          title={g.name}
                          style={{
                            color:
                              "var(--promo-accent, var(--mantine-color-indigo-6))",
                          }}
                        >
                          {g.name}
                        </Text>
                        {g.description && (
                          <Text
                            size="xs"
                            c="dimmed"
                            lineClamp={1}
                            title={g.description}
                          >
                            {g.description}
                          </Text>
                        )}
                      </Table.Td>
                      {visibleColumns.map((column) => (
                        <Table.Td key={column.key} ta={column.align}>
                          {column.render(g)}
                        </Table.Td>
                      ))}
                      <Table.Td onClick={(e) => e.stopPropagation()}>
                        <Menu shadow="md" position="bottom-end" withinPortal>
                          <Menu.Target>
                            <ActionIcon
                              variant="subtle"
                              color="gray"
                              size="sm"
                              aria-label="Campaign actions"
                            >
                              <IconDotsVertical size={16} />
                            </ActionIcon>
                          </Menu.Target>
                          <Menu.Dropdown>
                            <Menu.Item
                              leftSection={<IconExternalLink size={14} />}
                              onClick={() => open(g.id)}
                            >
                              Open
                            </Menu.Item>
                            <Menu.Item
                              leftSection={<IconEdit size={14} />}
                              onClick={() => setToEdit(g)}
                            >
                              Edit details
                            </Menu.Item>
                            {g.status === "PAUSED" ? (
                              <Menu.Item
                                leftSection={<IconPlayerPlay size={14} />}
                                onClick={() =>
                                  act(
                                    () => resumeCampaignGroup(g.id),
                                    "Campaign resumed",
                                  )
                                }
                              >
                                Resume
                              </Menu.Item>
                            ) : (
                              g.status !== "COMPLETED" && (
                                <Menu.Item
                                  leftSection={<IconPlayerPause size={14} />}
                                  onClick={() =>
                                    act(
                                      () => pauseCampaignGroup(g.id),
                                      "Campaign paused",
                                    )
                                  }
                                >
                                  Pause
                                </Menu.Item>
                              )
                            )}
                            <Menu.Item
                              leftSection={<IconCopy size={14} />}
                              onClick={() =>
                                act(
                                  () => duplicateCampaignGroup(g.id),
                                  "Campaign duplicated as drafts",
                                )
                              }
                            >
                              Duplicate
                            </Menu.Item>
                            <Menu.Divider />
                            <Menu.Item
                              color="red"
                              leftSection={<IconTrash size={14} />}
                              onClick={() => setToDelete(g)}
                            >
                              Delete
                            </Menu.Item>
                          </Menu.Dropdown>
                        </Menu>
                      </Table.Td>
                    </Table.Tr>
                  ))
                )}
              </Table.Tbody>
            </Table>
          </Table.ScrollContainer>
        </Box>

        {totalPages > 1 && (
          <Group justify="space-between">
            <Text size="xs" c="dimmed">
              {(currentPage - 1) * PAGE_SIZE + 1}–
              {Math.min(currentPage * PAGE_SIZE, groups.length)} of{" "}
              {groups.length}
            </Text>
            <Pagination
              size="sm"
              total={totalPages}
              value={currentPage}
              onChange={setPage}
            />
          </Group>
        )}
      </Stack>

      <DeleteCampaignModal
        group={toDelete}
        onClose={() => setToDelete(null)}
        onDeleted={load}
      />

      {toEdit && (
        <ParentCampaignFormModal
          opened={!!toEdit}
          onClose={() => setToEdit(null)}
          group={toEdit}
          onSaved={() => {
            setToEdit(null);
            load();
          }}
        />
      )}
    </>
  );
};

export default ParentCampaignTiles;
