siftlode/frontend/src/components/SyncStatus.tsx

import { useRef, useState } from "react";
import { createPortal } from "react-dom";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { useTranslation } from "react-i18next";
import { CheckCircle2, Clock, Database, History, Loader2, Pause, Play } from "lucide-react";
import { api, type MyStatus } from "../lib/api";
import { formatViews } from "../lib/format";
import { useDismiss } from "../lib/useDismiss";

// Per-user status (not the global catalog): shows the number of videos available to *this*
// user, how many of *their* channels are still being fetched, and how many lack full
// history (clickable -> channel manager filtered to those). The pause control is admin-only.
export default function SyncStatus({
  isAdmin,
  onGoToFullHistory,
}: {
  isAdmin: boolean;
  onGoToFullHistory: () => void;
}) {
  const { t } = useTranslation();
  const qc = useQueryClient();
  const [open, setOpen] = useState(false);
  const chipRef = useRef<HTMLButtonElement | null>(null);
  const popRef = useRef<HTMLDivElement | null>(null);
  // Fixed viewport coords: the popover is portaled out of the header, whose glass backdrop-filter
  // would otherwise trap its stacking and positioning.
  const [pos, setPos] = useState<{ top: number; right: number }>({ top: 0, right: 0 });
  useDismiss(open, () => setOpen(false), [chipRef, popRef]);
  const { data } = useQuery({
    queryKey: ["my-status"],
    queryFn: api.myStatus,
    // Track the scheduler near-real-time: poll even when the tab is backgrounded, and
    // refresh immediately on tab focus (the global default disables focus refetch), so the
    // "N without full history" count keeps ticking down without a manual reload. Poll faster
    // while a job is running or work is pending — so the live "syncing" state is actually
    // caught — and ease back to a slow idle tick once everything's settled.
    refetchInterval: (query) => {
      const d = query.state.data as MyStatus | undefined;
      const busy =
        !!d &&
        (d.sync_active || d.channels_recent_pending > 0 || d.channels_deep_pending > 0);
      return busy ? 8_000 : 30_000;
    },
    refetchIntervalInBackground: true,
    refetchOnWindowFocus: true,
    staleTime: 5_000,
  });

  const toggle = useMutation({
    mutationFn: () => (data?.paused ? api.resumeSync() : api.pauseSync()),
    onSuccess: () => qc.invalidateQueries({ queryKey: ["my-status"] }),
  });

  if (!data) return null;

  const syncing = data.channels_recent_pending;
  const notFull = data.channels_deep_pending; // your channels without full history yet
  // Spin only while a sync job is actually running; otherwise pending work shows as a calm,
  // static state (or, for deep history, just the "N without full history" link below).
  const active = data.sync_active;
  const showMain = data.paused || active || syncing > 0 || notFull === 0;

  // Calm one-liner describing the current sync state.
  const stateNode = data.paused ? (
    <span className="text-accent font-medium">{t("header.sync.paused")}</span>
  ) : active ? (
    <span className="flex items-center gap-1">
      <Loader2 className="w-3.5 h-3.5 animate-spin" />
      {syncing > 0
        ? t("header.sync.syncing", { count: syncing })
        : notFull > 0
          ? t("header.sync.backfillingHistory")
          : t("header.sync.working")}
    </span>
  ) : syncing > 0 ? (
    <span className="flex items-center gap-1">
      <Clock className="w-3.5 h-3.5" />
      {t("header.sync.recentQueued", { count: syncing })}
    </span>
  ) : (
    // A small check anchors the "all synced" state so it doesn't read as orphaned text.
    <span className="flex items-center gap-1 text-emerald-500">
      <CheckCircle2 className="w-3.5 h-3.5" />
      <span className="text-muted">{t("header.sync.allSynced")}</span>
    </span>
  );

  const pauseBtn = isAdmin && (data.paused || syncing > 0 || notFull > 0) && (
    <button
      onClick={() => toggle.mutate()}
      disabled={toggle.isPending}
      title={data.paused ? t("header.sync.resume") : t("header.sync.pause")}
      className="p-1 rounded-md hover:bg-card hover:text-fg transition"
    >
      {data.paused ? <Play className="w-3.5 h-3.5" /> : <Pause className="w-3.5 h-3.5" />}
    </button>
  );

  // Chip: the headline count rides in the header; the state, the history link and pause live in a
  // popover. An accent dot flags the only two things worth interrupting you for (paused / missing
  // history) so the collapsed chip still tells you when to look.
  const needsAttention = data.paused || notFull > 0;
  const countsText = `${formatViews(data.my_videos)} ${t("header.sync.yours")} / ${formatViews(
    data.total_videos
  )} ${t("header.sync.total")}`;
  return (
    <div className="pointer-events-auto shrink-0">
      <button
        ref={chipRef}
        onClick={() => {
          const r = chipRef.current?.getBoundingClientRect();
          if (r) setPos({ top: r.bottom + 8, right: window.innerWidth - r.right });
          setOpen((o) => !o);
        }}
        // Short label only: the popover already explains the numbers, and the long one overflowed
        // the viewport edge from here.
        title={countsText}
        aria-expanded={open}
        className="glass glass-hover relative flex items-center gap-1.5 px-2.5 py-1.5 rounded-xl text-xs text-muted"
      >
        {active ? (
          <Loader2 className="w-3.5 h-3.5 shrink-0 animate-spin text-accent" />
        ) : (
          <Database className="w-3.5 h-3.5 shrink-0" />
        )}
        <span className="text-fg font-medium tabular-nums">{formatViews(data.my_videos)}</span>
        {needsAttention && (
          <span className="absolute -top-0.5 -right-0.5 w-2 h-2 rounded-full bg-accent ring-2 ring-bg" />
        )}
      </button>

      {open &&
        createPortal(
          <div
            ref={popRef}
            style={{ position: "fixed", top: pos.top, right: pos.right }}
            className="glass-menu w-64 rounded-xl p-3 z-50 text-xs text-muted animate-[popIn_0.16s_ease]"
          >
            <div
              title={t("header.sync.countTooltip")}
              className="flex items-center gap-1.5 pb-2 border-b border-border/60"
            >
              <Database className="w-3.5 h-3.5 shrink-0" />
              <span>
                <span className="text-fg font-medium">{formatViews(data.my_videos)}</span>{" "}
                {t("header.sync.yours")}
                <span className="opacity-40"> / </span>
                {formatViews(data.total_videos)} {t("header.sync.total")}
              </span>
            </div>
            {showMain && (
              <div className="flex items-center justify-between gap-1.5 pt-2">
                <span className="flex items-center gap-1.5 min-w-0">{stateNode}</span>
                {pauseBtn}
              </div>
            )}
            {notFull > 0 && (
              <div className="flex items-center justify-between gap-1.5 pt-2">
                <button
                  onClick={() => {
                    setOpen(false);
                    onGoToFullHistory();
                  }}
                  title={t("header.sync.fullHistoryTooltip")}
                  className="flex items-center gap-1 hover:text-fg underline decoration-dotted decoration-muted/40 underline-offset-4 transition cursor-pointer"
                >
                  <History className="w-3.5 h-3.5" />
                  {t("header.sync.withoutFullHistory", { count: notFull })}
                </button>
                {!showMain && pauseBtn}
              </div>
            )}
          </div>,
          document.body
        )}
    </div>
  );
}