// ============================================================
// FINAFAMILY — API Client + App Context
// Backend: https://api.finafamily.com.br/api/v1 (production)
// Backend: http://localhost:4000/api/v1 (development)
// ============================================================

const { createContext, useContext, useState, useEffect, useCallback, useRef, useMemo } = React;

// ── API Base ───────────────────────────────────────────────
const API_BASE = typeof window !== 'undefined' && ['localhost', '127.0.0.1', '::1'].includes(window.location.hostname)
  ? 'http://127.0.0.1:4000/api/v1'
  : 'https://api.finafamily.com.br/api/v1';

// ── Auth Storage ───────────────────────────────────────────
function getToken()   { return localStorage.getItem('ff_token'); }
function setTokens(token, refresh) {
  localStorage.setItem('ff_token', token);
  if (refresh) localStorage.setItem('ff_refresh', refresh);
}
function clearTokens() {
  localStorage.removeItem('ff_token');
  localStorage.removeItem('ff_refresh');
}

let refreshPromise = null;

async function refreshAccessToken() {
  const refreshToken = localStorage.getItem('ff_refresh');
  if (!refreshToken) throw new Error('Sessão expirada');
  if (!refreshPromise) {
    refreshPromise = fetch(API_BASE + '/auth/refresh', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ refreshToken }),
    }).then(async res => {
      if (!res.ok) throw new Error('Sessão expirada');
      const tokens = await res.json();
      setTokens(tokens.accessToken, tokens.refreshToken);
      return tokens.accessToken;
    }).finally(() => { refreshPromise = null; });
  }
  return refreshPromise;
}

// ── HTTP Helper ────────────────────────────────────────────
async function apiFetch(path, options = {}) {
  const token = getToken();
  let res = await fetch(API_BASE + path, {
    ...options,
    headers: {
      'Content-Type': 'application/json',
      ...(token ? { Authorization: `Bearer ${token}` } : {}),
      ...(options.headers || {}),
    },
    body: options.body != null
      ? (typeof options.body === 'string' ? options.body : JSON.stringify(options.body))
      : undefined,
  });
  if (res.status === 401 && path !== '/auth/refresh' && localStorage.getItem('ff_refresh')) {
    try {
      const refreshedToken = await refreshAccessToken();
      res = await fetch(API_BASE + path, {
        ...options,
        headers: {
          'Content-Type': 'application/json',
          Authorization: `Bearer ${refreshedToken}`,
          ...(options.headers || {}),
        },
        body: options.body != null
          ? (typeof options.body === 'string' ? options.body : JSON.stringify(options.body))
          : undefined,
      });
    } catch {
      clearTokens();
    }
  }
  if (!res.ok) {
    const err = await res.json().catch(() => ({}));
    const e = new Error(err.message || `HTTP ${res.status}`);
    e.status = res.status;
    throw e;
  }
  if (res.status === 204) return null;
  return res.json();
}

// ── Data Mappers ───────────────────────────────────────────
function roleLabel(role) {
  if (role === 'MASTER1') return 'Master 1';
  if (role === 'MASTER2') return 'Master 2';
  return 'Filho';
}

function mapMember(m) {
  return {
    ...m,
    role:        roleLabel(m.role),
    diaDiaLimit: parseFloat(m.diaDiaLimit) || 300,
    salary:      parseFloat(m.salary)      || 0,
    avatar:      m.avatarUrl || null,
  };
}

function mapExpenseShare(s) {
  return {
    memberId: s.memberId,
    mode: s.mode || 'percentage',
    pct: s.pct == null ? null : (parseFloat(s.pct) || 0),
    amountCents: Number(s.amountCents),
    amount: Number(s.amountCents) / 100,
    value: Number(s.amountCents) / 100,
    approvedAt: s.approvedAt || null,
  };
}

function mapExpense(e) {
  const rawDate = e.date || '';
  const value = parseFloat(e.value) || 0;
  return {
    ...e,
    pmId:       e.paymentMethodId || '',
    value,
    valueCents: Number.isSafeInteger(e.valueCents) ? e.valueCents : Math.round(value * 100),
    responsibleMemberId: e.responsibleMemberId || null,
    seriesVersion: e.seriesVersion != null ? Number(e.seriesVersion) : (e.series?.currentVersion != null ? Number(e.series.currentVersion) : undefined),
    seriesTotal: e.seriesTotal != null
      ? Number(e.seriesTotal)
      : (e.series?.installmentTotalCents != null ? Number(e.series.installmentTotalCents) / 100 : undefined),
    date:       typeof rawDate === 'string' ? rawDate.split('T')[0] : rawDate,
    // Despesas projetadas representam uma NOVA ocorrência mensal — sempre pendente,
    // independente do status do registro original (que pode ter sido pago em outro mês)
    status:     e.isProjected ? 'pending' : (e.status || 'pending'),
    sharedWith: (e.expenseShares || []).map(mapExpenseShare),
  };
}

function mapExpenseSeriesResponse(response) {
  const rawSeries = response?.series || null;
  const series = rawSeries ? {
    ...rawSeries,
    responsibilityShares: (rawSeries.responsibilityShares || []).map(mapExpenseShare),
  } : null;
  const rawOccurrences = Array.isArray(response)
    ? response
    : (response?.occurrences || (response?.id ? [response] : []));
  const occurrences = rawOccurrences.map(item => ({
    ...mapExpense(item),
    seriesVersion: Number(series?.currentVersion ?? item.seriesVersion ?? item.series?.currentVersion ?? 1),
    seriesTotal: series?.installmentTotalCents != null
      ? Number(series.installmentTotalCents) / 100
      : item.seriesTotal,
    seriesResponsibilityShares: series?.responsibilityShares || item.seriesResponsibilityShares,
  }));
  return { series, occurrences };
}

function mapIncome(i) {
  const rawDate = i.date || '';
  return {
    ...i,
    value: parseFloat(i.value) || 0,
    date:  typeof rawDate === 'string' ? rawDate.split('T')[0] : rawDate,
  };
}

function mapPaymentMethod(pm) {
  // Build invoice history: API returns [{month:5,year:2026,value:"250.00",status:"paid"}]
  // Frontend expects [{month:'Mai/26', value: 250, status:'paid'}]
  const MONTHS_PT = ['Jan','Fev','Mar','Abr','Mai','Jun','Jul','Ago','Set','Out','Nov','Dez'];
  const invoices = (pm.invoices || []).map(inv => ({
    ...inv,
    month: `${MONTHS_PT[(inv.month || 1) - 1]}/${String(inv.year || 2026).slice(-2)}`,
    value: parseFloat(inv.value) || 0,
  }));
  return {
    ...pm,
    limit:   pm.limit   != null ? parseFloat(pm.limit)   : undefined,
    used:    pm.used    != null ? parseFloat(pm.used)     : 0,
    balance: pm.balance != null ? parseFloat(pm.balance)  : undefined,
    invoices,
  };
}

function mapInvoicePreview(invoice) {
  const total = invoice.total != null
    ? parseFloat(invoice.total) || 0
    : (Number(invoice.totalCents || 0) / 100);
  return {
    ...invoice,
    dueMonth:  Number(invoice.dueMonth),
    dueYear:   Number(invoice.dueYear),
    total,
    totalCents: invoice.totalCents != null ? Number(invoice.totalCents) : Math.round(total * 100),
    itemCount: Number(invoice.itemCount ?? invoice.items?.length ?? 0),
    items: (invoice.items || []).map(item => ({
      ...item,
      value: item.total != null
        ? parseFloat(item.total) || 0
        : item.amount != null
          ? parseFloat(item.amount) || 0
          : Number(item.amountCents ?? item.valueCents ?? 0) / 100,
    })),
  };
}

function mapInvestment(inv) {
  return {
    ...inv,
    value:       parseFloat(inv.value)       || 0,
    monthlyRate: parseFloat(inv.monthlyRate) || 0,
    visibility:  inv.visibility || 'open',
    history:     (inv.history || []).map(h => parseFloat(h.value) || 0),
  };
}

// ── Customizable list defaults (persisted in localStorage) ─
const DEFAULT_INVESTMENT_TYPES = [
  'CDB', 'Tesouro Direto', 'LCI/LCA', 'Ações', 'FII',
  'Poupança', 'Previdência', 'Criptomoedas', 'Outros',
];
const DEFAULT_INVESTMENT_PURPOSES = [
  { key: 'emergency',  label: 'Reserva de Emergência', color: '#EF4444' },
  { key: 'retirement', label: 'Aposentadoria',          color: '#8B5CF6' },
  { key: 'passive',    label: 'Renda Passiva',           color: '#10B981' },
  { key: 'travel',     label: 'Viagem',                  color: '#3B82F6' },
  { key: 'education',  label: 'Educação Filhos',         color: '#F59E0B' },
  { key: 'other',      label: 'Outros',                  color: '#94A3B8' },
];
const DEFAULT_INCOME_SOURCES = [
  { key: 'salary',    label: 'Salário' },
  { key: 'freelance', label: 'Freelance' },
  { key: 'passive',   label: 'Renda Passiva' },
  { key: 'rent',      label: 'Aluguel' },
  { key: 'other',     label: 'Outros' },
];
function lsGet(key, fallback) {
  try { const v = localStorage.getItem(key); return v ? JSON.parse(v) : fallback; }
  catch { return fallback; }
}
function lsSet(key, val) {
  try { localStorage.setItem(key, JSON.stringify(val)); } catch {}
}
// Limpa entradas antigas de cache mensal — mantém só os últimos `keep` meses
function lsEvictOldMonths(prefix, keep = 4) {
  try {
    const keys = Object.keys(localStorage).filter(k => k.startsWith(prefix + '_'));
    if (keys.length > keep) keys.sort().slice(0, keys.length - keep).forEach(k => localStorage.removeItem(k));
  } catch {}
}

// ── Merge helpers: substitui dados de um mês sem apagar os outros ─
function mergeMonthExp(prev, newItems, year, month) {
  const kept = prev.filter(e => {
    const d = new Date((e.date || '').length === 10 ? e.date + 'T00:00:00' : e.date);
    return !(d.getFullYear() === year && d.getMonth() + 1 === month);
  });
  return [...kept, ...newItems];
}
function mergeMonthInc(prev, newItems, year, month) {
  const kept = prev.filter(i => {
    if (String(i.id).startsWith('temp_')) return true; // mantém otimistas
    const d = new Date((i.date || '').length === 10 ? i.date + 'T00:00:00' : i.date);
    return !(d.getFullYear() === year && d.getMonth() + 1 === month);
  });
  return [...kept, ...newItems];
}

// ── Lógica pura de cálculo ──────────────────────────────────
// parseLocalDate, expenseInvolvesMember, monthExpensesTotal, calcBalancete e
// buildPendingApprovalGroups vivem em lib/finance-calc.js (carregado como
// <script> global antes deste arquivo), para poderem ser testados com Node
// sem depender de React/JSX. Ver Frontend/tests/business-logic.test.js.

