const DSct = 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')}`;
}

const CONTRACT_TYPES = {
  administracao: { label: 'Contrato de administração', icon: 'file-check' },
  locacao: { label: 'Contrato de locação', icon: 'file-pen-line' },
  termo: { label: 'Termo final de locação', icon: 'file-text' },
};

// Catálogo de variáveis que podem ser inseridas no modelo — puxam depois os dados reais do
// imóvel, das pessoas envolvidas e da locação na hora de gerar o contrato de verdade.
const VARIABLE_GROUPS = [
  { label: 'Imóvel', vars: [
    ['imovel.titulo', 'Título do imóvel'],
    ['imovel.endereco', 'Endereço completo'],
    ['imovel.bairro', 'Bairro'],
    ['imovel.cidade', 'Cidade'],
    ['imovel.uf', 'UF'],
    ['imovel.tipo', 'Tipo do imóvel'],
    ['imovel.area', 'Área (m²)'],
    ['imovel.valorAluguel', 'Valor do aluguel'],
  ] },
  { label: 'Proprietário', vars: [
    ['proprietario.nome', 'Nome completo'],
    ['proprietario.documento', 'CPF/CNPJ'],
    ['proprietario.endereco', 'Endereço'],
    ['proprietario.estadoCivil', 'Estado civil'],
    ['proprietario.nacionalidade', 'Nacionalidade'],
    ['proprietario.email', 'E-mail'],
    ['proprietario.telefone', 'Telefone'],
  ] },
  { label: 'Inquilino', vars: [
    ['inquilino.nome', 'Nome completo'],
    ['inquilino.documento', 'CPF/CNPJ'],
    ['inquilino.endereco', 'Endereço'],
    ['inquilino.email', 'E-mail'],
    ['inquilino.telefone', 'Telefone'],
  ] },
  { label: 'Fiador', vars: [
    ['fiador.nome', 'Nome completo'],
    ['fiador.documento', 'CPF/CNPJ'],
  ] },
  { label: 'Locação', vars: [
    ['locacao.finalidade', 'Finalidade (Residencial/Comercial/Rural)'],
    ['locacao.dataInicio', 'Data de início'],
    ['locacao.prazoMeses', 'Prazo (meses)'],
    ['locacao.dataVencimento', 'Data de término prevista'],
    ['locacao.dataFim', 'Data de encerramento (quando já encerrada)'],
    ['locacao.diaVencimento', 'Dia de vencimento mensal'],
    ['locacao.valorAluguel', 'Valor do aluguel'],
    ['locacao.qtdPagamentos', 'Quantidade de pagamentos já realizados'],
    ['locacao.totalPago', 'Total já pago pelo inquilino'],
    ['locacao.totalEmAberto', 'Total em aberto (a vencer/vencido)'],
    ['locacao.movimentacoes', 'Lista de movimentações financeiras do período'],
  ] },
  { label: 'Imobiliária', vars: [
    ['imobiliaria.razaoSocial', 'Razão social'],
    ['imobiliaria.cnpj', 'CNPJ'],
    ['imobiliaria.creci', 'CRECI'],
    ['imobiliaria.endereco', 'Endereço'],
    ['imobiliaria.email', 'E-mail'],
    ['imobiliaria.telefone', 'Telefone'],
    ['imobiliaria.site', 'Site'],
  ] },
  { label: 'Outros', vars: [
    ['data.hoje', 'Data de hoje'],
  ] },
];

function v(token) {
  return `<span style="background:var(--mb-blue-50);color:var(--action-accent);padding:1px 5px;border-radius:5px;font-weight:600;">{{${token}}}</span>`;
}

