import ConfirmAlert from "@/components/blocks/ConfirmAlert/confirmAlert";
import { useCampaignSocket } from "@/hooks/useCampaignSocket";
import { exportArraySheetsToXlsx } from "@/lib/export/exportXlsx";
import { searchMemberAccountTypes } from "@/lib/features/members/query";
import type { CoreMemberAccountType } from "@/lib/features/members/types";
import {
  attachCampaignsToGroup,
  deleteCampaign,
  detachCampaignsFromGroup,
  duplicateCampaignGroup,
  duplicateGroupCampaigns,
  getCampaignGroup,
  pauseCampaignGroup,
  resumeCampaign,
  resumeCampaignGroup,
  sendCampaign,
  stopCampaign,
  type CampaignGroupDetail,
} from "@/lib/features/notifications/action";
import {
  Badge,
  Button,
  Card,
  Center,
  Group,
  Loader,
  Modal,
  Stack,
  Text,
  TextInput,
  Timeline,
  Title,
  Tooltip,
} from "@mantine/core";
import { useDisclosure } from "@mantine/hooks";
import { notifications } from "@mantine/notifications";
import {
  IconArrowLeft,
  IconCheck,
  IconClock,
  IconCopy,
  IconDownload,
  IconEye,
  IconStack2,
  IconTag,
  IconTimeline,
  IconUsersGroup,
  IconEdit,
  IconExclamationCircleFilled,
  IconLink,
  IconPlayerPause,
  IconPlayerPlay,
  IconPlus,
  IconPrinter,
  IconSearch,
  IconSend,
  IconTrash,
  IconX,
} from "@tabler/icons-react";
import { useCallback, useEffect, useMemo, useState } from "react";
import { useNavigate, useParams } from "react-router";
import AddNotification from "../(widgets)/addNotification";
import CampaignsTable from "../(widgets)/CampaignsTable";
import type { Campaign } from "../(widgets)/CampaignsTable/types";
import type { FilterState } from "../(widgets)/CampaignsTable/Filters";
import ParentCampaignFormModal, {
  UnassignedCampaignPicker,
} from "../(widgets)/ParentCampaigns/ParentCampaignFormModal";
import {
  formatDateTime,
  GroupProgress,
  GroupStatusBadge,
  nextStepLabel,
  runGroupAction,
} from "../(widgets)/ParentCampaigns/shared";
import { RecipientsDrawer } from "../(widgets)/RecipientsDrawer";
import DeleteCampaignModal from "../(widgets)/ParentCampaigns/DeleteCampaignModal";
import NotificationFilterDrawer, {
  countActiveFilters,
  notificationFilterChips,
} from "../(widgets)/NotificationFilterDrawer";
import {
  ActiveFilterChips,
  FilterTrigger,
} from "@/routes/promo-code-campaigns/_components/FilterDrawer";
import { PromoThemeShell } from "@/routes/promo-code-campaigns/_components/PromoThemeShell";
import ThemedStatTiles, {
  type ThemedTileSpec,
} from "../(widgets)/ThemedStatTiles";

const TIMELINE_META: Record<string, { color: string; icon: React.ReactNode }> =
  {
    SENT: { color: "teal", icon: <IconCheck size={12} /> },
    COMPLETED: { color: "teal", icon: <IconCheck size={12} /> },
    SENDING: { color: "yellow", icon: <IconSend size={12} /> },
    QUEUED: { color: "yellow", icon: <IconSend size={12} /> },
    SCHEDULED: { color: "blue", icon: <IconClock size={12} /> },
    STOPPED: { color: "orange", icon: <IconPlayerPause size={12} /> },
    FAILED: { color: "red", icon: <IconX size={12} /> },
    DRAFT: { color: "gray", icon: <IconEdit size={12} /> },
  };

