const DSpl = window.MyBrokerPantanalDesignSystem_2460cb;

function fmtDateBR(iso) {
  if (!iso) return '';
  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso);
  return m ? `${m[3]}/${m[2]}/${m[1]}` : iso;
}
function todayISO() {
  const d = new Date();
  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
}
function addMonthsISO(iso, months) {
  if (!iso || !months) return '';
  const [y, mo, d] = iso.split('-').map(Number);
  // Soma meses ao índice do mês e só então aplica o dia, travando no último dia do mês de
  // destino quando ele for mais curto (ex.: dia 31 + 1 mês em fevereiro vira 28/29, nunca março).
  const totalMonths = mo - 1 + Number(months);
  const targetYear = y + Math.floor(totalMonths / 12);
  const targetMonth = ((totalMonths % 12) + 12) % 12;
  const lastDayOfTargetMonth = new Date(targetYear, targetMonth + 1, 0).getDate();
  const dt = new Date(targetYear, targetMonth, Math.min(d, lastDayOfTargetMonth));
  return `${dt.getFullYear()}-${String(dt.getMonth() + 1).padStart(2, '0')}-${String(dt.getDate()).padStart(2, '0')}`;
}
function diasAte(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);
}
function mesesEntre(inicioISO, fimISO) {
  if (!inicioISO || !fimISO) return 0;
  const [iy, im, id] = inicioISO.split('-').map(Number);
  const [fy, fm, fd] = fimISO.split('-').map(Number);
  let meses = (fy - iy) * 12 + (fm - im);
  if (fd < id) meses -= 1;
  return Math.max(0, meses);
}
function addDaysISO(iso, days) {
  if (!iso) return '';
  const [y, mo, d] = iso.split('-').map(Number);
  const dt = new Date(y, mo - 1, d + Number(days));
  return `${dt.getFullYear()}-${String(dt.getMonth() + 1).padStart(2, '0')}-${String(dt.getDate()).padStart(2, '0')}`;
}
function parseBR(v) {
  if (!v) return 0;
  const n = parseFloat(String(v).replace(/\./g, '').replace(',', '.').replace(/[^\d.-]/g, ''));
  return isNaN(n) ? 0 : n;
}
function fmtMoney(n) {
  return `R$ ${(n || 0).toLocaleString('pt-BR', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
}
const MES_NOMES_PL = ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'];
function monthsBetween(startISO, endISO) {
  if (!startISO) return [];
  const [sy, sm] = startISO.split('-').map(Number);
  const end = endISO || todayISO();
  const [ey, em] = end.split('-').map(Number);
  const out = [];
  let y = sy, mo = sm;
  let guard = 0;
  while ((y < ey || (y === ey && mo <= em)) && guard < 120) {
    out.push({ label: `${MES_NOMES_PL[mo - 1]}/${y}`, y, mo });
    mo += 1; if (mo > 12) { mo = 1; y += 1; }
    guard += 1;
  }
  return out;
}

// NOTA DE PROTÓTIPO (ver notas-producao-sistema-locacao no projeto): o botão "Excluir" abaixo
// fica funcionando neste ambiente de teste mesmo em locações encerradas, só para facilitar os
// testes. Em produção, esse botão não deve aparecer quando a locação já tiver "Fim da locação".
const LOCACAO_ACTIONS = [
  { key: 'financeiro', label: 'Resumo financeiro', icon: 'wallet' },
  { key: 'editar', label: 'Editar', icon: 'pencil' },
  { key: 'contrato', label: 'Contrato', icon: 'file-text' },
  { key: 'reajustar', label: 'Reajustar', icon: 'trending-up' },
  { key: 'renovar', label: 'Renovar', icon: 'refresh-cw' },
  { key: 'fim', label: 'Fim da locação', icon: 'calendar-check' },
  { key: 'docs', label: 'Doc Anexos', icon: 'paperclip' },
  { key: 'movimentacao', label: 'Movimentação', icon: 'history' },
  { key: 'excluir', label: 'Excluir', icon: 'trash-2' },
];

function LocacaoCard({ loc, property, onOpenPerson, onOpenProperty, onAction }) {
  const { Card, Badge, MetaField, Button, Avatar } = DSpl;
  return (
    <Card padding="md" style={{ gap: 14 }}>
      <div style={{ display: 'flex', flexWrap: 'wrap', gap: 14, alignItems: 'center', justifyContent: 'space-between' }}>
      <div style={{ display: 'flex', flexWrap: 'wrap', gap: 14, alignItems: 'center' }}>
        <Badge tone={loc.ativa ? 'success' : 'neutral'} size="sm">{loc.ativa ? 'Locação ativa' : 'Encerrada'}</Badge>
        <MetaField label="Tipo" value={loc.tipo} size="sm" />
        {loc.finalidade && <MetaField label="Finalidade" value={loc.finalidade} size="sm" />}
        <MetaField label="Inquilino" value={
          <span style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
            <Avatar name={loc.inquilino} size={18} />
            {loc.inquilino}
          </span>
        } size="sm" />
        {loc.fiador && (
          <MetaField label="Fiador" value={
            <span style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
              <Avatar name={loc.fiador} size={18} />
              {loc.fiador}
            </span>
          } size="sm" />
        )}
        <MetaField label="Início da locação" value={fmtDateBR(loc.dataInicio) || '—'} size="sm" />
        <MetaField label="Prazo" value={loc.prazoMeses ? `${loc.prazoMeses} meses` : '—'} size="sm" />
        <MetaField label="Até quando vai a locação" value={fmtDateBR(loc.dataVencimento) || '—'} size="sm" />
        {loc.diaVencimento && <MetaField label="Vencimento mensal" value={`Dia ${loc.diaVencimento}`} size="sm" />}
        {!loc.ativa && <MetaField label="Encerrada em" value={fmtDateBR(loc.dataFim) || '—'} size="sm" />}
      </div>
      {loc.ativa ? (
        <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'flex-end', gap: 1, padding: '6px 14px', background: 'var(--status-success-bg)', borderRadius: 10 }}>
          <span style={{ fontSize: 10, fontWeight: 600, color: 'var(--status-success-text)', textTransform: 'uppercase', letterSpacing: '0.03em' }}>Aluguel</span>
          <span style={{ fontSize: 17, fontWeight: 700, color: 'var(--status-success-text)' }}>{fmtMoney(loc.valorAluguelAtual || parseBR(property._form && property._form.valorAluguel))}</span>
        </div>
      ) : (
        <Button variant="secondary" size="sm" icon="file-check" onClick={() => onAction('termo', loc)}>Termo final de locação</Button>
      )}
      </div>
      <div style={{ display: 'flex', flexWrap: 'wrap', gap: 6 }}>
        {loc.inquilinoPersonId && (
          <Button variant="ghost" size="sm" icon="external-link" onClick={() => onOpenPerson && onOpenPerson(loc.inquilinoPersonId)}>
            Ver cadastro do inquilino
          </Button>
        )}
        {loc.fiadorPersonId && (
          <Button variant="ghost" size="sm" icon="external-link" onClick={() => onOpenPerson && onOpenPerson(loc.fiadorPersonId)}>
            Ver cadastro do fiador
          </Button>
        )}
        <Button variant="ghost" size="sm" icon="external-link" onClick={() => onOpenProperty && onOpenProperty(property.id)}>
          Ver cadastro do imóvel
        </Button>
      </div>
      <div style={{ display: 'flex', flexWrap: 'wrap', gap: 6, paddingTop: 10, borderTop: '1px solid var(--border-subtle)' }}>
        {LOCACAO_ACTIONS.map((a) => {
          const proximoVencer = loc.ativa && loc.dataVencimento && diasAte(loc.dataVencimento) <= 30;
          const destacarVerde = proximoVencer && (a.key === 'reajustar' || a.key === 'renovar');
          let btnStyle;
          if (a.key === 'excluir') btnStyle = { color: 'var(--status-danger-text)' };
          else if (destacarVerde) btnStyle = {
            color: 'var(--status-success-text)',
            background: 'var(--status-success-bg)',
            border: '1px solid var(--status-success-text)',
          };
          return (
            <Button key={a.key} variant="secondary" size="sm" icon={a.icon}
              onClick={() => onAction(a.key, loc)}
              style={btnStyle}>
              {a.label}
            </Button>
          );
        })}
      </div>
    </Card>
  );
}

// Busca simples de inquilino na base de Pessoas (mesmo padrão do vínculo de proprietário em Imóveis).
function TenantSearch({ label = 'Inquilino *', placeholder = 'Buscar cliente cadastrado...', nome, personId, onChangeNome, onPick, people }) {
  const { Input, ListItem, Badge } = DSpl;
  const [focused, setFocused] = React.useState(false);
  const q = (nome || '').trim().toLowerCase();
  const matches = q.length > 0 ? people.filter((p) => p.nome.toLowerCase().includes(q)).slice(0, 6) : [];
  return (
    <div style={{ position: 'relative' }}>
      <Input label={label} placeholder={placeholder} value={nome}
        onChange={(e) => onChangeNome(e.target.value)}
        onFocus={() => setFocused(true)} onBlur={() => setTimeout(() => setFocused(false), 150)} />
      {personId && <span style={{ position: 'absolute', right: 10, top: 30, fontSize: 10, color: 'var(--status-success-text)' }}>✓ vinculado</span>}
      {focused && matches.length > 0 && (
        <div style={{ position: 'absolute', zIndex: 20, top: '100%', left: 0, right: 0, marginTop: 4, background: 'var(--surface-card)', border: '1px solid var(--border-subtle)', borderRadius: 10, boxShadow: 'var(--shadow-md)', overflow: 'hidden' }}>
          {matches.map((p) => (
            <ListItem key={p.id} variant="plain" title={p.nome} description={p.documentoNumero || p.endereco.cidade}
              trailing={<Badge size="sm">{p.tipos[0]}</Badge>} onClick={() => onPick(p)} style={{ cursor: 'pointer', padding: '8px 10px' }} />
          ))}
        </div>
      )}
    </div>
  );
}

function DiaVencimentoField({ name, value, onChange }) {
  const { Radio } = DSpl;
  return (
    <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
      <span style={{ fontSize: 13, fontWeight: 500, color: 'var(--text-strong)' }}>Dia de vencimento do aluguel *</span>
      <div style={{ display: 'flex', gap: 22 }}>
        {['5', '15', '25'].map((d) => (
          <Radio key={d} name={name} value={d} checked={String(value) === d} label={`Dia ${d}`} onChange={() => onChange(d)} />
        ))}
      </div>
    </div>
  );
}

function NovaLocacaoDialog({ people, onClose, onSave }) {
  const { Dialog, Select, Button, Input } = DSpl;
  const [nome, setNome] = React.useState('');
  const [personId, setPersonId] = React.useState(null);
  const [nomeFiador, setNomeFiador] = React.useState('');
  const [fiadorPersonId, setFiadorPersonId] = React.useState(null);
  const [tipo, setTipo] = React.useState('Aluguel');
  const [dataInicio, setDataInicio] = React.useState(todayISO());
  const [prazoMeses, setPrazoMeses] = React.useState('12');
  const [diaVencimento, setDiaVencimento] = React.useState('5');
  const [error, setError] = React.useState('');
  const dataVencimento = addMonthsISO(dataInicio, prazoMeses);

  const handleSave = () => {
    if (!personId) { setError('Vincule um inquilino cadastrado em Pessoas antes de salvar.'); return; }
    onSave({ inquilino: nome, inquilinoPersonId: personId, fiador: nomeFiador || null, fiadorPersonId, tipo, dataInicio, prazoMeses: Number(prazoMeses) || 0, dataVencimento, diaVencimento: Number(diaVencimento) });
  };

  return (
    <Dialog open onClose={onClose} size="md" strategy="absolute" placement="center" icon="key-round" tone="accent" title="Nova locação" description="Inicia uma nova locação para este imóvel"
      footer={<><Button variant="secondary" onClick={onClose}>Cancelar</Button><Button icon="check" onClick={handleSave}>Iniciar locação</Button></>}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
        <TenantSearch nome={nome} personId={personId} people={people}
          onChangeNome={(v) => { setNome(v); setPersonId(null); }}
          onPick={(p) => { setNome(p.nome); setPersonId(p.id); setError(''); }} />
        {error && <span style={{ fontSize: 12, color: 'var(--status-danger-text)' }}>{error}</span>}
        <TenantSearch label="Fiador (opcional)" placeholder="Buscar fiador cadastrado..." nome={nomeFiador} personId={fiadorPersonId} people={people}
          onChangeNome={(v) => { setNomeFiador(v); setFiadorPersonId(null); }}
          onPick={(p) => { setNomeFiador(p.nome); setFiadorPersonId(p.id); }} />
        <Select label="Tipo" value={tipo} onChange={(e) => setTipo(e.target.value)} options={['Aluguel', 'Temporada']} />
        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 10 }}>
          <Input label="Início da locação" type="date" value={dataInicio} onChange={(e) => setDataInicio(e.target.value)} />
          <Input label="Prazo (meses) *" type="number" min={1} value={prazoMeses} onChange={(e) => setPrazoMeses(e.target.value)} />
        </div>
        <DiaVencimentoField name="dia-vencimento-nova" value={diaVencimento} onChange={setDiaVencimento} />
        <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Vai até: <b style={{ color: 'var(--text-strong)' }}>{fmtDateBR(dataVencimento) || '—'}</b> — usado depois para reajuste e renovação.</span>
      </div>
    </Dialog>
  );
}

// NOTE DE PROTÓTIPO: Prazo e Vencimento aparecem editáveis aqui só para facilitar os testes
// (ex.: simular uma locação perto do vencimento). Em produção esses dois campos deixam de ser
// editáveis — prazo/vencimento só mudam via Renovar. O Inquilino também não é editável em lugar
// nenhum: uma vez vinculado na criação da locação, só o Fiador pode ser trocado aqui.
function EditarLocacaoDialog({ loc, people, onClose, onSave }) {
  const { Dialog, Button, MetaField, Input } = DSpl;
  const [nomeFiador, setNomeFiador] = React.useState(loc.fiador || '');
  const [fiadorPersonId, setFiadorPersonId] = React.useState(loc.fiadorPersonId || null);
  const [prazoMeses, setPrazoMeses] = React.useState(String(loc.prazoMeses || ''));
  const [dataVencimento, setDataVencimento] = React.useState(loc.dataVencimento || '');
  const [diaVencimento, setDiaVencimento] = React.useState(String(loc.diaVencimento || '5'));

  const onChangePrazo = (v) => {
    setPrazoMeses(v);
    const n = Number(v);
    if (v !== '' && n > 0) setDataVencimento(addMonthsISO(loc.dataInicio, n));
  };
  const onChangeVencimento = (v) => {
    setDataVencimento(v);
    if (v && loc.dataInicio) setPrazoMeses(String(mesesEntre(loc.dataInicio, v)));
  };

  const handleSave = () => {
    onSave({
      fiador: nomeFiador || null,
      fiadorPersonId: fiadorPersonId || null,
      prazoMeses: Number(prazoMeses) || loc.prazoMeses,
      dataVencimento: dataVencimento || loc.dataVencimento,
      diaVencimento: Number(diaVencimento),
    });
  };

  return (
    <Dialog open onClose={onClose} size="md" strategy="absolute" placement="center" icon="pencil" tone="accent" title="Editar locação" description="O inquilino não pode ser alterado — fiador e dia de vencimento, sim"
      footer={<><Button variant="secondary" onClick={onClose}>Cancelar</Button><Button icon="check" onClick={handleSave}>Salvar</Button></>}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
        <div style={{ display: 'flex', flexWrap: 'wrap', gap: 14, padding: '10px 12px', background: 'var(--surface-sunken)', borderRadius: 10 }}>
          <MetaField label="Tipo" value={loc.tipo} size="sm" />
          <MetaField label="Início" value={fmtDateBR(loc.dataInicio) || '—'} size="sm" />
          <MetaField label="Inquilino" value={loc.inquilino || '—'} size="sm" />
        </div>

        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 10 }}>
          <Input label="Prazo (meses)" type="number" min={1} value={prazoMeses} onChange={(e) => onChangePrazo(e.target.value)} />
          <Input label="Vencimento" type="date" value={dataVencimento} onChange={(e) => onChangeVencimento(e.target.value)} />
        </div>
        <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>
          Prazo e vencimento se recalculam um a partir do outro (contando a partir do início em {fmtDateBR(loc.dataInicio) || '—'}). Editáveis apenas neste ambiente de teste — no site em produção, esses dois campos só mudam através de "Renovar".
        </span>

        <DiaVencimentoField name="dia-vencimento-editar" value={diaVencimento} onChange={setDiaVencimento} />

        <TenantSearch label="Fiador (opcional)" placeholder="Buscar fiador cadastrado..." nome={nomeFiador} personId={fiadorPersonId} people={people}
          onChangeNome={(v) => { setNomeFiador(v); setFiadorPersonId(null); }}
          onPick={(p) => { setNomeFiador(p.nome); setFiadorPersonId(p.id); }} />
      </div>
    </Dialog>
  );
}

function ReajustarDialog({ loc: locProp, property, setProperties, onClose }) {
  const { Dialog, Button, Input, Icon } = DSpl;
  const [pct, setPct] = React.useState('');
  const [valor, setValor] = React.useState('');

  const loc = (property.locacoes || []).find((l) => l.id === locProp.id) || locProp;
  const reajustes = loc.reajustes || [];
  const aluguelAtual = loc.valorAluguelAtual || parseBR(property._form && property._form.valorAluguel);

  const onChangePct = (v) => {
    setPct(v);
    const p = parseFloat(v.replace(',', '.'));
    if (v === '' || isNaN(p)) { setValor(''); return; }
    setValor((aluguelAtual * (p / 100)).toFixed(2).replace('.', ','));
  };
  const onChangeValor = (v) => {
    setValor(v);
    const r = parseBR(v);
    if (v === '' || aluguelAtual <= 0) { setPct(''); return; }
    setPct(((r / aluguelAtual) * 100).toFixed(2).replace('.', ','));
  };

  const acrescimo = parseBR(valor);
  const novoAluguel = aluguelAtual + acrescimo;

  const handleAplicar = () => {
    if (!acrescimo) return;
    const pctTx = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
    const valorAdmFixo = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
    const novaTaxaAdm = valorAdmFixo > 0 ? valorAdmFixo : novoAluguel * (pctTx / 100);
    const novoRepasseLiquido = novoAluguel - novaTaxaAdm;
    const novoValorStr = novoAluguel.toLocaleString('pt-BR', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
    const novoRecord = { id: `reaj-${Date.now()}`, data: todayISO(), valorAnterior: aluguelAtual, valorNovo: novoAluguel };
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p,
      _form: { ...p._form, valorAluguel: novoValorStr },
      locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : {
        ...l,
        valorAluguelAtual: novoAluguel,
        cobrancas: (l.cobrancas || []).map((c) => c.status === 'A vencer' ? { ...c, valor: novoAluguel } : c),
        repasses: (l.repasses || []).map((r) => r.status === 'A repassar' ? { ...r, valor: novoRepasseLiquido } : r),
        reajustes: [...(l.reajustes || []), novoRecord],
      }),
    }));
    setPct(''); setValor('');
  };

  const handleCancelarUltimo = () => {
    if (reajustes.length === 0) return;
    const ultimo = reajustes[reajustes.length - 1];
    const valorAnterior = ultimo.valorAnterior;
    const pctTx = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
    const valorAdmFixo = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
    const taxaAdm = valorAdmFixo > 0 ? valorAdmFixo : valorAnterior * (pctTx / 100);
    const repasseAnterior = valorAnterior - taxaAdm;
    const valorAnteriorStr = valorAnterior.toLocaleString('pt-BR', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p,
      _form: { ...p._form, valorAluguel: valorAnteriorStr },
      locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : {
        ...l,
        valorAluguelAtual: reajustes.length > 1 ? reajustes[reajustes.length - 2].valorNovo : null,
        cobrancas: (l.cobrancas || []).map((c) => c.status === 'A vencer' ? { ...c, valor: valorAnterior } : c),
        repasses: (l.repasses || []).map((r) => r.status === 'A repassar' ? { ...r, valor: repasseAnterior } : r),
        reajustes: reajustes.slice(0, -1),
      }),
    }));
  };

  const handleEditarUltimo = () => {
    if (reajustes.length === 0) return;
    const ultimo = reajustes[reajustes.length - 1];
    handleCancelarUltimo();
    setValor((ultimo.valorNovo - ultimo.valorAnterior).toFixed(2).replace('.', ','));
    setPct(ultimo.valorAnterior > 0 ? (((ultimo.valorNovo - ultimo.valorAnterior) / ultimo.valorAnterior) * 100).toFixed(2).replace('.', ',') : '');
  };

  return (
    <Dialog open onClose={onClose} size="sm" strategy="absolute" placement="center" icon="percent" tone="warning" title="Reajustar locação" description="Informe o percentual ou o valor do reajuste — o outro campo é calculado automaticamente"
      footer={<Button variant="secondary" onClick={onClose}>Fechar</Button>}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
        <div style={{ display: 'flex', gap: 16, padding: '10px 12px', background: 'var(--surface-sunken)', borderRadius: 10 }}>
          <div style={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
            <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>Valor atual</span>
            <span style={{ fontSize: 15, fontWeight: 600, color: 'var(--text-strong)' }}>{fmtMoney(aluguelAtual)}</span>
          </div>
          <div style={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
            <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>Novo valor</span>
            <span style={{ fontSize: 15, fontWeight: 600, color: 'var(--status-success-text)' }}>{fmtMoney(novoAluguel)}</span>
          </div>
        </div>
        <Input label="Reajuste (%)" placeholder="Ex: 8" value={pct} onChange={(e) => onChangePct(e.target.value)} />
        <Input label="Reajuste (R$)" placeholder="Ex: 160,00" value={valor} onChange={(e) => onChangeValor(e.target.value)} />
        <Button icon="check" disabled={!acrescimo} onClick={handleAplicar}>Aplicar reajuste</Button>

        <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
          <span style={{ fontSize: 12, fontWeight: 600, color: 'var(--text-strong)' }}>Histórico de reajustes</span>
          {reajustes.length === 0 ? (
            <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Nenhum reajuste aplicado ainda.</span>
          ) : (
            [...reajustes].reverse().map((r, i) => (
              <div key={r.id} style={{ display: 'flex', alignItems: 'center', gap: 10, padding: '8px 10px', border: '1px solid var(--border-subtle)', borderRadius: 10 }}>
                <Icon name="trending-up" size={16} color="var(--text-subtle)" />
                <div style={{ display: 'flex', flexDirection: 'column', flex: 1, minWidth: 0 }}>
                  <span style={{ fontSize: 13, color: 'var(--text-strong)' }}>{fmtMoney(r.valorAnterior)} → {fmtMoney(r.valorNovo)}</span>
                  <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>{fmtDateBR(r.data)}</span>
                </div>
                {i === 0 && (
                  <div style={{ display: 'flex', gap: 4 }}>
                    <Button variant="ghost" size="sm" onClick={handleEditarUltimo}>Editar</Button>
                    <Button variant="ghost" size="sm" style={{ color: 'var(--status-danger-text)' }} onClick={handleCancelarUltimo}>Cancelar</Button>
                  </div>
                )}
              </div>
            ))
          )}
        </div>
      </div>
    </Dialog>
  );
}

const COBRANCA_STATUS = ['A vencer', 'Pago', 'Vencido'];
const COBRANCA_TONE = { 'A vencer': 'neutral', 'Pago': 'success', 'Vencido': 'danger' };
const REPASSE_STATUS = ['A repassar', 'Repassado'];
const REPASSE_TONE = { 'A repassar': 'neutral', 'Repassado': 'success' };
const MOVIMENTACAO_TONE = { 'A vencer': 'info', 'Vencido': 'danger', 'Pago': 'success' };

function buildParcelas(loc, aluguel, repasseLiquido) {
  let base = loc.dataInicio || todayISO();
  // Alinha o dia do vencimento mensal ao dia escolhido na locação (5, 15 ou 25).
  if (loc.diaVencimento) {
    const [y, mo] = base.split('-');
    base = `${y}-${mo}-${String(loc.diaVencimento).padStart(2, '0')}`;
  }
  const hoje = todayISO();
  const nParcelas = loc.prazoMeses && loc.prazoMeses > 0 ? loc.prazoMeses : 12;
  const cobrancas = [];
  const repasses = [];
  for (let i = 0; i < nParcelas; i++) {
    const venc = addMonthsISO(base, i) || base;
    const dt = venc.split('-');
    const label = `${MES_NOMES_PL[Number(dt[1]) - 1]}/${dt[0]}`;
    // Garantia por Caução: a primeira cobrança já vem com o depósito (3x o aluguel) somado
    // ao aluguel do primeiro mês — portanto 4x o valor normal, só nessa parcela.
    const isPrimeiraComCaucao = i === 0 && loc.garantia === 'Caução';
    const valorCobranca = isPrimeiraComCaucao ? aluguel * 4 : aluguel;
    cobrancas.push({ mes: label, vencimento: venc, valor: valorCobranca, status: venc < hoje ? 'Vencido' : 'A vencer', caucao: isPrimeiraComCaucao });
    // O repasse ao proprietário sempre vence no dia seguinte ao vencimento do inquilino — a
    // caução não é repassada (fica retida como depósito), então o repasse segue o valor normal.
    const vencRepasse = addDaysISO(venc, 1);
    repasses.push({ mes: label, vencimento: vencRepasse, valor: repasseLiquido, status: 'A repassar' });
  }
  return { cobrancas, repasses };
}

// Ao renovar, acrescenta mais parcelas depois da última já existente — não mexe nas que já passaram (histórico).
function extendParcelas(loc, aluguel, repasseLiquido, novosMeses) {
  const existentesCobrancas = loc.cobrancas || [];
  const existentesRepasses = loc.repasses || [];
  const ultimaBase = existentesCobrancas.length ? existentesCobrancas[existentesCobrancas.length - 1].vencimento : (loc.dataVencimento || loc.dataInicio || todayISO());
  const hoje = todayISO();
  const novasCobrancas = [];
  const novosRepasses = [];
  for (let i = 1; i <= novosMeses; i++) {
    const venc = addMonthsISO(ultimaBase, i);
    const dt = venc.split('-');
    const label = `${MES_NOMES_PL[Number(dt[1]) - 1]}/${dt[0]}`;
    novasCobrancas.push({ mes: label, vencimento: venc, valor: aluguel, status: venc < hoje ? 'Vencido' : 'A vencer' });
    const vencRepasse = addDaysISO(venc, 1);
    novosRepasses.push({ mes: label, vencimento: vencRepasse, valor: repasseLiquido, status: 'A repassar' });
  }
  return {
    cobrancas: [...existentesCobrancas, ...novasCobrancas],
    repasses: [...existentesRepasses, ...novosRepasses],
    novoVencimento: addMonthsISO(ultimaBase, novosMeses),
  };
}

function RenovarDialog({ loc: locProp, property, setProperties, onClose }) {
  const { Dialog, Button, Input, Icon } = DSpl;
  const [meses, setMeses] = React.useState('12');

  const loc = (property.locacoes || []).find((l) => l.id === locProp.id) || locProp;
  const renovacoes = loc.renovacoes || [];

  const handleRenovar = () => {
    const novosMeses = Number(meses) || 0;
    if (!novosMeses) return;
    const aluguel = parseBR(property._form && property._form.valorAluguel);
    const pct = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
    const valorAdmFixo = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
    const taxaAdmMensal = valorAdmFixo > 0 ? valorAdmFixo : aluguel * (pct / 100);
    const repasseLiquido = aluguel - taxaAdmMensal;
    let base = loc;
    if (!base.cobrancas || !base.repasses) {
      const built = buildParcelas(base, aluguel, repasseLiquido);
      base = { ...base, cobrancas: built.cobrancas, repasses: built.repasses };
    }
    const ext = extendParcelas(base, aluguel, repasseLiquido, novosMeses);
    const novoRecord = {
      id: `renov-${Date.now()}`, data: todayISO(), meses: novosMeses,
      prazoAnterior: base.prazoMeses || 0, prazoNovo: (base.prazoMeses || 0) + novosMeses,
      vencimentoAnterior: base.dataVencimento, vencimentoNovo: ext.novoVencimento,
    };
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p,
      locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : {
        ...l,
        prazoMeses: novoRecord.prazoNovo,
        dataVencimento: ext.novoVencimento,
        cobrancas: ext.cobrancas,
        repasses: ext.repasses,
        renovacoes: [...(l.renovacoes || []), novoRecord],
      }),
    }));
    setMeses('12');
  };

  const handleCancelarUltimo = () => {
    if (renovacoes.length === 0) return;
    const ultimo = renovacoes[renovacoes.length - 1];
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p,
      locacoes: (p.locacoes || []).map((l) => {
        if (l.id !== loc.id) return l;
        const cobrancas = (l.cobrancas || []).slice(0, -ultimo.meses || undefined);
        const repasses = (l.repasses || []).slice(0, -ultimo.meses || undefined);
        return { ...l, prazoMeses: ultimo.prazoAnterior, dataVencimento: ultimo.vencimentoAnterior, cobrancas, repasses, renovacoes: renovacoes.slice(0, -1) };
      }),
    }));
  };

  const handleEditarUltimo = () => {
    if (renovacoes.length === 0) return;
    const ultimo = renovacoes[renovacoes.length - 1];
    handleCancelarUltimo();
    setMeses(String(ultimo.meses));
  };

  return (
    <Dialog open onClose={onClose} size="sm" strategy="absolute" placement="center" icon="refresh-cw" tone="accent" title="Renovar locação" description="Acrescenta mais parcelas ao fim da locação atual"
      footer={<Button variant="secondary" onClick={onClose}>Fechar</Button>}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
        <Input label="Renovar por quantos meses? *" type="number" min={1} value={meses} onChange={(e) => setMeses(e.target.value)} />
        <Button icon="check" onClick={handleRenovar}>Renovar</Button>

        <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
          <span style={{ fontSize: 12, fontWeight: 600, color: 'var(--text-strong)' }}>Histórico de renovações</span>
          {renovacoes.length === 0 ? (
            <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Nenhuma renovação feita ainda.</span>
          ) : (
            [...renovacoes].reverse().map((r, i) => (
              <div key={r.id} style={{ display: 'flex', alignItems: 'center', gap: 10, padding: '8px 10px', border: '1px solid var(--border-subtle)', borderRadius: 10 }}>
                <Icon name="refresh-cw" size={16} color="var(--text-subtle)" />
                <div style={{ display: 'flex', flexDirection: 'column', flex: 1, minWidth: 0 }}>
                  <span style={{ fontSize: 13, color: 'var(--text-strong)' }}>+{r.meses} meses — até {fmtDateBR(r.vencimentoNovo)}</span>
                  <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>{fmtDateBR(r.data)}</span>
                </div>
                {i === 0 && (
                  <div style={{ display: 'flex', gap: 4 }}>
                    <Button variant="ghost" size="sm" onClick={handleEditarUltimo}>Editar</Button>
                    <Button variant="ghost" size="sm" style={{ color: 'var(--status-danger-text)' }} onClick={handleCancelarUltimo}>Cancelar</Button>
                  </div>
                )}
              </div>
            ))
          )}
        </div>
      </div>
    </Dialog>
  );
}

function fmtFileSize(b) {
  return b > 1024 * 1024 ? `${(b / 1024 / 1024).toFixed(1)} MB` : `${Math.max(1, Math.round((b || 0) / 1024))} KB`;
}

function DocAnexosDialog({ loc: locProp, property, setProperties, onClose }) {
  const { Dialog, UploadTile, IconButton, Icon, Button } = DSpl;
  const fileRef = React.useRef(null);

  // A locação "ao vivo" (reflete anexos já salvos).
  const loc = (property.locacoes || []).find((l) => l.id === locProp.id) || locProp;
  const docs = loc.documentos || [];

  const onPick = (e) => {
    const files = Array.from(e.target.files || []).filter((f) => f.type === 'application/pdf' || f.type.startsWith('image/'));
    files.forEach((f) => {
      const reader = new FileReader();
      reader.onload = () => {
        const novo = { id: `doc-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`, name: f.name, size: f.size, type: f.type, dataUrl: reader.result };
        setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
          ...p, locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : { ...l, documentos: [...(l.documentos || []), novo] }),
        }));
      };
      reader.readAsDataURL(f);
    });
    e.target.value = '';
  };

  const removeDoc = (docId) => {
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p, locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : { ...l, documentos: (l.documentos || []).filter((d) => d.id !== docId) }),
    }));
  };

  const downloadDoc = (d) => {
    const a = document.createElement('a');
    a.href = d.dataUrl;
    a.download = d.name;
    document.body.appendChild(a);
    a.click();
    a.remove();
  };

  return (
    <Dialog open onClose={onClose} size="md" strategy="absolute" placement="center" icon="paperclip" tone="neutral" title="Doc Anexos" description="Anexos desta locação — apenas PDF ou imagem (JPG, PNG, etc.)"
      footer={<Button variant="secondary" onClick={onClose}>Fechar</Button>}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
        <input ref={fileRef} type="file" accept="image/*,application/pdf" multiple hidden onChange={onPick} />
        <UploadTile icon="upload" label="Subir arquivo" hint="PDF ou imagem (JPG, PNG...)" height={84} onClick={() => fileRef.current && fileRef.current.click()} />

        {docs.length === 0 ? (
          <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Nenhum arquivo anexado ainda.</span>
        ) : (
          <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fill, minmax(84px, 1fr))', gap: 12 }}>
            {docs.map((d) => (
              <div key={d.id} style={{ display: 'flex', flexDirection: 'column', gap: 4, position: 'relative' }}>
                {d.type === 'application/pdf' ? (
                  <div onClick={() => window.open(d.dataUrl, '_blank')}
                    style={{ width: '100%', aspectRatio: '1', borderRadius: 10, border: '1px solid var(--border-subtle)', background: 'var(--surface-sunken)', display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', gap: 4, cursor: 'pointer' }}>
                    <Icon name="file-text" size={22} color="var(--status-danger-text)" />
                    <span style={{ fontSize: 9, fontWeight: 700, color: 'var(--status-danger-text)' }}>PDF</span>
                  </div>
                ) : (
                  <img src={d.dataUrl} onClick={() => window.open(d.dataUrl, '_blank')} alt={d.name}
                    style={{ width: '100%', aspectRatio: '1', objectFit: 'cover', borderRadius: 10, border: '1px solid var(--border-subtle)', cursor: 'pointer' }} />
                )}
                <IconButton icon="download" label="Baixar" size="sm" variant="soft"
                  style={{ position: 'absolute', top: 4, left: 4 }} onClick={() => downloadDoc(d)} />
                <IconButton icon="trash-2" label="Remover" size="sm" variant="soft"
                  style={{ position: 'absolute', top: 4, right: 4 }} onClick={() => removeDoc(d.id)} />
                <span style={{ fontSize: 10, color: 'var(--text-muted)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }} title={d.name}>{d.name}</span>
                <span style={{ fontSize: 9, color: 'var(--text-subtle)' }}>{fmtFileSize(d.size)}</span>
              </div>
            ))}
          </div>
        )}
      </div>
    </Dialog>
  );
}

// Movimentação: registra uma despesa ligada à locação (ex.: reforma, conserto) e aplica o
// desconto correspondente nas próximas parcelas em aberto da cobrança do inquilino e/ou do
// repasse do proprietário. A taxa da imobiliária nunca é recalculada por causa disso — o que
// muda é só o valor que sai do inquilino e/ou chega ao proprietário.
const MOVIMENTACAO_PARTES = ['Inquilino', 'Proprietário', 'Imobiliária', 'Terceiro'];

// Ajusta (soma delta, positivo ou negativo) na parcela cujo vencimento cai no mesmo mês/ano
// da data de vencimento informada na movimentação.
// Ajuste de uma movimentação nas parcelas, com "carregamento": um desconto maior que a parcela do mês
// passa para as parcelas seguintes ainda em aberto. Parcela que zera fica "Compensado" (conta como
// paga/repassada). Cada parcela guarda em "ajustes" quanto cada movimentação tirou/somou, para o
// "Excluir" da movimentação desfazer exatamente o que foi feito.
function arred2(n) { return Math.round(n * 100) / 100; }
function aplicarAjusteParcelas(arr, dataVencimento, delta, movId, tipo) {
  const lista = (arr || []).map((x) => ({ ...x }));
  if (!dataVencimento || !delta) return { arr: lista, sobra: 0 };
  const alvo = dataVencimento.slice(0, 7);
  let inicio = lista.findIndex((x) => (x.vencimento || '').slice(0, 7) === alvo);
  if (inicio === -1) inicio = lista.findIndex((x) => (x.vencimento || '').slice(0, 7) > alvo);
  if (inicio === -1) return { arr: lista, sobra: Math.abs(delta) };
  const feita = (x) => tipo === 'repasse' ? x.status === 'Repassado' : x.status === 'Pago';
  if (delta > 0) {
    let i = inicio;
    while (i < lista.length && feita(lista[i])) i++;
    if (i >= lista.length) return { arr: lista, sobra: delta };
    lista[i].valor = arred2(lista[i].valor + delta);
    lista[i].ajustes = [...(lista[i].ajustes || []), { movId, valor: arred2(delta) }];
    return { arr: lista, sobra: 0 };
  }
  let resto = arred2(-delta);
  for (let i = inicio; i < lista.length && resto > 0; i++) {
    const x = lista[i];
    if (feita(x) || !(x.valor > 0)) continue;
    const tira = arred2(Math.min(resto, x.valor));
    x.valor = arred2(x.valor - tira);
    resto = arred2(resto - tira);
    x.ajustes = [...(x.ajustes || []), { movId, valor: -tira }];
    if (x.valor <= 0) {
      x.valor = 0; x.compensado = true; x.dataCompensacao = new Date().toISOString();
      x.status = tipo === 'repasse' ? 'Repassado' : 'Pago';
    }
  }
  return { arr: lista, sobra: resto };
}
function desfazerAjusteParcelas(arr, movId, tipo) {
  const hoje = todayISO();
  return (arr || []).map((x) => {
    const meus = (x.ajustes || []).filter((a) => a.movId === movId);
    if (!meus.length) return x;
    const soma = meus.reduce((a, b) => a + b.valor, 0);
    const y = { ...x, valor: arred2(x.valor - soma), ajustes: x.ajustes.filter((a) => a.movId !== movId) };
    if (y.compensado && y.valor > 0) {
      delete y.compensado; delete y.dataCompensacao;
      y.status = tipo === 'repasse' ? 'A repassar' : (y.vencimento < hoje ? 'Vencido' : 'A vencer');
    }
    return y;
  });
}

function ajustarParcelaPorMes(arr, dataVencimento, delta) {
  if (!arr || !dataVencimento || !delta) return arr || [];
  const alvoMes = dataVencimento.slice(0, 7);
  const idx = arr.findIndex((x) => (x.vencimento || '').slice(0, 7) === alvoMes);
  if (idx === -1) return arr;
  return arr.map((x, i) => i !== idx ? x : { ...x, valor: Math.max(0, x.valor + delta) });
}

function ParteSelect({ label, parte, setParte, terceiroNome, setTerceiroNome, terceiroPersonId, setTerceiroPersonId, people }) {
  const { Select } = DSpl;
  return (
    <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
      <Select label={label} value={parte} onChange={(e) => setParte(e.target.value)} options={MOVIMENTACAO_PARTES} />
      {parte === 'Terceiro' && (
        <TenantSearch label="Pessoa cadastrada *" placeholder="Buscar em Pessoas..." nome={terceiroNome} personId={terceiroPersonId} people={people}
          onChangeNome={(v) => { setTerceiroNome(v); setTerceiroPersonId(null); }}
          onPick={(p) => { setTerceiroNome(p.nome); setTerceiroPersonId(p.id); }} />
      )}
    </div>
  );
}

function MovimentacaoDialog({ loc: locProp, property, people, setProperties, maintenanceRecords, onClose }) {
  const { Dialog, Select, Button, Badge, Icon, IconButton } = DSpl;
  const [manutencaoId, setManutencaoId] = React.useState(null);
  const [dataVencimentoOrigem, setDataVencimentoOrigem] = React.useState('');
  const [dataVencimentoDestino, setDataVencimentoDestino] = React.useState('');
  const [origem, setOrigem] = React.useState('Proprietário');
  const [origemNome, setOrigemNome] = React.useState('');
  const [origemPersonId, setOrigemPersonId] = React.useState(null);
  const [destino, setDestino] = React.useState('Imobiliária');
  const [destinoNome, setDestinoNome] = React.useState('');
  const [destinoPersonId, setDestinoPersonId] = React.useState(null);
  const [error, setError] = React.useState('');

  const manutencoesRealizadas = React.useMemo(() => {
    const usadas = new Set(
      (property.locacoes || []).flatMap((l) => (l.movimentacoes || []).map((m) => m.manutencaoId).filter(Boolean))
    );
    return (maintenanceRecords || []).filter((r) => r.propertyId === property.id && r.status === 'Realizada' && !usadas.has(r.id));
  }, [maintenanceRecords, property.id, property.locacoes]);
  const manutencaoSelecionada = manutencoesRealizadas.find((r) => r.id === manutencaoId) || null;
  const descricao = manutencaoSelecionada ? manutencaoSelecionada.descricao : '';
  const valorNum = manutencaoSelecionada && manutencaoSelecionada.valor != null ? manutencaoSelecionada.valor : 0;

  const loc = (property.locacoes || []).find((l) => l.id === locProp.id) || locProp;
  const movimentacoes = loc.movimentacoes || [];
  const hoje = todayISO();

  // Inquilino e Proprietário têm parcela própria na locação (aluguel/cobrança para o inquilino,
  // repasse para o proprietário) — o vencimento dessas partes tem que ser sempre uma dessas
  // parcelas, nunca uma data livre. Imobiliária e Terceiro não têm parcela: o pagamento pra eles
  // acontece sempre na data do lançamento (hoje), sem seleção nenhuma.
  const temParcela = (parte) => parte === 'Inquilino' || parte === 'Proprietário';

  const basesParcelas = React.useMemo(() => {
    const aluguel = parseBR(property._form && property._form.valorAluguel);
    const pct = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
    const valorAdmFixo = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
    const taxaAdmMensal = valorAdmFixo > 0 ? valorAdmFixo : aluguel * (pct / 100);
    const repasseLiquido = aluguel - taxaAdmMensal;
    const faltaAlgum = !loc.cobrancas || !loc.repasses;
    const built = faltaAlgum ? buildParcelas(loc, aluguel, repasseLiquido) : null;
    const cobrancas = loc.cobrancas || (built && built.cobrancas) || [];
    const repasses = loc.repasses || (built && built.repasses) || [];
    const toOptions = (arr, rotulo) => arr.filter((x) => x.vencimento >= hoje).map((x) => ({ value: x.vencimento, label: `${x.mes} — ${rotulo} vence ${fmtDateBR(x.vencimento)}` }));
    return { cobrancas: toOptions(cobrancas, 'aluguel'), repasses: toOptions(repasses, 'repasse') };
  }, [loc.cobrancas, loc.repasses, loc.id]);

  const opcoesParte = (parte) => parte === 'Inquilino' ? basesParcelas.cobrancas : parte === 'Proprietário' ? basesParcelas.repasses : [];
  const origemOpcoes = opcoesParte(origem);
  const destinoOpcoes = opcoesParte(destino);

  React.useEffect(() => {
    if (temParcela(origem) && !dataVencimentoOrigem && origemOpcoes.length > 0) setDataVencimentoOrigem(origemOpcoes[0].value);
  }, [origem]);
  React.useEffect(() => {
    if (temParcela(destino) && !dataVencimentoDestino && destinoOpcoes.length > 0) setDataVencimentoDestino(destinoOpcoes[0].value);
  }, [destino]);

  // Quando "Tirar de"/"Pagar para" é Terceiro, já busca quem fez o serviço (prestador) cadastrado
  // na manutenção selecionada — a pessoa que vai receber o pagamento pelo reparo.
  React.useEffect(() => {
    if (origem === 'Terceiro' && manutencaoSelecionada && !origemPersonId) {
      setOrigemNome(manutencaoSelecionada.prestadorNome || '');
      setOrigemPersonId(manutencaoSelecionada.prestadorPersonId || null);
    }
  }, [origem, manutencaoSelecionada]);
  React.useEffect(() => {
    if (destino === 'Terceiro' && manutencaoSelecionada && !destinoPersonId) {
      setDestinoNome(manutencaoSelecionada.prestadorNome || '');
      setDestinoPersonId(manutencaoSelecionada.prestadorPersonId || null);
    }
  }, [destino, manutencaoSelecionada]);

  const nomeParte = (parte, terceiroNome) => parte === 'Terceiro' ? (terceiroNome || 'Terceiro') : parte;

  const handleAdd = () => {
    const v = valorNum;
    if (!manutencaoSelecionada) { setError('Selecione a manutenção vinculada a este lançamento.'); return; }
    if (!v) { setError('Esta manutenção não tem valor informado.'); return; }
    if (temParcela(origem) && !dataVencimentoOrigem) { setError(`Selecione a parcela de ${origem} de onde vai sair o valor.`); return; }
    if (temParcela(destino) && !dataVencimentoDestino) { setError(`Selecione a parcela de ${destino} que vai receber o valor.`); return; }
    if (origem === 'Terceiro' && !origemPersonId) { setError('Selecione a pessoa cadastrada de quem vai sair o valor.'); return; }
    if (destino === 'Terceiro' && !destinoPersonId) { setError('Selecione a pessoa cadastrada para quem vai o valor.'); return; }

    // Imobiliária e Terceiro: pagamento sempre na data do lançamento (hoje). Inquilino/Proprietário:
    // sempre na parcela (aluguel/repasse) escolhida.
    const dataOrigem = temParcela(origem) ? dataVencimentoOrigem : hoje;
    const dataDestino = temParcela(destino) ? dataVencimentoDestino : hoje;

    const aluguel = parseBR(property._form && property._form.valorAluguel);
    const pct = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
    const valorAdmFixo = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
    const taxaAdmMensal = valorAdmFixo > 0 ? valorAdmFixo : aluguel * (pct / 100);
    const repasseLiquido = aluguel - taxaAdmMensal;
    let base = loc;
    if (!base.cobrancas || !base.repasses) {
      const built = buildParcelas(base, aluguel, repasseLiquido);
      base = { ...base, cobrancas: built.cobrancas, repasses: built.repasses };
    }

    let cobrancas = base.cobrancas;
    let repasses = base.repasses;
    // Tirar de: Inquilino aumenta a cobrança dele (ele deve mais); Proprietário reduz o repasse dele
    // (se o repasse do mês não cobrir, o restante é descontado dos próximos; parcela zerada = Compensado).
    // Pagar para: Inquilino reduz a cobrança dele (desconto no aluguel); Proprietário aumenta o repasse dele.
    const movId = `mov-${Date.now()}`;
    let sobra = 0;
    const aplica = (lista, data, delta, tipo) => { const r = aplicarAjusteParcelas(lista, data, delta, movId, tipo); sobra += r.sobra; return r.arr; };
    if (origem === 'Inquilino') cobrancas = aplica(cobrancas, dataOrigem, v, 'cobranca');
    if (origem === 'Proprietário') repasses = aplica(repasses, dataOrigem, -v, 'repasse');
    if (destino === 'Inquilino') cobrancas = aplica(cobrancas, dataDestino, -v, 'cobranca');
    if (destino === 'Proprietário') repasses = aplica(repasses, dataDestino, v, 'repasse');
    // Imobiliária e Terceiro não mexem em cobrança/repasse — ficam como ordem de pagamento própria.

    const novoMov = {
      id: movId,
      saldoNaoCompensado: sobra > 0 ? arred2(sobra) : undefined,
      dataLancamento: hoje,
      dataVencimento: dataDestino,
      dataVencimentoOrigem: dataOrigem,
      descricao: descricao.trim(),
      valor: v,
      manutencaoId: manutencaoSelecionada.id,
      origem, origemNome: origem === 'Terceiro' ? origemNome : null, origemPersonId: origem === 'Terceiro' ? origemPersonId : null,
      destino, destinoNome: destino === 'Terceiro' ? destinoNome : null, destinoPersonId: destino === 'Terceiro' ? destinoPersonId : null,
      status: 'A vencer',
    };
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p,
      locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : {
        ...l, cobrancas, repasses, movimentacoes: [novoMov, ...(l.movimentacoes || [])],
      }),
    }));
    setManutencaoId(null); setDataVencimentoOrigem(''); setDataVencimentoDestino('');
    setOrigemNome(''); setOrigemPersonId(null); setDestinoNome(''); setDestinoPersonId(null); setError('');
  };

  // Desfaz o efeito da movimentação na cobrança/repasse (reverso do que handleAdd aplicou) e
  // remove o registro. Só deve ser usada enquanto a movimentação ainda não foi paga.
  const removeMovimentacao = (m) => {
    const dataOrigem = m.dataVencimentoOrigem || m.dataVencimento;
    const dataDestino = m.dataVencimento;
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p,
      locacoes: (p.locacoes || []).map((l) => {
        if (l.id !== loc.id) return l;
        let cobrancas = l.cobrancas;
        let repasses = l.repasses;
        const novoFormato = [...(cobrancas || []), ...(repasses || [])].some((x) => (x.ajustes || []).some((a) => a.movId === m.id));
        if (novoFormato) {
          cobrancas = desfazerAjusteParcelas(cobrancas, m.id, 'cobranca');
          repasses = desfazerAjusteParcelas(repasses, m.id, 'repasse');
        } else { // lançamentos antigos, de antes do desconto em cascata
          // O formato antigo zerava a parcela (sem passar o resto adiante), então ao excluir a parcela
          // volta ao valor normal — nunca acima dele (antes somava o valor inteiro de volta).
          const aluguelN = parseBR(property._form && property._form.valorAluguel);
          const pctN = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
          const admFixoN = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
          const repasseN = arred2(aluguelN - (admFixoN > 0 ? admFixoN : aluguelN * (pctN / 100)));
          const restaura = (arr, data, delta, teto, piso) => {
            const alvo = (data || '').slice(0, 7);
            return (arr || []).map((x) => {
              if ((x.vencimento || '').slice(0, 7) !== alvo || x.caucao) return x;
              let v = arred2((x.valor || 0) + delta);
              if (teto != null && teto > 0) v = Math.min(v, teto);
              if (piso != null && piso > 0) v = Math.max(v, piso);
              return { ...x, valor: Math.max(0, v) };
            });
          };
          if (m.origem === 'Inquilino') cobrancas = restaura(cobrancas, dataOrigem, -m.valor, null, aluguelN);
          if (m.origem === 'Proprietário') repasses = restaura(repasses, dataOrigem, m.valor, repasseN, null);
          if (m.destino === 'Inquilino') cobrancas = restaura(cobrancas, dataDestino, m.valor, aluguelN, null);
          if (m.destino === 'Proprietário') repasses = restaura(repasses, dataDestino, -m.valor, null, repasseN);
        }
        return { ...l, cobrancas, repasses, movimentacoes: (l.movimentacoes || []).filter((x) => x.id !== m.id) };
      }),
    }));
  };

  return (
    <Dialog open onClose={onClose} size="md" strategy="absolute" placement="center" icon="banknote" tone="success" title="Movimentação" description="Ordens de pagamento desta locação — vão aparecer na futura aba Financeiro"
      footer={<Button variant="secondary" onClick={onClose}>Fechar</Button>}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
        {loc.ativa ? (
          <div style={{ display: 'flex', flexDirection: 'column', gap: 10, padding: 12, background: 'var(--surface-sunken)', borderRadius: 10 }}>
            {manutencoesRealizadas.length === 0 ? (
              <div style={{ display: 'flex', alignItems: 'center', gap: 8, padding: '10px 12px', background: 'var(--surface-card)', border: '1px dashed var(--border-subtle)', borderRadius: 10 }}>
                <Icon name="wrench" size={16} color="var(--text-subtle)" />
                <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Nenhuma manutenção prevista para movimentação neste imóvel. Cadastre e marque uma manutenção como "Realizada" para poder lançá-la aqui.</span>
              </div>
            ) : (
              <React.Fragment>
                <Select label="Manutenção realizada *" value={manutencaoId || ''}
                  onChange={(e) => setManutencaoId(e.target.value || null)}
                  options={manutencoesRealizadas.map((r) => ({
                    value: r.id,
                    label: `${r.descricao} — ${fmtDateBR((r.data || '').slice(0, 10))}${r.valor != null ? ` · ${fmtMoney(r.valor)}` : ' · sem valor'}`,
                  }))}
                  placeholder="Selecione a manutenção vinculada" />
                {manutencaoSelecionada && (
                  <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 8, padding: '8px 10px', background: 'var(--surface-card)', border: '1px solid var(--border-subtle)', borderRadius: 8 }}>
                    <span style={{ fontSize: 13, color: 'var(--text-strong)' }}>{manutencaoSelecionada.descricao}</span>
                    <Badge tone="success" size="sm">{fmtMoney(valorNum)}</Badge>
                  </div>
                )}
              </React.Fragment>
            )}

            <div style={{ height: 1, background: 'var(--border-subtle)', margin: '2px 0' }} />

            <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 10, alignItems: 'start' }}>
              <ParteSelect label="Tirar de" parte={origem} setParte={setOrigem}
                terceiroNome={origemNome} setTerceiroNome={setOrigemNome} terceiroPersonId={origemPersonId} setTerceiroPersonId={setOrigemPersonId} people={people} />
              <ParteSelect label="Pagar para" parte={destino} setParte={setDestino}
                terceiroNome={destinoNome} setTerceiroNome={setDestinoNome} terceiroPersonId={destinoPersonId} setTerceiroPersonId={setDestinoPersonId} people={people} />
            </div>

            {(temParcela(origem) || temParcela(destino)) ? (
              <div style={{ display: 'grid', gridTemplateColumns: temParcela(origem) && temParcela(destino) ? '1fr 1fr' : '1fr', gap: 10 }}>
                {temParcela(origem) && (
                  <Select label={`Vencimento — ${origem} *`} value={dataVencimentoOrigem} onChange={(e) => setDataVencimentoOrigem(e.target.value)} options={origemOpcoes}
                    placeholder={origemOpcoes.length === 0 ? 'Nenhuma parcela gerada ainda' : undefined} />
                )}
                {temParcela(destino) && (
                  <Select label={`Vencimento — ${destino} *`} value={dataVencimentoDestino} onChange={(e) => setDataVencimentoDestino(e.target.value)} options={destinoOpcoes}
                    placeholder={destinoOpcoes.length === 0 ? 'Nenhuma parcela gerada ainda' : undefined} />
                )}
              </div>
            ) : (
              <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>Lançamento registrado para hoje, {fmtDateBR(hoje)}.</span>
            )}
            {manutencaoSelecionada && (
              <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>
                Tira {fmtMoney(valorNum)} de <b>{nomeParte(origem, origemNome)}</b>{temParcela(origem) ? ' no vencimento da parcela escolhida' : ' hoje'} e paga para <b>{nomeParte(destino, destinoNome)}</b>{temParcela(destino) ? ' no vencimento da parcela escolhida' : ` hoje, ${fmtDateBR(hoje)}`}.
                {(origem === 'Inquilino' || destino === 'Inquilino') && ' Isso ajusta a cobrança do inquilino.'}
                {(origem === 'Proprietário' || destino === 'Proprietário') && ' Isso ajusta o repasse do proprietário.'}
              </span>
            )}
            {error && <span style={{ fontSize: 12, color: 'var(--status-danger-text)' }}>{error}</span>}
            <Button icon="plus" onClick={handleAdd} disabled={manutencoesRealizadas.length === 0}>Adicionar movimentação</Button>
          </div>
        ) : (
          <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Locação encerrada — você só pode consultar o histórico de movimentações abaixo, sem adicionar novas.</span>
        )}

        {movimentacoes.length === 0 ? (
          <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Nenhuma movimentação registrada ainda.</span>
        ) : (
          <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
            {movimentacoes.map((m) => (
              <div key={m.id} style={{ display: 'flex', alignItems: 'center', gap: 10, padding: '8px 10px', border: '1px solid var(--border-subtle)', borderRadius: 10 }}>
                <Icon name="receipt" size={16} color="var(--text-subtle)" />
                <div style={{ display: 'flex', flexDirection: 'column', flex: 1, minWidth: 0 }}>
                  <span style={{ fontSize: 13, color: 'var(--text-strong)' }}>{m.descricao}</span>
                  <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>
                    {nomeParte(m.origem, m.origemNome)} → {nomeParte(m.destino, m.destinoNome)} · Lançado em {fmtDateBR(m.dataLancamento)} · Vence {fmtDateBR(m.dataVencimento)}
                  </span>
                </div>
                <Badge tone="neutral" size="sm">{fmtMoney(m.valor)}</Badge>
                {loc.ativa && <IconButton icon="trash-2" label="Excluir movimentação" size="sm" variant="ghost" onClick={() => removeMovimentacao(m)} />}
              </div>
            ))}
          </div>
        )}
      </div>
    </Dialog>
  );
}

function FinanceiroDialog({ loc: locProp, property, setProperties, onClose }) {
  const { Dialog, Badge, IconButton, Icon } = DSpl;
  const aluguel = parseBR(property._form && property._form.valorAluguel);
  const pct = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
  const valorAdmFixo = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
  const taxaAdmMensal = valorAdmFixo > 0 ? valorAdmFixo : aluguel * (pct / 100);
  const repasseLiquido = aluguel - taxaAdmMensal;

  // A locação "ao vivo" (reflete toggles de status já salvos).
  const loc = (property.locacoes || []).find((l) => l.id === locProp.id) || locProp;

  React.useEffect(() => {
    if (loc.cobrancas && loc.repasses) return;
    const { cobrancas, repasses } = buildParcelas(loc, aluguel, repasseLiquido);
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p, locacoes: (p.locacoes || []).map((l) => l.id === loc.id ? { ...l, cobrancas, repasses } : l),
    }));
  }, [loc.id, !!loc.cobrancas]);

  const cobrancas = loc.cobrancas || [];
  const repasses = loc.repasses || [];
  const [pixDe, setPixDe] = React.useState(null); // parcela com a janela de Pix aberta
  const [repasseDe, setRepasseDe] = React.useState(null); // índice do repasse com o QR de pagamento aberto
  const [movPix, setMovPix] = React.useState(null); // movimentação (despesa) com o QR de pagamento aberto

  // Enquanto houver Pix enviado e ainda não pago, confere o servidor a cada 15 s: quando o banco
  // confirma, a parcela vira "Pago" + "Pix pago" (verde) sem precisar recarregar a página.
  const temPixAberto = (loc.cobrancas || []).some((c) => c.pix && c.pix.status === 'ATIVA' && c.status !== 'Pago');
  React.useEffect(() => {
    if (!temPixAberto || pixDe) return;
    const t = setInterval(async () => {
      try {
        const r = await fetch(PIX_API + '/api/imoveis', { credentials: 'include' });
        if (!r.ok) return;
        const srv = (await r.json()).find((p) => p.id === property.id);
        const lsrv = srv && (srv.locacoes || []).find((l) => l.id === loc.id);
        if (!lsrv) return;
        const pagouAgora = (lsrv.cobrancas || []).some((c) => c.pix && c.pix.status === 'PAGA' &&
          (loc.cobrancas || []).some((x) => x.mes === c.mes && !(x.pix && x.pix.status === 'PAGA')));
        if (pagouAgora) setProperties((cur) => cur.map((p) => p.id === srv.id ? srv : p));
      } catch (e) { /* tenta de novo no próximo ciclo */ }
    }, 15000);
    return () => clearInterval(t);
  }, [temPixAberto, !!pixDe, property.id, loc.id]);
  const totalCobrado = cobrancas.reduce((a, c) => a + c.valor, 0);
  const totalRepasse = repasses.reduce((a, r) => a + r.valor, 0);
  // Pago/repassado vs. ainda em aberto — é isso que o botão "Financeiro" do imóvel quer mostrar
  // de cara, antes de entrar no detalhe mês a mês.
  const cobrancasPagas = cobrancas.filter((c) => c.status === 'Pago');
  const cobrancasAberto = cobrancas.filter((c) => c.status !== 'Pago');
  const totalCobradoPago = cobrancasPagas.reduce((a, c) => a + c.valor, 0);
  const totalCobradoAberto = cobrancasAberto.reduce((a, c) => a + c.valor, 0);
  const repassesFeitos = repasses.filter((r) => r.status === 'Repassado');
  const repassesAberto = repasses.filter((r) => r.status !== 'Repassado');
  const totalRepassadoFeito = repassesFeitos.reduce((a, r) => a + r.valor, 0);
  const totalRepasseAberto = repassesAberto.reduce((a, r) => a + r.valor, 0);

  const cycleCobranca = (idx) => {
    if (cobrancas[idx] && cobrancas[idx].pix && cobrancas[idx].pix.status === 'PAGA') return; // pago via Pix: só o banco muda
    if (cobrancas[idx] && cobrancas[idx].compensado) return;
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p, locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : {
        ...l, cobrancas: l.cobrancas.map((c, i) => i !== idx ? c : { ...c, status: COBRANCA_STATUS[(COBRANCA_STATUS.indexOf(c.status) + 1) % COBRANCA_STATUS.length] }),
      }),
    }));
  };
  // Repasse só fica liberado depois que o inquilino pagou a parcela do mesmo mês.
  const inquilinoPagou = (r) => {
    if (!r) return false;
    const doMes = cobrancas.filter((c) => c.mes === r.mes && !c.caucao);
    if (!doMes.length) return true; // sem parcela correspondente (dados antigos): não bloqueia
    return doMes.every((c) => c.status === 'Pago');
  };
  const cycleRepasse = (idx) => {
    if (repasses[idx] && repasses[idx].status !== 'Repassado' && !inquilinoPagou(repasses[idx])) return;
    if (repasses[idx] && repasses[idx].compensado) return; // compensado por movimentação: desfaz excluindo a movimentação
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p, locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : {
        ...l, repasses: l.repasses.map((r, i) => {
          if (i !== idx) return r;
          const novo = REPASSE_STATUS[(REPASSE_STATUS.indexOf(r.status) + 1) % REPASSE_STATUS.length];
          if (novo === 'Repassado') { const k = window.mbCarimbo('Manual'); return { ...r, status: novo, dataRepasse: k.em, formaRepasse: k.forma, repassadoPor: k.por }; }
          const { dataRepasse, formaRepasse, repassadoPor, ...resto } = r;
          return { ...resto, status: novo };
        }),
      }),
    }));
  };
  // Pagamento em dinheiro na imobiliária — marca direto como Pago/Repassado (em verde),
  // sem precisar ficar clicando no status até chegar lá.
  const marcarPagoCobranca = (idx) => {
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p, locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : {
        ...l, cobrancas: l.cobrancas.map((c, i) => {
          if (i !== idx || c.status === 'Pago') return c;
          const k = window.mbCarimbo('Dinheiro');
          return { ...c, status: 'Pago', dataPagamento: k.em, formaPagamento: k.forma, recebidoPor: k.por };
        }),
      }),
    }));
  };
  const marcarRepassadoDinheiro = (idx, forma) => {
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p, locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : {
        ...l, repasses: l.repasses.map((r, i) => {
          if (i !== idx || r.status === 'Repassado') return r;
          const k = window.mbCarimbo(forma || 'Dinheiro');
          return { ...r, status: 'Repassado', dataRepasse: k.em, formaRepasse: k.forma, repassadoPor: k.por };
        }),
      }),
    }));
  };

  const movimentacoes = loc.movimentacoes || [];
  const nomeParteFd = (parte, nomeTerceiro) => parte === 'Terceiro' ? (nomeTerceiro || 'Terceiro') : parte;
  // Mesma lógica de status das cobranças/repasses: Pago fica como está, senão vence hoje pra
  // frente é "A vencer" (azul) e antes de hoje é "Vencido" (vermelho).
  const statusMovimentacao = (mv) => mv.status === 'Pago' ? 'Pago' : (mv.dataVencimento < todayISO() ? 'Vencido' : 'A vencer');
  const marcarPagoMovimentacao = (movId, forma) => {
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p, locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : {
        ...l, movimentacoes: (l.movimentacoes || []).map((mv) => {
          if (mv.id !== movId || mv.status === 'Pago') return mv;
          const k = window.mbCarimbo(forma || 'Dinheiro');
          return { ...mv, status: 'Pago', dataPagamento: k.em, formaPagamento: k.forma, pagoPor: k.por };
        }),
      }),
    }));
  };

  return (
    <Dialog open onClose={onClose} size="lg" strategy="absolute" placement="center" icon="banknote" tone="success" title="Resumo financeiro" description={`${property.name} · Inquilino: ${loc.inquilino}`}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 20 }}>
        {aluguel === 0 && (
          <span style={{ fontSize: 12, color: 'var(--status-warning-text)' }}>Este imóvel não tem valor de aluguel cadastrado — edite o imóvel para que os valores abaixo fiquem corretos.</span>
        )}
        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: 10 }}>
          <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--surface-sunken)' }}>
            <div style={{ fontSize: 11, color: 'var(--text-muted)' }}>Aluguel mensal</div>
            <div style={{ fontSize: 17, fontWeight: 600, color: 'var(--text-strong)' }}>{fmtMoney(aluguel)}</div>
          </div>
          <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--surface-sunken)' }}>
            <div style={{ fontSize: 11, color: 'var(--text-muted)' }}>Taxa da imobiliária{pct ? ` (${pct}%)` : ''}</div>
            <div style={{ fontSize: 17, fontWeight: 600, color: 'var(--text-strong)' }}>{fmtMoney(taxaAdmMensal)}</div>
          </div>
          <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--surface-sunken)' }}>
            <div style={{ fontSize: 11, color: 'var(--text-muted)' }}>Repasse líquido ao proprietário</div>
            <div style={{ fontSize: 17, fontWeight: 600, color: 'var(--text-strong)' }}>{fmtMoney(repasseLiquido)}</div>
          </div>
        </div>

        {!loc.ativa && (() => {
          const movs = loc.movimentacoes || [];
          const despesasPagas = movs.filter((mv) => mv.status === 'Pago').reduce((a, mv) => a + (Number(mv.valor) || 0), 0);
          const despesasAbertas = movs.filter((mv) => mv.status !== 'Pago').reduce((a, mv) => a + (Number(mv.valor) || 0), 0);
          const taxaRetida = Math.max(0, totalCobradoPago - repasses.filter((r, i) => cobrancas[i] && cobrancas[i].status === 'Pago').reduce((a, r) => a + (Number(r.valor) || 0), 0));
          const box = (rot, val, cor, sub) => (
            <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--surface-raised, #fff)', border: '1px solid var(--border-subtle, #e5e7eb)' }}>
              <div style={{ fontSize: 11, color: 'var(--text-muted)' }}>{rot}</div>
              <div style={{ fontSize: 17, fontWeight: 700, color: cor || 'var(--text-strong)' }}>{fmtMoney(val)}</div>
              {sub && <div style={{ fontSize: 10.5, color: 'var(--text-subtle)' }}>{sub}</div>}
            </div>
          );
          return (
            <div style={{ display: 'flex', flexDirection: 'column', gap: 10, padding: 14, borderRadius: 14, background: 'var(--surface-sunken)' }}>
              <span style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 13, fontWeight: 600, color: 'var(--text-strong)' }}><Icon name="calendar-check" size={14} color="var(--text-accent)" />Fechamento da locação{loc.dataFim ? ' — encerrada em ' + fmtDateBR(loc.dataFim) : ''}</span>
              <div style={{ display: 'grid', gridTemplateColumns: 'repeat(4, 1fr)', gap: 8 }}>
                {box('Inquilino pagou', totalCobradoPago, 'var(--status-success-text)', `${cobrancasPagas.length} aluguel(is)` + (totalCobradoAberto > 0 ? ` · em aberto ${fmtMoney(totalCobradoAberto)}` : ''))}
                {box('Proprietário recebeu', totalRepassadoFeito, 'var(--status-success-text)', `${repassesFeitos.length} repasse(s)` + (totalRepasse - totalRepassadoFeito > 0.004 ? ` · a receber ${fmtMoney(totalRepasse - totalRepassadoFeito)}` : ''))}
                {box('Taxa da imobiliária', taxaRetida, null, 'sobre os aluguéis pagos')}
                {box('Manutenções / despesas', despesasPagas + despesasAbertas, despesasAbertas > 0 ? 'var(--status-warning-text)' : null, despesasAbertas > 0 ? `pago ${fmtMoney(despesasPagas)} · a pagar ${fmtMoney(despesasAbertas)}` : (movs.length ? 'tudo pago' : 'nenhuma'))}
              </div>
            </div>
          );
        })()}

        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 16 }}>
          <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
            <span style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 13, fontWeight: 600, color: 'var(--text-strong)' }}><Icon name="user" size={14} color="var(--text-accent)" />Cobrança do inquilino</span>
            <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>{cobrancas.length} meses · total {fmtMoney(totalCobrado)}</span>
            <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 8 }}>
              <div style={{ padding: '8px 10px', borderRadius: 10, background: 'var(--status-success-bg)' }}>
                <div style={{ fontSize: 10, color: 'var(--status-success-text)' }}>Pago ({cobrancasPagas.length})</div>
                <div style={{ fontSize: 14, fontWeight: 600, color: 'var(--status-success-text)' }}>{fmtMoney(totalCobradoPago)}</div>
              </div>
              <div style={{ padding: '8px 10px', borderRadius: 10, background: 'var(--status-warning-bg)' }}>
                <div style={{ fontSize: 10, color: 'var(--status-warning-text)' }}>Em aberto ({cobrancasAberto.length})</div>
                <div style={{ fontSize: 14, fontWeight: 600, color: 'var(--status-warning-text)' }}>{fmtMoney(totalCobradoAberto)}</div>
              </div>
            </div>
            <div style={{ display: 'flex', flexDirection: 'column', gap: 6, maxHeight: 360, overflowY: 'auto' }}>
              {cobrancas.map((c, i) => ({ c, i })).slice().reverse().map(({ c, i }) => (
                <div key={i} style={{ display: 'flex', flexDirection: 'column', gap: 6, padding: '8px 10px', borderRadius: 10, background: 'var(--surface-sunken)' }}>
                  <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 8 }}>
                    <span style={{ fontSize: 12, fontWeight: 500, color: 'var(--text-strong)' }}>{c.mes}{c.caucao && <span style={{ marginLeft: 6, fontSize: 10, fontWeight: 600, color: 'var(--text-accent)' }}>+ caução (3x)</span>}</span>
                    <span style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
                      {c.pix && c.pix.status === 'PAGA' && <span title="Ver comprovante do Pix" onClick={() => setPixDe(c)} style={{ cursor: 'pointer' }}><Badge tone="success" size="sm">Pix pago</Badge></span>}
                      {c.pix && c.pix.status === 'ATIVA' && c.status !== 'Pago' && <span title="Ver QR Code / situação do Pix" onClick={() => setPixDe(c)} style={{ cursor: 'pointer' }}><Badge tone="info" size="sm">Pix enviado</Badge></span>}
                      {c.compensado
                        ? <span title="Zerado por desconto de movimentação"><Badge tone="success" size="sm">Compensado</Badge></span>
                        : <span onClick={() => cycleCobranca(i)} style={{ cursor: 'pointer' }}><Badge tone={COBRANCA_TONE[c.status]} size="sm">{c.status}</Badge></span>}
                    </span>
                  </div>
                  <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 8 }}>
                    <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>Vence <b style={{ color: c.status === 'Vencido' ? 'var(--status-danger-text)' : 'var(--status-info-text)', fontWeight: 600 }}>{fmtDateBR(c.vencimento)}</b> · {fmtMoney(c.valor)}
                      {c.status === 'Pago' && (c.pix && c.pix.pagoEm || c.dataPagamento) && <><br /><span style={{ color: 'var(--status-success-text)' }}>Pago em {window.mbFmtDataHora(c.pix && c.pix.pagoEm || c.dataPagamento)}{c.formaPagamento ? ' · ' + c.formaPagamento : ''}</span></>}</span>
                    <div style={{ display: 'flex', gap: 4 }}>
                      <IconButton icon="qr-code" label={c.pix && c.pix.status === 'PAGA' ? 'Pago via Pix — ver comprovante' : c.status === 'Pago' ? 'Parcela já paga' : 'Emitir cobrança por Pix'} size="sm" variant="soft"
                        disabled={c.status === 'Pago' && !(c.pix && c.pix.status === 'PAGA')}
                        style={{ borderRadius: '50%', background: c.pix && c.pix.status === 'PAGA' ? 'var(--status-success-bg)' : c.pix && c.pix.status === 'ATIVA' ? 'var(--status-info-bg)' : undefined, color: c.pix && c.pix.status === 'PAGA' ? 'var(--status-success-text)' : c.pix && c.pix.status === 'ATIVA' ? 'var(--status-info-text)' : undefined }}
                        onClick={() => setPixDe(c)} />
                      <IconButton icon="banknote" label="Recebido em dinheiro na imobiliária" size="sm" variant="soft" style={{ borderRadius: '50%', background: c.status === 'Pago' ? 'var(--status-success-bg)' : undefined, color: c.status === 'Pago' ? 'var(--status-success-text)' : undefined }} onClick={() => c.status !== 'Pago' && window.mbConfirmarDinheiro({ titulo: 'Confirmar recebimento em dinheiro', detalhe: 'Aluguel ' + c.mes, valor: c.valor }).then((ok) => ok && marcarPagoCobranca(i))} />
                    </div>
                  </div>
                </div>
              ))}
            </div>
          </div>

          <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
            <span style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 13, fontWeight: 600, color: 'var(--text-strong)' }}><Icon name="wallet" size={14} color="var(--text-accent)" />Repasse do proprietário</span>
            <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>{repasses.length} meses · total {fmtMoney(totalRepasse)}</span>
            <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 8 }}>
              <div style={{ padding: '8px 10px', borderRadius: 10, background: 'var(--status-success-bg)' }}>
                <div style={{ fontSize: 10, color: 'var(--status-success-text)' }}>Repassado ({repassesFeitos.length})</div>
                <div style={{ fontSize: 14, fontWeight: 600, color: 'var(--status-success-text)' }}>{fmtMoney(totalRepassadoFeito)}</div>
              </div>
              <div style={{ padding: '8px 10px', borderRadius: 10, background: 'var(--status-warning-bg)' }}>
                <div style={{ fontSize: 10, color: 'var(--status-warning-text)' }}>Em aberto ({repassesAberto.length})</div>
                <div style={{ fontSize: 14, fontWeight: 600, color: 'var(--status-warning-text)' }}>{fmtMoney(totalRepasseAberto)}</div>
              </div>
            </div>
            <div style={{ display: 'flex', flexDirection: 'column', gap: 6, maxHeight: 360, overflowY: 'auto' }}>
              {repasses.map((r, i) => ({ r, i })).slice().reverse().map(({ r, i }) => (
                <div key={i} style={{ display: 'flex', flexDirection: 'column', gap: 6, padding: '8px 10px', borderRadius: 10, background: 'var(--surface-sunken)' }}>
                  <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 8 }}>
                    <span style={{ fontSize: 12, fontWeight: 500, color: 'var(--text-strong)' }}>{r.mes}</span>
                    {r.compensado
                      ? <span title="Zerado por desconto de movimentação"><Badge tone="success" size="sm">Compensado</Badge></span>
                      : <span onClick={() => cycleRepasse(i)} style={{ cursor: 'pointer' }}><Badge tone={REPASSE_TONE[r.status]} size="sm">{r.status}</Badge></span>}
                  </div>
                  <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 8 }}>
                    <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>Vence <b style={{ color: (r.vencimento < todayISO() && r.status !== 'Repassado') ? 'var(--status-danger-text)' : 'var(--status-info-text)', fontWeight: 600 }}>{fmtDateBR(r.vencimento)}</b> · {fmtMoney(r.valor)}
                      {r.status === 'Repassado' && r.dataRepasse && <><br /><span style={{ color: 'var(--status-success-text)' }}>Repassado em {window.mbFmtDataHora(r.dataRepasse)}{r.formaRepasse ? ' · ' + r.formaRepasse : ''}</span></>}
                      {r.encargos && <><br /><span style={{ color: 'var(--status-success-text)' }} title={`Multa ${fmtMoney(r.encargos.multa)} + juros ${fmtMoney(r.encargos.juros)} pagos pelo inquilino; imobiliária ficou com ${r.encargos.taxaPerc}% (${fmtMoney(r.encargos.parteImobiliaria)})`}>{r.encargos.aposRepasse ? 'A repassar à parte: ' : 'Inclui multa/juros: '}{fmtMoney(r.encargos.parteProprietario)}</span></>}
                      {(r.ajustes || []).some((a) => a.valor < 0) && <><br /><span style={{ color: 'var(--status-warning-text)' }}>Desconto de despesa: {fmtMoney(-(r.ajustes || []).filter((a) => a.valor < 0).reduce((s, a) => s + a.valor, 0))}{r.compensado ? ' · compensado' : ''}</span></>}</span>
                    {(r.status === 'Repassado' || inquilinoPagou(r)) ? <div style={{ display: 'flex', gap: 4 }}>
                      <IconButton icon="qr-code" label={r.status === 'Repassado' ? 'Repasse já feito' : 'Pagar repasse por Pix (QR do proprietário)'} size="sm" variant="soft" style={{ borderRadius: '50%' }} onClick={() => setRepasseDe(i)} />
                      <IconButton icon="banknote" label="Repassado em dinheiro na imobiliária" size="sm" variant="soft" style={{ borderRadius: '50%', background: r.status === 'Repassado' ? 'var(--status-success-bg)' : undefined, color: r.status === 'Repassado' ? 'var(--status-success-text)' : undefined }} onClick={() => r.status !== 'Repassado' && window.mbConfirmarDinheiro({ titulo: 'Confirmar repasse em dinheiro', detalhe: 'Repasse ' + r.mes, valor: r.valor }).then((ok) => ok && marcarRepassadoDinheiro(i))} />
                    </div> : <span title="O repasse é liberado quando o inquilino pagar a parcela deste mês" style={{ fontSize: 10, color: 'var(--text-subtle)', textAlign: 'right', maxWidth: 90, lineHeight: 1.2 }}>Aguardando pagamento do inquilino</span>}
                  </div>
                </div>
              ))}
            </div>
          </div>
        </div>

        <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
          <span style={{ display: 'flex', alignItems: 'center', gap: 6, fontSize: 13, fontWeight: 600, color: 'var(--text-strong)' }}><Icon name="banknote" size={14} color="var(--text-accent)" />Movimentações</span>
          <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>Lançamentos extras desta locação — ex.: valor tirado do proprietário e pago para um pintor.</span>
          {movimentacoes.length === 0 ? (
            <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Nenhuma movimentação lançada ainda.</span>
          ) : (
            <div style={{ display: 'flex', flexDirection: 'column', gap: 6, maxHeight: 240, overflowY: 'auto' }}>
              {[...movimentacoes].reverse().map((mv) => {
                const st = statusMovimentacao(mv);
                return (
                  <div key={mv.id} style={{ display: 'flex', flexDirection: 'column', gap: 6, padding: '8px 10px', borderRadius: 10, background: 'var(--surface-sunken)' }}>
                    <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 8 }}>
                      <span style={{ fontSize: 12, fontWeight: 500, color: 'var(--text-strong)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{mv.descricao}</span>
                      {mv.saldoNaoCompensado > 0 && <span style={{ fontSize: 10, color: 'var(--status-danger-text)' }}>{fmtMoney(mv.saldoNaoCompensado)} sem parcela futura para descontar</span>}
                      <Badge tone={MOVIMENTACAO_TONE[st]} size="sm">{st}</Badge>
                    </div>
                    <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 8 }}>
                      <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>{nomeParteFd(mv.origem, mv.origemNome)} → {nomeParteFd(mv.destino, mv.destinoNome)} · vence <b style={{ color: st === 'Vencido' ? 'var(--status-danger-text)' : st === 'A vencer' ? 'var(--status-info-text)' : 'var(--status-success-text)', fontWeight: 600 }}>{fmtDateBR(mv.dataVencimento)}</b> · {fmtMoney(mv.valor)}</span>
                      <div style={{ display: 'flex', gap: 4 }}>
                        {st === 'Pago' ? (
                          <span style={{ fontSize: 11, color: 'var(--status-success-text)', textAlign: 'right' }}>Pago{mv.dataPagamento ? ' em ' + (window.mbFmtDataHora ? window.mbFmtDataHora(mv.dataPagamento) : fmtDateBR(String(mv.dataPagamento).slice(0, 10))) : ''}{mv.formaPagamento ? ' · ' + mv.formaPagamento : ''}</span>
                        ) : (<>
                        <IconButton icon="qr-code" label={mv.destino === 'Terceiro' ? `Pagar por Pix${mv.destinoNome ? ' — ' + mv.destinoNome : ''}` : 'Pix disponível para pagamento a terceiros'} size="sm" variant="soft" style={{ borderRadius: '50%' }}
                          disabled={mv.destino !== 'Terceiro'} onClick={() => mv.destino === 'Terceiro' && setMovPix(mv)} />
                        <IconButton icon="banknote" label="Pago em dinheiro na imobiliária" size="sm" variant="soft" style={{ borderRadius: '50%', background: st === 'Pago' ? 'var(--status-success-bg)' : undefined, color: st === 'Pago' ? 'var(--status-success-text)' : undefined }} onClick={() => st !== 'Pago' && window.mbConfirmarDinheiro({ titulo: 'Confirmar pagamento em dinheiro', detalhe: mv.descricao, valor: mv.valor }).then((ok) => ok && marcarPagoMovimentacao(mv.id))} />
                        </>)}
                      </div>
                    </div>
                  </div>
                );
              })}
            </div>
          )}
        </div>

        <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>Clique no status para alternar (A vencer / Pago / Vencido, e A repassar / Repassado), ou use o ícone de dinheiro pra marcar como pago/repassado em dinheiro na imobiliária. O ícone de QR gera a cobrança Pix da parcela — quando o banco confirma o pagamento, ela vira "Pago" sozinha. No repasse, o QR é para você pagar o proprietário pela chave Pix dele.</span>
      </div>
      {movPix && window.PixPagarDialog && (
        <window.PixPagarDialog titulo="Pagar despesa por Pix" descricao={`${movPix.descricao} · ${property.name} · venc. ${fmtDateBR(movPix.dataVencimento)}`}
          valor={movPix.valor} nomeBeneficiario={movPix.destinoNome} personId={movPix.destinoPersonId}
          txidRef={'DESP' + String(movPix.id || '').replace(/\D/g, '').slice(-12)} textoPix={String(movPix.descricao || 'Despesa').slice(0, 40)}
          pago={movPix.status === 'Pago'} pagoEm={movPix.dataPagamento}
          onPago={(forma) => marcarPagoMovimentacao(movPix.id, forma)} onClose={() => setMovPix(null)} />
      )}
      {repasseDe !== null && repasses[repasseDe] && window.PixRepasseDialog && (
        <window.PixRepasseDialog property={property} loc={loc} repasse={repasses[repasseDe]}
          onMarcarRepassado={(forma) => marcarRepassadoDinheiro(repasseDe, forma)} onClose={() => setRepasseDe(null)} />
      )}
      {pixDe && window.PixCobrancaDialog && (
        <window.PixCobrancaDialog property={property} loc={loc} cobranca={pixDe} setProperties={setProperties} onClose={() => setPixDe(null)} />
      )}
    </Dialog>
  );
}

// Página própria de Financeiro do imóvel (aberta pelo menu "⋯" › Financeiro em Imóveis) — mesmo
// conteúdo do Resumo financeiro, mas como página cheia em vez de card. A locação ativa é achada
// automaticamente; se não houver nenhuma, mostra um aviso em vez do resumo.
// Monta e baixa (via janela de impressão) o relatório completo de uma locação: resumo
// financeiro, parcela a parcela de cobranças/repasses, e todas as movimentações extras
// (despesas de pintura, manutenção etc.) lançadas durante o período.
function exportarRelatorioLocacao({ property, loc, aluguel, taxaAdmMensal, repasseLiquido }) {
  const cobrancas = loc.cobrancas || [];
  const repasses = loc.repasses || [];
  const movimentacoes = loc.movimentacoes || [];
  const totalCobrado = cobrancas.reduce((a, c) => a + c.valor, 0);
  const totalCobradoPago = cobrancas.filter((c) => c.status === 'Pago').reduce((a, c) => a + c.valor, 0);
  const totalCobradoAberto = totalCobrado - totalCobradoPago;
  const totalRepasse = repasses.reduce((a, r) => a + r.valor, 0);
  const totalRepassadoFeito = repasses.filter((r) => r.status === 'Repassado').reduce((a, r) => a + r.valor, 0);
  const totalRepasseAberto = totalRepasse - totalRepassadoFeito;
  const totalTerceiros = movimentacoes.filter((mv) => mv.destino === 'Terceiro').reduce((a, mv) => a + mv.valor, 0);
  const totalImobiliaria = movimentacoes.filter((mv) => mv.destino === 'Imobiliária').reduce((a, mv) => a + mv.valor, 0);
  const nomeParte = (parte, nomeTerceiro) => parte === 'Terceiro' ? (nomeTerceiro || 'Terceiro') : parte;

  const linhasCobranca = cobrancas.map((c) => `<tr><td>${c.mes}</td><td>${fmtDateBR(c.vencimento)}</td><td>${fmtMoney(c.valor)}</td><td>${c.status}</td></tr>`).join('');
  const linhasRepasse = repasses.map((r) => `<tr><td>${r.mes}</td><td>${fmtDateBR(r.vencimento)}</td><td>${fmtMoney(r.valor)}</td><td>${r.status}</td></tr>`).join('');
  const linhasMov = movimentacoes.length
    ? [...movimentacoes].reverse().map((mv) => `<tr><td>${fmtDateBR(mv.dataVencimento)}</td><td>${mv.descricao}</td><td>${nomeParte(mv.origem, mv.origemNome)} → ${nomeParte(mv.destino, mv.destinoNome)}</td><td>${fmtMoney(mv.valor)}</td></tr>`).join('')
    : '<tr><td colspan="4">Nenhuma movimentação registrada.</td></tr>';

  const titulo = `Relatório financeiro — ${loc.inquilino || ''} — ${property.name}`;
  const w = window.open('', '_blank');
  if (!w) return;
  w.document.write(`<!DOCTYPE html><html><head><meta charset="utf-8"><title>${titulo}</title>
    <style>
      @page { margin: 18mm 16mm; }
      body { font-family: Arial, Helvetica, sans-serif; font-size: 12px; color: #1a1a1a; }
      h1 { font-size: 18px; margin: 0 0 4px; }
      h2 { font-size: 14px; margin: 22px 0 8px; }
      p { margin: 2px 0; }
      table { width: 100%; border-collapse: collapse; margin-top: 6px; }
      th, td { border: 1px solid #ddd; padding: 5px 8px; text-align: left; font-size: 11px; }
      th { background: #f3f3f3; }
      .resumo { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; margin-top: 10px; }
      .box { border: 1px solid #ddd; border-radius: 6px; padding: 8px 10px; }
      .box .lbl { font-size: 10px; color: #666; }
      .box .val { font-size: 15px; font-weight: 700; }
    </style>
    </head><body>
    <h1>Relatório financeiro da locação</h1>
    <p>${property.name} — ${property.region || ''}</p>
    <p>Inquilino: <b>${loc.inquilino || '—'}</b>${loc.fiador ? ` · Fiador: ${loc.fiador}` : ''}</p>
    <p>Período: ${fmtDateBR(loc.dataInicio) || '—'} até ${fmtDateBR(loc.dataFim || loc.dataVencimento) || '—'} · ${loc.ativa ? 'Locação ativa' : 'Encerrada'}</p>

    <div class="resumo">
      <div class="box"><div class="lbl">Aluguel mensal</div><div class="val">${fmtMoney(aluguel)}</div></div>
      <div class="box"><div class="lbl">Taxa da imobiliária</div><div class="val">${fmtMoney(taxaAdmMensal)}</div></div>
      <div class="box"><div class="lbl">Repasse líquido</div><div class="val">${fmtMoney(repasseLiquido)}</div></div>
      <div class="box"><div class="lbl">Cobrado — pago</div><div class="val">${fmtMoney(totalCobradoPago)}</div></div>
      <div class="box"><div class="lbl">Cobrado — em aberto</div><div class="val">${fmtMoney(totalCobradoAberto)}</div></div>
      <div class="box"><div class="lbl">Repasse — em aberto</div><div class="val">${fmtMoney(totalRepasseAberto)}</div></div>
      <div class="box"><div class="lbl">Repasses a terceiros</div><div class="val">${fmtMoney(totalTerceiros)}</div></div>
      <div class="box"><div class="lbl">Repasses à imobiliária</div><div class="val">${fmtMoney(totalImobiliaria)}</div></div>
    </div>

    <h2>Cobrança do inquilino (${cobrancas.length} meses · total ${fmtMoney(totalCobrado)})</h2>
    <table><thead><tr><th>Mês</th><th>Vencimento</th><th>Valor</th><th>Status</th></tr></thead><tbody>${linhasCobranca}</tbody></table>

    <h2>Repasse ao proprietário (${repasses.length} meses · total ${fmtMoney(totalRepasse)})</h2>
    <table><thead><tr><th>Mês</th><th>Vencimento</th><th>Valor</th><th>Status</th></tr></thead><tbody>${linhasRepasse}</tbody></table>

    <h2>Movimentações (despesas, descontos e outros lançamentos)</h2>
    <table><thead><tr><th>Data</th><th>Descrição</th><th>De → Para</th><th>Valor</th></tr></thead><tbody>${linhasMov}</tbody></table>
    </body></html>`);
  w.document.close();
  w.focus();
  setTimeout(() => w.print(), 300);
}

// Card de resumo financeiro de uma locação (ativa ou já encerrada) — só totais, sem o
// mês a mês (isso fica no "Resumo financeiro" de dentro da Locação).
function LocacaoFinanceiroCard({ property, loc, mode }) {
  const { Card, Badge, Button } = DSpl;
  const m = mode === 'mobile';
  const aluguel = loc.valorAluguelAtual || parseBR(property._form && property._form.valorAluguel);
  const pct = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
  const valorAdmFixo = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
  const taxaAdmMensal = valorAdmFixo > 0 ? valorAdmFixo : aluguel * (pct / 100);
  const repasseLiquido = aluguel - taxaAdmMensal;

  const cobrancas = loc.cobrancas || [];
  const repasses = loc.repasses || [];
  const cobrancasAberto = cobrancas.filter((c) => c.status !== 'Pago');
  const totalCobradoAberto = cobrancasAberto.reduce((a, c) => a + c.valor, 0);
  const repassesAberto = repasses.filter((r) => r.status !== 'Repassado');
  const totalRepasseAberto = repassesAberto.reduce((a, r) => a + r.valor, 0);

  // Movimentações extras (lançadas manualmente) com destino Terceiro ou Imobiliária — reformas,
  // manutenções, comissões etc. pagas durante a locação, fora do repasse mensal normal.
  const movimentacoes = loc.movimentacoes || [];
  const movTerceiros = movimentacoes.filter((mv) => mv.destino === 'Terceiro');
  const totalTerceiros = movTerceiros.reduce((a, mv) => a + mv.valor, 0);
  const movImobiliaria = movimentacoes.filter((mv) => mv.destino === 'Imobiliária');
  const totalImobiliaria = movImobiliaria.reduce((a, mv) => a + mv.valor, 0);

  return (
    <Card padding="lg" style={{ gap: 14 }}>
      <div style={{ display: 'flex', flexWrap: 'wrap', alignItems: 'center', justifyContent: 'space-between', gap: 10 }}>
        <div style={{ display: 'flex', flexWrap: 'wrap', alignItems: 'center', gap: 10 }}>
          <Badge tone={loc.ativa ? 'success' : 'neutral'} size="sm">{loc.ativa ? 'Locação ativa' : 'Encerrada'}</Badge>
          <span style={{ fontSize: 13, fontWeight: 600, color: 'var(--text-strong)' }}>Inquilino: {loc.inquilino || '—'}</span>
          <span style={{ fontSize: 12, color: 'var(--text-subtle)' }}>{fmtDateBR(loc.dataInicio) || '—'} até {fmtDateBR(loc.dataFim || loc.dataVencimento) || '—'}</span>
        </div>
        <Button variant="secondary" size="sm" icon="download" onClick={() => exportarRelatorioLocacao({ property, loc, aluguel, taxaAdmMensal, repasseLiquido })}>Exportar relatório</Button>
      </div>
      <div style={{ display: 'grid', gridTemplateColumns: m ? '1fr 1fr' : 'repeat(4, 1fr)', gap: 10 }}>
        <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--surface-sunken)' }}>
          <div style={{ fontSize: 11, color: 'var(--text-muted)' }}>Aluguel mensal</div>
          <div style={{ fontSize: 16, fontWeight: 600, color: 'var(--text-strong)' }}>{fmtMoney(aluguel)}</div>
        </div>
        <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--surface-sunken)' }}>
          <div style={{ fontSize: 11, color: 'var(--text-muted)' }}>Taxa da imobiliária{pct ? ` (${pct}%)` : ''}</div>
          <div style={{ fontSize: 16, fontWeight: 600, color: 'var(--text-strong)' }}>{fmtMoney(taxaAdmMensal)}</div>
        </div>
        <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--surface-sunken)' }}>
          <div style={{ fontSize: 11, color: 'var(--text-muted)' }}>Repasse líquido</div>
          <div style={{ fontSize: 16, fontWeight: 600, color: 'var(--text-strong)' }}>{fmtMoney(repasseLiquido)}</div>
        </div>
        <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--surface-sunken)' }}>
          <div style={{ fontSize: 11, color: 'var(--text-muted)' }}>Repasses à imobiliária ({movImobiliaria.length})</div>
          <div style={{ fontSize: 16, fontWeight: 600, color: 'var(--text-strong)' }}>{fmtMoney(totalImobiliaria)}</div>
        </div>
        <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--status-warning-bg)' }}>
          <div style={{ fontSize: 11, color: 'var(--status-warning-text)' }}>Cobranças em aberto ({cobrancasAberto.length})</div>
          <div style={{ fontSize: 16, fontWeight: 600, color: 'var(--status-warning-text)' }}>{fmtMoney(totalCobradoAberto)}</div>
        </div>
        <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--status-warning-bg)' }}>
          <div style={{ fontSize: 11, color: 'var(--status-warning-text)' }}>Repasses em aberto ({repassesAberto.length})</div>
          <div style={{ fontSize: 16, fontWeight: 600, color: 'var(--status-warning-text)' }}>{fmtMoney(totalRepasseAberto)}</div>
        </div>
        <div style={{ padding: '10px 12px', borderRadius: 12, background: 'var(--status-warning-bg)' }}>
          <div style={{ fontSize: 11, color: 'var(--status-warning-text)' }}>Repasses a terceiros ({movTerceiros.length})</div>
          <div style={{ fontSize: 16, fontWeight: 600, color: 'var(--status-warning-text)' }}>{fmtMoney(totalTerceiros)}</div>
        </div>
      </div>
    </Card>
  );
}

function PropertyFinanceiro({ propertyId, properties, setProperties, go, mode }) {
  const { Button } = DSpl;
  const m = mode === 'mobile';
  const property = (properties || []).find((p) => p.id === propertyId);
  const locacoes = property ? (property.locacoes || []) : [];

  // Garante que toda locação (ativa ou já encerrada) tenha cobrancas/repasses construídos,
  // pra mostrar o total em aberto de cada uma sem precisar abrir a locação primeiro.
  React.useEffect(() => {
    if (!property) return;
    const faltando = locacoes.some((l) => !l.cobrancas || !l.repasses);
    if (!faltando) return;
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p,
      locacoes: (p.locacoes || []).map((l) => {
        if (l.cobrancas && l.repasses) return l;
        const aluguel = l.valorAluguelAtual || parseBR(property._form && property._form.valorAluguel);
        const pct = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
        const valorAdmFixo = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
        const taxaAdmMensal = valorAdmFixo > 0 ? valorAdmFixo : aluguel * (pct / 100);
        const repasseLiquido = aluguel - taxaAdmMensal;
        const built = buildParcelas(l, aluguel, repasseLiquido);
        return { ...l, cobrancas: built.cobrancas, repasses: built.repasses };
      }),
    }));
  }, [property && property.id, locacoes.length]);

  if (!property) {
    return (
      <div style={{ padding: m ? '16px' : 'var(--page-pad)' }}>
        <Button variant="secondary" icon="arrow-left" size="sm" onClick={() => go('properties')}>Voltar para Imóveis</Button>
        <div style={{ marginTop: 20, color: 'var(--text-muted)' }}>Imóvel não encontrado.</div>
      </div>
    );
  }

  // Mais recente primeiro: a ativa (se houver) sempre em cima, depois as encerradas da mais
  // nova pra mais antiga.
  const locacoesOrdenadas = [...locacoes].sort((a, b) => (b.ativa ? 1 : 0) - (a.ativa ? 1 : 0) || (b.dataInicio || '').localeCompare(a.dataInicio || ''));

  return (
    <div style={{ padding: m ? '4px 16px 24px' : '4px var(--page-pad) var(--page-pad)' }}>
      <Button variant="secondary" icon="arrow-left" size="sm" onClick={() => go('properties')}>Voltar para Imóveis</Button>
      <div style={{ display: 'flex', alignItems: 'center', gap: 12, margin: '14px 0 20px' }}>
        <IconBadge icon="banknote" tone="success" size={m ? 36 : 44} />
        <div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
          <h1 style={{ margin: 0, fontSize: m ? 22 : 28, fontWeight: 600, letterSpacing: '-0.01em', color: 'var(--text-strong)' }}>Financeiro</h1>
          <span style={{ fontSize: 13, color: 'var(--text-muted)' }}>{property.name} — demonstrativo por locação. Para ver mês a mês, abra o Resumo financeiro dentro da locação.</span>
        </div>
      </div>

      {locacoesOrdenadas.length === 0 ? (
        <div style={{ padding: 30, textAlign: 'center', color: 'var(--text-muted)', fontSize: 13 }}>
          Este imóvel ainda não teve nenhuma locação registrada.
        </div>
      ) : (
        <div style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>
          {locacoesOrdenadas.map((loc) => <LocacaoFinanceiroCard key={loc.id} property={property} loc={loc} mode={mode} />)}
        </div>
      )}
    </div>
  );
}

function PropertyLocacoes({ propertyId, properties, setProperties, people, go, mode, onOpenPerson, onOpenProperty, contractTemplates, imobiliaria, onNovoContrato, maintenanceRecords }) {
  const { Button, Card, Icon } = DSpl;
  const m = mode === 'mobile';
  const property = (properties || []).find((p) => p.id === propertyId);
  const [creating, setCreating] = React.useState(false);
  const [financeiroLoc, setFinanceiroLoc] = React.useState(null);
  const [renovandoLoc, setRenovandoLoc] = React.useState(null);
  const [editandoLoc, setEditandoLoc] = React.useState(null);
  const [reajustandoLoc, setReajustandoLoc] = React.useState(null);
  const [docsLoc, setDocsLoc] = React.useState(null);
  const [movimentandoLoc, setMovimentandoLoc] = React.useState(null);
  const [contratoLoc, setContratoLoc] = React.useState(null);
  const [termoLoc, setTermoLoc] = React.useState(null);

  // Migra o "retrato atual" (imóveis importados) para um histórico persistido em property.locacoes,
  // na primeira vez que a página é aberta para esse imóvel.
  React.useEffect(() => {
    if (!property || property.locacoes) return;
    const nameLc = (property.tenant || '').trim().toLowerCase();
    const temTenant = property.tenant && property.tenant !== '—';
    const tenantId = (property._form && property._form.tenantId) || (people.find((p) => p.nome.trim().toLowerCase() === nameLc) || {}).id || null;
    const initial = temTenant ? [{
      id: `${property.id}-hist-1`,
      tipo: (property._form && property._form.ops && property._form.ops.Temporada) ? 'Temporada' : 'Aluguel',
      inquilino: property.tenant,
      inquilinoPersonId: tenantId,
      dataInicio: (property._form && property._form.fields && property._form.fields.dataAngariacao) || '',
      dataFim: null,
      ativa: property.status === 'Locado',
    }] : [];
    setProperties((cur) => cur.map((p) => p.id === property.id ? { ...p, locacoes: initial } : p));
  }, [property && property.id]);

  if (!property) {
    return (
      <div style={{ padding: m ? '16px' : 'var(--page-pad)' }}>
        <Button variant="secondary" icon="arrow-left" size="sm" onClick={() => go('properties')}>Voltar para Imóveis</Button>
        <div style={{ marginTop: 20, color: 'var(--text-muted)' }}>Imóvel não encontrado.</div>
      </div>
    );
  }

  const locacoes = property.locacoes || [];
  const temAtiva = locacoes.some((l) => l.ativa);

  const encerrarLocacao = (loc) => {
    const dataFim = todayISO();
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p, status: 'Disponível', tenant: '—', due: '—',
      locacoes: (p.locacoes || []).map((l) => {
        if (l.id !== loc.id) return l;
        // Ao encerrar a locação, os compromissos financeiros futuros somem — só fica
        // o que já venceu até (e incluindo) o dia do encerramento.
        // Parcelas já pagas/repassadas (mesmo adiantadas) ficam no histórico; o repasse fica se o
        // aluguel daquele mês foi pago (o proprietário ainda tem a receber).
        const cobs = l.cobrancas || [];
        const fica = (i) => (cobs[i] && (cobs[i].vencimento <= dataFim || cobs[i].status === 'Pago'));
        const cobrancas = cobs.filter((c, i) => fica(i));
        const repasses = (l.repasses || []).filter((r, i) => r.vencimento <= dataFim || r.status === 'Repassado' || fica(i));
        return { ...l, ativa: false, dataFim, cobrancas, repasses };
      }),
    }));
  };
  const excluirLocacao = (loc) => handleAction('excluir-confirmado', loc);
  const handleAction = (key, loc) => {
    if (key === 'editar') { setEditandoLoc(loc); return; }
    if (key === 'reajustar') { setReajustandoLoc(loc); return; }
    if (key === 'financeiro') { setFinanceiroLoc(loc); return; }
    if (key === 'fim') {
      if (!loc.ativa) return;
      // Antes de encerrar: confirmação, listando o que ainda está pendente nesta locação.
      const hojeF = todayISO();
      const brlF = (v) => Number(v || 0).toLocaleString('pt-BR', { style: 'currency', currency: 'BRL' });
      const pend = [];
      const cobAbertas = (loc.cobrancas || []).filter((c) => c.status !== 'Pago' && c.vencimento <= hojeF);
      if (cobAbertas.length) pend.push(`${cobAbertas.length} aluguel(is) vencido(s) sem pagamento — ${brlF(cobAbertas.reduce((a, c) => a + (Number(c.valor) || 0), 0))}`);
      const repAbertos = (loc.repasses || []).filter((r, i) => r.status !== 'Repassado' && (loc.cobrancas || [])[i] && loc.cobrancas[i].status === 'Pago');
      if (repAbertos.length) pend.push(`${repAbertos.length} repasse(s) ao proprietário ainda não feito(s) — ${brlF(repAbertos.reduce((a, r) => a + (Number(r.valor) || 0), 0))}`);
      const movAbertas = (loc.movimentacoes || []).filter((mv) => mv.status !== 'Pago');
      if (movAbertas.length) pend.push(`${movAbertas.length} movimentação(ões) a pagar: ${movAbertas.map((mv) => mv.descricao).join(', ')}`);
      const usadas = new Set((property.locacoes || []).flatMap((l) => (l.movimentacoes || []).map((mv) => mv.manutencaoId).filter(Boolean)));
      const semVinculo = (maintenanceRecords || []).filter((r) => r.propertyId === property.id && r.status === 'Realizada' && !usadas.has(r.id));
      if (semVinculo.length) pend.push(`${semVinculo.length} manutenção(ões) realizada(s) sem movimentação vinculada: ${semVinculo.map((r) => r.descricao).join(', ')}`);
      const confirmar = window.mbConfirmar || ((o) => Promise.resolve(window.confirm(o.titulo + '\n\n' + o.texto)));
      confirmar({
        titulo: 'Confirmar o fim desta locação?',
        texto: `Locação de ${loc.inquilino || 'inquilino'}. Antes de encerrar, verifique se já conferiu as movimentações a pagar e os pagamentos a vincular. Caso tenha feito tudo isso, confirme o fim da locação — as parcelas que ainda não venceram serão removidas.`,
        pendencias: pend,
        semPendencias: 'Nenhuma pendência encontrada: aluguéis, repasses e movimentações em dia.',
        ok: 'Confirmar fim',
      }).then((ok) => { if (ok) encerrarLocacao(loc); });
      return;
    }
    if (key === 'fim-confirmado') {
      encerrarLocacao(loc);
      return;
    }
    if (false) {
      const dataFim = todayISO();
      setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
        ...p, status: 'Disponível', tenant: '—', due: '—',
        locacoes: (p.locacoes || []).map((l) => {
          if (l.id !== loc.id) return l;
          // Ao encerrar a locação, os compromissos financeiros futuros somem — só fica
          // o que já venceu até (e incluindo) o dia do encerramento.
          const cobrancas = (l.cobrancas || []).filter((c) => c.vencimento <= dataFim);
          const repasses = (l.repasses || []).filter((r) => r.vencimento <= dataFim);
          return { ...l, ativa: false, dataFim, cobrancas, repasses };
        }),
      }));
      return;
    }
    if (key === 'excluir') {
      const nCob = (loc.cobrancas || []).filter((c) => c.status === 'Pago').length;
      const nRep = (loc.repasses || []).filter((r) => r.status === 'Repassado').length;
      const nMov = (loc.movimentacoes || []).length;
      const avisos = [];
      if (nCob) avisos.push(`${nCob} aluguel(is) já pago(s) serão apagados do histórico`);
      if (nRep) avisos.push(`${nRep} repasse(s) já feito(s) serão apagados do histórico`);
      if (nMov) avisos.push(`${nMov} movimentação(ões) serão apagadas`);
      if (loc.ativa) avisos.push('O imóvel volta a ficar "Disponível"');
      const confirmar = window.mbConfirmar || ((o) => Promise.resolve(window.confirm(o.titulo + '\n\n' + o.texto)));
      confirmar({
        perigo: true,
        titulo: 'Tem certeza que deseja excluir esta locação?',
        texto: `Locação de ${loc.inquilino || 'inquilino'}. A locação e todos os lançamentos dela (cobranças, repasses e movimentações) serão excluídos. Essa ação não pode ser desfeita.`,
        pendencias: avisos,
        ok: 'Excluir locação',
      }).then((ok) => { if (ok) excluirLocacao(loc); });
      return;
    }
    if (key === 'excluir-confirmado') {
      setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
        ...p,
        status: loc.ativa ? 'Disponível' : p.status,
        tenant: loc.ativa ? '—' : p.tenant,
        due: loc.ativa ? '—' : p.due,
        locacoes: (p.locacoes || []).filter((l) => l.id !== loc.id),
      }));
      return;
    }
    if (key === 'renovar') { setRenovandoLoc(loc); return; }
    if (key === 'docs') { setDocsLoc(loc); return; }
    if (key === 'movimentacao') { setMovimentandoLoc(loc); return; }
    if (key === 'contrato') { setContratoLoc(loc); return; }
    if (key === 'termo') { setTermoLoc(loc); return; }
  };

  const handleEditar = ({ fiador, fiadorPersonId, prazoMeses, dataVencimento, diaVencimento }) => {
    if (!editandoLoc) return;
    const loc = editandoLoc;
    // Prazo/vencimento (só neste ambiente de teste) ou o dia de vencimento mudaram: a cobrança/
    // repasse salvos ficam desatualizados em relação ao novo prazo/dia, então são regerados do
    // zero — senão "Renovar" e "Movimentação" continuam usando o cronograma antigo (bug).
    const prazoMudou = prazoMeses !== loc.prazoMeses || dataVencimento !== loc.dataVencimento || diaVencimento !== loc.diaVencimento;
    let cobrancas = loc.cobrancas;
    let repasses = loc.repasses;
    if (prazoMudou) {
      const aluguel = parseBR(property._form && property._form.valorAluguel);
      const pct = parseBR(property._form && property._form.fields && property._form.fields.txAdm);
      const valorAdmFixo = parseBR(property._form && property._form.fields && property._form.fields.valorAdm);
      const taxaAdmMensal = valorAdmFixo > 0 ? valorAdmFixo : aluguel * (pct / 100);
      const repasseLiquido = aluguel - taxaAdmMensal;
      const rebuilt = buildParcelas({ ...loc, prazoMeses, diaVencimento }, aluguel, repasseLiquido);
      cobrancas = rebuilt.cobrancas;
      repasses = rebuilt.repasses;
    }
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p,
      locacoes: (p.locacoes || []).map((l) => l.id !== loc.id ? l : { ...l, fiador, fiadorPersonId, prazoMeses, dataVencimento, diaVencimento, cobrancas, repasses }),
    }));
    setEditandoLoc(null);
  };


  const handleNovaLocacao = ({ inquilino, inquilinoPersonId, fiador, fiadorPersonId, tipo, dataInicio, prazoMeses, dataVencimento, diaVencimento }) => {
    const novo = { id: `${property.id}-hist-${Date.now()}`, tipo, inquilino, inquilinoPersonId, fiador, fiadorPersonId, dataInicio, prazoMeses, dataVencimento, diaVencimento, dataFim: null, ativa: true };
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p, status: 'Locado', tenant: inquilino, due: '—',
      locacoes: [novo, ...(p.locacoes || [])],
    }));
    setCreating(false);
  };

  return (
    <div style={{ padding: m ? '4px 16px 24px' : '4px var(--page-pad) var(--page-pad)' }}>
      <div style={{ display: 'flex', alignItems: 'center', gap: 10, marginBottom: 14 }}>
        <Button variant="secondary" icon="arrow-left" size="sm" onClick={() => go('properties')}>Voltar para Imóveis</Button>
        {!temAtiva && <Button variant="primary" icon="plus" size="sm" onClick={() => onNovoContrato ? onNovoContrato(property.id) : setCreating(true)}>Nova Locação</Button>}
      </div>
      <div style={{ display: 'flex', alignItems: 'center', gap: 12, marginBottom: 20 }}>
        <IconBadge icon="key-round" tone="accent" size={m ? 36 : 44} />
        <div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
          <h1 style={{ margin: 0, fontSize: m ? 22 : 28, fontWeight: 600, letterSpacing: '-0.01em', color: 'var(--text-strong)' }}>{property.name}</h1>
          <span style={{ fontSize: 13, color: 'var(--text-muted)' }}>{property.region} · Proprietário: <b style={{ color: 'var(--text-strong)' }}>{property.owner}</b></span>
        </div>
      </div>

      <div style={{ display: 'flex', flexDirection: 'column', gap: 6, marginBottom: 12 }}>
        <span style={{ fontSize: 13, fontWeight: 600, color: 'var(--text-strong)' }}>Histórico de locações</span>
        <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>Uma linha por locação que este imóvel já teve. A atual aparece como "Locação ativa", sem data de fim.</span>
      </div>

      {locacoes.length === 0 ? (
        <Card padding="lg" style={{ alignItems: 'center', textAlign: 'center', gap: 8 }}>
          <Icon name="file-text" size={28} color="var(--mb-gray-400)" strokeWidth={1.25} />
          <span style={{ fontSize: 13, color: 'var(--text-muted)' }}>Nenhuma locação registrada para este imóvel ainda.</span>
        </Card>
      ) : (
        <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
          {locacoes.map((loc) => <LocacaoCard key={loc.id} loc={loc} property={property} onOpenPerson={onOpenPerson} onOpenProperty={onOpenProperty} onAction={handleAction} />)}
        </div>
      )}

      {creating && <NovaLocacaoDialog people={people} onClose={() => setCreating(false)} onSave={handleNovaLocacao} />}
      {financeiroLoc && <FinanceiroDialog loc={financeiroLoc} property={property} setProperties={setProperties} onClose={() => setFinanceiroLoc(null)} />}
      {renovandoLoc && <RenovarDialog loc={renovandoLoc} property={property} setProperties={setProperties} onClose={() => setRenovandoLoc(null)} />}
      {editandoLoc && <EditarLocacaoDialog loc={editandoLoc} people={people} onClose={() => setEditandoLoc(null)} onSave={handleEditar} />}
      {reajustandoLoc && <ReajustarDialog loc={reajustandoLoc} property={property} setProperties={setProperties} onClose={() => setReajustandoLoc(null)} />}
      {docsLoc && <DocAnexosDialog loc={docsLoc} property={property} setProperties={setProperties} onClose={() => setDocsLoc(null)} />}
      {movimentandoLoc && <MovimentacaoDialog loc={movimentandoLoc} property={property} people={people} setProperties={setProperties} maintenanceRecords={maintenanceRecords} onClose={() => setMovimentandoLoc(null)} />}
      {contratoLoc && (
        <ContratoGeradoDialog tipo="locacao" property={property} loc={contratoLoc} people={people} templates={contractTemplates} imobiliaria={imobiliaria} setProperties={setProperties} onClose={() => setContratoLoc(null)} />
      )}
      {termoLoc && (
        <ContratoGeradoDialog tipo="termo" property={property} loc={termoLoc} people={people} templates={contractTemplates} imobiliaria={imobiliaria} setProperties={setProperties} onClose={() => setTermoLoc(null)} />
      )}
    </div>
  );
}

window.PropertyLocacoes = PropertyLocacoes;
window.PropertyFinanceiro = PropertyFinanceiro;
window.FinanceiroDialog = FinanceiroDialog;
window.TenantSearch = TenantSearch;