function parseBRct(val) {
  if (!val) return 0;
  const n = parseFloat(String(val).replace(/\./g, '').replace(',', '.').replace(/[^\d.-]/g, ''));
  return isNaN(n) ? 0 : n;
}
function fmtMoneyCt(n) {
  return `R$ ${(n || 0).toLocaleString('pt-BR', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
}
function montarEnderecoPessoa(p) {
  if (!p || !p.endereco) return '';
  const e = p.endereco;
  const cidadeUf = e.cidade && e.uf ? `${e.cidade}/${e.uf}` : (e.cidade || '');
  return [e.rua, e.numero, e.bairro, cidadeUf].filter(Boolean).join(', ');
}
function montarEnderecoImovel(fields) {
  if (!fields) return '';
  return [fields.rua, fields.numero, fields.bairro].filter(Boolean).join(', ');
}

// Monta o mapa {token: valor} com os dados reais de um imóvel/locação/pessoas, para preencher
// um modelo de contrato. Qualquer variável sem dado correspondente fica marcada no texto final.
function montarDadosContrato({ property, loc, people, imobiliaria }) {
  const fields = (property && property._form && property._form.fields) || {};
  const ownersLinked = ((property && property._form && property._form.owners) || []).filter((o) => o.personId);
  const proprietarioPerson = ownersLinked.length ? (people || []).find((p) => p.id === ownersLinked[0].personId) : null;
  const inquilinoPerson = loc && loc.inquilinoPersonId ? (people || []).find((p) => p.id === loc.inquilinoPersonId) : null;
  const fiadorPerson = loc && loc.fiadorPersonId ? (people || []).find((p) => p.id === loc.fiadorPersonId) : null;
  const aluguelAtual = (loc && loc.valorAluguelAtual) || parseBRct(property && property._form && property._form.valorAluguel);
  const area = fields.totalArea || fields.construida || fields.util || fields.privativa || '';

  // Resumo financeiro do período da locação — usado sobretudo no Termo final de locação, para
  // mostrar quanto já foi pago, quanto ainda está em aberto e o que mais movimentou a conta.
  const cobrancas = (loc && loc.cobrancas) || [];
  const pagas = cobrancas.filter((c) => c.status === 'Pago');
  const emAberto = cobrancas.filter((c) => c.status !== 'Pago');
  const totalPago = pagas.reduce((a, c) => a + (c.valor || 0), 0);
  const totalEmAberto = emAberto.reduce((a, c) => a + (c.valor || 0), 0);
  const movimentacoes = (loc && loc.movimentacoes) || [];
  const nomeParteCt = (parte, nomeTerceiro) => parte === 'Terceiro' ? (nomeTerceiro || 'Terceiro') : parte;
  const movimentacoesTexto = movimentacoes.length
    ? [...movimentacoes].reverse().map((m) =>
        `${fmtDateBR(m.dataVencimento)} — ${m.descricao} (${nomeParteCt(m.origem, m.origemNome)} → ${nomeParteCt(m.destino, m.destinoNome)}): ${fmtMoneyCt(m.valor)}`
      ).join('; ')
    : 'Nenhuma movimentação registrada durante o período.';

  return {
    'imovel.titulo': (property && property.name) || '',
    'imovel.endereco': montarEnderecoImovel(fields),
    'imovel.bairro': fields.bairro || '',
    'imovel.cidade': fields.cidade || '',
    'imovel.uf': fields.uf || '',
    'imovel.tipo': (property && property.type) || '',
    'imovel.area': area,
    'imovel.valorAluguel': fmtMoneyCt(aluguelAtual),
    'proprietario.nome': proprietarioPerson ? proprietarioPerson.nome : '',
    'proprietario.documento': proprietarioPerson ? proprietarioPerson.documentoNumero : '',
    'proprietario.endereco': montarEnderecoPessoa(proprietarioPerson),
    'proprietario.estadoCivil': proprietarioPerson ? proprietarioPerson.estadoCivil : '',
    'proprietario.nacionalidade': proprietarioPerson ? proprietarioPerson.nacionalidade : '',
    'proprietario.email': proprietarioPerson ? proprietarioPerson.email : '',
    'proprietario.telefone': proprietarioPerson ? proprietarioPerson.telefoneCelular : '',
    'inquilino.nome': inquilinoPerson ? inquilinoPerson.nome : ((loc && loc.inquilino) || ''),
    'inquilino.documento': inquilinoPerson ? inquilinoPerson.documentoNumero : '',
    'inquilino.endereco': montarEnderecoPessoa(inquilinoPerson),
    'inquilino.email': inquilinoPerson ? inquilinoPerson.email : '',
    'inquilino.telefone': inquilinoPerson ? inquilinoPerson.telefoneCelular : '',
    'fiador.nome': fiadorPerson ? fiadorPerson.nome : ((loc && loc.fiador) || ''),
    'fiador.documento': fiadorPerson ? fiadorPerson.documentoNumero : '',
    'locacao.dataInicio': loc ? fmtDateBR(loc.dataInicio) : '',
    'locacao.prazoMeses': loc && loc.prazoMeses ? String(loc.prazoMeses) : '',
    'locacao.dataVencimento': loc ? fmtDateBR(loc.dataVencimento) : '',
    'locacao.diaVencimento': loc && loc.diaVencimento ? String(loc.diaVencimento) : '',
    'locacao.finalidade': (loc && loc.finalidade) || '',
    'locacao.valorAluguel': fmtMoneyCt(aluguelAtual),
    'locacao.dataFim': loc && loc.dataFim ? fmtDateBR(loc.dataFim) : '',
    'locacao.qtdPagamentos': String(pagas.length),
    'locacao.totalPago': fmtMoneyCt(totalPago),
    'locacao.totalEmAberto': fmtMoneyCt(totalEmAberto),
    'locacao.movimentacoes': movimentacoesTexto,
    'imobiliaria.razaoSocial': (imobiliaria && imobiliaria.razaoSocial) || '',
    'imobiliaria.cnpj': (imobiliaria && imobiliaria.cnpj) || '',
    'imobiliaria.creci': (imobiliaria && imobiliaria.creci) || '',
    'imobiliaria.endereco': (imobiliaria && imobiliaria.endereco) || '',
    'imobiliaria.email': (imobiliaria && imobiliaria.email) || '',
    'imobiliaria.telefone': (imobiliaria && imobiliaria.telefone) || '',
    'imobiliaria.site': (imobiliaria && imobiliaria.site) || '',
    'data.hoje': fmtDateBR(todayISO()),
  };
}

function escapeHtmlCt(s) {
  return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
}

// Substitui cada {{token}} (inclusive dentro do span azul do editor) pelo valor real. O que não
// tiver dado correspondente fica destacado em vermelho, para dar pra ver o que falta no check-up.
function preencherTemplate(corpoHtml, dados) {
  let html = corpoHtml || '';
  html = html.replace(/<span[^>]*>(\{\{[a-zA-Z0-9_.]+\}\})<\/span>(&nbsp;)?/g, '$1 ');
  html = html.replace(/\{\{([a-zA-Z0-9_.]+)\}\}/g, (match, token) => {
    const valor = dados[token];
    if (valor === undefined || valor === null || valor === '') {
      return `<span style="background:var(--mb-red-50);color:var(--status-danger-text);padding:1px 5px;border-radius:5px;font-weight:600;">[${token} — sem dado]</span>`;
    }
    return escapeHtmlCt(valor);
  });
  return html;
}

// Modelos de exemplo — só para servir de ponto de partida (texto e variáveis), não são
// contratos reais já assinados nem têm dados verdadeiros de ninguém.
function seedTemplatesFor(tipo) {
  const hoje = todayISO();
  if (tipo === 'administracao') {
    return [{
      id: 'adm-modelo-exemplo', nome: 'Modelo padrão — Administração', atualizadoEm: hoje,
      corpoHtml: `<h2>CONTRATO DE ADMINISTRAÇÃO DE IMÓVEL</h2>
<p>Pelo presente instrumento particular, de um lado ${v('imobiliaria.razaoSocial')}, inscrita no CNPJ sob o nº ${v('imobiliaria.cnpj')}, CRECI ${v('imobiliaria.creci')}, com sede em ${v('imobiliaria.endereco')}, doravante denominada <strong>ADMINISTRADORA</strong>, e de outro lado ${v('proprietario.nome')}, ${v('proprietario.nacionalidade')}, ${v('proprietario.estadoCivil')}, portador(a) do documento ${v('proprietario.documento')}, residente em ${v('proprietario.endereco')}, doravante denominado(a) <strong>PROPRIETÁRIO(A)</strong>, têm entre si justo e contratado o seguinte:</p>
<h2>1. Objeto</h2>
<p>A ADMINISTRADORA se compromete a administrar o imóvel ${v('imovel.titulo')}, situado em ${v('imovel.endereco')}, ${v('imovel.bairro')}, ${v('imovel.cidade')}/${v('imovel.uf')}, do tipo ${v('imovel.tipo')}, de propriedade do(a) PROPRIETÁRIO(A).</p>
<h2>2. Obrigações da Administradora</h2>
<p>Cabe à ADMINISTRADORA: anunciar e divulgar o imóvel; selecionar inquilinos; firmar e acompanhar contratos de locação; repassar mensalmente os valores devidos ao(à) PROPRIETÁRIO(A), descontada a taxa de administração; e prestar contas.</p>
<h2>3. Taxa de Administração</h2>
<p>Pela prestação dos serviços, a ADMINISTRADORA fará jus a uma taxa de administração sobre o valor de cada locação administrada, descontada do repasse mensal ao(à) PROPRIETÁRIO(A).</p>
<h2>4. Vigência</h2>
<p>O presente contrato vigora a partir de ${v('data.hoje')}, por prazo indeterminado, podendo ser rescindido por qualquer das partes mediante aviso prévio de 30 (trinta) dias.</p>
<p>${v('imovel.cidade')}, ${v('data.hoje')}.</p>
<p>_____________________________<br/>${v('proprietario.nome')} — Proprietário(a)</p>
<p>_____________________________<br/>${v('imobiliaria.razaoSocial')} — Administradora</p>`,
    }];
  }
  if (tipo === 'locacao') {
    return [{
      id: 'loc-modelo-exemplo', nome: 'Modelo padrão — Locação', atualizadoEm: hoje,
      corpoHtml: `<h2>CONTRATO DE LOCAÇÃO</h2>
<p><strong>LOCADOR(A):</strong> ${v('proprietario.nome')}, ${v('proprietario.nacionalidade')}, ${v('proprietario.estadoCivil')}, portador(a) do documento ${v('proprietario.documento')}, residente em ${v('proprietario.endereco')}.</p>
<p><strong>LOCATÁRIO(A):</strong> ${v('inquilino.nome')}, portador(a) do documento ${v('inquilino.documento')}, residente em ${v('inquilino.endereco')}.</p>
<p><strong>FIADOR(A):</strong> ${v('fiador.nome')}, portador(a) do documento ${v('fiador.documento')}.</p>
<h2>1. Objeto</h2>
<p>O(A) LOCADOR(A) dá em locação ao(à) LOCATÁRIO(A), para fins ${v('locacao.finalidade')}, o imóvel ${v('imovel.titulo')}, situado em ${v('imovel.endereco')}, ${v('imovel.bairro')}, ${v('imovel.cidade')}/${v('imovel.uf')}, com área aproximada de ${v('imovel.area')} m².</p>
<h2>2. Prazo</h2>
<p>A locação terá início em ${v('locacao.dataInicio')} e prazo de ${v('locacao.prazoMeses')} meses, encerrando-se em ${v('locacao.dataVencimento')}.</p>
<h2>3. Valor e Vencimento</h2>
<p>O aluguel mensal é de ${v('locacao.valorAluguel')}, com vencimento todo dia ${v('locacao.diaVencimento')} de cada mês.</p>
<h2>4. Administração</h2>
<p>O presente contrato é intermediado por ${v('imobiliaria.razaoSocial')}, CRECI ${v('imobiliaria.creci')}.</p>
<p>${v('imovel.cidade')}, ${v('data.hoje')}.</p>
<p>_____________________________<br/>${v('proprietario.nome')} — Locador(a)</p>
<p>_____________________________<br/>${v('inquilino.nome')} — Locatário(a)</p>
<p>_____________________________<br/>${v('fiador.nome')} — Fiador(a)</p>`,
    }];
  }
  return [{
    id: 'termo-modelo-exemplo', nome: 'Modelo padrão — Termo final de locação', atualizadoEm: hoje,
    corpoHtml: `<h2>TERMO FINAL DE LOCAÇÃO</h2>
<p>Pelo presente termo, as partes abaixo identificadas dão por encerrada a locação do imóvel ${v('imovel.titulo')}, situado em ${v('imovel.endereco')}, ${v('imovel.bairro')}, ${v('imovel.cidade')}/${v('imovel.uf')}, celebrada entre:</p>
<p><strong>LOCADOR(A):</strong> ${v('proprietario.nome')}, portador(a) do documento ${v('proprietario.documento')}, residente em ${v('proprietario.endereco')}.</p>
<p><strong>LOCATÁRIO(A):</strong> ${v('inquilino.nome')}, portador(a) do documento ${v('inquilino.documento')}, residente em ${v('inquilino.endereco')}.</p>
<h2>1. Objeto e Período</h2>
<p>As partes declaram encerrada a locação iniciada em ${v('locacao.dataInicio')}, com prazo contratual de ${v('locacao.prazoMeses')} meses e vencimento contratual em ${v('locacao.dataVencimento')}, estando a locação efetivamente encerrada em ${v('locacao.dataFim')}.</p>
<h2>2. Situação Financeira</h2>
<p>Durante o período da locação, o(a) LOCATÁRIO(A) efetuou ${v('locacao.qtdPagamentos')} pagamento(s) de aluguel, totalizando ${v('locacao.totalPago')} pagos. Há, na data deste termo, o valor de ${v('locacao.totalEmAberto')} em aberto (parcelas a vencer ou vencidas).</p>
<p><strong>Movimentações financeiras do período:</strong> ${v('locacao.movimentacoes')}</p>
<h2>3. Vistoria e Entrega das Chaves</h2>
<p>O(A) LOCATÁRIO(A) devolve o imóvel nas condições verificadas em vistoria de saída, fazendo entrega das chaves ao(à) LOCADOR(A) ou à administradora ${v('imobiliaria.razaoSocial')}.</p>
<h2>4. Quitação</h2>
<p>Ressalvado eventual saldo em aberto indicado acima, as partes declaram nada mais terem a reclamar uma da outra quanto a aluguéis, encargos e demais obrigações decorrentes da locação ora encerrada, sem prejuízo de pendências eventualmente apuradas na vistoria final.</p>
<p>${v('imovel.cidade')}, ${v('data.hoje')}.</p>
<p>_____________________________<br/>${v('proprietario.nome')} — Locador(a)</p>
<p>_____________________________<br/>${v('inquilino.nome')} — Locatário(a)</p>
<p>_____________________________<br/>${v('imobiliaria.razaoSocial')} — Administradora</p>`,
  }];
}

function ModeloCard({ modelo, onOpen, onEdit, onDelete }) {
  const { Card, Icon, IconButton } = DSct;
  const preview = (modelo.corpoHtml || '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 140);
  return (
    <Card onClick={onOpen} padding="md" style={{ gap: 8, cursor: 'pointer' }}>
      <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
        <Icon name="file-text" size={16} color="var(--text-subtle)" />
        <span style={{ fontSize: 13, fontWeight: 600, color: 'var(--text-strong)', flex: 1, minWidth: 0, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{modelo.nome}</span>
        <div style={{ display: 'flex', gap: 2 }} onClick={(e) => e.stopPropagation()}>
          <IconButton icon="pencil" label="Editar modelo" size="sm" variant="ghost" onClick={onEdit} />
          <IconButton icon="trash-2" label="Excluir modelo" size="sm" variant="ghost" style={{ color: 'var(--status-danger-text)' }} onClick={onDelete} />
        </div>
      </div>
      <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>Atualizado em {fmtDateBR(modelo.atualizadoEm)}</span>
      <span style={{ fontSize: 12, color: 'var(--text-muted)', overflow: 'hidden', display: '-webkit-box', WebkitLineClamp: 2, WebkitBoxOrient: 'vertical' }}>{preview}…</span>
    </Card>
  );
}

function TemplateEditor({ tipo, modelo, onSave, onCancel }) {
  const { Dialog, Button, Input } = DSct;
  const editableRef = React.useRef(null);
  const fileInputRef = React.useRef(null);
  const [nome, setNome] = React.useState(modelo.nome);
  const [variaveisAbertas, setVariaveisAbertas] = React.useState(false);
  // Modo HTML: permite colar/editar o código-fonte do modelo diretamente (ex.: um contrato
  // pronto em HTML vindo de outro sistema), em vez de só digitar no editor visual.
  const [htmlMode, setHtmlMode] = React.useState(false);
  const [htmlText, setHtmlText] = React.useState(modelo.corpoHtml || '<p></p>');

  React.useEffect(() => {
    if (editableRef.current) editableRef.current.innerHTML = modelo.corpoHtml || '<p></p>';
    setHtmlText(modelo.corpoHtml || '<p></p>');
    setHtmlMode(false);
  }, [modelo.id]);

  const cmd = (command, value) => {
    if (editableRef.current) editableRef.current.focus();
    document.execCommand(command, false, value);
  };

  const insertVariable = (token) => {
    const el = editableRef.current;
    if (!el) return;
    el.focus();
    document.execCommand('insertHTML', false, `<span style="background:var(--mb-blue-50);color:var(--action-accent);padding:1px 5px;border-radius:5px;font-weight:600;">{{${token}}}</span>&nbsp;`);
  };

  // Alterna entre o editor visual e o código HTML, sincronizando o conteúdo nos dois sentidos.
  const toggleHtmlMode = () => {
    if (!htmlMode) {
      setHtmlText(editableRef.current ? editableRef.current.innerHTML : htmlText);
      setHtmlMode(true);
    } else {
      if (editableRef.current) editableRef.current.innerHTML = htmlText;
      setHtmlMode(false);
    }
  };

  // Importa um arquivo .html do computador direto como o corpo do modelo.
  const handleImportFile = (e) => {
    const file = e.target.files && e.target.files[0];
    if (!file) return;
    const reader = new FileReader();
    reader.onload = () => {
      const texto = String(reader.result || '');
      setHtmlText(texto);
      setHtmlMode(true);
    };
    reader.readAsText(file);
    e.target.value = '';
  };

  const handleSave = () => {
    const corpoHtml = htmlMode ? htmlText : (editableRef.current ? editableRef.current.innerHTML : modelo.corpoHtml);
    onSave({ ...modelo, nome: nome.trim() || modelo.nome, corpoHtml, atualizadoEm: todayISO() });
  };

  const btnStyle = { border: '1px solid var(--border-subtle)', background: 'var(--surface-card)', borderRadius: 8, minWidth: 30, height: 30, padding: '0 8px', display: 'inline-flex', alignItems: 'center', justifyContent: 'center', cursor: 'pointer', fontSize: 13, fontWeight: 600, color: 'var(--text-strong)', userSelect: 'none' };

  return (
    <Dialog open onClose={onCancel} size="lg" strategy="absolute" placement="center" icon="file-pen-line" tone="accent" title="Modelo de contrato" description={CONTRACT_TYPES[tipo].label}
      footer={<><Button variant="secondary" onClick={onCancel}>Cancelar</Button><Button icon="check" onClick={handleSave}>Salvar modelo</Button></>}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
        <Input label="Nome do modelo" value={nome} onChange={(e) => setNome(e.target.value)} />

        <div style={{ display: 'flex', flexWrap: 'wrap', gap: 6, alignItems: 'center', padding: '8px 10px', background: 'var(--surface-sunken)', borderRadius: 10, position: 'relative' }}>
          <span title="Negrito" onMouseDown={(e) => { e.preventDefault(); cmd('bold'); }} style={{ ...btnStyle, opacity: htmlMode ? 0.4 : 1, pointerEvents: htmlMode ? 'none' : 'auto' }}>B</span>
          <span title="Itálico" onMouseDown={(e) => { e.preventDefault(); cmd('italic'); }} style={{ ...btnStyle, fontStyle: 'italic', opacity: htmlMode ? 0.4 : 1, pointerEvents: htmlMode ? 'none' : 'auto' }}>I</span>
          <span title="Sublinhado" onMouseDown={(e) => { e.preventDefault(); cmd('underline'); }} style={{ ...btnStyle, textDecoration: 'underline', opacity: htmlMode ? 0.4 : 1, pointerEvents: htmlMode ? 'none' : 'auto' }}>U</span>
          <span title="Título" onMouseDown={(e) => { e.preventDefault(); cmd('formatBlock', 'H2'); }} style={{ ...btnStyle, opacity: htmlMode ? 0.4 : 1, pointerEvents: htmlMode ? 'none' : 'auto' }}>H2</span>
          <span title="Parágrafo" onMouseDown={(e) => { e.preventDefault(); cmd('formatBlock', 'P'); }} style={{ ...btnStyle, opacity: htmlMode ? 0.4 : 1, pointerEvents: htmlMode ? 'none' : 'auto' }}>¶</span>
          <span title="Lista" onMouseDown={(e) => { e.preventDefault(); cmd('insertUnorderedList'); }} style={{ ...btnStyle, opacity: htmlMode ? 0.4 : 1, pointerEvents: htmlMode ? 'none' : 'auto' }}>•</span>
          <span title="Lista numerada" onMouseDown={(e) => { e.preventDefault(); cmd('insertOrderedList'); }} style={{ ...btnStyle, opacity: htmlMode ? 0.4 : 1, pointerEvents: htmlMode ? 'none' : 'auto' }}>1.</span>
          <span title="Centralizar" onMouseDown={(e) => { e.preventDefault(); cmd('justifyCenter'); }} style={{ ...btnStyle, opacity: htmlMode ? 0.4 : 1, pointerEvents: htmlMode ? 'none' : 'auto' }}>≡</span>

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

          <span title={htmlMode ? 'Voltar ao editor visual' : 'Editar/colar o código HTML do modelo'} onMouseDown={(e) => { e.preventDefault(); toggleHtmlMode(); }}
            style={{ ...btnStyle, minWidth: 40, background: htmlMode ? 'var(--action-accent)' : 'var(--surface-card)', color: htmlMode ? '#fff' : 'var(--text-strong)', borderColor: htmlMode ? 'var(--action-accent)' : 'var(--border-subtle)' }}>{'</>'}</span>
          <Button variant="secondary" size="sm" icon="upload" onMouseDown={(e) => e.preventDefault()} onClick={() => fileInputRef.current && fileInputRef.current.click()}>Importar HTML</Button>
          <input ref={fileInputRef} type="file" accept=".html,.htm,text/html" style={{ display: 'none' }} onChange={handleImportFile} />

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

          <Button variant="secondary" size="sm" icon="plus" disabled={htmlMode} onMouseDown={(e) => e.preventDefault()} onClick={() => setVariaveisAbertas((x) => !x)}>Inserir variável</Button>

          {variaveisAbertas && !htmlMode && (
            <div style={{ position: 'absolute', zIndex: 30, top: '110%', left: 0, minWidth: 270, maxHeight: 320, overflowY: 'auto', background: 'var(--surface-card)', border: '1px solid var(--border-subtle)', borderRadius: 12, boxShadow: 'var(--shadow-md)', padding: 8 }}>
              {VARIABLE_GROUPS.map((g) => (
                <div key={g.label} style={{ marginBottom: 6 }}>
                  <div style={{ fontSize: 10, fontWeight: 700, color: 'var(--text-subtle)', textTransform: 'uppercase', padding: '4px 6px' }}>{g.label}</div>
                  {g.vars.map(([token, label]) => (
                    <div key={token} onMouseDown={(e) => { e.preventDefault(); insertVariable(token); }}
                      style={{ padding: '6px 8px', borderRadius: 8, fontSize: 12, cursor: 'pointer', color: 'var(--text-strong)' }}
                      onMouseEnter={(e) => (e.currentTarget.style.background = 'var(--mb-gray-25)')} onMouseLeave={(e) => (e.currentTarget.style.background = 'transparent')}>
                      {label} <span style={{ color: 'var(--text-subtle)' }}>({'{{'}{token}{'}}'})</span>
                    </div>
                  ))}
                </div>
              ))}
            </div>
          )}
        </div>

        <div
          ref={editableRef}
          contentEditable
          suppressContentEditableWarning
          style={{ display: htmlMode ? 'none' : 'block', minHeight: 420, maxHeight: 480, overflowY: 'auto', padding: '28px 32px', background: '#fff', border: '1px solid var(--border-subtle)', borderRadius: 10, fontSize: 13, lineHeight: 1.6, color: 'var(--text-strong)' }}
        />
        {htmlMode && (
          <textarea
            value={htmlText}
            onChange={(e) => setHtmlText(e.target.value)}
            spellCheck={false}
            style={{ minHeight: 420, maxHeight: 480, overflowY: 'auto', padding: '14px 16px', background: '#0f172a', color: '#e2e8f0', border: '1px solid var(--border-subtle)', borderRadius: 10, fontSize: 12, lineHeight: 1.6, fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Consolas, monospace', resize: 'vertical' }}
          />
        )}
        <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>
          {htmlMode
            ? 'Modo HTML: cole ou edite o código-fonte do modelo (pode incluir estilos e formatação prontos). As variáveis continuam no formato {{token}}. Clique em "</>" de novo para voltar ao editor visual.'
            : 'Clique em "Inserir variável" para colocar um campo que será preenchido automaticamente com os dados do imóvel, do proprietário, do inquilino, do fiador ou da imobiliária quando o contrato for gerado a partir deste modelo. Use "</>" ou "Importar HTML" para colar ou subir um modelo já pronto em HTML.'}
        </span>
      </div>
    </Dialog>
  );
}

function ContractTypeDetail({ tipo, templates, setTemplates, go, mode }) {
  const { Button, Dialog } = DSct;
  const m = mode === 'mobile';
  const info = CONTRACT_TYPES[tipo];
  const lista = (templates && templates[tipo]) || [];
  const [editing, setEditing] = React.useState(null);
  const [deleting, setDeleting] = React.useState(null);

  const handleNovo = () => setEditing({ id: `${tipo}-${Date.now()}`, nome: 'Novo modelo', atualizadoEm: todayISO(), corpoHtml: '<p></p>' });

  const handleSave = (modeloSalvo) => {
    setTemplates((cur) => {
      const atual = cur[tipo] || [];
      const existe = atual.some((x) => x.id === modeloSalvo.id);
      const novaLista = existe ? atual.map((x) => x.id === modeloSalvo.id ? modeloSalvo : x) : [modeloSalvo, ...atual];
      return { ...cur, [tipo]: novaLista };
    });
    setEditing(null);
  };

  const handleConfirmDelete = () => {
    if (!deleting) return;
    setTemplates((cur) => ({ ...cur, [tipo]: (cur[tipo] || []).filter((x) => x.id !== deleting.id) }));
    setDeleting(null);
  };

  if (!info) {
    return (
      <div style={{ padding: m ? '16px' : 'var(--page-pad)' }}>
        <Button variant="secondary" icon="arrow-left" size="sm" onClick={() => go('contracts')}>Voltar para Contratos</Button>
      </div>
    );
  }

  return (
    <div style={{ padding: m ? '16px' : 'var(--page-pad)' }}>
      <Button variant="secondary" icon="arrow-left" size="sm" onClick={() => go('contracts')}>Voltar para Contratos</Button>
      <div style={{ display: 'flex', flexWrap: 'wrap', alignItems: 'center', justifyContent: 'space-between', gap: 10, margin: '14px 0 20px' }}>
        <div style={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
          <h1 style={{ margin: 0, fontSize: m ? 20 : 26, fontWeight: 600, letterSpacing: '-0.01em', color: 'var(--text-strong)' }}>{info.label}</h1>
          <span style={{ fontSize: 13, color: 'var(--text-muted)' }}>Modelos de contrato — personalize o texto e insira variáveis dos cadastros.</span>
        </div>
        <Button icon="plus" onClick={handleNovo}>Novo modelo</Button>
      </div>

      {lista.length === 0 ? (
        <div style={{ padding: 30, textAlign: 'center', color: 'var(--text-muted)', fontSize: 13 }}>Nenhum modelo criado ainda.</div>
      ) : (
        <div style={{ display: 'grid', gridTemplateColumns: m ? '1fr' : 'repeat(3, 1fr)', gap: 14 }}>
          {lista.map((mo) => <ModeloCard key={mo.id} modelo={mo} onOpen={() => setEditing(mo)} onEdit={() => setEditing(mo)} onDelete={() => setDeleting(mo)} />)}
        </div>
      )}

      {editing && <TemplateEditor tipo={tipo} modelo={editing} onSave={handleSave} onCancel={() => setEditing(null)} />}

      <Dialog open={!!deleting} onClose={() => setDeleting(null)} size="sm" strategy="absolute" placement="center" icon="trash-2" tone="danger"
        title="Excluir modelo" description={deleting ? `Tem certeza que quer excluir o modelo "${deleting.nome}"?` : ''}
        footer={<><Button variant="secondary" onClick={() => setDeleting(null)}>Cancelar</Button><Button variant="danger" icon="trash-2" onClick={handleConfirmDelete}>Excluir</Button></>} />
    </div>
  );
}

// Pega o modelo "padrão" de um tipo (o mais recente) para gerar o contrato automaticamente.
function modeloPadrao(templates, tipo) {
  const lista = (templates && templates[tipo]) || [];
  return lista[0] || null;
}

function ContratoGeradoDialog({ tipo, property, loc, people, templates, imobiliaria, setProperties, onClose, onSelecionarModelo }) {
  const { Dialog, Button, Select } = DSct;
  const lista = (templates && templates[tipo]) || [];
  const [modeloId, setModeloId] = React.useState((lista[0] && lista[0].id) || null);
  const modelo = lista.find((x) => x.id === modeloId) || lista[0];

  if (lista.length === 0) {
    return (
      <Dialog open onClose={onClose} size="sm" strategy="absolute" placement="center" icon="circle-alert" tone="warning" title="Nenhum modelo cadastrado"
        description={`Crie um modelo de ${CONTRACT_TYPES[tipo].label.toLowerCase()} em Contratos antes de gerar.`}
        footer={<Button onClick={onClose}>Fechar</Button>} />
    );
  }

  const dados = montarDadosContrato({ property, loc, people, imobiliaria });
  const htmlPreenchido = preencherTemplate(modelo.corpoHtml, dados);
  const faltando = Object.keys(dados).filter((k) => !dados[k]);

  // Se esse tipo de documento já foi salvo antes pra essa mesma locação (ou pro imóvel, quando
  // não há locação), reabrir o diálogo carrega a versão salva (já editada) em vez de gerar o
  // texto do zero a partir do modelo — senão toda edição salva "sumia" ao fechar e abrir de novo.
  const existente = ((property && property.contratosGerados) || []).find((g) => g.tipo === tipo && (g.locId || null) === (loc ? loc.id : null));

  // Texto que vai pro PDF/salvamento — começa no texto já salvo (se houver) ou no gerado pelo
  // modelo, e o botão "Editar" deixa ajustar na hora (contentEditable) antes de salvar/imprimir.
  // Trocar de modelo gera um documento novo a partir daquele modelo (não mexe no salvo).
  //
  // Importante: enquanto está editando, NÃO fica atualizando o estado React a cada tecla —
  // isso faria o dangerouslySetInnerHTML ser reaplicado em cima do próprio texto que o usuário
  // está digitando (mexendo no cursor/seleção) e, em casos raros de re-render do componente pai
  // nesse meio tempo, apagava a edição. Em vez disso, o texto editado só vive no DOM (via
  // contentEditable) — vira estado React (htmlAtual) só quando a edição é concluída (botão
  // "Concluir edição"/"Salvar"/"Gerar PDF"), lendo sempre direto do DOM nesse momento.
  const previewRef = React.useRef(null);
  const editedRef = React.useRef(existente ? existente.htmlContent : htmlPreenchido);
  const [htmlAtual, setHtmlAtual] = React.useState(() => (existente ? existente.htmlContent : htmlPreenchido));
  const [editing, setEditing] = React.useState(false);
  const [salvo, setSalvo] = React.useState(false);
  // Id do registro salvo que esse diálogo está editando — Salvar/Gerar PDF atualizam ele em vez
  // de criar um documento duplicado toda vez, enquanto o diálogo continuar aberto.
  const [registroId, setRegistroId] = React.useState(existente ? existente.id : null);
  const primeiraRenderRef = React.useRef(true);
  React.useEffect(() => {
    if (primeiraRenderRef.current) { primeiraRenderRef.current = false; return; }
    setHtmlAtual(htmlPreenchido);
    editedRef.current = htmlPreenchido;
    setEditing(false);
    setRegistroId(null);
  }, [modeloId]);

  // Captura o texto atual do DOM (editado ou não) — usada sempre que algo precisa do texto final.
  const capturarHtmlAtual = () => {
    if (editing && previewRef.current) { editedRef.current = previewRef.current.innerHTML; return editedRef.current; }
    return htmlAtual;
  };

  const toggleEditing = () => {
    if (editing) { const html = capturarHtmlAtual(); setHtmlAtual(html); setEditing(false); }
    else { editedRef.current = htmlAtual; setEditing(true); }
    setSalvo(false);
  };

  // Grava (ou atualiza, se já existir um salvo desse tipo pra essa locação) o registro na pasta
  // de Doc Anexos do imóvel — reaproveita o mesmo id enquanto o diálogo seguir aberto, pra não
  // duplicar documento a cada Salvar/Gerar PDF.
  const salvarRegistro = (htmlFinal) => {
    if (!setProperties || !property) return;
    const idParaUsar = registroId || `gerado-${Date.now()}`;
    setProperties((cur) => cur.map((p) => {
      if (p.id !== property.id) return p;
      const atuais = p.contratosGerados || [];
      const registro = {
        id: idParaUsar,
        nome: `${CONTRACT_TYPES[tipo].label}${loc ? ` — ${loc.inquilino || ''}` : ''}`,
        tipo,
        locId: loc ? loc.id : null,
        geradoEm: todayISO(),
        htmlContent: htmlFinal,
      };
      const jaExiste = atuais.some((g) => g.id === idParaUsar);
      return { ...p, contratosGerados: jaExiste ? atuais.map((g) => g.id === idParaUsar ? registro : g) : [registro, ...atuais] };
    }));
    if (!registroId) setRegistroId(idParaUsar);
  };

  // Salva o texto (já editado, se for o caso) em Doc Anexos, sem abrir a tela de impressão.
  const handleSalvar = () => {
    const htmlFinal = capturarHtmlAtual();
    setHtmlAtual(htmlFinal);
    setEditing(false);
    salvarRegistro(htmlFinal);
    setSalvo(true);
  };

  const handleGerarPdf = () => {
    const htmlFinal = capturarHtmlAtual();
    setHtmlAtual(htmlFinal);
    setEditing(false);
    const titulo = `${CONTRACT_TYPES[tipo].label} — ${(property && 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: 24mm 20mm; }
        body { font-family: Georgia, 'Times New Roman', serif; font-size: 13px; line-height: 1.6; color: #1a1a1a; padding: 0; }
        h2 { font-size: 15px; margin: 18px 0 8px; }
        p { margin: 0 0 10px; }
        span[style] { background: none !important; color: inherit !important; padding: 0 !important; font-weight: 600; }
      </style>
      </head><body>${htmlFinal}</body></html>`);
    w.document.close();
    w.focus();
    setTimeout(() => w.print(), 300);

    // Fica registrado na pasta de Doc Anexos do imóvel, vinculado à locação quando houver uma.
    salvarRegistro(htmlFinal);
  };

  return (
    <Dialog open onClose={onClose} size="lg" strategy="absolute" placement="center" icon="file-text" tone="accent" title="Contrato gerado" description={`${CONTRACT_TYPES[tipo].label} · ${property ? property.name : ''}`}
      footer={<>
        <Button variant="secondary" onClick={onClose}>Fechar</Button>
        <Button variant="secondary" icon={editing ? 'check' : 'pencil'} onClick={toggleEditing}>{editing ? 'Concluir edição' : 'Editar'}</Button>
        <Button variant="secondary" icon="folder" onClick={handleSalvar}>Salvar</Button>
        <Button icon="download" onClick={handleGerarPdf}>Gerar PDF</Button>
      </>}>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
        {lista.length > 1 && (
          <Select label="Modelo" value={modeloId} onChange={(e) => setModeloId(e.target.value)} options={lista.map((x) => ({ value: x.id, label: x.nome }))} />
        )}
        {faltando.length > 0 && (
          <span style={{ fontSize: 11, color: 'var(--status-warning-text)' }}>
            Este é o check-up: {faltando.length} campo(s) sem dado cadastrado aparecem destacados em vermelho no texto abaixo — complete o cadastro correspondente (imóvel, pessoa ou Configurações) e gere de novo.
          </span>
        )}
        {editing && (
          <span style={{ fontSize: 11, color: 'var(--text-accent)' }}>Modo de edição — clique no texto abaixo e ajuste à vontade. Clique em "Concluir edição" ou "Salvar" quando terminar.</span>
        )}
        <div ref={previewRef} contentEditable={editing} suppressContentEditableWarning
          onInput={() => { if (editing && previewRef.current) editedRef.current = previewRef.current.innerHTML; }}
          style={{ minHeight: 420, maxHeight: 480, overflowY: 'auto', padding: '28px 32px', background: '#fff', border: editing ? '2px solid var(--action-accent)' : '1px solid var(--border-subtle)', borderRadius: 10, fontSize: 13, lineHeight: 1.6, color: 'var(--text-strong)', cursor: editing ? 'text' : 'default' }}
          dangerouslySetInnerHTML={{ __html: htmlAtual }} />
        <span style={{ fontSize: 11, color: 'var(--text-subtle)' }}>
          Gerado automaticamente a partir do modelo "{modelo.nome}". "Editar" deixa ajustar o texto na hora; "Salvar" guarda esse texto em Doc Anexos do imóvel sem imprimir; "Gerar PDF" abre a tela de impressão — escolha "Salvar como PDF" no destino. Assinatura digital ainda será implementada neste protótipo.
          {salvo && <b style={{ color: 'var(--status-success-text)' }}> Salvo em Doc Anexos.</b>}
        </span>
      </div>
    </Dialog>
  );
}

window.CONTRACT_TYPES = CONTRACT_TYPES;
window.seedContractTemplates = () => ({
  administracao: seedTemplatesFor('administracao'),
  locacao: seedTemplatesFor('locacao'),
  termo: seedTemplatesFor('termo'),
});
window.montarDadosContrato = montarDadosContrato;
window.preencherTemplateContrato = preencherTemplate;
window.ContratoGeradoDialog = ContratoGeradoDialog;
window.ContractTypeDetail = ContractTypeDetail;