const ParentCampaignClient: React.FC = () => {
  const { groupId } = useParams() as { groupId: string };
  const navigate = useNavigate();
  const [group, setGroup] = useState<CampaignGroupDetail | null>(null);
  const [loading, setLoading] = useState(true);
  const [notFound, setNotFound] = useState<string | null>(null);
  const [busy, setBusy] = useState(false);
  const [sendingId, setSendingId] = useState<string | null>(null);
  const [accountTypes, setAccountTypes] = useState<CoreMemberAccountType[]>([]);

  const [composerOpened, { open: openComposer, close: closeComposer }] =
    useDisclosure(false);
  const [composerData, setComposerData] = useState<Campaign | null>(null);
  const [editingId, setEditingId] = useState<string | null>(null);
  const [editOpened, { open: openEdit, close: closeEdit }] =
    useDisclosure(false);
  const [attachOpened, { open: openAttach, close: closeAttach }] =
    useDisclosure(false);
  const [attachIds, setAttachIds] = useState<string[]>([]);
  const [recipientsCampaign, setRecipientsCampaign] = useState<Campaign | null>(
    null,
  );
  const [search, setSearch] = useState("");
  const [filters, setFilters] = useState<FilterState>({
    platform: [],
    status: [],
  });
  const [filtersOpen, setFiltersOpen] = useState(false);
  const [deleteOpen, setDeleteOpen] = useState(false);
  const [confirm, setConfirm] = useState<{
    title: string;
    message: string;
    run: () => Promise<void>;
  } | null>(null);
  const [addAnotherOpened, { open: openAddAnother, close: closeAddAnother }] =
    useDisclosure(false);
  const [createdCount, setCreatedCount] = useState(0);

  const load = useCallback(async () => {
    const res = await getCampaignGroup(groupId);
    if (res.success) {
      setGroup(res.data);
      setNotFound(null);
    } else {
      setNotFound(res.message || "Parent campaign not found");
    }
    setLoading(false);
  }, [groupId]);

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

  useEffect(() => {
    searchMemberAccountTypes(1, 100)
      .then((res) => {
        if (res.success)
          setAccountTypes(
            (res.data?.account_types ?? []).filter(
              (t: any) => t.name !== "Karma Lite",
            ),
          );
      })
      .catch(() => {});
  }, []);

  const { generalStatusUpdate } = useCampaignSocket();
  useEffect(() => {
    if (
      generalStatusUpdate &&
      group?.campaigns.some((c) => c.id === generalStatusUpdate.campaignId)
    )
      load();
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [generalStatusUpdate]);

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

  const visibleCampaigns = useMemo(() => {
    const all = (group?.campaigns ?? []) as Campaign[];
    const q = search.trim().toLowerCase();
    return all.filter((c) => {
      if (
        q &&
        ![c.name, c.title, c.body].some((v) => v?.toLowerCase().includes(q))
      )
        return false;
      if (filters.status.length && !filters.status.includes(c.status))
        return false;
      if (filters.platform.length) {
        const criteria =
          typeof c.target_criteria === "string"
            ? JSON.parse(c.target_criteria || "{}")
            : (c.target_criteria ?? {});
        const segments: string[] = (criteria.userSegment ?? []).map(
          (seg: string) => seg.toLowerCase(),
        );
        if (
          segments.length &&
          !filters.platform.some((p) => segments.includes(p.toLowerCase()))
        )
          return false;
      }
      return true;
    });
  }, [group, search, filters]);

  const runBulk = async (
    ids: string[],
    allowed: (c: Campaign) => boolean,
    action: (id: string) => Promise<any>,
    verb: string,
  ) => {
    const byId = new Map(
      ((group?.campaigns ?? []) as Campaign[]).map((c) => [c.id, c]),
    );
    const eligible = ids.filter((id) => byId.get(id) && allowed(byId.get(id)!));
    const skipped = ids.length - eligible.length;
    if (eligible.length === 0) {
      notifications.show({
        title: "Nothing to do",
        message: `None of the selected notifications can be ${verb}.`,
        color: "gray",
      });
      return;
    }
    setBusy(true);
    const results = await Promise.allSettled(eligible.map((id) => action(id)));
    const ok = results.filter(
      (r) => r.status === "fulfilled" && (r.value as any)?.success,
    ).length;
    const failed = eligible.length - ok;
    const parts = [`${ok} ${verb}`];
    if (skipped) parts.push(`${skipped} skipped (status doesn't allow it)`);
    if (failed) parts.push(`${failed} failed`);
    notifications.show({
      title: failed ? "Partially done" : "Done",
      message: parts.join(", "),
      color: failed ? "orange" : skipped ? "blue" : "green",
    });
    setBusy(false);
    await load();
  };

  const ask = (title: string, message: string, run: () => Promise<void>) =>
    setConfirm({ title, message, run });

  if (loading) {
    return (
      <Center h={300}>
        <Loader />
      </Center>
    );
  }

  if (!group) {
    return (
      <Stack px="xl" py="xl" align="flex-start">
        <Button
          variant="subtle"
          leftSection={<IconArrowLeft size={16} />}
          onClick={() => navigate("/admin/notifications")}
        >
          Back
        </Button>
        <Text c="red">{notFound}</Text>
      </Stack>
    );
  }

  const isCompleted = group.status === "COMPLETED";
  const isPaused = group.status === "PAUSED";
  const addBlockedReason = isCompleted
    ? "This parent campaign is completed. Duplicate it to start a new one."
    : isPaused
      ? "Resume the parent campaign before adding notifications."
      : null;
  const campaigns = group.campaigns as Campaign[];
  const isFiltered = visibleCampaigns.length !== campaigns.length;

  const handleExport = async () => {
    await exportArraySheetsToXlsx({
      filename: `parent_campaign_${group.name.replace(/[^a-z0-9]+/gi, "_")}.xlsx`,
      sheets: [
        {
          sheetName: "Summary",
          rows: [
            ["Field", "Value"],
            ["Title", group.name],
            ["Description", group.description ?? ""],
            ["Status", group.status],
            ["Start", formatDateTime(group.start_at)],
            ["Next scheduled", formatDateTime(group.next_scheduled_at)],
            ["Subcampaigns", group.progress.total],
            ["Completed", group.progress.completed],
            ["Upcoming", group.progress.upcoming],
            ["Stopped / failed", group.progress.failed],
            ["Total audience", group.totals.audience],
            ["Total sent", group.totals.sent],
            ["Total seen", group.totals.opens],
            ["Created by", group.created_by ?? ""],
          ],
        },
        {
          sheetName: "Subcampaigns",
          rows: [
            [
              "Name",
              "Title",
              "Status",
              "Scheduled",
              "Audience",
              "Sent",
              "Seen",
              "Published by",
            ],
            ...campaigns.map((c) => [
              c.name,
              c.title,
              c.status,
              formatDateTime(c.scheduled_at ?? c.created_at),
              c.total_count ?? 0,
              c.sent_count ?? 0,
              c.open_count ?? 0,
              c.published_by ?? "",
            ]),
          ],
        },
      ],
    });
  };

  const openNew = () => {
    setEditingId(null);
    setComposerData(null);
    openComposer();
  };

  const campaignAction = async (
    fn: () => Promise<any>,
    msg: string,
    id?: string,
  ) => {
    if (id) setSendingId(id);
    await act(fn, msg);
    setSendingId(null);
  };

  const filterChips = notificationFilterChips(filters, setFilters);
  const summaryTiles = buildSummaryTiles(group);

  return (
    <PromoThemeShell>
      <Stack px="xl" py="xl" gap="lg">
        <Group justify="space-between" align="flex-start">
          <Stack gap={4} style={{ flex: 1, minWidth: 0 }}>
            <Group gap="xs">
              <Button
                variant="subtle"
                size="compact-sm"
                leftSection={<IconArrowLeft size={14} />}
                onClick={() => navigate("/admin/notifications")}
              >
                Notifications
              </Button>
            </Group>
            <Group gap="sm">
              <Title order={3}>{group.name}</Title>
              <GroupStatusBadge status={group.status} />
              <Badge variant="light" size="lg">
                {campaigns.length} notification
                {campaigns.length === 1 ? "" : "s"}
              </Badge>
            </Group>
            {group.tags?.length > 0 && (
              <Group gap={6}>
                {group.tags.map((tag) => (
                  <Badge
                    key={tag.id}
                    variant="outline"
                    radius="sm"
                    leftSection={<IconTag size={11} />}
                    tt="none"
                  >
                    {tag.name}
                  </Badge>
                ))}
              </Group>
            )}
            {group.description && (
              <Text c="dimmed" size="sm">
                {group.description}
              </Text>
            )}
          </Stack>
          <Group gap="xs">
            <Button
              variant="default"
              leftSection={<IconEdit size={16} />}
              onClick={openEdit}
            >
              Edit
            </Button>
            {isPaused ? (
              <Button
                color="green"
                variant="light"
                leftSection={<IconPlayerPlay size={16} />}
                loading={busy}
                onClick={() =>
                  ask(
                    "Resume parent campaign",
                    "Notifications paused with this parent will restart. Any whose scheduled time is still ahead go back to Scheduled; the rest start sending now.",
                    async () =>
                      void (await act(
                        () => resumeCampaignGroup(group.id),
                        "Parent campaign resumed",
                      )),
                  )
                }
              >
                Resume
              </Button>
            ) : (
              !isCompleted && (
                <Button
                  color="orange"
                  variant="light"
                  leftSection={<IconPlayerPause size={16} />}
                  loading={busy}
                  onClick={() =>
                    ask(
                      "Pause parent campaign",
                      "All scheduled, queued and sending notifications in this parent will be paused. Sent notifications are not affected.",
                      async () =>
                        void (await act(
                          () => pauseCampaignGroup(group.id),
                          "Parent campaign paused",
                        )),
                    )
                  }
                >
                  Pause
                </Button>
              )
            )}
            <Button
              variant="default"
              leftSection={<IconCopy size={16} />}
              loading={busy}
              onClick={async () => {
                const copy = await act(
                  () => duplicateCampaignGroup(group.id),
                  "Duplicated as drafts",
                );
                if (copy)
                  navigate(
                    `/admin/notifications/groups/${(copy as CampaignGroupDetail).id}`,
                  );
              }}
            >
              Duplicate
            </Button>
            <Button
              variant="default"
              leftSection={<IconDownload size={16} />}
              onClick={handleExport}
            >
              Export
            </Button>
            <Button
              variant="default"
              leftSection={<IconPrinter size={16} />}
              onClick={() => window.print()}
            >
              Print
            </Button>
            <Button
              color="red"
              variant="light"
              leftSection={<IconTrash size={16} />}
              onClick={() => setDeleteOpen(true)}
            >
              Delete
            </Button>
          </Group>
        </Group>

        <ThemedStatTiles tiles={summaryTiles} maxCols={4} />

        <Card withBorder radius="lg" p="lg">
          <Stack gap="md">
            <Group justify="space-between" align="center">
              <Group gap={8} align="center">
                <IconTimeline size={17} stroke={1.8} />
                <Text fw={700} size="md">
                  Progress
                </Text>
              </Group>
              <Group gap="lg">
                <Text size="xs" c="dimmed">
                  Start{" "}
                  <Text span size="xs" fw={600} c="var(--mantine-color-text)">
                    {formatDateTime(group.start_at)}
                  </Text>
                </Text>
                <Text size="xs" c="dimmed">
                  Up next{" "}
                  <Text span size="xs" fw={600} c="var(--mantine-color-text)">
                    {nextStepLabel(group)}
                  </Text>
                </Text>
              </Group>
            </Group>
            <GroupProgress group={group} />
            {campaigns.length > 0 && (
              <Timeline bulletSize={22} lineWidth={2} active={-1}>
                {campaigns.map((c) => {
                  const meta = TIMELINE_META[c.status] ?? TIMELINE_META.DRAFT;
                  const isNext = c.id === group.next_campaign_id;
                  return (
                    <Timeline.Item
                      key={c.id}
                      bullet={meta.icon}
                      color={meta.color}
                      title={
                        <Group gap="xs">
                          <Text size="sm" fw={500}>
                            {c.name || c.title}
                          </Text>
                          <Badge size="xs" variant="light" color={meta.color}>
                            {c.status}
                          </Badge>
                          {isNext && (
                            <Badge size="xs" variant="filled" color="blue">
                              Next
                            </Badge>
                          )}
                        </Group>
                      }
                    >
                      <Text size="xs" c="dimmed">
                        {c.scheduled_at
                          ? formatDateTime(c.scheduled_at)
                          : c.status === "DRAFT"
                            ? "Not scheduled"
                            : `Sent now · ${formatDateTime(c.created_at)}`}
                        {Number(c.sent_count) > 0 &&
                          ` · ${Number(c.sent_count).toLocaleString()} sent`}
                      </Text>
                    </Timeline.Item>
                  );
                })}
              </Timeline>
            )}
          </Stack>
        </Card>

        <Group justify="space-between">
          <Group gap="xs">
            <Text fw={700} size="md">
              Notifications
            </Text>
            <Badge variant="light" size="md" radius="sm">
              {isFiltered
                ? `${visibleCampaigns.length} of ${campaigns.length}`
                : campaigns.length}
            </Badge>
          </Group>
          <Group gap="xs">
            <TextInput
              placeholder="Search name, title or text"
              leftSection={<IconSearch size={16} />}
              value={search}
              onChange={(e) => setSearch(e.currentTarget.value)}
              w={260}
            />
            <FilterTrigger
              activeCount={countActiveFilters(filters)}
              onClick={() => setFiltersOpen(true)}
            />
            <Tooltip label={addBlockedReason} disabled={!addBlockedReason}>
              <Button
                variant="light"
                leftSection={<IconLink size={16} />}
                disabled={!!addBlockedReason}
                onClick={() => {
                  setAttachIds([]);
                  openAttach();
                }}
              >
                Add existing
              </Button>
            </Tooltip>
            <Tooltip label={addBlockedReason} disabled={!addBlockedReason}>
              <Button
                leftSection={<IconPlus size={16} />}
                disabled={!!addBlockedReason}
                onClick={openNew}
              >
                New notification
              </Button>
            </Tooltip>
          </Group>
        </Group>

        <ActiveFilterChips
          chips={filterChips}
          onReset={() => setFilters({ platform: [], status: [] })}
        />

        <NotificationFilterDrawer
          opened={filtersOpen}
          onClose={() => setFiltersOpen(false)}
          filters={filters}
          onChange={setFilters}
        />

        <CampaignsTable
          campaigns={visibleCampaigns}
          bulkActions={[
            {
              label: "Duplicate",
              icon: <IconCopy size={14} />,
              onClick: (ids) => {
                if (addBlockedReason) {
                  notifications.show({
                    title: "Can't duplicate here",
                    message: addBlockedReason,
                    color: "orange",
                  });
                  return;
                }
                ask(
                  "Duplicate notifications",
                  `Copy ${ids.length} notification${ids.length === 1 ? "" : "s"} into this campaign as unscheduled drafts? Edit each copy to set its schedule.`,
                  async () =>
                    void (await act(
                      () => duplicateGroupCampaigns(group.id, ids),
                      "Notifications duplicated as drafts",
                    )),
                );
              },
            },
            {
              label: "Pause / stop",
              icon: <IconPlayerPause size={14} />,
              color: "orange",
              onClick: (ids) =>
                ask(
                  "Pause / stop notifications",
                  "Scheduled and queued notifications won't send; sending ones stop after the current batch. Sent, draft and already-stopped ones are skipped.",
                  () =>
                    runBulk(
                      ids,
                      (c) =>
                        ["SCHEDULED", "QUEUED", "SENDING"].includes(c.status),
                      stopCampaign,
                      "paused",
                    ),
                ),
            },
            {
              label: "Resume",
              icon: <IconPlayerPlay size={14} />,
              color: "green",
              onClick: (ids) =>
                ask(
                  "Resume notifications",
                  "Stopped or failed notifications restart. Any whose scheduled time is still ahead go back to Scheduled; the rest start sending now.",
                  () =>
                    runBulk(
                      ids,
                      (c) => ["STOPPED", "FAILED"].includes(c.status),
                      resumeCampaign,
                      "resumed",
                    ),
                ),
            },
          ]}
          onBulkDelete={async (ids) =>
            ask(
              "Delete notifications",
              `Delete ${ids.length} notification${ids.length === 1 ? "" : "s"}? Sending ones stop. They can be restored from Deleted Campaigns.`,
              async () => {
                setBusy(true);
                const results = await Promise.allSettled(
                  ids.map((id) => deleteCampaign(id)),
                );
                const ok = results.filter(
                  (r) => r.status === "fulfilled" && (r.value as any)?.success,
                ).length;
                const failed = ids.length - ok;
                notifications.show({
                  title: failed ? "Partially deleted" : "Deleted",
                  message: failed
                    ? `${ok} deleted, ${failed} failed`
                    : `${ok} notification${ok === 1 ? "" : "s"} deleted`,
                  color: failed ? "orange" : "green",
                });
                setBusy(false);
                await load();
              },
            )
          }
          loading={busy}
          sendingId={sendingId}
          onSendNow={(id) =>
            campaignAction(() => sendCampaign(id), "Sending started", id)
          }
          onStop={(id) =>
            campaignAction(() => stopCampaign(id), "Notification paused", id)
          }
          onResume={(id) =>
            campaignAction(() => resumeCampaign(id), "Notification resumed", id)
          }
          onDelete={async (id) =>
            ask(
              "Delete notification",
              "Delete this notification? It can be restored from Deleted Campaigns.",
              async () =>
                campaignAction(
                  () => deleteCampaign(id),
                  "Notification deleted",
                ),
            )
          }
          onActivate={async () => {}}
          onDuplicate={(c) => {
            setEditingId(null);
            setComposerData(c);
            openComposer();
          }}
          onEdit={(c) => {
            setEditingId(c.id);
            setComposerData(c);
            openComposer();
          }}
          onDetach={(c) =>
            ask(
              "Remove from parent",
              `Remove "${c.name || c.title}" from this parent? The notification itself is kept with its current status.`,
              async () =>
                campaignAction(
                  () => detachCampaignsFromGroup(group.id, [c.id]),
                  "Removed from parent",
                ),
            )
          }
          onViewRecipients={setRecipientsCampaign}
        />

        <AddNotification
          accountTypes={accountTypes}
          opened={composerOpened}
          onClose={closeComposer}
          initialData={composerData}
          editingId={editingId}
          parentId={addBlockedReason ? null : group.id}
          onSuccess={() => {
            const wasCreate = !editingId;
            closeComposer();
            load();
            if (wasCreate && !addBlockedReason) {
              setCreatedCount((n) => n + 1);
              openAddAnother();
            }
          }}
        />

        <Modal
          opened={addAnotherOpened}
          onClose={() => {
            closeAddAnother();
            setCreatedCount(0);
          }}
          title="Notification added"
          centered
          size="sm"
        >
          <Stack>
            <Text size="sm">
              {createdCount > 1
                ? `${createdCount} notifications added`
                : "Notification added"}{" "}
              to <b>{group.name}</b>. Add another notification to this campaign?
            </Text>
            <Group justify="flex-end">
              <Button
                variant="default"
                onClick={() => {
                  closeAddAnother();
                  setCreatedCount(0);
                }}
              >
                Done
              </Button>
              <Button
                leftSection={<IconPlus size={14} />}
                onClick={() => {
                  closeAddAnother();
                  openNew();
                }}
              >
                Add another
              </Button>
            </Group>
          </Stack>
        </Modal>

        <DeleteCampaignModal
          group={deleteOpen ? group : null}
          onClose={() => setDeleteOpen(false)}
          onDeleted={() => navigate("/admin/notifications")}
        />

        <ParentCampaignFormModal
          opened={editOpened}
          onClose={closeEdit}
          group={group}
          onSaved={() => load()}
        />

        <Modal
          opened={attachOpened}
          onClose={closeAttach}
          title="Add existing notifications"
          centered
          size="lg"
        >
          <Stack>
            <UnassignedCampaignPicker
              value={attachIds}
              onChange={setAttachIds}
              label="Notifications without a parent"
            />
            <Group justify="flex-end">
              <Button variant="default" onClick={closeAttach}>
                Cancel
              </Button>
              <Button
                disabled={attachIds.length === 0}
                loading={busy}
                onClick={async () => {
                  if (
                    await act(
                      () => attachCampaignsToGroup(group.id, attachIds),
                      "Notifications added",
                    )
                  )
                    closeAttach();
                }}
              >
                Add {attachIds.length || ""}
              </Button>
            </Group>
          </Stack>
        </Modal>

        <RecipientsDrawer
          opened={!!recipientsCampaign}
          onClose={() => setRecipientsCampaign(null)}
          campaign={recipientsCampaign}
        />

        <ConfirmAlert
          title={confirm?.title ?? ""}
          titleIcon={<IconExclamationCircleFilled color="orange" />}
          message={confirm?.message ?? ""}
          handleConfirm={async () => {
            const c = confirm;
            setConfirm(null);
            await c?.run();
          }}
          modalProps={{ opened: !!confirm, onClose: () => setConfirm(null) }}
        />
      </Stack>
    </PromoThemeShell>
  );
};

const percentOf = (part: number, whole: number) =>
  whole > 0 ? Math.min(100, (part / whole) * 100) : 0;

function buildSummaryTiles(group: CampaignGroupDetail): ThemedTileSpec[] {
  const { progress, totals } = group;
  const sentPct = percentOf(totals.sent, totals.audience);
  const seenPct = percentOf(totals.opens, totals.sent);
  return [
    {
      key: "notifications",
      label: "Notifications",
      value: progress.total,
      icon: <IconStack2 size={18} stroke={1.8} />,
      percent: percentOf(progress.completed, progress.total),
      hint: `${progress.completed} completed · ${progress.upcoming} upcoming`,
    },
    {
      key: "audience",
      label: "Audience",
      value: totals.audience,
      icon: <IconUsersGroup size={18} stroke={1.8} />,
      hint: "Members targeted across notifications",
    },
    {
      key: "sent",
      label: "Sent",
      value: totals.sent,
      icon: <IconSend size={18} stroke={1.8} />,
      percent: sentPct,
      hint: `${sentPct.toFixed(1)}% of audience reached`,
    },
    {
      key: "seen",
      label: "Seen",
      value: totals.opens,
      icon: <IconEye size={18} stroke={1.8} />,
      percent: seenPct,
      hint: `${seenPct.toFixed(1)}% of sent opened`,
    },
  ];
}

export default ParentCampaignClient;
