const DS = window.MyBrokerPantanalDesignSystem_2460cb;

// API real (Cloudflare Workers + D1) — primeiro recurso do sistema conectado ao backend de
// verdade. O resto das telas ainda usa dados fictícios em memória (window.MB_DATA) até serem
// migradas uma a uma; só login/sessão já fala com o banco real.
const API_BASE = 'https://api.mybrokerpantanal.com.br';

function App({ initialRoute = 'dashboard' }) {
  const rootRef = React.useRef(null);
  const mode = useContainerMode(rootRef);
  const [route, setRoute] = React.useState(initialRoute);

  // Sessão real: ao carregar, pergunta pra API se já existe um login válido (cookie). Enquanto
  // não responde, não mostra nem o painel (dados fictícios) nem o login, pra não "piscar".
  const [authUser, setAuthUser] = React.useState(null);
  const [authChecked, setAuthChecked] = React.useState(false);
  React.useEffect(() => {
    fetch(`${API_BASE}/api/eu`, { credentials: 'include' })
      .then((r) => (r.ok ? r.json() : null))
      .then((u) => setAuthUser(u))
      .catch(() => setAuthUser(null))
      .finally(() => setAuthChecked(true));
  }, []);
  const [search, setSearch] = React.useState(false);
  const [menu, setMenu] = React.useState(false);
  const [create, setCreate] = React.useState(false);
  const scrollRef = React.useRef(null);
  const D = window.MB_DATA;
  // Pessoas e imóveis vivem aqui para que o cadastro de imóvel possa buscar/vincular clientes e,
  // ao salvar, atualizar o tipo deles em Pessoas (ex.: virar Proprietário). NUNCA começam com o
  // dado fictício (D.people/D.properties) — só o banco real, carregado abaixo. Começar com o
  // fictício e trocar "quando der certo" é perigoso: se a busca falhar por qualquer motivo (rede,
  // navegador embutido de outro app bloqueando cookie entre domínios, etc.), a tela ficava
  // mostrando números fictícios como se fossem reais, sem avisar nada.
  const [people, setPeople] = React.useState([]);
  const [properties, setPropertiesRaw] = React.useState([]);
  const [maintenanceRecordsRaw, setMaintenanceRecordsRaw] = React.useState([]);
  const [dadosCarregados, setDadosCarregados] = React.useState(false);
  const [erroCarregarDados, setErroCarregarDados] = React.useState(false);
  React.useEffect(() => { window.MB_DATA.people = people; }, [people]);
  React.useEffect(() => { window.MB_DATA.properties = properties; }, [properties]);

  // Assim que confirma que tem sessão válida, busca os dados de verdade — o resto do sistema
  // (Imóveis, Contratos, Vistorias, Manutenção etc.) continua lendo esses mesmos "people"/
  // "properties"/"maintenanceRecords" por prop, então já passam a ver dado real também, sem
  // precisar mexer em cada tela. Se qualquer uma falhar, acende um aviso em vez de ficar quieto.
  const carregarDadosRef = React.useRef(null);
  const carregarDados = React.useCallback(() => {
    setDadosCarregados(false);
    setErroCarregarDados(false);
    Promise.all([
      fetch(`${API_BASE}/api/pessoas`, { credentials: 'include' }).then((r) => { if (!r.ok) throw new Error('pessoas'); return r.json(); }).then(setPeople),
      fetch(`${API_BASE}/api/imoveis`, { credentials: 'include' }).then((r) => { if (!r.ok) throw new Error('imoveis'); return r.json(); }).then(setPropertiesRaw),
      fetch(`${API_BASE}/api/manutencoes`, { credentials: 'include' }).then((r) => { if (!r.ok) throw new Error('manutencoes'); return r.json(); }).then(setMaintenanceRecordsRaw),
    ])
      .then(() => setDadosCarregados(true))
      .catch(() => { setErroCarregarDados(true); setDadosCarregados(true); });
  }, []);
  carregarDadosRef.current = carregarDados;
  React.useEffect(() => { if (authUser) carregarDados(); }, [authUser]);

  // Toda gravação em segundo plano passa por aqui: se o servidor recusar ou cair, em vez de
  // engolir o erro em silêncio (o que fazia a tela mostrar a ação como feita e ela "desfazer" no
  // F5), mostra um aviso vermelho e recarrega os dados reais do servidor na hora.
  const [erroGravar, setErroGravar] = React.useState('');
  const gravar = (url, opts) => fetch(url, { credentials: 'include', ...opts })
    .then(async (r) => {
      if (!r.ok) {
        const corpo = await r.json().catch(() => ({}));
        throw new Error(corpo.erro || `Erro ${r.status}`);
      }
    })
    .catch((e) => {
      setErroGravar(`Não consegui salvar a última alteração (${e.message}). Recarreguei os dados do servidor — confira e tente de novo.`);
      carregarDadosRef.current && carregarDadosRef.current();
    });
  // "Sincronizado": por fora, exatamente o mesmo contrato de useState (array novo OU função
  // atualizadora) que toda tela do sistema já usa — por dentro, depois de atualizar o estado
  // local, descobre o que mudou (comparando por id) e grava cada imóvel alterado/criado via PUT
  // e cada um removido via DELETE. Como NINGUÉM fora daqui precisa saber disso, não foi preciso
  // tocar em Properties.jsx, PropertyLocacoes.jsx, Billing.jsx, Repasses.jsx, Inspections.jsx,
  // ContractWizard.jsx nem Maintenance.jsx — todos continuam só chamando "setProperties(...)".
  const sincronizarImoveis = (anterior, novo) => {
    const idsNovos = new Set(novo.map((p) => p.id));
    novo.forEach((p) => {
      const antes = anterior.find((x) => x.id === p.id);
      if (antes === p) return; // mesma referência = nada mudou nesse item
      gravar(`${API_BASE}/api/imoveis/${p.id}`, {
        method: 'PUT', headers: { 'content-type': 'application/json' }, body: JSON.stringify(p),
      });
    });
    anterior.forEach((p) => {
      if (!idsNovos.has(p.id)) gravar(`${API_BASE}/api/imoveis/${p.id}`, { method: 'DELETE' });
    });
  };
  const setProperties = (updater) => {
    setPropertiesRaw((anterior) => {
      const novo = typeof updater === 'function' ? updater(anterior) : updater;
      sincronizarImoveis(anterior, novo);
      return novo;
    });
  };

  const sincronizarManutencoes = (anterior, novo) => {
    const idsNovos = new Set(novo.map((r) => r.id));
    novo.forEach((r) => {
      const antes = anterior.find((x) => x.id === r.id);
      if (antes === r) return;
      gravar(`${API_BASE}/api/manutencoes/${r.id}`, {
        method: 'PUT', headers: { 'content-type': 'application/json' }, body: JSON.stringify(r),
      });
    });
    anterior.forEach((r) => {
      if (!idsNovos.has(r.id)) gravar(`${API_BASE}/api/manutencoes/${r.id}`, { method: 'DELETE' });
    });
  };
  const setMaintenanceRecords = (updater) => {
    setMaintenanceRecordsRaw((anterior) => {
      const novo = typeof updater === 'function' ? updater(anterior) : updater;
      sincronizarManutencoes(anterior, novo);
      return novo;
    });
  };

  // Cadastro de Pessoas — grava na API de verdade; setPeople local acompanha a resposta do
  // servidor pra tela atualizar na hora, sem precisar recarregar.
  const apiCriarPessoa = (p) => fetch(`${API_BASE}/api/pessoas`, {
    method: 'POST', credentials: 'include', headers: { 'content-type': 'application/json' }, body: JSON.stringify(p),
  }).then(async (r) => { const d = await r.json().catch(() => ({})); if (!r.ok) throw new Error(d.erro || `Erro ${r.status}`); return d; }).then((nova) => { setPeople((cur) => [...cur, nova]); return nova; });
  const apiAtualizarPessoa = (p) => fetch(`${API_BASE}/api/pessoas/${p.id}`, {
    method: 'PUT', credentials: 'include', headers: { 'content-type': 'application/json' }, body: JSON.stringify(p),
  }).then(async (r) => { const d = await r.json().catch(() => ({})); if (!r.ok) throw new Error(d.erro || `Erro ${r.status}`); return d; }).then((atualizada) => { setPeople((cur) => cur.map((x) => x.id === atualizada.id ? atualizada : x)); return atualizada; });
  const apiExcluirPessoa = (id) => fetch(`${API_BASE}/api/pessoas/${id}`, { method: 'DELETE', credentials: 'include' })
    .then(async (r) => { const d = await r.json().catch(() => ({})); if (!r.ok) throw new Error(d.erro || `Erro ${r.status}`); return d; }).then(() => setPeople((cur) => cur.filter((x) => x.id !== id)));
  // Algumas telas (cadastro de imóvel, assistente de contrato, vistorias) marcam/desmarcam o
  // "tipo de cadastro" de uma pessoa já existente (ex.: adicionar "Proprietário" ou "Inquilino"
  // automaticamente) chamando setPeople diretamente. Sem isso a marcação só vivia no estado
  // local em memória e sumia no próximo F5/login, porque nunca era gravada na API de verdade.
  // Este wrapper tem a mesma assinatura de setPeople, mas detecta qualquer pessoa cujo array
  // `tipos` mudou e grava via apiAtualizarPessoa (PUT), igual ao fluxo normal da tela Pessoas.
  const setPeopleSync = (updater) => {
    setPeople((anterior) => {
      const novo = typeof updater === 'function' ? updater(anterior) : updater;
      const porId = new Map(anterior.map((p) => [p.id, p]));
      novo.forEach((p) => {
        const antiga = porId.get(p.id);
        if (antiga && JSON.stringify(antiga.tipos || []) !== JSON.stringify(p.tipos || [])) {
          apiAtualizarPessoa(p).catch((e) => {
            setErroGravar(`Não consegui salvar a alteração no cadastro da pessoa${e && e.message ? ' (' + e.message + ')' : ''}. Recarreguei os dados do servidor — confira e tente de novo.`);
            carregarDadosRef.current && carregarDadosRef.current();
          });
        }
      });
      return novo;
    });
  };
  // Ir pra "login" é como o menu "Sair" navega hoje — aproveitamos esse mesmo caminho pra
  // também encerrar a sessão de verdade na API (apaga o cookie/token no servidor).
  const go = (r) => {
    if (r === 'login' && authUser) {
      fetch(`${API_BASE}/api/logout`, { method: 'POST', credentials: 'include' }).catch(() => {});
      setAuthUser(null);
    }
    setRoute(r);
    if (scrollRef.current) scrollRef.current.scrollTop = 0;
  };

  // Navegação cruzada: abrir o cadastro de uma pessoa a partir de um imóvel, e vice-versa.
  const [openPersonId, setOpenPersonId] = React.useState(null);
  const [openPropertyId, setOpenPropertyId] = React.useState(null);
  const [openNewPerson, setOpenNewPerson] = React.useState(false);
  const openPerson = (id) => { setOpenPersonId(id); go('people'); };
  const openProperty = (id) => { setOpenPropertyId(id); go('properties'); };

  // Atalhos do Painel ("Novo contrato", "Agendar vistoria", "Cadastrar cliente").
  const onQuick = (id) => {
    if (id === 'contrato') { go('contract-new'); return; }
    if (id === 'imovel') { go('properties'); return; }
    if (id === 'vistoria') { go('inspections'); return; }
    if (id === 'cobranca') { go('billing'); return; }
    if (id === 'pagamento') { go('maintenance'); return; }
    if (id === 'cliente') { setOpenNewPerson(true); go('people'); return; }
    go(route);
  };

  // Página de locações de um imóvel específico (aberta a partir do menu "⋯" › Locação).
  const [locacaoPropertyId, setLocacaoPropertyId] = React.useState(null);
  const openLocacoes = (id) => { setLocacaoPropertyId(id); go('property-locacoes'); };

  // "Financeiro" no menu do imóvel leva para a página de Locação já com o resumo financeiro
  // (cobrança do inquilino / repasse do proprietário) aberto.
  const [financeiroPropertyId, setFinanceiroPropertyId] = React.useState(null);
  const openFinanceiro = (id) => { setFinanceiroPropertyId(id); go('property-financeiro'); };

  // "Nova Locação" dentro de um imóvel leva direto para o wizard de Novo contrato, já com
  // esse imóvel selecionado.
  const [prefillContractPropertyId, setPrefillContractPropertyId] = React.useState(null);
  const openNovoContrato = (id) => { setPrefillContractPropertyId(id); go('contract-new'); };

  // Modelos de contrato por tipo (administração/locação/serviços) — começam com um exemplo
  // de cada, prontos para o usuário personalizar.
  const [contractTemplates, setContractTemplates] = React.useState(() => window.seedContractTemplates());
  const [contractTipo, setContractTipo] = React.useState(null);
  const openContractTipo = (tipo) => { setContractTipo(tipo); go('contract-type'); };

  // Dados da imobiliária (Configurações) — usados como variáveis "imobiliaria.*" nos modelos de contrato.
  // logoUrl já começa com a logo atual (a usada na barra lateral) — Configurações permite trocar.
  const [imobiliaria, setImobiliaria] = React.useState({
    razaoSocial: 'Hamar e Allianca Imobiliaria LTDA (My Broker Pantanal)',
    cnpj: '57.553.793/0001-93',
    creci: '19716',
    endereco: 'Rua General Osório, 1860 — Centro, Cáceres/MT',
    email: 'mybrokerpantanal@gmail.com',
    telefone: '',
    site: 'MyBrokerPantanal.com.br',
    logoUrl: './assets/logo-mybroker-pantanal.png',
  });
  // Sincroniza pra o Dialog (ds_bundle.js) conseguir mostrar a logo da imobiliária no cabeçalho
  // de qualquer card/modal sem precisar receber isso por prop em cada um dos 30 e tantos lugares.
  React.useEffect(() => { window.MB_DATA.imobiliaria = imobiliaria; }, [imobiliaria]);

  // Contratos (locações ativas) vencendo nos próximos 30 dias — é esse conjunto que acende o
  // sininho de notificações em vermelho e aparece ao clicar nele.
  const diasAteApp = (iso) => {
    if (!iso) return Infinity;
    const [y, mo, d] = iso.split('-').map(Number);
    const alvo = new Date(y, mo - 1, d);
    const hoje = new Date(); hoje.setHours(0, 0, 0, 0);
    return Math.round((alvo - hoje) / 86400000);
  };
  const contratosAVencer30 = properties.flatMap((p) => (p.locacoes || [])
    .filter((l) => l.ativa && l.dataVencimento)
    .map((l) => ({ propertyId: p.id, title: p.name, sub: `Inquilino: ${l.inquilino || '—'}`, dias: diasAteApp(l.dataVencimento) })))
    .filter((r) => r.dias >= 0 && r.dias <= 30)
    .sort((a, b) => a.dias - b.dias);

  // Usuários do sistema (login/senha e papel de acesso) — exibidos em Configurações. Carregado
  // da API assim que tem sessão válida (substitui o rascunho local).
  const [systemUsers, setSystemUsers] = React.useState([]);
  React.useEffect(() => {
    if (!authUser) return;
    fetch(`${API_BASE}/api/usuarios`, { credentials: 'include' })
      .then((r) => (r.ok ? r.json() : null))
      .then((lista) => { if (lista) setSystemUsers(lista); })
      .catch(() => {});
  }, [authUser]);
  const apiCriarUsuario = (u) => fetch(`${API_BASE}/api/usuarios`, {
    method: 'POST', credentials: 'include', headers: { 'content-type': 'application/json' }, body: JSON.stringify(u),
  }).then(async (r) => { const d = await r.json().catch(() => ({})); if (!r.ok) return Promise.reject(d); setSystemUsers((cur) => [...cur, d]); return d; });
  const apiAtualizarUsuario = (u) => fetch(`${API_BASE}/api/usuarios/${u.id}`, {
    method: 'PUT', credentials: 'include', headers: { 'content-type': 'application/json' }, body: JSON.stringify(u),
  }).then(async (r) => { const d = await r.json().catch(() => ({})); if (!r.ok) return Promise.reject(d); setSystemUsers((cur) => cur.map((x) => x.id === d.id ? d : x)); return d; });
  const apiExcluirUsuario = (id) => fetch(`${API_BASE}/api/usuarios/${id}`, { method: 'DELETE', credentials: 'include' })
    .then(async (r) => { const d = await r.json().catch(() => ({})); if (!r.ok) return Promise.reject(d); setSystemUsers((cur) => cur.filter((x) => x.id !== id)); });

  // Cargo exibido no cabeçalho vem do papel do usuário logado de verdade (API) — se não tiver
  // sessão ainda, cai num rótulo neutro só pra não quebrar o layout antes de checar.
  const cargoFromPapel = (papel) => papel === 'Administrador geral' ? 'Diretor' : papel === 'Gestor de locação' ? 'Gestor' : (papel || 'Usuário');
  const headerUser = authUser
    ? { name: authUser.nome, first: (authUser.nome || '').split(' ')[0], email: authUser.email, papel: authUser.papel, role: `${cargoFromPapel(authUser.papel)} · MyBroker Pantanal` }
    : { name: '', first: '', email: '', papel: '', role: '' };
  // Algumas telas antigas (Dashboard, vistorias, etc.) ainda leem "quem está logado" direto de
  // window.MB_DATA.user, que no protótipo original vinha fixo com os dados fictícios do Pedro.
  // Sem sincronizar isso, QUALQUER usuário logado (ex.: Marquinhos) via essas telas o saudo e —
  // pior — o registro de "enviado por" em laudos de vistoria gravava o nome errado. Mantemos
  // window.MB_DATA.user sempre igual ao usuário real da sessão.
  React.useEffect(() => { window.MB_DATA.user = headerUser; }, [authUser]);

  // Dados financeiros da imobiliária (Pix, banco, agência, conta) — exibidos em Configurações.
  const [financeiroEmpresa, setFinanceiroEmpresa] = React.useState({
    tipoChavePix: 'E-mail', chavePix: 'mybrokerpantanal@gmail.com', banco: '', agencia: '', conta: '',
  });

  // Manutenções cadastradas (imóvel, prestador, recebedor, descrição, data, valor) — página
  // Manutenção. "maintenanceRecords" é só o alias local pro estado sincronizado lá em cima.
  const maintenanceRecords = maintenanceRecordsRaw;

  React.useEffect(() => {
    const k = (e) => { if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === 'k') { e.preventDefault(); setSearch(true); } };
    window.addEventListener('keydown', k); return () => window.removeEventListener('keydown', k);
  }, []);

  const m = mode === 'mobile';
  let page;
  if (route === 'dashboard') page = <Dashboard mode={mode} go={go} onQuick={onQuick} properties={properties} onOpenLocacoes={openLocacoes} maintenanceRecords={maintenanceRecords} />;
  else if (route === 'properties') page = <Properties mode={mode} go={go} people={people} setPeople={setPeopleSync} properties={properties} setProperties={setProperties}
    openPropertyId={openPropertyId} clearOpenProperty={() => setOpenPropertyId(null)} onOpenPerson={openPerson} onOpenLocacoes={openLocacoes} onOpenFinanceiro={openFinanceiro}
    contractTemplates={contractTemplates} imobiliaria={imobiliaria} />;
  else if (route === 'property-locacoes') page = <PropertyLocacoes propertyId={locacaoPropertyId} properties={properties} setProperties={setProperties} people={people} go={go} mode={mode} onOpenPerson={openPerson} onOpenProperty={openProperty} contractTemplates={contractTemplates} imobiliaria={imobiliaria} onNovoContrato={openNovoContrato} maintenanceRecords={maintenanceRecords} />;
  else if (route === 'property-financeiro') page = <PropertyFinanceiro propertyId={financeiroPropertyId} properties={properties} setProperties={setProperties} go={go} mode={mode} />;
  else if (route === 'contract-new') page = <ContractWizard mode={mode} go={go} properties={properties} setProperties={setProperties} people={people} setPeople={setPeopleSync} onOpenLocacoes={openLocacoes}
    prefillPropertyId={prefillContractPropertyId} clearPrefillPropertyId={() => setPrefillContractPropertyId(null)} />;
  else if (route === 'contracts') page = <Contracts mode={mode} go={go} properties={properties} onOpenTipo={openContractTipo} onOpenLocacoes={openLocacoes} contractTemplates={contractTemplates} />;
  else if (route === 'contract-type') page = <ContractTypeDetail tipo={contractTipo} templates={contractTemplates} setTemplates={setContractTemplates} go={go} mode={mode} />;
  else if (route === 'people') page = <People mode={mode} go={go} people={people} setPeople={setPeople} properties={properties}
    openPersonId={openPersonId} clearOpenPerson={() => setOpenPersonId(null)} onOpenProperty={openProperty}
    openNewPerson={openNewPerson} clearOpenNewPerson={() => setOpenNewPerson(false)}
    onCreatePerson={apiCriarPessoa} onUpdatePerson={apiAtualizarPessoa} onDeletePerson={apiExcluirPessoa} />;
  else if (route === 'settings') page = <Settings mode={mode} imobiliaria={imobiliaria} setImobiliaria={setImobiliaria} users={systemUsers} setUsers={setSystemUsers} financeiro={financeiroEmpresa} setFinanceiro={setFinanceiroEmpresa} people={people}
    authUser={authUser} onCreateUser={apiCriarUsuario} onUpdateUser={apiAtualizarUsuario} onDeleteUser={apiExcluirUsuario} />;
  else if (route === 'inspections') page = <Inspections mode={mode} go={go} people={people} setPeople={setPeopleSync} properties={properties} setProperties={setProperties} onOpenProperty={openProperty} />;
  else if (route === 'maintenance') page = <Maintenance mode={mode} go={go} properties={properties} people={people} records={maintenanceRecords} setRecords={setMaintenanceRecords} />;
  else if (route === 'billing') page = <Billing mode={mode} go={go} properties={properties} setProperties={setProperties} onOpenLocacoes={openLocacoes} />;
  else if (route === 'payouts') page = <Repasses mode={mode} go={go} properties={properties} setProperties={setProperties} onOpenLocacoes={openLocacoes} />;
  else if (route === 'reports') page = <Relatorios mode={mode} properties={properties} maintenanceRecords={maintenanceRecords} />;
  else { const n = NAV.find((x) => x.id === route); page = <Placeholder label={n ? n.label : route} mode={mode} />; }

  // Enquanto não sabemos se já existe sessão válida, não mostra nada (nem login, nem painel
  // com dado fictício) — evita o "flash" de uma tela errada por meio segundo.
  if (!authChecked) {
    return <div ref={rootRef} style={{ height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center', background: 'var(--bg-app)' }} />;
  }

  // Sem sessão válida (ou navegação explícita pra /login): sempre a tela de login — ela é quem
  // chama a API de verdade (/api/login) e, se der certo, avisa aqui em cima via onLoggedIn.
  if (route === 'login' || !authUser) {
    const onLoggedIn = (usuario) => { setAuthUser(usuario); go('dashboard'); };
    return <div ref={rootRef} style={{ position: 'relative', height: '100%', display: 'flex', overflow: 'hidden', background: 'var(--bg-app)' }}><div style={{ flex: 1, minWidth: 0, overflowY: 'auto' }}><Login mode={mode} apiBase={API_BASE} onLoggedIn={onLoggedIn} /></div></div>;
  }

  // Painel com sessão ok, mas os dados de verdade (Pessoas/Imóveis/Manutenção) ainda não
  // chegaram ou nenhum terminou de carregar — evita mostrar telas vazias "piscando" por meio
  // segundo antes do primeiro carregamento.
  if (!dadosCarregados) {
    return <div ref={rootRef} style={{ height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center', background: 'var(--bg-app)' }} />;
  }

  return (
    <div ref={rootRef} style={{ position: 'relative', height: '100%', display: 'flex', background: 'var(--gradient-header-wash) 0 0 / 100% 360px no-repeat, var(--bg-app)', overflow: 'hidden' }}>
      {!m && <Sidebar route={route} go={go} collapsed={mode === 'tablet'} logoUrl={imobiliaria.logoUrl} />}
      <div ref={scrollRef} style={{ flex: 1, minWidth: 0, overflowY: 'auto', paddingBottom: m ? 'var(--mobile-nav-h)' : 0, scrollbarWidth: m ? 'none' : 'thin' }}>
        <Topbar user={headerUser} mode={mode} onSearch={() => setSearch(true)} notifItems={contratosAVencer30} onOpenLocacoes={openLocacoes} />
        {erroGravar && (
          <div style={{ margin: m ? '12px 16px 0' : '16px var(--page-pad) 0', padding: '12px 16px', borderRadius: 10, background: 'var(--status-danger-bg)', color: 'var(--status-danger-text)', fontSize: 13, display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12 }}>
            <span>{erroGravar}</span>
            <button onClick={() => setErroGravar('')} style={{ flexShrink: 0, border: '1px solid currentColor', background: 'transparent', color: 'inherit', borderRadius: 8, padding: '6px 12px', fontSize: 12, fontWeight: 600, cursor: 'pointer' }}>Entendi</button>
          </div>
        )}
        {erroCarregarDados && (
          <div style={{ margin: m ? '12px 16px 0' : '16px var(--page-pad) 0', padding: '12px 16px', borderRadius: 10, background: 'var(--status-danger-bg)', color: 'var(--status-danger-text)', fontSize: 13, display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12 }}>
            <span>Não consegui carregar os dados do servidor agora — o que está sendo exibido pode estar incompleto ou desatualizado. Verifique sua conexão.</span>
            <button onClick={carregarDados} style={{ flexShrink: 0, border: '1px solid currentColor', background: 'transparent', color: 'inherit', borderRadius: 8, padding: '6px 12px', fontSize: 12, fontWeight: 600, cursor: 'pointer' }}>Tentar de novo</button>
          </div>
        )}
        {page}
      </div>
      {m && <MobileNav route={route} go={go} onPlus={() => setCreate(true)} onMenu={() => setMenu(true)} />}
      {m && <MobileMenuSheet open={menu} onClose={() => setMenu(false)} route={route} go={go} user={headerUser} />}
      {m && <CreateSheet open={create} onClose={() => setCreate(false)} actions={D.quickActions} onAction={onQuick} />}
      <SearchOverlay open={search} onClose={() => setSearch(false)} mode={mode} go={go} onOpenPerson={openPerson} onOpenProperty={openProperty} />
    </div>
  );
}

window.App = App;
