const DSr = window.MyBrokerPantanalDesignSystem_2460cb;
const MES_NOMES_PLr = ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'];

function todayISOr() {
  const d = new Date();
  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
}
// Soma meses travando no último dia do mês de destino (mesma lógica usada no resto do sistema).
function addMonthsISOr(iso, months) {
  if (!iso) return '';
  const [y, mo, d] = iso.split('-').map(Number);
  const totalMonths = mo - 1 + Number(months);
  const targetYear = y + Math.floor(totalMonths / 12);
  const targetMonth = ((totalMonths % 12) + 12) % 12;
  const lastDay = new Date(targetYear, targetMonth + 1, 0).getDate();
  const dt = new Date(targetYear, targetMonth, Math.min(d, lastDay));
  return `${dt.getFullYear()}-${String(dt.getMonth() + 1).padStart(2, '0')}-${String(dt.getDate()).padStart(2, '0')}`;
}
function addDaysISOr(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 fmtDateBRr(iso) {
  if (!iso) return '';
  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso);
  return m ? `${m[3]}/${m[2]}/${m[1]}` : iso;
}
function parseBRr(v) {
  if (!v) return 0;
  const n = parseFloat(String(v).replace(/\./g, '').replace(',', '.').replace(/[^\d.-]/g, ''));
  return isNaN(n) ? 0 : n;
}
function fmtMoneyr(n) {
  return (n || 0).toLocaleString('pt-BR', { style: 'currency', currency: 'BRL' });
}

// Mesma geração "ao vivo" de cobranças/repasses usada em Billing.jsx — lê o que já estiver
// persistido na locação; senão gera só pra leitura aqui (sem salvar em lugar nenhum).
function gerarCobrancasR(loc, aluguel) {
  if (loc.cobrancas) return loc.cobrancas;
  let base = loc.dataInicio || todayISOr();
  if (loc.diaVencimento) {
    const [y, mo] = base.split('-');
    base = `${y}-${mo}-${String(loc.diaVencimento).padStart(2, '0')}`;
  }
  const hoje = todayISOr();
  const nParcelas = loc.prazoMeses && loc.prazoMeses > 0 ? loc.prazoMeses : 12;
  const cobrancas = [];
  for (let i = 0; i < nParcelas; i++) {
    const venc = addMonthsISOr(base, i) || base;
    const isPrimeiraComCaucao = i === 0 && loc.garantia === 'Caução';
    const valor = isPrimeiraComCaucao ? aluguel * 4 : aluguel;
    cobrancas.push({ vencimento: venc, valor, status: venc < hoje ? 'Vencido' : 'A vencer' });
  }
  return cobrancas;
}
function gerarRepassesR(loc, repasseLiquido) {
  if (loc.repasses) return loc.repasses;
  let base = loc.dataInicio || todayISOr();
  if (loc.diaVencimento) {
    const [y, mo] = base.split('-');
    base = `${y}-${mo}-${String(loc.diaVencimento).padStart(2, '0')}`;
  }
  const nParcelas = loc.prazoMeses && loc.prazoMeses > 0 ? loc.prazoMeses : 12;
  const repasses = [];
  for (let i = 0; i < nParcelas; i++) {
    const venc = addMonthsISOr(base, i) || base;
    const vencRepasse = addDaysISOr(venc, 1);
    repasses.push({ vencimento: vencRepasse, valor: repasseLiquido, status: 'A repassar' });
  }
  return repasses;
}

