rebreak-monorepo/apps/rebreak-native/hooks/useMailStats.ts

import { useCallback, useEffect, useRef, useState } from 'react';
import { apiFetch } from '../lib/api';

export type BlockedByDayEntry = {
  date: string;
  count: number;
};

export type BlockedByConnectionEntry = {
  connectionId: string;
  title: string | null;
  email: string;
  providerLabel: string;
  count: number;
};

type MailStatsState = {
  blockedByDay: BlockedByDayEntry[];
  blockedByConnection: BlockedByConnectionEntry[];
  loading: boolean;
};

type ConnectionAgeGranularity = 'too-new' | 'day' | 'week' | 'month';

function resolveGranularity(createdAt: string | null | undefined): ConnectionAgeGranularity {
  if (!createdAt) return 'day';
  const ageMs = Date.now() - new Date(createdAt).getTime();
  const ageH = ageMs / 3_600_000;
  if (ageH < 24) return 'too-new';
  const ageD = ageH / 24;
  if (ageD <= 14) return 'day';
  if (ageD <= 90) return 'week';
  return 'month';
}

type ConnectionStatsState = {
  data: BlockedByDayEntry[];
  granularity: ConnectionAgeGranularity;
  loading: boolean;
};

/**
 * Fetches per-connection blocked-by-day stats lazily (only when `enabled` flips true).
 * Adaptive heading granularity based on connection age:
 *   < 24h  → 'too-new'  (empty-state, data collection in progress)
 *   1-14d  → 'day'      (30-day bars)
 *   15-90d → 'week'     (client-aggregated into week buckets)
 *   > 90d  → 'month'    (client-aggregated into month buckets)
 */
export function useMailConnectionStats(
  connectionId: string,
  createdAt: string | null | undefined,
  enabled: boolean,
) {
  const fetchedRef = useRef(false);
  const [state, setState] = useState<ConnectionStatsState>({
    data: [],
    granularity: resolveGranularity(createdAt),
    loading: false,
  });

  const granularity = resolveGranularity(createdAt);

  const fetch = useCallback(async () => {
    if (!enabled || !connectionId) return;
    setState((s) => ({ ...s, loading: true }));
    try {
      const raw = await apiFetch<BlockedByDayEntry[]>(
        `/api/mail/stats/blocked-by-day?days=30&connectionId=${connectionId}`,
      );

      let data = raw;

      if (granularity === 'week') {
        data = aggregateToWeeks(raw);
      } else if (granularity === 'month') {
        data = aggregateToMonths(raw);
      }

      setState({ data, granularity, loading: false });
    } catch {
      setState((s) => ({ ...s, loading: false }));
    }
  }, [enabled, connectionId, granularity]);

  useEffect(() => {
    if (!enabled) return;
    if (fetchedRef.current) return;
    fetchedRef.current = true;
    fetch();
  }, [enabled, fetch]);

  return { ...state, refresh: fetch };
}

function aggregateToWeeks(entries: BlockedByDayEntry[]): BlockedByDayEntry[] {
  const buckets: Map<string, number> = new Map();
  for (const e of entries) {
    const d = new Date(e.date + 'T00:00:00');
    const day = d.getDay();
    const diff = d.getDate() - day + (day === 0 ? -6 : 1);
    const monday = new Date(d);
    monday.setDate(diff);
    const key = monday.toISOString().slice(0, 10);
    buckets.set(key, (buckets.get(key) ?? 0) + e.count);
  }
  return [...buckets.entries()]
    .sort(([a], [b]) => a.localeCompare(b))
    .map(([date, count]) => ({ date, count }));
}

function aggregateToMonths(entries: BlockedByDayEntry[]): BlockedByDayEntry[] {
  const buckets: Map<string, number> = new Map();
  for (const e of entries) {
    const key = e.date.slice(0, 7);
    buckets.set(key, (buckets.get(key) ?? 0) + e.count);
  }
  return [...buckets.entries()]
    .sort(([a], [b]) => a.localeCompare(b))
    .map(([date, count]) => ({ date, count }));
}

export function useMailStats(enabled: boolean) {
  const [state, setState] = useState<MailStatsState>({
    blockedByDay: [],
    blockedByConnection: [],
    loading: false,
  });

  const fetch = useCallback(async () => {
    if (!enabled) return;
    setState((s) => ({ ...s, loading: true }));
    try {
      const [byDay, byConn] = await Promise.all([
        apiFetch<BlockedByDayEntry[]>('/api/mail/stats/blocked-by-day?days=30'),
        apiFetch<BlockedByConnectionEntry[]>('/api/mail/stats/blocked-by-connection'),
      ]);
      setState({ blockedByDay: byDay, blockedByConnection: byConn, loading: false });
    } catch {
      setState((s) => ({ ...s, loading: false }));
    }
  }, [enabled]);

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

  return { ...state, refresh: fetch };
}