/* global React, Icon, Button, Badge, Card, Drawer, Field, PageHead, EmptyState, brl,
fmtDate, useProdutosList, useBalancos, useEmpresasList,
DocPrintOverlay, DocCabecalhoEmpresa, DocTitulo, DocTituloSecao, DocTabelaItens */
// ─── Balanço de estoque (inventário) — módulo Estoque ────────────────────────
// O estoque dos produtos de venda está inflado há anos (a venda B2B nunca baixou
// até a correção recente) e há produto com saldo negativo. Nenhum código conserta
// isso: só contagem física. Este módulo transforma a contagem numa operação
// controlada em vez de planilha.
//
// TRÊS COISAS QUE NÃO PODEM SAIR ERRADAS — e onde cada uma está resolvida:
//
// 1. O PRIMEIRO BALANÇO NÃO ENTRA NO RESULTADO. A diferença dele é o acerto de
// anos de venda não baixada, não prejuízo do mês. `tipo: 'acerto_inicial'`
// separa isso de `'inventario'` (perda/sobra de verdade). Ver BAL_TIPOS.
//
// 2. CONTAGEM CEGA. A folha impressa (BalancoFolha) NÃO leva o saldo do sistema,
// e a tela de digitação (BalancoDigitacao) só revela o saldo DEPOIS que a
// pessoa digitou. Se o número aparece antes, ela confirma em vez de contar —
// é o erro clássico de inventário e destrói o propósito da operação.
//
// 3. O AJUSTE USA O SALDO DA APLICAÇÃO, NÃO O DA ABERTURA. Entre abrir, contar e
// aplicar há venda e produção. `saldo_sistema_abertura` é só referência; quem
// decide o ajuste é o saldo lido na hora de aplicar. (A aplicação em si é a
// próxima etapa — ainda não está implementada, de propósito.)
const BAL_STATUS = {
aberto: { l: 'Aberto', tone: 'info' },
contado: { l: 'Contado', tone: 'warning' },
aplicado: { l: 'Aplicado', tone: 'success' },
};
// O texto importa tanto quanto o valor: ela precisa ENTENDER a escolha, não só marcar.
const BAL_TIPOS = {
acerto_inicial: {
l: 'Acerto inicial',
resumo: 'Corrige a base. NÃO entra no resultado.',
texto: 'A diferença deste balanço é o acerto de anos de estoque errado — principalmente venda que nunca foi baixada. Não é perda do mês. Ele conserta o saldo dos produtos, mas o valor da diferença não deve ser lançado como prejuízo.',
},
inventario: {
l: 'Inventário',
resumo: 'Rotina. A diferença é perda/sobra de verdade.',
texto: 'A base já está confiável e esta contagem é de rotina. O que faltar é perda real (quebra, furto, erro de separação) e o que sobrar é sobra real — o valor da diferença conta como resultado.',
},
};
const ESCOPOS = [
{ id: 'categoria', label: 'Categoria', campo: 'categoria' },
{ id: 'marca', label: 'Marca', campo: 'marca' },
{ id: 'linha', label: 'Linha', campo: 'linha' },
{ id: 'tipo_produto', label: 'Tipo de produto', campo: 'tipo' },
{ id: 'selecao', label: 'Seleção manual', campo: null },
];
const balUsuario = () => {
const p = window.tmUserProfile || {};
return p.nome || p.name || (window.tmUser && window.tmUser.email) || '';
};
const balHoje = () => new Date().toISOString().slice(0, 10);
const balFmtD = (iso) => iso ? (fmtDate(iso) || String(iso).slice(0, 10).split('-').reverse().join('/')) : '—';
const balQtd = (n) => (Number(n) || 0).toLocaleString('pt-BR');
// Produto sem SKU NÃO ENTRA na contagem. `salvarMovimentacao` aplica o estoque
// procurando o produto pelo SKU — sem SKU a movimentação grava e o estoque não
// muda, que é o pior dos mundos: parece que ajustou e não ajustou.
const balContavel = (p) => String((p && p.sku) || '').trim() !== '';
// Recorta os produtos pelo escopo escolhido.
function balAplicarEscopo(produtos, escopoTipo, escopoValor, selecionados) {
const lista = produtos || [];
if (escopoTipo === 'selecao') {
const set = selecionados instanceof Set ? selecionados : new Set(selecionados || []);
return lista.filter(p => set.has(p.id));
}
const def = ESCOPOS.find(e => e.id === escopoTipo);
if (!def || !def.campo || !escopoValor) return [];
return lista.filter(p => String(p[def.campo] || '') === String(escopoValor));
}
// Valores distintos de um campo, pra montar o seletor do escopo.
function balValoresDe(produtos, campo) {
const s = new Set();
(produtos || []).forEach(p => { const v = p[campo]; if (v) s.add(String(v)); });
return [...s].sort((a, b) => a.localeCompare(b, 'pt-BR'));
}
// Resumo da conferência. Fora do componente de propósito (helper puro e testável).
// ⚠️ `contada === null` é PENDENTE, não zero — ver numOuNull em db.js.
// Item APLICADO usa o saldo da aplicação e o ajuste GRAVADOS — é o que de fato
// aconteceu; o saldo da abertura é referência só enquanto o item não foi aplicado.
function balResumo(itens) {
const lin = (itens || []).map(it => {
const contada = (it.contada === null || it.contada === undefined) ? null : Number(it.contada);
const aplicado = !!it.aplicado && it.saldoAplicacao !== null && it.saldoAplicacao !== undefined;
const sistema = aplicado ? Number(it.saldoAplicacao) : (Number(it.saldoAbertura) || 0);
const custo = Number(it.custoUn) || 0;
const dif = contada === null ? null : (aplicado ? (Number(it.ajuste) || 0) : contada - sistema);
return { ...it, contada, sistema, custo, dif, difValor: dif === null ? null : dif * custo };
});
const contados = lin.filter(l => l.contada !== null);
const pendentes = lin.filter(l => l.contada === null);
const divergem = contados.filter(l => l.dif !== 0);
return {
linhas: lin, contados, pendentes, divergem,
difUnidades: contados.reduce((a, l) => a + l.dif, 0),
difValor: contados.reduce((a, l) => a + l.difValor, 0),
faltando: contados.filter(l => l.dif < 0).reduce((a, l) => a + l.difValor, 0),
sobrando: contados.filter(l => l.dif > 0).reduce((a, l) => a + l.difValor, 0),
// ordenado pelo IMPACTO EM REAIS — é onde ela vai querer recontar antes de aceitar
maiores: [...divergem].sort((a, b) => Math.abs(b.difValor) - Math.abs(a.difValor)),
};
}
// ── Abrir balanço ────────────────────────────────────────────────────────────
function BalancoAbrirForm({ produtos, empresas, onClose, onAberto }) {
const [escopoTipo, setEscopoTipo] = React.useState('categoria');
const [escopoValor, setEscopoValor] = React.useState('');
const [selecao, setSelecao] = React.useState([]); // ids (escopo 'selecao')
const [buscaSel, setBuscaSel] = React.useState('');
const [desc, setDesc] = React.useState('');
const [tipo, setTipo] = React.useState('acerto_inicial');
const [responsavel, setResponsavel] = React.useState(balUsuario());
const [empresaId, setEmpresaId] = React.useState('');
const [jaAjustados, setJaAjustados] = React.useState(null); // Set de produto_id, null = carregando
const [erro, setErro] = React.useState('');
const [salvando, setSalvando] = React.useState(false);
// Quais produtos JÁ passaram por um balanço aplicado. É o que define se este é
// "o primeiro" (acerto inicial) ou já é rotina (inventário).
React.useEffect(() => {
let vivo = true;
if (!window.tmSupabase) { setJaAjustados(new Set()); return; }
window.tmSupabase.from('balanco_itens').select('produto_id').eq('aplicado', true)
.then(({ data }) => { if (vivo) setJaAjustados(new Set((data || []).map(r => r.produto_id))); })
.catch(() => { if (vivo) setJaAjustados(new Set()); });
return () => { vivo = false; };
}, []);
React.useEffect(() => {
const emp = window.tmEmpresaId || ((empresas || [])[0] && empresas[0].id) || '';
setEmpresaId(emp);
}, [empresas]);
const escopo = balAplicarEscopo(produtos, escopoTipo, escopoValor, selecao);
const contaveis = escopo.filter(balContavel);
const semSku = escopo.filter(p => !balContavel(p));
const inedito = jaAjustados ? contaveis.filter(p => !jaAjustados.has(p.id)) : [];
// Sugere o tipo assim que o recorte muda: se NENHUM produto do recorte já foi
// ajustado, é o primeiro balanço deles → acerto inicial. Ela pode trocar.
React.useEffect(() => {
if (!jaAjustados || !contaveis.length) return;
setTipo(inedito.length === contaveis.length ? 'acerto_inicial' : 'inventario');
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [escopoTipo, escopoValor, selecao.length, jaAjustados]);
const opcoes = React.useMemo(() => {
const def = ESCOPOS.find(e => e.id === escopoTipo);
return (def && def.campo) ? balValoresDe(produtos, def.campo) : [];
}, [escopoTipo, produtos]);
const candidatosSel = React.useMemo(() => {
const q = buscaSel.trim().toLowerCase();
if (!q) return [];
return (produtos || []).filter(p =>
String(p.sku || '').toLowerCase().includes(q) ||
String(p.nome || p.name || '').toLowerCase().includes(q)
).slice(0, 12);
}, [buscaSel, produtos]);
const podeSalvar = contaveis.length > 0 && !salvando;
const salvar = async () => {
setErro(''); setSalvando(true);
const r = await window.tmDb.abrirBalanco({
desc: desc.trim() || null, escopoTipo,
escopoValor: escopoTipo === 'selecao' ? `${contaveis.length} produtos` : escopoValor,
tipo, responsavel: responsavel.trim() || null, empresaId: empresaId || null,
}, contaveis);
setSalvando(false);
if (r.error) { setErro(r.error.message || 'Não foi possível abrir o balanço.'); return; }
onAberto(r.balanco);
};
const info = BAL_TIPOS[tipo] || BAL_TIPOS.inventario;
return (
}>
{erro && (
{escopoTipo === 'selecao' && (
<>
setBuscaSel(typeof v === 'string' ? v : v.target.value)}
placeholder="Digite o SKU…" />
{candidatosSel.length > 0 && (
{candidatosSel.map(p => {
const dentro = selecao.includes(p.id);
return (
setSelecao(s => dentro ? s.filter(x => x !== p.id) : [...s, p.id])}>
{p.sku || '—'}{p.nome || p.name}
);
})}
)}
{selecao.length > 0 &&
{selecao.length} produto(s) selecionado(s).
}
)}
Identificação
setDesc(typeof v === 'string' ? v : v.target.value)}
placeholder="Ex.: Contagem linha Sensations" />
setResponsavel(typeof v === 'string' ? v : v.target.value)} />
{(empresas || []).length > 1 && (
)}
{/* ── A escolha que não pode sair errada ── */}
Este balanço entra no resultado?
{Object.keys(BAL_TIPOS).map(k => (
setTipo(k)}>
{BAL_TIPOS[k].l}{BAL_TIPOS[k].resumo}
))}
{info.texto}
{jaAjustados && contaveis.length > 0 && (
{inedito.length === contaveis.length
? <>Nenhum destes {contaveis.length} produtos passou por um balanço aplicado ainda — por isso a sugestão é acerto inicial.
: <>{contaveis.length - inedito.length} de {contaveis.length} produtos já foram ajustados em balanço anterior — por isso a sugestão é inventário.}
)}
{/* ── O que vai (e o que não vai) pra folha ── */}
O que será contado
{escopo.length === 0 ? (
Escolha um recorte para ver os produtos.
) : (
{contaveis.length}a contar
{semSku.length}não contáveis
)}
{semSku.length > 0 && (
{semSku.length} produto(s) ficam de fora: não têm SKU.
O ajuste de estoque é aplicado procurando o produto pelo SKU. Sem SKU a
movimentação seria gravada e o estoque não mudaria — pior do que não contar.
Cadastre o SKU em Estoque › Produtos › Lista e reabra o balanço.
{semSku.slice(0, 12).map(p =>
{p.nome || p.name || p.id}
)}
{semSku.length > 12 &&
…e mais {semSku.length - 12}.
}
)}
);
}
// ── Folha de contagem (A4, CEGA) ─────────────────────────────────────────────
// ⚠️ NÃO IMPRIMA O SALDO DO SISTEMA AQUI. Se o número aparece na folha, a pessoa
// confirma em vez de contar. A folha leva SKU, descrição, unidade e um campo em
// branco — nada mais. Usa o DocImpressao.jsx sem alterá-lo.
function BalancoFolha({ balanco, itens, prodById, empresa, onClose }) {
const emp = empresa || window.tmEmpresa || (window.tmEmpresas || [])[0] || {};
const nomeDe = (it) => { const p = prodById[it.produtoId] || {}; return p.nome || p.name || '—'; };
const unDe = (it) => { const p = prodById[it.produtoId] || {}; return p.unidade || 'UN'; };
const lista = [...(itens || [])].sort((a, b) => String(a.sku || '').localeCompare(String(b.sku || ''), 'pt-BR'));
const campoEmBranco = ;
return (
Contado por: ______________________________
Data da contagem: ______ / ______ / __________
Conte a prateleira e escreva a quantidade encontrada [
{ v: it.sku || '—', muted: true },
{ v: nomeDe(it) },
{ v: unDe(it), align: 'center' },
{ v: campoEmBranco },
])}
totais={[['Linhas a contar', balQtd(lista.length), true]]}
/>
{/* Instrução no papel: sem ela, item não contado vira zero na cabeça de quem digita. */}
Como preencher: escreva a quantidade encontrada na prateleira, em números.
Se não houver nenhuma unidade, escreva 0 (zero). Se você não conseguiu contar o
item, deixe em branco — em branco é diferente de zero: zero manda o sistema zerar o
saldo, em branco deixa o item pendente e o saldo intacto.
);
}
// ── Digitação (o saldo do sistema fica escondido até ela digitar) ────────────
function BalancoDigitacao({ balanco, itens, prodById, onClose, onMudou }) {
const [linhas, setLinhas] = React.useState(itens || []);
const [busca, setBusca] = React.useState('');
const [foco, setFoco] = React.useState(null); // item sendo digitado
const [valor, setValor] = React.useState('');
const [ultimo, setUltimo] = React.useState(null); // { item, contada, sistema, dif } — revelado
const [erro, setErro] = React.useState('');
const [salvando, setSalvando] = React.useState(false);
const buscaRef = React.useRef(null);
React.useEffect(() => { if (buscaRef.current) buscaRef.current.focus(); }, []);
const nomeDe = (it) => { const p = prodById[it.produtoId] || {}; return p.nome || p.name || '—'; };
const unDe = (it) => { const p = prodById[it.produtoId] || {}; return p.unidade || 'UN'; };
const achados = React.useMemo(() => {
const q = busca.trim().toLowerCase();
if (!q) return [];
return linhas.filter(it =>
String(it.sku || '').toLowerCase().includes(q) ||
nomeDe(it).toLowerCase().includes(q)
).slice(0, 8);
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [busca, linhas]);
const escolher = (it) => {
// Item aplicado é imutável: recontar aqui mudaria o número na tela e nunca
// chegaria ao estoque (a aplicação pula item já aplicado). db.js tem a mesma
// trava no update — esta é só a versão educada.
if (it.aplicado) { setErro(`${it.sku} já foi aplicado — a contagem dele não pode mais mudar.`); return; }
setFoco(it);
setValor(it.contada === null || it.contada === undefined ? '' : String(it.contada));
setUltimo(null); setErro('');
};
const gravar = async () => {
if (!foco) return;
const txt = String(valor).trim();
if (txt === '') { setErro('Digite a quantidade contada, ou 0 se a prateleira estiver vazia.'); return; }
const n = Number(txt.replace(',', '.'));
if (isNaN(n) || n < 0) { setErro('Quantidade inválida.'); return; }
setSalvando(true); setErro('');
const r = await window.tmDb.salvarContagem(foco.id, n, balUsuario());
setSalvando(false);
if (r.error) { setErro(r.error.message || 'Não foi possível gravar a contagem.'); return; }
setLinhas(ls => ls.map(l => l.id === r.item.id ? r.item : l));
// SÓ AGORA o saldo do sistema aparece — depois de ela ter comprometido o número.
const sistema = Number(foco.saldoAbertura) || 0;
setUltimo({ item: r.item, nome: nomeDe(foco), contada: n, sistema, dif: n - sistema });
setFoco(null); setValor(''); setBusca('');
if (buscaRef.current) buscaRef.current.focus();
onMudou && onMudou();
};
const limpar = async (it) => {
setSalvando(true);
const r = await window.tmDb.salvarContagem(it.id, null, balUsuario());
setSalvando(false);
if (r.error) { setErro(r.error.message || 'Não foi possível apagar a contagem.'); return; }
setLinhas(ls => ls.map(l => l.id === r.item.id ? r.item : l));
setUltimo(null);
onMudou && onMudou();
};
const contados = linhas.filter(l => l.contada !== null && l.contada !== undefined);
const pendentes = linhas.filter(l => l.contada === null || l.contada === undefined);
// aberto → contado quando a digitação termina (e volta se uma contagem for
// apagada). Nunca mexe num balanço já aplicado.
const fechar = async () => {
if (balanco.status !== 'aplicado' && window.tmSupabase) {
const novo = (linhas.length > 0 && pendentes.length === 0) ? 'contado' : 'aberto';
if (novo !== balanco.status) {
await window.tmSupabase.from('balancos')
.update({ status: novo, updated_at: new Date().toISOString() }).eq('id', balanco.id);
}
}
onClose();
};
return (
Fechar}>
escolher(it)}>
{it.sku}{nomeDe(it)}
{/* SEM SALDO AQUI — só o estado da contagem */}
{(it.contada !== null && it.contada !== undefined)
? contado
: pendente}
))}
)}
{foco && (
{foco.sku}{nomeDe(foco)}{unDe(foco)}
{/* ⚠️ nenhum saldo do sistema neste bloco — é o ponto da contagem cega */}
Se essa mercadoria saiu (ou entrou) da prateleira depois de contada, o
número contado está velho — aplicar assim desfaz a movimentação. Recontar é o seguro.
);
})}
{faltaDecidir.length > 0 && (
Decida os {faltaDecidir.length} item(ns) acima para liberar a aplicação.
)}
{progresso && (
Aplicando {progresso.feito + 1} de {progresso.total} — {progresso.atual}…
)}
{erro && (
Parou no item {erro.sku}: {erro.msg}
Os {erro.feitos} anteriores ficaram aplicados e marcados — nada dobra.
Tentar de novo retoma exatamente do ponto onde parou.
)}
)}
{resultado && (
<>
{resultado.movimentos}ajustes gerados
{resultado.batidos}batidos (sem ajuste)
{resultado.retomados}retomados
{resultado.deixados.length}pra recontar
{resultado.statusFinal === 'aplicado' ? (
Balanço aplicado. A partir de agora ele é somente leitura — fica no
histórico como o documento da operação: quem contou, quando, o que divergiu.
) : (
O balanço continua em contagem: {resultado.deixados.length} item(ns) ficaram
de fora para recontagem ({resultado.deixados.map(d => d.sku).join(', ')}).
Reconte-os em Digitar contagem e aplique de novo — só os que faltam entram.
)}
{/* ⚠️ NADA é lançado no financeiro automaticamente. Mostrar e orientar, só. */}
{balanco.tipo === 'acerto_inicial' ? (
Acerto inicial — fora do resultado. {info.texto} Não lance este
valor no financeiro: nenhum título foi (nem deve ser) gerado.
) : (
Inventário — perda/sobra real. {info.texto} Nenhum lançamento foi feito
automaticamente: se você quiser que a perda apareça no resultado (DRE), lance-a em
Financeiro › Contas a Pagar na categoria adequada — a decisão é sua.
Item pendente não é zero — ele fica de fora do ajuste e o saldo
atual continua valendo. Se algum deles deveria ter sido contado, volte
em Digitar contagem antes de aplicar.
)}
{/* Onde ela vai querer recontar: as maiores divergências EM VALOR */}
)}
{/* ⚠️ Antes de aplicar, os números usam o saldo da ABERTURA (referência).
Depois, usam o saldo da APLICAÇÃO e o ajuste gravados — o que aconteceu. */}
{aplicado ? (
Números da aplicação: saldo lido no momento de aplicar e o ajuste
que de fato foi gerado. Este é o documento da operação.
) : (
As diferenças acima usam o saldo da abertura do balanço, como referência.
Na hora de aplicar, o sistema relê o saldo daquele momento e recalcula —
senão o ajuste apagaria as vendas e produções que aconteceram no meio.
)}
);
}
// ── Lista / página do módulo ────────────────────────────────────────────────
function Balancos({ onNav }) { // eslint-disable-line no-unused-vars
const bals = useBalancos();
const prodHook = useProdutosList([]);
const empresasHook = useEmpresasList([]);
const [abrindo, setAbrindo] = React.useState(false);
const [folha, setFolha] = React.useState(null); // { balanco, itens }
const [digitar, setDigitar] = React.useState(null);
const [conferir, setConferir] = React.useState(null);
const [aplicar, setAplicar] = React.useState(null);
const [busy, setBusy] = React.useState(false);
const prodById = {}; (prodHook.rows || []).forEach(p => { prodById[p.id] = p; });
// Sem filtro de status de propósito: produto Inativo/Descontinuado com sobra na
// prateleira também precisa ser contado — o balanço mede a realidade física.
const produtos = prodHook.rows || [];
const abrirCom = async (bal, setter) => {
setBusy(true);
const d = await window.tmDb.loadBalanco(bal.id);
setBusy(false);
setter({ balanco: bal, itens: d.itens });
};
const rows = bals.rows || [];
return (