// Linha reaproveitada pelas duas listas (atrasados / a fazer) — cada uma com os botõezinhos de
// Pix (ainda só visual) e "pago em dinheiro na imobiliária".
function RepasseRow({ item, onOpen, onPix }) {
  const { IconButton } = DSr;
  return (
    <div onClick={() => onOpen(item)}
      style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', gap: 10, padding: '10px 12px', borderRadius: 10, background: 'var(--surface-sunken)', cursor: 'pointer' }}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 2, minWidth: 0 }}>
        <span style={{ fontSize: 12, fontWeight: 500, color: 'var(--text-strong)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{item.descricao}</span>
        <span style={{ fontSize: 11, color: item.atrasado ? 'var(--status-danger-text)' : 'var(--text-subtle)' }}>{item.propertyName} · vence {fmtDateBRr(item.data)}</span>
      </div>
      <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'flex-end', gap: 4 }}>
        <span style={{ fontSize: 13, fontWeight: 600, color: 'var(--text-strong)', whiteSpace: 'nowrap' }}>{fmtMoneyr(item.valor)}</span>
        <div style={{ display: 'flex', gap: 4 }} onClick={(e) => e.stopPropagation()}>
          <IconButton icon="qr-code" label={item.podePagar ? 'Repassar via Pix (QR do proprietário)' : 'Aguardando o inquilino pagar o aluguel do mês'} size="sm" variant="soft" style={{ borderRadius: '50%' }} disabled={!item.podePagar} onClick={() => item.podePagar && onPix && onPix(item)} />
          <IconButton icon="banknote" label={item.podePagar ? 'Repassado em dinheiro na imobiliária' : 'Aguardando o inquilino pagar o aluguel do mês'} size="sm" variant="soft"
            style={{ borderRadius: '50%' }} disabled={!item.podePagar} onClick={() => item.podePagar && window.mbConfirmarDinheiro({ titulo: 'Confirmar repasse em dinheiro', detalhe: (item.descricao || '') + (item.propertyName ? ' · ' + item.propertyName : ''), valor: item.valor }).then((ok) => ok && item.acaoPagar())} />
        </div>
      </div>
    </div>
  );
}