// ── CSV Export ─────────────────────────────────────────────
function exportToCSV(data, filename) {
  if (!data || !data.length) return;
  const keys = Object.keys(data[0]);
  const rows = [keys.join(','), ...data.map(row => keys.map(k => {
    const v = row[k];
    if (v === null || v === undefined) return '';
    const s = String(v);
    return s.includes(',') || s.includes('"') || s.includes('\n') ? `"${s.replace(/"/g, '""')}"` : s;
  }).join(','))];
  const blob = new Blob([rows.join('\n')], { type: 'text/csv;charset=utf-8;' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url; a.download = filename; a.click();
  URL.revokeObjectURL(url);
}

// ── Theme Context ──────────────────────────────────────────
const ThemeContext = createContext(null);
function useTheme() { return useContext(ThemeContext); }

// Temas: referência clara/escura e Nubank claro.
const THEME_ORDER = ['light', 'dark', 'nubank-light'];
const THEME_COLORS = { light: '#2167D5', dark: '#101827', 'nubank-light': '#8A05BE' };

function ThemeProvider({ children }) {
  const [theme, setTheme] = useState(() => {
    const saved = localStorage.getItem('finafamily_theme');
    if (saved && THEME_ORDER.includes(saved)) return saved;
    // Preferências antigas escuras migram para o design system escuro.
    if (saved === 'classic' || saved === 'nubank-dark') return 'dark';
    const legacy = localStorage.getItem('finafamily_dark');
    if (legacy !== null) return JSON.parse(legacy) ? 'dark' : 'light';
    return 'light';
  });
  useEffect(() => {
    localStorage.setItem('finafamily_theme', theme);
    localStorage.removeItem('finafamily_dark');
    document.documentElement.classList.toggle('dark', theme === 'dark');
    document.documentElement.classList.remove('nubank-dark');
    document.documentElement.classList.toggle('nubank-light', theme === 'nubank-light');
    const metaTheme = document.querySelector('meta[name="theme-color"]');
    if (metaTheme) metaTheme.setAttribute('content', THEME_COLORS[theme]);
  }, [theme]);

  const dark = theme === 'dark'; // atalho para quem só precisa saber "é escuro?"
  const cycleTheme = () => setTheme(t => THEME_ORDER[(THEME_ORDER.indexOf(t) + 1) % THEME_ORDER.length]);

  return (
    <ThemeContext.Provider value={{ theme, setTheme, dark, toggle: cycleTheme }}>
      {children}
    </ThemeContext.Provider>
  );
}

const NavContext = createContext(null);
function useNav() { return useContext(NavContext); }

const AppContext = createContext(null);
function useApp() { return useContext(AppContext); }

// ── App Provider ───────────────────────────────────────────
function AppProvider({ children }) {
  const now = new Date();
  const [isLoggedIn,     setIsLoggedIn]     = useState(false);
  const [loading,        setLoading]        = useState(true);   // checking stored token
  const [loadingData,    setLoadingData]    = useState(false);
  const [authError,      setAuthError]      = useState(null);
  const [members,        setMembers]        = useState([]);
  const [expenses,          setExpenses]          = useState([]);
  const [balanceteExpenses, setBalanceteExpenses] = useState([]); // todas as despesas da família (sem filtro de mês) para o balancete
  const loadedExpMonths     = useRef(new Set()); // meses já carregados do backend
  const loadedIncMonths     = useRef(new Set()); // idem para receitas
  const staticLoadedAt      = useRef(0);         // timestamp da última carga de dados estáticos
  // Ids de despesas marcadas como pagas localmente, ainda não confirmadas pelo servidor.
  // Protege a atualização otimista de ser revertida por um refetch em voo (race condition).
  const pendingPaidIds      = useRef(new Set());
  // Aplica as marcações locais de "pago" sobre qualquer lista vinda do servidor/cache.
  // Quando o servidor já devolve a despesa como paga, remove da lista pendente.
  const applyPaidOverride = useCallback((list) => (list || []).map(e => {
    if (e.isProjected) return e;            // nunca força status em projeções
    if (!pendingPaidIds.current.has(e.id)) return e;
    if (e.status === 'paid') { pendingPaidIds.current.delete(e.id); return e; }
    return { ...e, status: 'paid' };
  }), []);
  const STATIC_TTL          = 5 * 60 * 1000;    // 5 min — re-busca members/cats/payments/investments
  const [incomes,        setIncomes]        = useState([]);
  const [investments,    setInvestments]    = useState([]);
  const [paymentMethods, setPaymentMethods] = useState([]);
  const [categories,     setCategories]     = useState([]);
  const [notifications,  setNotifications]  = useState([]);
  // Pulsa por alguns segundos quando uma notificação nova chega, mesmo fora da tela de Notificações.
  const [notifAlert,     setNotifAlert]     = useState(false);
  const prevUnreadCount  = useRef(null);
  const [sharedStatus,   setSharedStatus]   = useState({});
  const [currentMember,  setCurrentMember]  = useState(null);
  const [memberOperations, setMemberOperations] = useState([]);
  const [memberOperationsLoading, setMemberOperationsLoading] = useState(false);
  const [memberOperationsError, setMemberOperationsError] = useState(null);
  const memberOperationKeys = useRef(new Map());
  const memberOperationSession = useRef({ memberId: null, generation: 0 });
  const memberOperationRequest = useRef(0);
  if (memberOperationSession.current.memberId !== (currentMember?.id || null)) {
    memberOperationSession.current = { memberId: currentMember?.id || null,
      generation: memberOperationSession.current.generation + 1 };
  }
  const [currentMonth,   setCurrentMonth]   = useState({ year: now.getFullYear(), month: now.getMonth() + 1 });
  const [settlements,    setSettlements]    = useState([]);
  const [balancete,      setBalancete]      = useState([]);
  const [settlementsLoading, setSettlementsLoading] = useState(false);
  const [settlementsError, setSettlementsError] = useState(null);
  const settlementIdempotencyKeys = useRef(new Map());

  // Estado de aprovação vem do banco, nunca do localStorage. Assim todos os
  // membros e dispositivos veem a mesma confirmação.
  useEffect(() => {
    const next = {};
    [...expenses, ...balanceteExpenses].forEach(exp => {
      (exp.sharedWith || []).forEach(share => {
        if (share.approvedAt) next[`${exp.id}:${share.memberId}`] = 'accepted';
      });
    });
    setSharedStatus(next);
  }, [expenses, balanceteExpenses]);
  const invoiceHistoryRef = useRef({});

  // ── Notification preferences ──────────────────────────────
  const DEFAULT_NOTIF_PREFS = { cardDue: true, installmentDue: true, diaDia80: true, investmentStale: true };
  const [notifPrefs, _setNotifPrefs] = useState(() => lsGet('ff_notif_prefs', DEFAULT_NOTIF_PREFS));
  function setNotifPrefs(v) { localStorage.setItem('ff_notif_prefs', JSON.stringify(v)); _setNotifPrefs(v); }

  // ── Resumo diário (popup no primeiro acesso do dia) ────────
  const [dailyDigest, setDailyDigest] = useState(null); // null = ainda não checado/nada a mostrar; [] ou [itens] após checar

  useEffect(() => {
    if (!isLoggedIn || !currentMember?.id) return;
    const storageKey = `ff_digest_shown_${currentMember.id}`;
    const todayKey = todayLocalISO();
    const lastShown = localStorage.getItem(storageKey);
    if (lastShown === todayKey) return;
    apiFetch('/notifications/daily-digest', { method: 'POST' })
      .then(res => {
        const items = res?.data || [];
        localStorage.setItem(storageKey, todayKey);
        if (items.length > 0) setDailyDigest(items);
      })
      .catch(() => {});
  }, [isLoggedIn, currentMember?.id]);

  function dismissDailyDigest() { setDailyDigest(null); }

  // ── Customizable lists ────────────────────────────────────
  const [investmentTypes, _setInvestmentTypes] = useState(() => lsGet('ff_inv_types', DEFAULT_INVESTMENT_TYPES));
  function setInvestmentTypes(v) { localStorage.setItem('ff_inv_types', JSON.stringify(v)); _setInvestmentTypes(v); }

  const [investmentPurposes, _setInvestmentPurposes] = useState(() => lsGet('ff_inv_purposes', DEFAULT_INVESTMENT_PURPOSES));
  function setInvestmentPurposes(v) { localStorage.setItem('ff_inv_purposes', JSON.stringify(v)); _setInvestmentPurposes(v); }

  const [incomeSources, _setIncomeSources] = useState(() => lsGet('ff_income_sources', DEFAULT_INCOME_SOURCES));
  function setIncomeSources(v) { localStorage.setItem('ff_income_sources', JSON.stringify(v)); _setIncomeSources(v); }


  // Build invoiceHistory map from paymentMethods
  const invoiceHistory = {};
  paymentMethods.forEach(pm => {
    if (pm.invoices && pm.invoices.length) {
      invoiceHistory[pm.id] = pm.invoices;
    }
  });

  const refreshSettlements = useCallback(async () => {
    const session = memberOperationSession.current;
    setSettlementsLoading(true);
    setSettlementsError(null);
    try {
      const [balanceData, settlementData] = await Promise.all([
        apiFetch(`/settlements/balancete?year=${currentMonth.year}&month=${currentMonth.month}`),
        apiFetch('/settlements'),
      ]);
      if (session !== memberOperationSession.current) return;
      setBalancete((balanceData || []).map(item => ({
        ...item,
        from: item.from?.id,
        to: item.to?.id,
        fromMember: item.from,
        toMember: item.to,
        amount: parseFloat(item.amount) || 0,
        items: (item.items || []).map(detail => ({
          ...detail,
          expId: detail.expenseId,
          desc: detail.description,
          amount: parseFloat(detail.amount) || 0,
        })),
        offsetItems: (item.offsetItems || []).map(detail => ({
          ...detail,
          expId: detail.expenseId,
          desc: detail.description,
          amount: parseFloat(detail.amount) || 0,
        })),
      })));
      setSettlements((settlementData || []).map(item => ({
        ...item,
        amount: parseFloat(item.amount) || 0,
      })));
    } catch (err) {
      if (session !== memberOperationSession.current) return;
      setSettlementsError(err?.message || 'Não foi possível carregar o balancete.');
      throw err;
    } finally {
      if (session === memberOperationSession.current) setSettlementsLoading(false);
    }
  }, [currentMonth.year, currentMonth.month]);

  // ── Load all app data (stale-while-revalidate + static TTL) ──
  // silent=true → refresh silencioso em background (sem loading spinner, sem re-buscar estáticos)
  const loadData = useCallback(async (year, month, silent = false) => {
    const key = `${year}-${month}`;

    // ── 1. Serve cache local imediatamente (stale-while-revalidate) ──
    // Dados estáticos: só serve na primeira carga da sessão (evita piscar ao trocar de mês)
    if (!staticLoadedAt.current) {
      const cs = lsGet('ff_cache_static', null);
      if (cs) {
        if (cs.members)     setMembers(cs.members);
        if (cs.categories)  setCategories(cs.categories);
        if (cs.investments) setInvestments(cs.investments);
        if (cs.payments)    setPaymentMethods(cs.payments);
      }
    }
    // Dados mensais: serve cache enquanto fetch fresco acontece em background
    const cachedExp = lsGet(`ff_exp_${key}`, null);
    const cachedInc = lsGet(`ff_inc_${key}`, null);
    if (cachedExp) setExpenses(prev => mergeMonthExp(prev, applyPaidOverride(cachedExp), year, month));
    if (cachedInc) setIncomes(prev => mergeMonthInc(prev, cachedInc, year, month));

    // Mostra loading indicator só se não há cache E não é refresh silencioso
    let didSetLoading = false;
    if (!silent && !cachedExp) { setLoadingData(true); didSetLoading = true; }

    // ── 2. Decide o que buscar no servidor ────────────────────
    // Dados estáticos: só re-busca se passaram mais de STATIC_TTL ms desde a última carga
    const needsStatic = !silent && (Date.now() - staticLoadedAt.current > STATIC_TTL);

    try {
      const promises = [];
      if (needsStatic) {
        promises.push(apiFetch('/members').then(d => ({ t: 'members', d })));
        promises.push(apiFetch('/categories').then(d => ({ t: 'cats', d })));
        promises.push(apiFetch('/investments').then(d => ({ t: 'inv', d })));
        promises.push(apiFetch('/payments').then(d => ({ t: 'pm', d })));
      }
      // Dados mensais: sempre busca (para mostrar novos lançamentos de outros membros)
      promises.push(apiFetch(`/expenses?year=${year}&month=${month}&limit=500`).then(d => ({ t: 'exp', d })));
      promises.push(apiFetch(`/incomes?year=${year}&month=${month}`).then(d => ({ t: 'inc', d })));
      // Notificações: sempre busca, mesmo em refresh silencioso — é o único jeito
      // de saber que uma nova chegou enquanto o usuário está em outra tela.
      promises.push(apiFetch('/notifications').then(d => ({ t: 'notif', d })));

      const results = await Promise.all(promises);

      const staticUpdates = {};
      results.forEach(({ t, d }) => {
        switch (t) {
          case 'members': {
            const v = (d || []).map(mapMember);
            setMembers(v); staticUpdates.members = v; break;
          }
          case 'cats': {
            const v = d || [];
            setCategories(v); staticUpdates.categories = v; break;
          }
          case 'inv': {
            const v = (d?.data || d || []).map(mapInvestment);
            setInvestments(v); staticUpdates.investments = v; break;
          }
          case 'pm': {
            const v = (d || []).map(mapPaymentMethod);
            setPaymentMethods(v); staticUpdates.payments = v; break;
          }
          case 'exp': {
            const mapped = applyPaidOverride((d?.data || d || []).map(mapExpense));
            setExpenses(prev => mergeMonthExp(prev, mapped, year, month));
            loadedExpMonths.current.add(key);
            lsSet(`ff_exp_${key}`, mapped);
            lsEvictOldMonths('ff_exp');
            break;
          }
          case 'inc': {
            const mapped = (d?.data || d || []).map(mapIncome);
            setIncomes(prev => mergeMonthInc(prev, mapped, year, month));
            loadedIncMonths.current.add(key);
            lsSet(`ff_inc_${key}`, mapped);
            lsEvictOldMonths('ff_inc');
            break;
          }
          case 'notif': {
            const list = d?.data || d || [];
            const unread = list.filter(n => !n.read).length;
            if (prevUnreadCount.current != null && unread > prevUnreadCount.current) {
              setNotifAlert(true);
              setTimeout(() => setNotifAlert(false), 6000);
            }
            prevUnreadCount.current = unread;
            setNotifications(list);
            break;
          }
        }
      });

      // Persiste cache estático se foi recarregado
      if (needsStatic && Object.keys(staticUpdates).length) {
        staticLoadedAt.current = Date.now();
        lsSet('ff_cache_static', staticUpdates);
      }
    } catch (err) {
      console.error('loadData error:', err);
      if (err.status === 401) {
        clearTokens(); setIsLoggedIn(false); setCurrentMember(null);
      }
    } finally {
      if (didSetLoading) setLoadingData(false);
    }
  }, []);

  // Operações são carregadas do servidor, sem cache financeiro compartilhado.
  const refreshMemberOperations = useCallback(async () => {
    const session = memberOperationSession.current;
    if (!session.memberId || !getToken()) return [];
    const request = ++memberOperationRequest.current;
    setMemberOperationsLoading(true);
    setMemberOperationsError(null);
    try {
      const response = await apiFetch('/member-operations');
      if (session !== memberOperationSession.current || request !== memberOperationRequest.current) return [];
      const list = Array.isArray(response) ? response : response.data || [];
      setMemberOperations(list);
      return list;
    } catch (error) {
      if (session === memberOperationSession.current && request === memberOperationRequest.current) {
        setMemberOperationsError(error?.message || 'Não foi possível carregar os valores entre membros.');
      }
      throw error;
    } finally {
      if (session === memberOperationSession.current && request === memberOperationRequest.current) setMemberOperationsLoading(false);
    }
  }, []);

  useEffect(() => {
    setMemberOperations([]);
    setMemberOperationsError(null);
    setMemberOperationsLoading(false);
    memberOperationKeys.current.clear();
    if (!isLoggedIn || !currentMember?.id) return;
    refreshMemberOperations().catch(() => {});
    const timer = setInterval(() => refreshMemberOperations().catch(() => {}), 60000);
    return () => clearInterval(timer);
  }, [isLoggedIn, currentMember?.id, refreshMemberOperations]);

  async function mutateMemberOperation(path, body) {
    const session = memberOperationSession.current;
    if (!session.memberId || !getToken()) return { success: false, message: 'Entre novamente na sua conta.' };
    const signature = JSON.stringify([session.memberId, path, body]);
    if (!memberOperationKeys.current.has(signature)) {
      memberOperationKeys.current.set(signature, resolveIdempotencyKey(null, () =>
        globalThis.crypto?.randomUUID?.() || `member-operation:${Date.now()}:${Math.random().toString(36).slice(2)}`));
    }
    let operation;
    let affectedOperations = [];
    try {
      const response = await apiFetch(path, { method: 'POST', body,
        headers: { 'Idempotency-Key': memberOperationKeys.current.get(signature) } });
      operation = response.operation || response;
      affectedOperations = response.operations || [operation];
    } catch (error) {
      return { success: false, message: error?.message || 'Não foi possível salvar. Tente novamente.' };
    }
    if (session !== memberOperationSession.current) return { success: false, message: 'A conta foi alterada. Recarregue os dados.' };
    memberOperationKeys.current.delete(signature);
    try {
      // Invalida todos os meses já vistos: conversão/recebimento pode afetar meses diferentes.
      const months = new Set([...loadedExpMonths.current, ...loadedIncMonths.current,
        `${currentMonth.year}-${currentMonth.month}`]);
      const affectedMonths = new Set(months);
      affectedOperations.forEach(item => {
        [item.date, item.dueDate, ...(item.receipts || []).map(r => r.date)].forEach(date => {
          if (date) { const d = parseLocalDate(date); affectedMonths.add(`${d.getFullYear()}-${d.getMonth() + 1}`); }
        });
      });
      // Uma série pode cobrir 72 meses: invalida todas as datas, mas recarrega
      // somente os meses já vistos. Os demais serão buscados ao navegar.
      affectedMonths.forEach(key => { const [year, month] = key.split('-').map(Number); invalidateMonthCache(year, month); });
      const updates = await Promise.all([...months].map(async key => {
        const [year, month] = key.split('-').map(Number);
        const [exp, inc] = await Promise.all([
          apiFetch(`/expenses?year=${year}&month=${month}&limit=500`),
          apiFetch(`/incomes?year=${year}&month=${month}`),
        ]);
        return { year, month, exp: (exp.data || exp || []).map(mapExpense), inc: (inc.data || inc || []).map(mapIncome) };
      }));
      if (session !== memberOperationSession.current) return { success: true, operation };
      updates.forEach(({ year, month, exp, inc }) => {
        setExpenses(prev => mergeMonthExp(prev, exp, year, month));
        setIncomes(prev => mergeMonthInc(prev, inc, year, month));
        lsSet(`ff_exp_${year}-${month}`, exp); lsSet(`ff_inc_${year}-${month}`, inc);
      });
      await Promise.all([refreshMemberOperations(), refreshSettlements()]);
    } catch (_) {
      if (session === memberOperationSession.current) {
        setMemberOperationsError('Registro salvo. Não foi possível atualizar todos os totais; toque em Atualizar.');
        refreshMemberOperations().catch(() => {});
      }
    }
    return { success: true, operation };
  }
  const fetchMemberOperationConversionEligibility = async id => {
    const session = memberOperationSession.current;
    const result = await apiFetch(`/member-operations/from-expense/${encodeURIComponent(id)}/eligibility`);
    if (session !== memberOperationSession.current) throw new Error('A conta foi alterada. Reabra a edição.');
    return result;
  };
  const createMemberOperation = data => mutateMemberOperation('/member-operations', data);
  const closeMemberOperationSeries = (id, data) => mutateMemberOperation(`/member-operations/series/${encodeURIComponent(id)}/close`, data);
  const recordMemberOperationReceipt = (id, data) => mutateMemberOperation(`/member-operations/${encodeURIComponent(id)}/receipts`, data);
  const reverseMemberOperationReceipt = (id, receiptId, data) => mutateMemberOperation(`/member-operations/${encodeURIComponent(id)}/receipts/${encodeURIComponent(receiptId)}/reverse`, data);
  const cancelMemberOperation = (id, data) => mutateMemberOperation(`/member-operations/${encodeURIComponent(id)}/cancel`, data);
  const convertExpenseToMemberOperation = (id, data) => mutateMemberOperation(`/member-operations/from-expense/${encodeURIComponent(id)}`, data);

  // ── Auto-login from stored token ───────────────────────────
  useEffect(() => {
    const token = getToken();
    if (!token) { setLoading(false); return; }

    // Conta local (criada quando API não tem endpoint de registro)
    if (token.startsWith('local_')) {
      try {
        const payload = JSON.parse(atob(token.replace('local_', '')));
        if (payload.exp > Date.now()) {
          const localMember = { id: payload.id, name: payload.name || 'Usuário', email: payload.email, role: 'MASTER1', color: 'var(--accent)', initials: 'U', diaDiaLimit: 300, salary: 0, isLocalAccount: true };
          setCurrentMember(localMember);
          setMembers([localMember]);
          setIsLoggedIn(true);
        } else {
          clearTokens();
        }
      } catch { clearTokens(); }
      setLoading(false);
      return;
    }

    // 1. Busca o membro dono do token (/auth/me) — garante que Carla não vira Valtercio após refresh
    apiFetch('/auth/me')
      .then(me => {
        const currentMe = mapMember(me);
        setCurrentMember(currentMe);
        setIsLoggedIn(true);
        // loadData é disparado pelo useEffect [isLoggedIn] abaixo — não chamar aqui para evitar duplicata
        // 2. Depois carrega a lista completa de membros da família
        return apiFetch('/members');
      })
      .then(data => {
        const mappedMembers = (data || []).map(mapMember);
        setMembers(mappedMembers);
      })
      .catch(() => {
        clearTokens();
        setIsLoggedIn(false);
        setCurrentMember(null);
      })
      .finally(() => {
        setLoading(false);
      });
  }, []);

  useEffect(() => {
    if (!isLoggedIn || !currentMember?.id) return;
    refreshSettlements().catch(() => {});
  }, [isLoggedIn, currentMember?.id, refreshSettlements]);

  // Reload data when month changes (only if logged in)
  useEffect(() => {
    if (isLoggedIn) {
      loadData(currentMonth.year, currentMonth.month);
    }
  }, [currentMonth.year, currentMonth.month, isLoggedIn]);

  // ── Refresh silencioso a cada 60s: busca novos lançamentos de outros membros ──
  useEffect(() => {
    if (!isLoggedIn) return;
    const id = setInterval(() => {
      loadData(currentMonth.year, currentMonth.month, true /* silent */);
    }, 60_000);
    return () => clearInterval(id);
  }, [isLoggedIn, currentMonth.year, currentMonth.month]);

  // ── Pré-carrega meses adjacentes 2s após o mês atual estar pronto ────────────
  useEffect(() => {
    if (!isLoggedIn) return;
    const t = setTimeout(() => {
      const prevDate = new Date(currentMonth.year, currentMonth.month - 2);
      const nextDate = new Date(currentMonth.year, currentMonth.month);
      const adjacent = [
        [prevDate.getFullYear(), prevDate.getMonth() + 1],
        [nextDate.getFullYear(), nextDate.getMonth() + 1],
      ];
      adjacent.forEach(([y, m]) => {
        const k = `${y}-${m}`;
        if (loadedExpMonths.current.has(k) && loadedIncMonths.current.has(k)) return;
        // Marca como em carregamento antes para não duplicar fetches concorrentes
        loadedExpMonths.current.add(k);
        loadedIncMonths.current.add(k);
        Promise.all([
          apiFetch(`/expenses?year=${y}&month=${m}&limit=500`),
          apiFetch(`/incomes?year=${y}&month=${m}`),
        ]).then(([expData, incData]) => {
          const exps = applyPaidOverride((expData?.data || expData || []).map(mapExpense));
          const incs = (incData?.data || incData || []).map(mapIncome);
          setExpenses(prev => mergeMonthExp(prev, exps, y, m));
          setIncomes(prev => mergeMonthInc(prev, incs, y, m));
          lsSet(`ff_exp_${k}`, exps); lsEvictOldMonths('ff_exp');
          lsSet(`ff_inc_${k}`, incs); lsEvictOldMonths('ff_inc');
        }).catch(() => {
          // Desfaz a marcação se falhar — próxima navegação tentará novamente
          loadedExpMonths.current.delete(k);
          loadedIncMonths.current.delete(k);
        });
      });
    }, 2000);
    return () => clearTimeout(t);
  }, [isLoggedIn, currentMonth.year, currentMonth.month]);

  // ── Carrega receitas de um mês específico (merge) — históricos de 6 meses ──
  async function fetchMonthIncomes(year, month) {
    const key = `${year}-${month}`;
    if (loadedIncMonths.current.has(key)) return;
    loadedIncMonths.current.add(key);
    try {
      const incData = await apiFetch(`/incomes?year=${year}&month=${month}`);
      const incs = (incData?.data || incData || []).map(mapIncome);
      setIncomes(prev => mergeMonthInc(prev, incs, year, month));
      lsSet(`ff_inc_${key}`, incs);
      lsEvictOldMonths('ff_inc');
    } catch {
      loadedIncMonths.current.delete(key);
    }
  }

  // ── Carrega despesas de um mês específico (merge, sem substituir) ──
  async function fetchMonthExpenses(year, month) {
    const key = `${year}-${month}`;
    if (loadedExpMonths.current.has(key)) return; // já carregado
    loadedExpMonths.current.add(key);
    try {
      const expData = await apiFetch(`/expenses?year=${year}&month=${month}&limit=500`);
      const newExps = applyPaidOverride((expData?.data || expData || []).map(mapExpense));
      setExpenses(prev => mergeMonthExp(prev, newExps, year, month));
      lsSet(`ff_exp_${key}`, newExps);
      lsEvictOldMonths('ff_exp');
    } catch {
      loadedExpMonths.current.delete(key); // permite retry
    }
  }

  // Cache financeiro local (despesas/receitas por mês) é de UM membro. Sessão que
  // expira sem "Sair" deixava o cache do anterior, exibido ao próximo login no
  // mesmo aparelho até a API responder.
  function purgeFinancialCache({ includeLoginHistory = false } = {}) {
    try {
      Object.keys(localStorage)
        .filter(k =>
          k.startsWith('ff_exp_') ||
          k.startsWith('ff_inc_') ||
          k === 'ff_cache_static' ||
          k === 'ff_shared_status' ||
          k === 'ff_family_members' ||
          k === 'ff_cache_owner' ||
          (includeLoginHistory && k === 'ff_login_history')
        )
        .forEach(k => localStorage.removeItem(k));
    } catch {}
  }

  // ── Auth ───────────────────────────────────────────────────
  async function login(email, password) {
    setAuthError(null);
    const data = await apiFetch('/auth/login', {
      method: 'POST',
      body: { email, password },
    });
    setTokens(data.accessToken, data.refreshToken);
    const member = mapMember(data.member);
    let owner = null;
    try { owner = localStorage.getItem('ff_cache_owner'); } catch {}
    if (owner !== member.id) {
      purgeFinancialCache();
      loadedExpMonths.current.clear();
      loadedIncMonths.current.clear();
      staticLoadedAt.current = 0;
      try { localStorage.setItem('ff_cache_owner', member.id); } catch {}
    }
    setCurrentMember(member);
    setIsLoggedIn(true);
    const n = new Date();
    loadData(n.getFullYear(), n.getMonth() + 1);
    return member;
  }

  function logout() {
    memberOperationSession.current = { memberId: null, generation: memberOperationSession.current.generation + 1 };
    ++memberOperationRequest.current;
    setMemberOperations([]);
    setMemberOperationsError(null);
    memberOperationKeys.current.clear();
    clearTokens();
    // ── Segurança: limpa cache financeiro do localStorage ─────
    // Impede que o próximo usuário (outro membro ou terceiro) acesse
    // os dados financeiros do usuário anterior sem nova autenticação.
    purgeFinancialCache({ includeLoginHistory: true });
    // Reseta refs de controle para forçar re-fetch na próxima sessão
    loadedExpMonths.current.clear();
    loadedIncMonths.current.clear();
    staticLoadedAt.current = 0;
    // Limpa estado React
    setIsLoggedIn(false);
    setCurrentMember(null);
    setExpenses([]);
    setIncomes([]);
    setInvestments([]);
    setPaymentMethods([]);
    setCategories([]);
    setNotifications([]);
    setMembers([]);
    setSettlements([]);
    setBalanceteExpenses([]);
    setSharedStatus({});
  }

  // ── LGPD art. 18, VI — Exclusão real da conta ─────────────
  async function deleteAccount() {
    try {
      // Tenta endpoint de exclusão real no backend
      await apiFetch(`/members/${currentMember?.id}`, { method: 'DELETE' });
    } catch {
      // Se o endpoint ainda não existir, a exclusão local ainda acontece;
      // a remoção no servidor deve ser solicitada à equipe via e-mail
    }
    logout();
  }

  // ── Segurança: alterar e-mail (exige senha atual) ─────────
  async function updateEmail(newEmail, password) {
    // Re-autentica para confirmar identidade antes de trocar o e-mail (LGPD art. 46)
    await apiFetch('/auth/login', { method: 'POST', body: { email: currentMember.email, password } });
    try {
      await apiFetch('/auth/update-email', { method: 'PATCH', body: { email: newEmail } });
    } catch {
      // Tenta endpoint alternativo
      await apiFetch(`/members/${currentMember.id}`, { method: 'PATCH', body: { email: newEmail } }).catch(() => {});
    }
    setCurrentMember(prev => ({ ...prev, email: newEmail }));
    setMembers(prev => prev.map(m => m.id === currentMember?.id ? { ...m, email: newEmail } : m));
    saveLoginHistory({ ...currentMember, email: newEmail });
  }

  // ── Segurança: alterar senha ───────────────────────────────
  async function updatePassword(currentPassword, newPassword) {
    // O servidor confere a senha atual (LGPD art. 46). Qualquer erro sobe para a
    // tela — antes caía numa rota inexistente e a tela dizia "alterada com sucesso".
    const r = await apiFetch('/auth/change-password', { method: 'POST', body: { currentPassword, newPassword } });
    // Outras sessões caem; esta recebe tokens novos para não ser deslogada depois.
    if (r?.accessToken && r?.refreshToken) setTokens(r.accessToken, r.refreshToken);
  }

  // ── Notifications ──────────────────────────────────────────
  function markNotificationRead(id) {
    setNotifications(prev => prev.map(n => n.id === id ? { ...n, read: true } : n));
    apiFetch(`/notifications/${id}/read`, { method: 'PATCH' }).catch(() => {});
  }
  function markAllRead() {
    setNotifications(prev => prev.map(n => ({ ...n, read: true })));
    apiFetch('/notifications/read-all', { method: 'POST' }).catch(() => {});
  }

  // ── Invalidação de cache mensal após mutações ─────────────
  // Chama após qualquer operação que altera dados do mês corrente para
  // garantir que o stale-while-revalidate sirva dados frescos na próxima visita.
  function invalidateMonthCache(year, month) {
    const key = `${year}-${month}`;
    loadedExpMonths.current.delete(key);
    loadedIncMonths.current.delete(key);
    try { localStorage.removeItem(`ff_exp_${key}`); } catch {}
    try { localStorage.removeItem(`ff_inc_${key}`); } catch {}
  }

  // Uma importação pode criar parcelas em meses já consultados. Atualiza
  // somente esses meses; as demais datas serão buscadas ao navegar.
  async function refreshImportedInvoiceData() {
    const session = memberOperationSession.current;
    if (!session.memberId || !getToken()) throw new Error('Entre novamente para atualizar os totais.');
    const months = new Set([...loadedExpMonths.current, ...loadedIncMonths.current,
      `${currentMonth.year}-${currentMonth.month}`]);
    try {
      Object.keys(localStorage).filter(key => key.startsWith('ff_exp_') || key.startsWith('ff_inc_'))
        .forEach(key => localStorage.removeItem(key));
    } catch {}
    loadedExpMonths.current.clear(); loadedIncMonths.current.clear();
    const jobs = [...months].map(async key => {
      const [year, month] = key.split('-').map(Number);
      const [exp, inc] = await Promise.all([
        apiFetch(`/expenses?year=${year}&month=${month}&limit=500`),
        apiFetch(`/incomes?year=${year}&month=${month}`),
      ]);
      if (session !== memberOperationSession.current) return;
      const expensesForMonth = applyPaidOverride((exp.data || exp || []).map(mapExpense));
      const incomesForMonth = (inc.data || inc || []).map(mapIncome);
      setExpenses(prev => mergeMonthExp(prev, expensesForMonth, year, month));
      setIncomes(prev => mergeMonthInc(prev, incomesForMonth, year, month));
      loadedExpMonths.current.add(key); loadedIncMonths.current.add(key);
      lsSet(`ff_exp_${key}`, expensesForMonth); lsSet(`ff_inc_${key}`, incomesForMonth);
    });
    jobs.push((async () => {
      const payments = (await apiFetch('/payments') || []).map(mapPaymentMethod);
      if (session !== memberOperationSession.current) return;
      setPaymentMethods(payments);
      const cached = lsGet('ff_cache_static', null);
      if (cached) lsSet('ff_cache_static', { ...cached, payments });
    })());
    jobs.push(refreshSettlements());
    const results = await Promise.allSettled(jobs);
    if (session !== memberOperationSession.current) return;
    if (results.some(result => result.status === 'rejected')) {
      throw new Error('Importação concluída. Não foi possível atualizar todos os totais; tente atualizar novamente.');
    }
  }

  // ── Expenses ───────────────────────────────────────────────
  // Aceita o OBJETO da despesa clicada (preferido) ou o id.
  // Importante: o mesmo id pode existir duas vezes no array — o registro REAL do mês e
  // uma PROJEÇÃO legada de outro mês (mesmo id, isProjected:true). Por isso usamos o
  // objeto clicado para decidir; só bloqueamos quando NÃO há registro real desse id.
  async function markExpensePaid(expOrId) {
    let exp = (expOrId && typeof expOrId === 'object') ? expOrId : null;
    if (!exp) {
      const id = expOrId;
      // Prefere o registro real (não projetado) com esse id
      exp = expenses.find(e => e.id === id && !e.isProjected) || expenses.find(e => e.id === id);
    }
    if (!exp) return false;
    if (exp.origin === 'member_operation' || String(exp.id).startsWith('op-expense:')) return new Error('O recebedor deve confirmar o pagamento em Entre membros.');
    // Projeção legada: id aponta para a linha de outro mês — ainda não existe registro
    // real para esta ocorrência. Materializa a ocorrência deste mês já como paga, em vez
    // de tentar marcar (incorretamente) o registro de outro mês.
    if (exp.isProjected) {
      const sharedPayload = exp.shared
        ? buildExpenseSharesPayload(exp.sharedWith, exp.shareMode || exp.sharedWith?.[0]?.mode || 'percentage')
        : undefined;
      const payload = {
        desc:                exp.desc,
        value:               exp.value,
        date:                exp.date,
        categoryId:          exp.categoryId,
        type:                exp.type || 'fixed',
        status:              'paid',
        paymentMethodId:     exp.pmId || undefined,
        responsibleMemberId: exp.shared ? undefined : exp.responsibleMemberId,
        shared:              exp.shared || false,
        expenseShares:       sharedPayload,
        visibility:          exp.visibility || 'open',
        blocked:             exp.blocked || false,
        isDiaDia:            exp.isDiaDia || false,
      };
      try {
        const created = await apiFetch('/expenses', { method: 'POST', body: payload });
        const mapped = mapExpense(created);
        setExpenses(prev => [...prev.filter(e => !(e.id === exp.id && e.isProjected)), mapped]);
        setBalanceteExpenses(prev => [...prev.filter(e => !(e.id === exp.id && e.isProjected)), mapped]);
        invalidateMonthCache(currentMonth.year, currentMonth.month);
        return true;
      } catch (err) {
        return err;
      }
    }
    const id = exp.id;
    pendingPaidIds.current.add(id); // protege contra refetch em voo revertendo o status
    // Marca só os registros REAIS desse id (não as projeções de outros meses)
    setExpenses(prev => prev.map(e => (e.id === id && !e.isProjected) ? { ...e, status: 'paid' } : e));
    try {
      await apiFetch(`/expenses/${id}/pay`, { method: 'PATCH' });
      invalidateMonthCache(currentMonth.year, currentMonth.month);
      return true;
    } catch (err) {
      // PATCH falhou (ex: despesa de cartão exige quitação pela fatura, ou quem
      // clicou não é quem criou a despesa) — reverte o otimismo, senão a tela
      // mostra "paga" pra sempre até o próximo refetch derrubar silenciosamente.
      pendingPaidIds.current.delete(id);
      setExpenses(prev => prev.map(e => (e.id === id && !e.isProjected) ? { ...e, status: exp.status } : e));
      return err;
    }
  }

  async function fetchInvoicePreview(paymentMethodId, month, year) {
    const preview = await apiFetch(`/payments/${paymentMethodId}/invoices/preview?month=${month}&year=${year}`);
    return mapInvoicePreview(preview);
  }

  function reconcileInvoiceItems(preview) {
    const statuses = new Map((preview.items || []).map(item => [item.expenseId || item.id, item.status]));
    const reconcile = expense => {
      const status = statuses.get(expense.id);
      return status ? { ...expense, status } : expense;
    };
    setExpenses(prev => prev.map(reconcile));
    setBalanceteExpenses(prev => prev.map(reconcile));
  }

  async function payInvoice(paymentMethodId, month, year, expectedFingerprint, idempotencyKey) {
    const paid = await apiFetch(`/payments/${paymentMethodId}/invoices/pay`, {
      method: 'POST',
      headers: { 'Idempotency-Key': idempotencyKey },
      body: { month, year, expectedFingerprint },
    });
    const mapped = mapInvoicePreview(paid);
    reconcileInvoiceItems(mapped);
    invalidateMonthCache(year, month);
    return mapped;
  }

  async function reopenInvoice(paymentMethodId, month, year, reason, idempotencyKey) {
    const reopened = await apiFetch(`/payments/${paymentMethodId}/invoices/reopen`, {
      method: 'POST',
      headers: { 'Idempotency-Key': idempotencyKey },
      body: { month, year, reason },
    });
    const mapped = mapInvoicePreview(reopened);
    reconcileInvoiceItems(mapped);
    invalidateMonthCache(year, month);
    return mapped;
  }

  async function deleteExpense(id) {
    const exp = expenses.find(e => e.id === id);
    if (exp?.origin === 'member_operation' || String(id).startsWith('op-expense:')) return false;
    if (exp?.status === 'paid') return false; // Despesas pagas não podem ser apagadas

    // Remoção optimista — some imediatamente da UI
    setExpenses(prev => prev.filter(e => e.id !== id));
    setBalanceteExpenses(prev => prev.filter(e => e.id !== id));

    try {
      await apiFetch(`/expenses/${id}`, { method: 'DELETE' });
      // Só invalida o cache depois do DELETE confirmado no servidor
      // (evita race condition onde a sincronização silenciosa busca antes do DELETE completar)
      invalidateMonthCache(currentMonth.year, currentMonth.month);
      refreshAfterExpenseChange();
      return true;
    } catch (err) {
      // DELETE falhou (ex: sem permissão para apagar despesa de outro membro)
      // Restaura a despesa no estado para não perder dados
      setExpenses(prev => {
        // Insere de volta na posição correta (evita duplicar se já estiver presente)
        if (prev.some(e => e.id === id)) return prev;
        return [...prev, exp].sort((a, b) => parseLocalDate(b.date) - parseLocalDate(a.date));
      });
      setBalanceteExpenses(prev => {
        if (prev.some(e => e.id === id)) return prev;
        return [...prev, exp];
      });
      return false; // sinaliza falha ao chamador
    }
  }

  // Apaga uma série (parcelada/fixa): scope 'one' = só esta; 'future' = esta e as
  // dos meses à frente (date >= a desta). Não apaga parcelas já pagas.
  async function deleteExpenseSeries(originalExpense, scope = 'future') {
    if (!originalExpense) return false;
    if (scope === 'one') return deleteExpense(originalExpense.id);

    // Série identificada: o servidor apaga ESTA série (nunca por nome — duas
    // compras "PAYGO 6x" em cartões diferentes eram apagadas juntas), inclusive
    // meses ainda não carregados na tela, numa transação.
    if (originalExpense.seriesId) {
      try {
        const r = await apiFetch(`/expense-series/${originalExpense.seriesId}?fromOccurrenceId=${originalExpense.id}`, { method: 'DELETE' });
        const ids = new Set(r?.deletedIds || []);
        setExpenses(prev => prev.filter(e => !ids.has(e.id)));
        setBalanceteExpenses(prev => prev.filter(e => !ids.has(e.id)));
        invalidateMonthCache(currentMonth.year, currentMonth.month);
        refreshAfterExpenseChange();
        return r?.deleted > 0 ? r : false;
      } catch {
        return false;
      }
    }

    // Legado (despesa sem série): heurística antiga, só para dados antigos.
    const baseTime = parseLocalDate(originalExpense.date).getTime();
    const isInstallment = originalExpense.type === 'installment';
    const src = (balanceteExpenses && balanceteExpenses.length ? balanceteExpenses : expenses);
    const series = src.filter(e => {
      if (e.memberId !== originalExpense.memberId) return false;
      if (e.type !== originalExpense.type) return false;
      if ((e.desc || '').trim().toLowerCase() !== (originalExpense.desc || '').trim().toLowerCase()) return false;
      if (isInstallment && parseInt(e.installments) !== parseInt(originalExpense.installments)) return false;
      if (e.status === 'paid') return false; // não apaga já pagas
      return parseLocalDate(e.date).getTime() >= baseTime; // este mês e os futuros
    });
    if (!series.length) return false;
    const ids = new Set(series.map(e => e.id));

    // Remoção otimista
    setExpenses(prev => prev.filter(e => !ids.has(e.id)));
    setBalanceteExpenses(prev => prev.filter(e => !ids.has(e.id)));

    // DELETE em paralelo (se algum falhar, o próximo refresh recupera)
    await Promise.allSettled(series.map(e => apiFetch(`/expenses/${e.id}`, { method: 'DELETE' })));
    invalidateMonthCache(currentMonth.year, currentMonth.month);
    return true;
  }

  async function deleteIncome(id) {
    // Receitas sempre podem ser apagadas (ao contrário de despesas pagas)
    const previous = incomes.find(i => i.id === id);
    if (previous?.origin === 'member_operation' || String(id).startsWith('op-income:')) return new Error('Gerencie este registro em Entre membros.');
    setIncomes(prev => prev.filter(i => i.id !== id));
    try {
      await apiFetch(`/incomes/${id}`, { method: 'DELETE' });
      invalidateMonthCache(currentMonth.year, currentMonth.month);
      return true;
    } catch (err) {
      if (previous) setIncomes(prev => prev.some(i => i.id === id) ? prev : [...prev, previous]);
      return err;
    }
  }

  async function deleteInvestment(id) {
    setInvestments(prev => prev.filter(i => i.id !== id));
    apiFetch(`/investments/${id}`, { method: 'DELETE' }).catch(() => {});
  }

  async function addExpense(exp) {
    const sharedPayload = exp.shared
      ? buildExpenseSharesPayload(exp.sharedWith, exp.shareMode || exp.sharedWith?.[0]?.mode || 'percentage')
      : undefined;

    if (exp.type === 'fixed' || (exp.type === 'installment' && (exp.installments || 1) > 1)) {
      const idempotencyKey = resolveIdempotencyKey(exp._idempotencyKey, () =>
        globalThis.crypto?.randomUUID?.() || `expense-series:${Date.now()}`);
      const response = await apiFetch('/expenses/series', {
        method: 'POST',
        headers: { 'Idempotency-Key': idempotencyKey },
        body: buildExpenseSeriesCreatePayload(exp),
      });
      const mapped = mapExpenseSeriesResponse(response);
      if (!mapped.occurrences.length) throw new Error('A API não retornou as ocorrências criadas.');
      setExpenses(prev => [...prev, ...mapped.occurrences.filter(item => !prev.some(old => old.id === item.id))]);
      setBalanceteExpenses(prev => [...prev, ...mapped.occurrences.filter(item => !prev.some(old => old.id === item.id))]);
      refreshAfterExpenseChange();
      return mapped.occurrences[0];
    }

    // ── Única ────────────────────────────────────────────────
    // Se usa cartão de terceiro → gera receita automaticamente para o dono do cartão
    // Dia a Dia pago em débito ou PIX → já entra como PAGO (o dinheiro sai na hora)
    const _pm = paymentMethods.find(p => p.id === exp.pmId);
    const _isImmediate = _pm && (_pm.type === 'debit' || _pm.type === 'pix');
    const _effStatus = (exp.isDiaDia && _isImmediate) ? 'paid' : (exp.status || 'pending');
    const payload = {
      desc:               exp.desc,
      value:              parseFloat(exp.value) || exp.value,
      date:               exp.date,
      categoryId:         exp.categoryId,
      type:               exp.type       || 'single',
      status:             _effStatus,
      paymentMethodId:    exp.pmId       || undefined,
      responsibleMemberId: exp.shared ? undefined : exp.responsibleMemberId,
      shared:             exp.shared     || false,
      expenseShares:      sharedPayload,
      visibility:         exp.visibility || 'open',
      blocked:            exp.blocked    || false,
      isDiaDia:           exp.isDiaDia   || false,
      frequency:          exp.frequency || undefined,
    };
    const created = await apiFetch('/expenses', { method: 'POST', body: payload });
    const mapped = mapExpense(created);
    setExpenses(prev => [...prev, mapped]);
    setBalanceteExpenses(prev => [...prev, mapped]);
    refreshAfterExpenseChange();
    return mapped;
  }

  // Lançar/editar/apagar despesa cria, muda ou remove Reembolsos (receitas) no
  // servidor e mexe no Balancete — sem recarregar, "A Receber", a receita do mês
  // e o saldo ficavam desatualizados até recarregar a página.
  function refreshAfterExpenseChange() {
    loadedIncMonths.current.clear();
    try { Object.keys(localStorage).filter(k => k.startsWith('ff_inc_')).forEach(k => localStorage.removeItem(k)); } catch {}
    fetchMonthIncomes(currentMonth.year, currentMonth.month);
    refreshSettlements().catch(() => {});
  }

  // ── Update functions ───────────────────────────────────────
  async function updateExpense(id, updates) {
    const exp = expenses.find(e => e.id === id);
    if (exp?.origin === 'member_operation' || String(id).startsWith('op-expense:')) throw new Error('Gerencie este registro em Entre membros.');
    if (exp?.status === 'paid') throw new Error('Despesas pagas não podem ser editadas.');
    const payload = {
      desc:            updates.desc,
      value:           updates.value,
      date:            updates.date,
      categoryId:      updates.categoryId,
      type:            updates.type,
      status:          updates.status,
      paymentMethodId: updates.pmId,
      responsibleMemberId: updates.shared ? undefined : updates.responsibleMemberId,
      shared:          updates.shared,
      expenseShares:   updates.shared && updates.sharedWith?.length
        ? buildExpenseSharesPayload(updates.sharedWith, updates.shareMode || updates.sharedWith?.[0]?.mode || 'percentage')
        : (updates.shared === false ? [] : undefined),
      visibility:      updates.visibility,
      blocked:         updates.blocked,
      frequency:       updates.frequency,
    };
    const updated = await apiFetch(`/expenses/${id}`, { method: 'PATCH', body: payload });
    const mapped = mapExpense(updated);
    setExpenses(prev => prev.map(e => e.id === id ? mapped : e));
    setBalanceteExpenses(prev => prev.map(e => e.id === id ? mapped : e));
    invalidateMonthCache(currentMonth.year, currentMonth.month);
    refreshAfterExpenseChange();
    return mapped;
  }

  async function fetchExpenseSeriesDetails(seriesId) {
    if (!seriesId) throw new Error('Série não identificada.');
    const response = await apiFetch(`/expense-series/${seriesId}`);
    const mapped = mapExpenseSeriesResponse(response);
    if (!mapped.series || !mapped.occurrences.length) {
      throw new Error('A API não retornou os detalhes completos da série.');
    }
    return mapped;
  }

  async function updateExpenseSeries(newData, originalExpense, scope) {
    if (!originalExpense?.seriesId) throw new Error('Esta despesa não possui uma série identificável.');
    const expectedVersion = Number(newData.seriesVersion ?? originalExpense.seriesVersion ?? originalExpense.series?.currentVersion);
    if (!Number.isInteger(expectedVersion) || expectedVersion < 1) {
      throw new Error('A versão atual da série não foi informada pela API. Recarregue e tente novamente.');
    }
    if (!['occurrence', 'future', 'series'].includes(scope)) throw new Error('Escolha o escopo da edição.');
    const idempotencyKey = resolveIdempotencyKey(newData._idempotencyKey, () =>
      globalThis.crypto?.randomUUID?.() || `expense-series-edit:${originalExpense.seriesId}:${Date.now()}`);
    const requestBody = buildExpenseSeriesEditBody(newData, originalExpense, scope, expectedVersion);
    if (Object.keys(requestBody.changes).length === 0) return [originalExpense];
    const response = await apiFetch(`/expense-series/${originalExpense.seriesId}`, {
      method: 'PATCH',
      headers: { 'Idempotency-Key': idempotencyKey },
      body: requestBody,
    });
    const mapped = mapExpenseSeriesResponse(response);
    if (!mapped.occurrences.length) throw new Error('A API não retornou as ocorrências atualizadas.');
    const byId = new Map(mapped.occurrences.map(e => [e.id, e]));
    const reconcile = e => byId.get(e.id) || e;
    setExpenses(prev => prev.map(reconcile));
    setBalanceteExpenses(prev => prev.map(reconcile));
    invalidateMonthCache(currentMonth.year, currentMonth.month);
    refreshAfterExpenseChange();
    return mapped.occurrences;
  }

  async function updateIncome(id, updates) {
    const previous = incomes.find(i => i.id === id);
    if (previous?.origin === 'member_operation' || String(id).startsWith('op-income:')) return new Error('Confirme o recebimento em Entre membros.');
    // Atualização otimista — reflete imediatamente sem bloquear por status
    setIncomes(prev => prev.map(i => i.id === id ? { ...i, ...updates } : i));
    // Não sincroniza com API se for id temporário (ainda não persistido)
    if (id?.startsWith('temp_')) return true;
    try {
      await apiFetch(`/incomes/${id}`, { method: 'PATCH', body: updates });
      // Receita recebida/voltada a prevista é o que quita (ou reabre) a dívida
      // no balancete — sem refetch o card continuaria mostrando o saldo antigo.
      if (updates.status) refreshSettlements().catch(() => {});
      return true;
    } catch (err) {
      if (previous) setIncomes(prev => prev.map(i => i.id === id ? previous : i));
      return err;
    }
  }

  // Marca todas as receitas previstas de um mês como recebidas
  async function markAllReceivedByMonth(month, year) {
    const toMark = incomes.filter(i => {
      if (i.status === 'received') return false;
      // Exclui receitas projetadas (recorrentes mensais sem registro próprio)
      if (i._projected) return false;
      // Reembolso recebido quita dívida no Balancete — só por confirmação
      // individual do credor, nunca em lote junto com salário/renda própria.
      if (isMemberReceivableIncome(i)) return false;
      const d = new Date((i.date || '').length === 10 ? i.date + 'T00:00:00' : i.date);
      return d.getFullYear() === year && d.getMonth() + 1 === month;
    });
    if (!toMark.length) return 0;

    // Atualização otimista imediata
    setIncomes(prev => prev.map(i =>
      toMark.some(t => t.id === i.id) ? { ...i, status: 'received' } : i
    ));

    // Dispara todas as chamadas em paralelo; as que falharem voltam ao estado
    // anterior em vez de ficarem "recebidas" só na tela.
    const results = await Promise.all(toMark
      .filter(i => !i.id?.startsWith('temp_'))
      .map(i => apiFetch(`/incomes/${i.id}`, { method: 'PATCH', body: { status: 'received' } })
        .then(() => null, () => i.id))
    );
    const failedIds = new Set(results.filter(Boolean));
    if (failedIds.size) {
      setIncomes(prev => prev.map(i => failedIds.has(i.id) ? { ...i, status: 'expected' } : i));
    }
    refreshSettlements().catch(() => {});

    return toMark.length - failedIds.size;
  }

  async function updateInvestment(id, updates) {
    setInvestments(prev => prev.map(i => i.id === id ? { ...i, ...updates } : i));
    const payload = {
      name:        updates.name,
      type:        updates.type,
      bank:        updates.bank,
      purpose:     updates.purpose,
      value:       updates.value,
      monthlyRate: updates.monthlyRate,
      memberId:    updates.memberId,
      visibility:  updates.visibility || 'open',
    };
    apiFetch(`/investments/${id}`, { method: 'PATCH', body: payload }).catch(() => {});
  }

  async function addInvestment(inv) {
    try {
      const payload = {
        name:        inv.name,
        type:        inv.type,
        bank:        inv.bank,
        purpose:     inv.purpose || 'other',
        value:       inv.value,
        monthlyRate: inv.monthlyRate || 0,
        memberId:    inv.memberId || currentMember?.id,
        visibility:  inv.visibility || 'open',
      };
      const created = await apiFetch('/investments', { method: 'POST', body: payload });
      setInvestments(prev => [...prev, mapInvestment(created)]);
    } catch (err) {
      const local = { ...inv, id: 'inv' + Date.now(), history: [], visibility: inv.visibility || 'open' };
      setInvestments(prev => [...prev, local]);
    }
  }

  // ── Auth: Register new family ─────────────────────────────
  async function register(name, email, password) {
    try {
      const data = await apiFetch('/auth/register', { method: 'POST', body: { name, email, password } });
      setTokens(data.accessToken, data.refreshToken);
      const member = mapMember(data.member || data.user || { id: 'tmp', name, email, role: 'MASTER1', diaDiaLimit: 300 });
      setCurrentMember(member);
      setMembers([member]);
      setIsLoggedIn(true);
      const n = new Date();
      loadData(n.getFullYear(), n.getMonth() + 1);
      return member;
    } catch (err) {
      // Fallback local somente se o endpoint não existir (404) — ambiente sem servidor
      if (err.status === 404) {
        const localId  = 'local_' + Date.now();
        const colors   = ['#0D9488','#7C3AED','#EA580C','#0284C7'];
        const color    = colors[name.charCodeAt(0) % colors.length];
        const initials = name.split(' ').map(w => w[0]).slice(0, 2).join('').toUpperCase();
        const member   = { id: localId, name, email, role: 'MASTER1', color, initials, diaDiaLimit: 300, salary: 0, isLocalAccount: true };
        const localToken = 'local_' + btoa(JSON.stringify({ id: localId, name, email, exp: Date.now() + 86400000 }));
        setTokens(localToken, null);
        setCurrentMember(member);
        setMembers([member]);
        setIsLoggedIn(true);
        return member;
      }
      throw err; // 409 email duplicado, 400 validação — exibe mensagem da API
    }
  }

  // ── Member CRUD ────────────────────────────────────────────
  async function addMember(m) {
    try {
      const created = await apiFetch('/members', { method: 'POST', body: m });
      const mapped = mapMember(created);
      setMembers(prev => [...prev, mapped]);
      return mapped;
    } catch (err) {
      // Fallback local apenas se o endpoint não existir (404) ou sem conexão
      if (err.status === 404 || !err.status) {
        const local = { ...m, id: 'm_' + Date.now(), role: roleLabel(m.role || 'CHILD'), diaDiaLimit: 200, salary: 0 };
        setMembers(prev => [...prev, local]);
        return local;
      }
      // Outros erros (409 e-mail duplicado, 403 sem permissão, etc.) sobem para a UI
      throw err;
    }
  }

  async function updateMember(id, updates) {
    const updated = await apiFetch(`/members/${id}`, { method: 'PATCH', body: updates });
    const safeUpdated = mapMember(updated);
    setMembers(prev => prev.map(m => m.id === id ? { ...m, ...safeUpdated } : m));
    // Atualizações de perfil nunca podem substituir a identidade autenticada.
    if (id === currentMember?.id) setCurrentMember(m => ({ ...m, ...safeUpdated, id: m.id }));
    return safeUpdated;
  }

  // ── Category CRUD ─────────────────────────────────────────
  async function addCategory(cat) {
    try {
      const created = await apiFetch('/categories', { method: 'POST', body: cat });
      setCategories(prev => [...prev, created]);
    } catch {
      setCategories(prev => [...prev, { ...cat, id: 'cat_' + Date.now() }]);
    }
  }
  async function updateCategory(id, updates) {
    setCategories(prev => prev.map(c => c.id === id ? { ...c, ...updates } : c));
    apiFetch(`/categories/${id}`, { method: 'PATCH', body: updates }).catch(() => {});
  }
  async function deleteCategory(id) {
    setCategories(prev => prev.filter(c => c.id !== id));
    apiFetch(`/categories/${id}`, { method: 'DELETE' }).catch(() => {});
  }

  // ── Payment Method CRUD ────────────────────────────────────
  async function addPaymentMethod(pm) {
    try {
      const created = await apiFetch('/payments', { method: 'POST', body: pm });
      setPaymentMethods(prev => [...prev, mapPaymentMethod(created)]);
    } catch {
      setPaymentMethods(prev => [...prev, mapPaymentMethod({ ...pm, id: 'pm_' + Date.now(), invoices: [] })]);
    }
  }

  async function updatePaymentMethod(id, updates) {
    setPaymentMethods(prev => prev.map(pm => pm.id === id ? { ...pm, ...updates } : pm));
    apiFetch(`/payments/${id}`, { method: 'PATCH', body: updates }).catch(() => {});
  }

  async function deletePaymentMethod(id) {
    setPaymentMethods(prev => prev.filter(pm => pm.id !== id));
    apiFetch(`/payments/${id}`, { method: 'DELETE' }).catch(() => {});
  }

  async function addIncome(inc) {
    const recurrence = inc.recurrence || 'single';

    // ── Mensal: cria 13 registros (um por mês, como despesas fixas) ──
    if (recurrence === 'monthly') {
      const baseDate = new Date((inc.date || todayLocalISO()) + 'T00:00:00');
      const memberId = inc.memberId || currentMember?.id;

      // Atualização otimista apenas do mês atual
      const tempId = 'temp_' + Date.now();
      const optimistic = {
        ...inc, id: tempId,
        value: parseFloat(inc.value) || 0,
        memberId, recurrence: 'monthly',
        status: inc.status || 'expected',
      };
      setIncomes(prev => [...prev, optimistic]);

      // Cria todos os meses em background
      const allCreated = [];
      for (let i = 0; i < 13; i++) {
        const d = new Date(baseDate);
        d.setMonth(d.getMonth() + i);
        const dateStr = d.toISOString().split('T')[0];
        const payload = {
          desc:       inc.desc,
          value:      parseFloat(inc.value) || 0,
          date:       dateStr,
          source:     inc.source || 'other',
          recurrence: 'monthly',
          // Apenas o mês base herda o status original; meses futuros sempre começam como 'expected'
          status:     i === 0 ? (inc.status || 'expected') : 'expected',
          memberId,
        };
        try {
          const created = await apiFetch('/incomes', { method: 'POST', body: payload });
          allCreated.push(mapIncome(created));
        } catch (err) {
          allCreated.push({ ...payload, id: 'temp_' + Date.now() + '_' + i });
        }
      }

      // Substitui o otimista pelo registro do mês atual e adiciona os demais
      setIncomes(prev => {
        const withoutTemp = prev.filter(i => i.id !== tempId);
        return [...withoutTemp, ...allCreated];
      });
      return allCreated[0];
    }

    // ── Única / outros: atualização otimista simples ──
    const tempId = 'temp_' + Date.now();
    const optimistic = {
      ...inc,
      id:         tempId,
      value:      parseFloat(inc.value) || 0,
      memberId:   inc.memberId || currentMember?.id,
      source:     inc.source || 'other',
      recurrence: 'single',
      status:     inc.status || 'received',
    };
    setIncomes(prev => [...prev, optimistic]);

    try {
      const payload = {
        desc:         optimistic.desc,
        value:        optimistic.value,
        date:         optimistic.date,
        source:       optimistic.source,
        recurrence:   optimistic.recurrence,
        status:       optimistic.status,
        memberId:     optimistic.memberId,
        ...(inc.fromMemberId     ? { fromMemberId:     inc.fromMemberId     } : {}),
        ...(inc.relatedExpenseId ? { relatedExpenseId: inc.relatedExpenseId } : {}),
      };
      const created = await apiFetch('/incomes', { method: 'POST', body: payload });
      // Substitui o temp pelo registro real (com id do banco)
      setIncomes(prev => prev.map(i => i.id === tempId ? mapIncome(created) : i));
    } catch (err) {
      // Mantém a versão local — o id temp permanece, visível na tela
      console.warn('addIncome: API falhou, mantendo local', err?.message);
    }
  }

  async function registerSettlement(from, to, amount) {
    if (currentMember?.id !== from) throw new Error('Somente o pagador pode iniciar este acerto.');
    const signature = `${from}:${to}:${Number(amount).toFixed(2)}`;
    let key = settlementIdempotencyKeys.current.get(signature);
    if (!key) {
      key = globalThis.crypto?.randomUUID?.() || `settlement:${signature}:${Date.now()}`;
      settlementIdempotencyKeys.current.set(signature, key);
    }
    const created = await apiFetch('/settlements', {
      method: 'POST',
      headers: { 'Idempotency-Key': key },
      body: { fromId: from, toId: to, amount, note: 'Acerto iniciado pelo pagador' },
    });
    await refreshSettlements();
    settlementIdempotencyKeys.current.delete(signature);
    return created;
  }

  async function decideSettlement(id, decision) {
    if (!['confirm', 'reject'].includes(decision)) throw new Error('Decisão de acerto inválida.');
    const updated = await apiFetch(`/settlements/${id}/${decision}`, { method: 'POST' });
    await refreshSettlements();
    return updated;
  }

  // ── Aceite de despesa dividida ─────────────────────────────
  // Aceita UMA despesa compartilhada (compatibilidade — delega para o lote).
  async function acceptSharedExpense(expenseId) {
    const expense = (expenses.find(e => e.id === expenseId)
      || balanceteExpenses.find(e => e.id === expenseId));
    if (!expense) return;
    return acceptSharedExpenses([expense]);
  }

  // Aceita VÁRIAS despesas compartilhadas de uma só vez (ex: todas as parcelas
  // de uma série parcelada). Marca todas como aceitas, gera UMA notificação e
  // cria a receita esperada (reembolso) de cada parcela no seu respectivo mês.
  async function acceptSharedExpenses(expenseList) {
    const authenticatedMemberId = currentMember?.id;
    if (!authenticatedMemberId) {
      throw new Error('Sessão inválida. Entre novamente para aprovar a despesa.');
    }
    const list = (expenseList || []).filter(Boolean);
    if (!list.length) return;
    // Séries novas possuem seriesId e são aprovadas em uma chamada. Para dados
    // legados (sem a chave), confirma cada ocorrência do grupo explicitamente.
    // Assim uma aprovação antiga também não volta a aparecer após o refresh.
    if (list[0].seriesId) {
      await apiFetch(`/expenses/${list[0].id}/approve`, { method: 'POST' });
    } else {
      await Promise.all(list.map(exp => apiFetch(`/expenses/${exp.id}/approve`, { method: 'POST' })));
    }
    const approvedAt = new Date().toISOString();
    const ids = new Set(list.map(e => e.id));
    const markApproved = e => ids.has(e.id)
      ? {
          ...e,
          sharedWith: (e.sharedWith || []).map(s => s.memberId === authenticatedMemberId ? { ...s, approvedAt } : s),
          // Feedback imediato também pra responsabilidade integral (shared:false),
          // que nunca teve cota em sharedWith pra refletir a aprovação.
          approval: e.approval ? { ...e.approval, requiresMyApproval: false, myDecision: 'approved' } : e.approval,
        }
      : e;
    setExpenses(prev => prev.map(markApproved));
    setBalanceteExpenses(prev => prev.map(markApproved));
    await loadData(currentMonth.year, currentMonth.month, true);
  }

  // ── Derived state ──────────────────────────────────────────
  const unreadCount = notifications.filter(n => !n.read).length;

  // monthExpenses: apenas as despesas do próprio membro (para Dia a Dia, etc.)
  const monthExpenses = expenses.filter(e => {
    const d = parseLocalDate(e.date);
    return d.getFullYear() === currentMonth.year
      && d.getMonth() + 1 === currentMonth.month
      && e.memberId === currentMember?.id;
  });

  // monthIncomes: receitas diretas do mês + projeção automática de receitas mensais recorrentes
  const monthIncomes = useMemo(() => {
    // 1. Receitas que já têm data no mês atual
    const direct = incomes.filter(i => {
      const d = parseLocalDate(i.date);
      return d.getFullYear() === currentMonth.year
        && d.getMonth() + 1 === currentMonth.month
        && i.memberId === currentMember?.id;
    });

    // 2. Assinaturas de QUALQUER receita já presente neste mês (desc+source)
    //    Suprime projeções mesmo quando o registro existente tem recurrence:'single'
    const presentSigs = new Set(
      direct
        .filter(i => !isMemberReceivableIncome(i))
        .map(i => `${(i.desc || '').trim().toLowerCase()}|${i.source}|${i.memberId}`)
    );

    // 3. Projeção: receitas mensais de OUTROS meses → gera instância no mês atual
    const sigMap = {};
    incomes.forEach(i => {
      const d = parseLocalDate(i.date);
      const isCurrent = d.getFullYear() === currentMonth.year && d.getMonth() + 1 === currentMonth.month;
      if (isCurrent) return;
      if (i.recurrence !== 'monthly') return;
      if (i.memberId !== currentMember?.id) return;
      if (isMemberReceivableIncome(i)) return;
      const sig = `${(i.desc || '').trim().toLowerCase()}|${i.source}|${i.memberId}`;
      if (presentSigs.has(sig)) return;
      // Guarda a ocorrência mais recente (melhor referência de valor/categoria)
      const prev = sigMap[sig] ? parseLocalDate(sigMap[sig].date) : null;
      if (!prev || d > prev) sigMap[sig] = i;
    });

    const projected = Object.values(sigMap).map(i => {
      const orig = parseLocalDate(i.date);
      const day  = orig.getDate();
      const proj = new Date(currentMonth.year, currentMonth.month - 1, day);
      // Ajusta se o dia não existir no mês (ex: 31 em fevereiro → último dia)
      if (proj.getMonth() !== currentMonth.month - 1) proj.setDate(0);
      return {
        ...i,
        id:          `projected_${i.id}_${currentMonth.year}_${currentMonth.month}`,
        date:        proj.toISOString().split('T')[0],
        _projected:  true,
        _originalId: i.id,   // id do registro original (para edição/exclusão)
        // Cada projeção mensal é uma nova ocorrência — sempre começa como esperada,
        // independente do status do registro original (evita que meses anteriores
        // marcados como recebidos contaminem os meses futuros)
        status:      'expected',
      };
    });

    return [...direct, ...projected];
  }, [incomes, currentMonth, currentMember]);

  // totalExpenses: fonte única de verdade (valor cheio) + envelope de Dia a Dia.
  // O limite de Dia a Dia entra reservado no total do mês desde o dia 1; os gastos
  // reais consomem essa reserva. Reflete no saldo e no comprometimento.
  const totalExpenses = monthExpensesTotal(
    expenses, currentMember?.id, paymentMethods, currentMonth.year, currentMonth.month,
    currentMember?.diaDiaLimit || 300
  );

  const diaDiaExpenses = monthExpenses.filter(e => e.isDiaDia);

  // Despesas que o membro atual precisa aprovar — cobre tanto a cota de uma
  // despesa dividida quanto uma despesa NÃO dividida cuja responsabilidade foi
  // atribuída inteiramente a ele por outra pessoa (ex: "IPHONE CARLA" lançado
  // por Valtercio, mas 100% responsabilidade da Carla). A fonte de verdade é
  // sempre `e.approval` (ExpenseApproval, calculado pelo backend) — nunca
  // `sharedWith.approvedAt` sozinho, que só existe pra despesas compartilhadas.
  const mySharedDebts = expenses.filter(e => {
    const d = parseLocalDate(e.date);
    const inMonth = d.getFullYear() === currentMonth.year && d.getMonth() + 1 === currentMonth.month;
    // e.settled: o credor já registrou o acerto no banco — não cobrar de novo do devedor
    if (!inMonth || e.settled) return false;
    return !!e.approval?.requiresMyApproval;
  });

  // "A Receber": os Reembolsos (receitas third_party) do mês do membro atual —
  // uma linha por devedor e por despesa, criada pelo backend no lançamento. É
  // a mesma base do Balancete: marcar uma delas como recebida quita aquela
  // dívida dos dois lados. Cobre divisão, responsabilidade transferida e uso de
  // cartão de terceiro, sem recalcular cota nenhuma no cliente.
  const myReceivables = monthIncomes.filter(isMemberReceivableIncome);
  const totalAReceber = myReceivables.reduce((s, i) => s + (Number(i.value) || 0), 0);
  const totalProprio  = monthIncomes.filter(i => !isMemberReceivableIncome(i)).reduce((s, i) => s + i.value, 0);

  // totalIncome unificado: receitas próprias + a receber de outros membros (sem dupla-contagem)
  const totalIncome  = totalProprio + totalAReceber;
  const balance      = totalIncome - totalExpenses;
  const commitment   = totalIncome > 0 ? (totalExpenses / totalIncome) * 100 : 0;

  const diaDiaUsed     = diaDiaExpenses.reduce((s, e) => s + e.value, 0);
  const diaDiaLimit    = currentMember?.diaDiaLimit || 300;
  const diaDiaPct      = diaDiaLimit > 0 ? (diaDiaUsed / diaDiaLimit) * 100 : 0;

  // Ritmo diário: em vez de alertar em 80% do total, compara o gasto médio por
  // dia (até hoje) com a meta diária (limite do mês ÷ dias do mês). Fora do mês
  // corrente, usamos o mês inteiro como "decorrido" (nada para acompanhar em tempo real).
  const _diaDiaNow           = new Date();
  const _diaDiaIsCurrentMonth = currentMonth.year === _diaDiaNow.getFullYear() && currentMonth.month === (_diaDiaNow.getMonth() + 1);
  const diaDiaDaysInMonth    = new Date(currentMonth.year, currentMonth.month, 0).getDate();
  const diaDiaElapsedDays    = _diaDiaIsCurrentMonth ? _diaDiaNow.getDate() : diaDiaDaysInMonth;
  const diaDiaDailyTarget    = diaDiaLimit / diaDiaDaysInMonth;
  const diaDiaActualPace     = diaDiaUsed / Math.max(diaDiaElapsedDays, 1);
  const diaDiaOverPace       = _diaDiaIsCurrentMonth && diaDiaActualPace > diaDiaDailyTarget;
  const diaDiaRemainingDays  = Math.max(diaDiaDaysInMonth - diaDiaElapsedDays, 1);
  const diaDiaTargetFromNow  = _diaDiaIsCurrentMonth
    ? Math.max(0, diaDiaLimit - diaDiaUsed) / diaDiaRemainingDays
    : diaDiaDailyTarget;

  // ── Badge do ícone do app (PWA): nº de despesas pendentes do MÊS ATUAL real ──
  useEffect(() => {
    if (typeof navigator === 'undefined' || !('setAppBadge' in navigator)) return;
    if (!isLoggedIn || !currentMember) { navigator.clearAppBadge?.().catch(() => {}); return; }
    const now = new Date();
    const y = now.getFullYear(), m = now.getMonth() + 1;
    const count = expenses.filter(e => {
      if (e.status === 'paid' || e.isProjected) return false;
      const d = parseLocalDate(e.date);
      if (d.getFullYear() !== y || d.getMonth() + 1 !== m) return false;
      return expenseInvolvesMember(e, currentMember.id, paymentMethods);
    }).length;
    if (count > 0) navigator.setAppBadge(count).catch(() => {});
    else navigator.clearAppBadge?.().catch(() => {});
  }, [expenses, paymentMethods, currentMember, isLoggedIn]);

  return (
    <AppContext.Provider value={{
      // Auth
      isLoggedIn, loading, loadingData, authError, setAuthError,
      login, logout, register, updateEmail, updatePassword, deleteAccount,
      // Data
      members, setMembers, addMember, updateMember,
      expenses, setExpenses, addExpense, markExpensePaid, deleteExpense, deleteExpenseSeries, updateExpense, updateExpenseSeries, fetchExpenseSeriesDetails, fetchMonthExpenses, fetchMonthIncomes,
      fetchInvoicePreview, payInvoice, reopenInvoice,
      incomes, setIncomes, addIncome, deleteIncome, updateIncome, markAllReceivedByMonth,
      investments, setInvestments, addInvestment, deleteInvestment, updateInvestment,
      investmentTypes, setInvestmentTypes,
      investmentPurposes, setInvestmentPurposes,
      incomeSources, setIncomeSources,
      paymentMethods, setPaymentMethods, addPaymentMethod, updatePaymentMethod, deletePaymentMethod,
      categories, setCategories, addCategory, updateCategory, deleteCategory,
      notifications, markNotificationRead, markAllRead, unreadCount, notifAlert, notifPrefs, setNotifPrefs,
      dailyDigest, dismissDailyDigest,
      currentMember,
      currentMonth, setCurrentMonth,
      monthExpenses, monthIncomes,
      totalExpenses, totalIncome, totalProprio, totalAReceber, balance, commitment,
      diaDiaUsed, diaDiaLimit, diaDiaPct, diaDiaExpenses,
      diaDiaDailyTarget, diaDiaActualPace, diaDiaOverPace, diaDiaTargetFromNow,
      mySharedDebts, myReceivables, sharedStatus, acceptSharedExpense, acceptSharedExpenses,
      balancete, balanceteExpenses, registerSettlement, decideSettlement, settlements,
      refreshSettlements, settlementsLoading, settlementsError,
      memberOperations, memberOperationsLoading, memberOperationsError, refreshMemberOperations,
      fetchMemberOperationConversionEligibility, createMemberOperation, closeMemberOperationSeries, recordMemberOperationReceipt, reverseMemberOperationReceipt,
      cancelMemberOperation, convertExpenseToMemberOperation,
      invoiceHistory,
      exportToCSV,
      // Reload
      loadData, refreshImportedInvoiceData,
    }}>
      {children}
    </AppContext.Provider>
  );
}

Object.assign(window, {
  ThemeProvider, useTheme,
  AppProvider, useApp,
  NavContext, useNav,
  calcBalancete, exportToCSV,
  parseLocalDate,
  expenseInvolvesMember, monthExpensesTotal,
  buildPendingApprovalGroups,
  API_BASE, apiFetch,
});