// Busca por qualquer pessoa cadastrada (proprietário OU prestador de serviço/Terceiro) e mostra
// o que ela tem a receber da imobiliária: repasses de locações (se for proprietário de algum
// imóvel) e/ou movimentações pendentes de pagamento a Terceiro (se for prestador de serviço).
function BuscaRepasseCard({ properties, onOpenLocacoes }) {
  const { Card, Input, ListItem } = DSr;
  const [q, setQ] = React.useState('');
  const [pessoa, setPessoa] = React.useState(null);
  const people = (window.MB_DATA && window.MB_DATA.people) || [];
  const hoje = todayISOr();
  const ql = q.trim().toLowerCase();
  const matches = !pessoa && ql.length > 0 ? people.filter((p) => (p.nome || '').toLowerCase().includes(ql)).slice(0, 8) : [];

  let itens = [];
  if (pessoa) {
    (properties || []).forEach((p) => {
      const owners = (p._form && p._form.owners) || [];
      const ehProprietario = owners.some((o) => o.personId === pessoa.id);
      (p.locacoes || []).forEach((loc) => {
        if (!loc.ativa) return;
        // Repasses — só entram se a pessoa buscada é (co)proprietária deste imóvel.
        if (ehProprietario) {
          const aluguel = loc.valorAluguelAtual || parseBRr(p._form && p._form.valorAluguel);
          const pct = parseBRr(p._form && p._form.fields && p._form.fields.txAdm);
          const valorAdmFixo = parseBRr(p._form && p._form.fields && p._form.fields.valorAdm);
          const taxaAdmMensal = valorAdmFixo > 0 ? valorAdmFixo : aluguel * (pct / 100);
          const repasseLiquido = aluguel - taxaAdmMensal;
          const repasses = gerarRepassesR(loc, repasseLiquido);
          repasses.forEach((r) => {
            if (r.status === 'Repassado') return;
            itens.push({ tipo: 'Repasse', property: p, loc, data: r.vencimento, valor: r.valor, atrasado: r.vencimento < hoje });
          });
        }
        // Movimentações pendentes para Terceiro — a pessoa buscada como prestador de serviço.
        (loc.movimentacoes || []).forEach((mv) => {
          if (mv.destino !== 'Terceiro' || mv.destinoPersonId !== pessoa.id) return;
          if (mv.status === 'Pago') return;
          itens.push({ tipo: 'Serviço prestado', property: p, loc, data: mv.dataVencimento, valor: mv.valor, atrasado: mv.dataVencimento < hoje });
        });
      });
    });
    itens.sort((a, b) => a.data.localeCompare(b.data));
  }

  const atrasados = itens.filter((i) => i.atrasado);
  const aReceber = itens.filter((i) => !i.atrasado);
  const totalAtrasado = atrasados.reduce((a, i) => a + i.valor, 0);
  const totalAReceber = aReceber.reduce((a, i) => a + i.valor, 0);

  return (
    <Card padding="lg" icon="search" tone="success" title="Buscar proprietário ou prestador de serviço" style={{ gap: 12, marginBottom: 16 }}>
      <div style={{ position: 'relative' }}>
        <Input placeholder="Buscar pessoa cadastrada pelo nome..." value={pessoa ? pessoa.nome : q}
          onChange={(e) => { setQ(e.target.value); setPessoa(null); }} />
        {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', maxHeight: 240, overflowY: 'auto' }}>
            {matches.map((p) => (
              <ListItem key={p.id} variant="plain" title={p.nome} description={(p.tipos || [])[0] || ''}
                onClick={() => { setPessoa(p); setQ(''); }} style={{ cursor: 'pointer', padding: '8px 10px' }} />
            ))}
          </div>
        )}
      </div>
      {pessoa && (
        <div style={{ display: 'flex', flexDirection: 'column', gap: 10 }}>
          <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 8 }}>
            <div style={{ padding: '8px 10px', borderRadius: 10, background: 'var(--status-danger-bg)' }}>
              <div style={{ fontSize: 10, color: 'var(--status-danger-text)' }}>Atrasado ({atrasados.length})</div>
              <div style={{ fontSize: 14, fontWeight: 600, color: 'var(--status-danger-text)' }}>{fmtMoneyr(totalAtrasado)}</div>
            </div>
            <div style={{ padding: '8px 10px', borderRadius: 10, background: 'var(--status-success-bg)' }}>
              <div style={{ fontSize: 10, color: 'var(--status-success-text)' }}>A receber ({aReceber.length})</div>
              <div style={{ fontSize: 14, fontWeight: 600, color: 'var(--status-success-text)' }}>{fmtMoneyr(totalAReceber)}</div>
            </div>
          </div>
          {itens.length === 0 ? (
            <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>{pessoa.nome} não tem repasse ou pagamento pendente cadastrado.</span>
          ) : (
            <div style={{ display: 'flex', flexDirection: 'column', gap: 6, maxHeight: 220, overflowY: 'auto' }}>
              {itens.map((i, idx) => (
                <div key={idx} onClick={() => onOpenLocacoes && onOpenLocacoes(i.property.id)}
                  style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 10, padding: '8px 10px', border: '1px solid var(--border-subtle)', borderRadius: 10, cursor: 'pointer' }}>
                  <div style={{ display: 'flex', flexDirection: 'column', minWidth: 0 }}>
                    <span style={{ fontSize: 13, color: 'var(--text-strong)' }}>{i.tipo} · {i.property.name}</span>
                    <span style={{ fontSize: 11, color: i.atrasado ? 'var(--status-danger-text)' : 'var(--text-subtle)' }}>vence {fmtDateBRr(i.data)}{i.atrasado ? ' · Vencido' : ''}</span>
                  </div>
                  <span style={{ fontSize: 13, fontWeight: 600, color: 'var(--text-strong)', whiteSpace: 'nowrap' }}>{fmtMoneyr(i.valor)}</span>
                </div>
              ))}
            </div>
          )}
        </div>
      )}
    </Card>
  );
}

function Repasses({ mode, go, properties, setProperties, onOpenLocacoes }) {
  const { Card, BarChart } = DSr;
  const m = mode === 'mobile';
  const props = properties || [];
  const hoje = todayISOr();
  const mesAtual = hoje.slice(0, 7);
  const [verFinanceiroDe, setVerFinanceiroDe] = React.useState(null);
  const [pixRepasse, setPixRepasse] = React.useState(null); // item do repasse com o QR do proprietário aberto

  const meses6 = [];
  for (let i = 5; i >= 0; i--) {
    const d = new Date(); d.setDate(1); d.setMonth(d.getMonth() - i);
    meses6.push({ chave: `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`, label: `${MES_NOMES_PLr[d.getMonth()]}/${String(d.getFullYear()).slice(2)}` });
  }
  const realizadosPorMes = {};
  meses6.forEach((mo) => { realizadosPorMes[mo.chave] = 0; });

  let repassadoMes = 0, aFazerMes = 0, vencidoMes = 0;
  let recebidoMes = 0, aReceberMes = 0, vencidoCobMes = 0;
  const repassesAtrasados = [];
  const repassesAFazer = [];

  props.forEach((p) => {
    (p.locacoes || []).forEach((loc) => {
      if (!loc.ativa) return;
      const aluguel = loc.valorAluguelAtual || parseBRr(p._form && p._form.valorAluguel);
      const pct = parseBRr(p._form && p._form.fields && p._form.fields.txAdm);
      const valorAdmFixo = parseBRr(p._form && p._form.fields && p._form.fields.valorAdm);
      const taxaAdmMensal = valorAdmFixo > 0 ? valorAdmFixo : aluguel * (pct / 100);
      const repasseLiquido = aluguel - taxaAdmMensal;
      const cobrancas = gerarCobrancasR(loc, aluguel);
      const repasses = gerarRepassesR(loc, repasseLiquido);

      cobrancas.forEach((c) => {
        if (c.vencimento.slice(0, 7) !== mesAtual) return;
        if (c.status === 'Pago') recebidoMes += c.valor;
        else if (c.status === 'Vencido') vencidoCobMes += c.valor;
        else aReceberMes += c.valor;
      });

      repasses.forEach((r, idx) => {
        if (realizadosPorMes.hasOwnProperty(r.vencimento.slice(0, 7)) && r.status === 'Repassado') {
          realizadosPorMes[r.vencimento.slice(0, 7)] += r.valor;
        }
        if (r.vencimento.slice(0, 7) === mesAtual) {
          if (r.status === 'Repassado') repassadoMes += r.valor;
          else if (r.vencimento < hoje) vencidoMes += r.valor;
          else aFazerMes += r.valor;
        }
      });

      // Mesmo critério do card Finanças: inclui todos os repasses atrasados (ainda não feitos)
      // dessa locação, mais só o próximo em aberto — senão uma locação com contrato longo
      // sozinha ocuparia todas as vagas, deixando de fora as demais locações.
      for (let idx = 0; idx < repasses.length; idx++) {
        const r = repasses[idx];
        if (r.status === 'Repassado') continue;
        const atrasado = r.vencimento < hoje;
        const cRel = cobrancas[idx];
        const podePagar = cRel ? cRel.status === 'Pago' : true;
        const item = {
          key: `rep-${p.id}-${loc.id}-${idx}`,
          descricao: `Repasse — ${p.owner || 'proprietário'}`,
          valor: r.valor,
          data: r.vencimento,
          atrasado,
          podePagar,
          propertyName: p.name,
          property: p,
          loc,
          acaoPagar: (forma) => marcarRepassePago(p, loc, repasses, idx, forma),
          repasse: r,
        };
        if (atrasado) repassesAtrasados.push(item);
        else { repassesAFazer.push(item); break; }
      }
    });
  });

  repassesAtrasados.sort((a, b) => a.data.localeCompare(b.data));
  repassesAFazer.sort((a, b) => a.data.localeCompare(b.data));
  const atrasados20 = repassesAtrasados.slice(0, 20);
  const aFazer20 = repassesAFazer.slice(0, 20);

  const marcarRepassePago = (property, loc, repassesBase, idx, forma) => {
    setProperties((cur) => cur.map((p) => p.id !== property.id ? p : {
      ...p,
      locacoes: (p.locacoes || []).map((l) => {
        if (l.id !== loc.id) return l;
        const base = l.repasses || repassesBase;
        const k = window.mbCarimbo ? window.mbCarimbo(forma || 'Dinheiro') : { em: new Date().toISOString(), forma: forma || 'Dinheiro', por: null };
        return { ...l, repasses: base.map((r, i) => i !== idx || r.status === 'Repassado' ? r : { ...r, status: 'Repassado', dataRepasse: k.em, formaRepasse: k.forma, repassadoPor: k.por }) };
      }),
    }));
  };

  const chartData = meses6.map((mo) => ({ label: mo.label, value: Math.round(realizadosPorMes[mo.chave]) }));

  return (
    <div style={{ padding: m ? '16px' : 'var(--page-pad)' }}>
      <div style={{ display: 'flex', alignItems: 'center', gap: 12, marginBottom: 20 }}>
        <IconBadge icon="wallet" 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)' }}>Repasses</h1>
          <span style={{ fontSize: 13, color: 'var(--text-muted)' }}>Repasses aos proprietários e aluguéis dos inquilinos — todas as locações ativas.</span>
        </div>
      </div>

      <BuscaRepasseCard properties={props} onOpenLocacoes={onOpenLocacoes} />

      <div style={{ display: 'grid', gridTemplateColumns: m ? '1fr' : 'repeat(3, 1fr)', gap: 16 }}>
        <Card padding="lg" title="Repasses — mês atual" icon="wallet" tone="success" style={{ gap: 14 }}>
          <DonutChart
            segments={[
              { label: 'Realizados', value: repassadoMes, tone: 'success' },
              { label: 'A fazer', value: aFazerMes, tone: 'soft' },
              { label: 'Vencidos', value: vencidoMes, tone: 'danger' },
            ]}
            centerValue={fmtMoneyr(repassadoMes + aFazerMes + vencidoMes).replace(',00', '')}
            centerLabel="no mês"
            valueFormat={fmtMoneyr}
          />
        </Card>

        <Card variant="dark" pattern padding="lg" title="Repasses realizados — últimos 6 meses" icon="chart-column" subtitle="Valor repassado por mês" style={{ gap: 14 }}>
          <BarChart height={m ? 170 : 200} data={chartData} valueFormat={(v) => fmtMoneyr(v).replace(/\s?R\$\s?/, 'R$').replace(',00', '')} showLine={false} />
        </Card>

        <Card padding="lg" title="Aluguéis a receber — mês atual" icon="banknote" tone="accent" style={{ gap: 14 }}>
          <DonutChart
            segments={[
              { label: 'Recebidos', value: recebidoMes, tone: 'success' },
              { label: 'A receber', value: aReceberMes, tone: 'soft' },
              { label: 'Vencidos', value: vencidoCobMes, tone: 'danger' },
            ]}
            centerValue={fmtMoneyr(recebidoMes + aReceberMes + vencidoCobMes).replace(',00', '')}
            centerLabel="no mês"
            valueFormat={fmtMoneyr}
          />
        </Card>
      </div>

      <div style={{ marginTop: 16, display: 'grid', gridTemplateColumns: m ? '1fr' : '1fr 1fr', gap: 16 }}>
        <Card padding="lg" title="Repasses atrasados" icon="circle-alert" tone="danger"
          action={<span style={{ fontSize: 12, color: 'var(--status-danger-text)' }}>{repassesAtrasados.length}</span>} style={{ gap: 10 }}>
          <div style={{ display: 'flex', flexDirection: 'column', gap: 6, maxHeight: 520, overflowY: 'auto' }}>
            {atrasados20.length === 0 ? (
              <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Nenhum repasse atrasado — tudo em dia.</span>
            ) : atrasados20.map((item) => (
              <RepasseRow key={item.key} item={item} onPix={setPixRepasse} onOpen={(it) => setVerFinanceiroDe({ property: it.property, loc: it.loc })} />
            ))}
          </div>
        </Card>

        <Card padding="lg" title="Próximos repasses a fazer" icon="calendar-clock" tone="accent"
          action={<span style={{ fontSize: 12, color: 'var(--text-muted)' }}>{repassesAFazer.length}</span>} style={{ gap: 10 }}>
          <div style={{ display: 'flex', flexDirection: 'column', gap: 6, maxHeight: 520, overflowY: 'auto' }}>
            {aFazer20.length === 0 ? (
              <span style={{ fontSize: 12, color: 'var(--text-muted)' }}>Nenhum repasse em aberto nas locações ativas.</span>
            ) : aFazer20.map((item) => (
              <RepasseRow key={item.key} item={item} onPix={setPixRepasse} onOpen={(it) => setVerFinanceiroDe({ property: it.property, loc: it.loc })} />
            ))}
          </div>
        </Card>
      </div>

      {pixRepasse && window.PixRepasseDialog && (
        <window.PixRepasseDialog property={pixRepasse.property} loc={pixRepasse.loc} repasse={pixRepasse.repasse}
          onMarcarRepassado={(forma) => pixRepasse.acaoPagar(forma)} onClose={() => setPixRepasse(null)} />
      )}
      {verFinanceiroDe && (
        <window.FinanceiroDialog
          property={verFinanceiroDe.property}
          loc={verFinanceiroDe.loc}
          setProperties={setProperties}
          onClose={() => setVerFinanceiroDe(null)}
        />
      )}
    </div>
  );
}

window.Repasses = Repasses;
