#!/usr/bin/env bash
#
# Teste rápido da API de ponta a ponta. Rode depois do dev-up.sh:
#   ./scripts/smoke-test.sh
#
# Faz login, confere que as rotas protegidas exigem login e CSRF, cria
# uma conta de e-mail (senha cifrada), mexe nas configurações, regras,
# empresas, importa o OFX de exemplo (python-worker/tests/exemplo.ofx) e
# roda o worker Python pela API. Não acessa e-mail nem WhatsApp reais.

set -uo pipefail

API_PORT="${API_PORT:-8000}"
API_BASE="http://localhost:$API_PORT/api"
COOKIE_JAR="$(mktemp)"
BODY="$(mktemp)"
trap 'rm -f "$COOKIE_JAR" "$BODY"' EXIT

LOGIN_USER="${SMOKE_TEST_USER:-admin}"
LOGIN_PASS="${SMOKE_TEST_PASS:-senha-de-desenvolvimento}"

pass=0
fail=0
csrf_token=""

# check "descrição" MÉTODO URL código_esperado [json] [sem_csrf]
check() {
    local desc="$1" method="$2" url="$3" expected="$4" data="${5:-}" nocsrf="${6:-}"
    local args=(-s -b "$COOKIE_JAR" -c "$COOKIE_JAR" -o "$BODY" -w "%{http_code}" -X "$method")
    if [ -n "$csrf_token" ] && [ "$method" != "GET" ] && [ -z "$nocsrf" ]; then
        args+=(-H "X-CSRF-Token: $csrf_token")
    fi
    [ -n "$data" ] && args+=(-H "Content-Type: application/json" -d "$data")
    local code
    code=$(curl "${args[@]}" "$url")
    if [ "$code" = "$expected" ]; then
        echo "OK   [$code] $desc"; pass=$((pass+1))
    else
        echo "FAIL [$code, esperado $expected] $desc"
        echo "     resposta: $(head -c 300 "$BODY")"; fail=$((fail+1))
    fi
}

echo "== Smoke test =="

check "Sem login, /resumo é bloqueado"        GET  "$API_BASE/resumo" 401
check "Senha errada é recusada"               POST "$API_BASE/auth/login" 401 '{"username":"admin","password":"errada-errada"}'

login=$(curl -s -c "$COOKIE_JAR" -X POST -H "Content-Type: application/json" \
    -d "{\"username\":\"$LOGIN_USER\",\"password\":\"$LOGIN_PASS\"}" "$API_BASE/auth/login")
csrf_token=$(echo "$login" | grep -o '"csrf_token":"[^"]*"' | cut -d'"' -f4)
if [ -n "$csrf_token" ]; then echo "OK   login (csrf_token obtido)"; pass=$((pass+1)); else echo "FAIL login: $login"; fail=$((fail+1)); fi

check "Resumo do painel"                      GET  "$API_BASE/resumo" 200
check "Lista de boletos"                      GET  "$API_BASE/documentos?grupo=boletos" 200
check "Lista de notas do mês"                 GET  "$API_BASE/documentos?grupo=notas&mes=$(date +%Y-%m)" 200
check "POST sem CSRF é bloqueado"             PUT  "$API_BASE/config" 403 '{"dias_aviso":"5"}' sem_csrf
check "Salvar configuração"                   PUT  "$API_BASE/config" 200 '{"dias_aviso":"3,1,0","whatsapp_provedor":"desligado"}'
check "Configuração inválida é recusada"      PUT  "$API_BASE/config" 422 '{"contabilidade_remoto":"x; rm -rf /"}'
check "Criar conta de e-mail (domínio)"       POST "$API_BASE/contas" 200 '{"provedor":"dominio","nome":"Teste","usuario":"financeiro@exemplo.com.br","host":"mail.exemplo.com.br","porta":993,"senha":"senha-teste"}'
conta_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Conta inválida é recusada"             POST "$API_BASE/contas" 422 '{"provedor":"dominio","usuario":"nao-e-email","host":"x"}'
check "Listar contas (senha não aparece)"     GET  "$API_BASE/contas" 200
if grep -q "senha-teste\|segredo_cifrado" "$BODY"; then echo "FAIL senha/segredo apareceu na listagem"; fail=$((fail+1)); else echo "OK   senha não é devolvida pela API"; pass=$((pass+1)); fi
check "Worker Python responde (diagnóstico)"  GET  "$API_BASE/tarefas/diagnostico" 200
check "WhatsApp desligado: teste responde"    POST "$API_BASE/tarefas/notificar-teste" 200
check "Histórico de atividades"               GET  "$API_BASE/tarefas" 200
check "Download inexistente dá 404"           GET  "$API_BASE/documentos/999999/arquivo" 404
check "ZIP de mês sem notas dá 404"           GET  "$API_BASE/contabilidade/zip?mes=1999-01" 404
[ -n "$conta_id" ] && check "Histórico da caixa: desligar" POST "$API_BASE/contas/$conta_id/historico" 200 '{"acao":"desligar"}'
[ -n "$conta_id" ] && check "Histórico da caixa: ação inválida" POST "$API_BASE/contas/$conta_id/historico" 422 '{"acao":"apagar"}'
[ -n "$conta_id" ] && check "Histórico da caixa: ler de novo" POST "$API_BASE/contas/$conta_id/historico" 200 '{"acao":"reiniciar"}'
check "Contas mostram o progresso do histórico" GET "$API_BASE/contas" 200
grep -q '"historico_status":"pendente"' "$BODY" && { echo "OK   caixa com leitura do histórico na fila"; pass=$((pass+1)); } || { echo "FAIL historico_status"; fail=$((fail+1)); }
[ -n "$conta_id" ] && check "Excluir conta de teste" DELETE "$API_BASE/contas/$conta_id" 200

# --- Gestão da captura ---
check "Lista da revisão"                      GET  "$API_BASE/revisao" 200
check "Histórico de e-mails"                  GET  "$API_BASE/emails" 200
check "E-mails por remetente"                 GET  "$API_BASE/emails/remetentes" 200
check "Criar regra de descarte"               POST "$API_BASE/regras" 200 '{"campo":"dominio","valor":"spam-smoke.com.br","acao":"descartar"}'
regra_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Regra de domínio público é recusada"   POST "$API_BASE/regras" 422 '{"campo":"dominio","valor":"gmail.com","acao":"descartar"}'
check "Listar regras"                         GET  "$API_BASE/regras" 200
[ -n "$regra_id" ] && check "Excluir regra"   DELETE "$API_BASE/regras/$regra_id" 200

# --- Empresas e conciliação OFX ---
check "Empresa com CNPJ inválido é recusada"  POST "$API_BASE/empresas" 422 '{"nome":"X","cnpj":"11.111.111/1111-11"}'
check "Criar empresa"                         POST "$API_BASE/empresas" 200 '{"nome":"Empresa Smoke","cnpj":"11.222.333/0001-81"}'
empresa_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
code=$(curl -s -b "$COOKIE_JAR" -o "$BODY" -w "%{http_code}" -H "X-CSRF-Token: $csrf_token" \
    -F "empresa_id=$empresa_id" -F "arquivos[]=@$ROOT_DIR/python-worker/tests/exemplo.ofx" "$API_BASE/conciliacao/ofx")
if [ "$code" = "200" ] && grep -q '"novos":3' "$BODY"; then echo "OK   [200] Importar OFX de exemplo (3 débitos)"; pass=$((pass+1));
else echo "FAIL [$code] Importar OFX: $(head -c 300 "$BODY")"; fail=$((fail+1)); fi
code=$(curl -s -b "$COOKIE_JAR" -o "$BODY" -w "%{http_code}" -F "empresa_id=$empresa_id" -F "arquivos[]=@$ROOT_DIR/python-worker/tests/exemplo.ofx" "$API_BASE/conciliacao/ofx")
if [ "$code" = "403" ]; then echo "OK   [403] Upload sem CSRF é bloqueado"; pass=$((pass+1)); else echo "FAIL [$code] upload sem CSRF"; fail=$((fail+1)); fi
check "Resumo da conciliação"                 GET  "$API_BASE/conciliacao/resumo" 200
check "Débitos sem boleto"                    GET  "$API_BASE/conciliacao/transacoes?aba=sem" 200
check "Boletos em aberto para ligar"          GET  "$API_BASE/conciliacao/boletos?valor=99" 200
check "Conciliar de novo"                     POST "$API_BASE/conciliacao/executar" 200
check "Empresas com contas bancárias"         GET  "$API_BASE/empresas" 200
grep -q '"conta":"56789-0"' "$BODY" && { echo "OK   conta bancária criada a partir do OFX"; pass=$((pass+1)); } || { echo "FAIL conta bancária não criada"; fail=$((fail+1)); }
[ -n "$empresa_id" ] && check "Excluir empresa de teste" DELETE "$API_BASE/empresas/$empresa_id" 200

# --- v6: rastreador, titular pessoa física (CPF), .zip de OFX sem titular ---
check "CPF inválido é recusado"               POST "$API_BASE/empresas" 422 '{"nome":"Fulano","cnpj":"123.456.789-00"}'
check "Titular pessoa física (CPF)"           POST "$API_BASE/empresas" 200 '{"nome":"Socio Smoke PF","cnpj":"123.456.789-09"}'
pf_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Titulares listam o tipo PF"            GET  "$API_BASE/empresas" 200
grep -q '"tipo":"pf"' "$BODY" && { echo "OK   CPF vira titular pessoa física"; pass=$((pass+1)); } || { echo "FAIL tipo pf"; fail=$((fail+1)); }
ZIPTMP="$(mktemp -d)"
sed -e 's/<BANKID>0341<BRANCHID>1234<ACCTID>56789-0/<BANKID>0260<BRANCHID>0001<ACCTID>4455667-1/' -e 's/<FITID>A/<FITID>SMK/' \
    "$ROOT_DIR/python-worker/tests/exemplo.ofx" > "$ZIPTMP/pf.ofx"
(cd "$ZIPTMP" && python3 -c "import zipfile; z=zipfile.ZipFile('extratos.zip','w'); z.write('pf.ofx'); z.close()")
code=$(curl -s -b "$COOKIE_JAR" -o "$BODY" -w "%{http_code}" -H "X-CSRF-Token: $csrf_token" -F "arquivos[]=@$ZIPTMP/extratos.zip" "$API_BASE/conciliacao/ofx")
if [ "$code" = "200" ] && grep -q '"contas_desconhecidas":\[{' "$BODY"; then echo "OK   [200] .zip sem titular: conta nunca vista volta para escolher o titular"; pass=$((pass+1));
else echo "FAIL [$code] zip sem titular: $(head -c 300 "$BODY")"; fail=$((fail+1)); fi
code=$(curl -s -b "$COOKIE_JAR" -o "$BODY" -w "%{http_code}" -H "X-CSRF-Token: $csrf_token" -F "empresa_id=$pf_id" -F "arquivos[]=@$ZIPTMP/extratos.zip" "$API_BASE/conciliacao/ofx")
if [ "$code" = "200" ] && grep -q '"novos":3' "$BODY"; then echo "OK   [200] .zip com titular PF importado (3 débitos)"; pass=$((pass+1));
else echo "FAIL [$code] zip com titular: $(head -c 300 "$BODY")"; fail=$((fail+1)); fi
code=$(curl -s -b "$COOKIE_JAR" -o "$BODY" -w "%{http_code}" -H "X-CSRF-Token: $csrf_token" -F "arquivos[]=@$ZIPTMP/extratos.zip" "$API_BASE/conciliacao/ofx")
if [ "$code" = "200" ] && grep -q '"contas_desconhecidas":\[\]' "$BODY"; then echo "OK   [200] reenvio sem titular: conta reconhecida sozinha"; pass=$((pass+1));
else echo "FAIL [$code] reconhecer conta: $(head -c 300 "$BODY")"; fail=$((fail+1)); fi
rm -rf "$ZIPTMP"
check "Rastreador: resumo"                    GET  "$API_BASE/rastreador/resumo" 200
grep -q '"cobertura":\[{' "$BODY" && grep -q '"caixas"' "$BODY" && { echo "OK   rastreador mostra a cobertura dos extratos e as caixas"; pass=$((pass+1)); } || { echo "FAIL resumo do rastreador: $(head -c 300 "$BODY")"; fail=$((fail+1)); }
check "Rastreador: lista por situação"        GET  "$API_BASE/rastreador?situacao=vencido_sem_extrato" 200
check "Rastreador: situação desconhecida = tudo" GET "$API_BASE/rastreador?situacao=xpto&de=2020-01-01" 200
curl -s -b "$COOKIE_JAR" -o "$BODY" "$API_BASE/rastreador/exportar"
python3 -c "import zipfile,sys; n=zipfile.ZipFile(sys.argv[1]).namelist(); sys.exit(0 if 'xl/worksheets/sheet2.xml' in n else 1)" "$BODY" \
  && { echo "OK   rastreador exporta Excel (2 abas)"; pass=$((pass+1)); } || { echo "FAIL Excel do rastreador"; fail=$((fail+1)); }
check "Config: histórico e pasta de entrada"  PUT  "$API_BASE/config" 200 '{"historico_auto":"1","historico_minutos":"5","ofx_pasta_entrada":"1","contabilidade_enviar_historico":"0"}'
check "Config: minutos do histórico inválido" PUT  "$API_BASE/config" 422 '{"historico_minutos":"500"}'
[ -n "$pf_id" ] && check "Excluir titular PF de teste" DELETE "$API_BASE/empresas/$pf_id" 200

# --- v7: duplicidades (mesma cobrança em dobro) ---
check "Duplicidades: lista"                   GET  "$API_BASE/duplicidades" 200
check "Lançar cobrança (1a)"                  POST "$API_BASE/lancamentos" 200 "{\"descricao\":\"Fornecedor Duplicado Smoke\",\"valor\":\"777,77\",\"vencimento\":\"$(date -d '+20 days' +%Y-%m-%d)\"}"
dup1=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Lançar a MESMA cobrança (2a)"          POST "$API_BASE/lancamentos" 200 "{\"descricao\":\"Fornecedor Duplicado Smoke\",\"valor\":\"777,77\",\"vencimento\":\"$(date -d '+22 days' +%Y-%m-%d)\"}"
dup2=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Duplicidades: verificar agora"         POST "$API_BASE/duplicidades/verificar" 200
grep -q '"novas":[1-9]' "$BODY" && { echo "OK   cobrança em dobro encontrada"; pass=$((pass+1)); } || { echo "FAIL duplicidade não achada: $(head -c 300 "$BODY")"; fail=$((fail+1)); }
check "Duplicidades: lista em aberto"         GET  "$API_BASE/duplicidades?status=aberta" 200
dup_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
grep -q 'MESMA COBRAN' "$BODY" && grep -q '777,77' "$BODY" && { echo "OK   caso detalhado (tipo e valor)"; pass=$((pass+1)); } || { echo "FAIL detalhes da duplicidade"; fail=$((fail+1)); }
check "Painel mostra a duplicidade"           GET  "$API_BASE/resumo" 200
grep -q '"duplicidades":{"n":[1-9]' "$BODY" && { echo "OK   contador de duplicidades no painel"; pass=$((pass+1)); } || { echo "FAIL contador duplicidades: $(grep -o '"duplicidades":[^}]*}' "$BODY")"; fail=$((fail+1)); }
check "Boleto mostra o aviso de duplicidade"  GET  "$API_BASE/documentos/$dup1" 200
grep -q "\"duplicidade_id\":$dup_id" "$BODY" && { echo "OK   boleto ligado ao caso"; pass=$((pass+1)); } || { echo "FAIL duplicidade_id no boleto"; fail=$((fail+1)); }
check "Resolver sem dizer o que foi feito"    POST "$API_BASE/duplicidades/$dup_id/resolver" 422 '{"decisao":"resolvida"}'
check "Resolver com a providência"            POST "$API_BASE/duplicidades/$dup_id/resolver" 200 '{"decisao":"resolvida","observacao":"2a via cancelada com o fornecedor"}'
# --- v8: nota fiscal do boleto (SEFAZ / NFS-e Nacional) ---
check "Config: busca de notas"                PUT  "$API_BASE/config" 200 '{"nota_busca_auto":"1","nota_prazo_dias":"5","nfe_manifestar_ciencia":"1","nfse_nacional_auto":"1","sefaz_ambiente":"1"}'
check "Config: prazo da nota inválido"        PUT  "$API_BASE/config" 422 '{"nota_prazo_dias":"0"}'
check "Nota: sem NF-e exige o motivo"         POST "$API_BASE/documentos/$dup1/nota" 422 '{"acao":"sem_nfe"}'
check "Nota: boleto válido sem NF-e"          POST "$API_BASE/documentos/$dup1/nota" 200 '{"acao":"sem_nfe","motivo":"aluguel"}'
grep -q '"nota_situacao":"sem_nfe"' "$BODY" && grep -q 'nota_decidida_por_nome' "$BODY" && { echo "OK   decisão registrada com quem decidiu"; pass=$((pass+1)); } || { echo "FAIL sem_nfe: $(head -c 300 "$BODY")"; fail=$((fail+1)); }
check "Filtro: boletos sem NF-e"              GET  "$API_BASE/documentos?grupo=boletos&status=&nota=sem_nfe" 200
grep -q "\"id\":$dup1," "$BODY" && { echo "OK   filtro por situação da nota"; pass=$((pass+1)); } || { echo "FAIL filtro nota"; fail=$((fail+1)); }
check "Nota: verificar com o fornecedor"      POST "$API_BASE/documentos/$dup2/nota" 200 '{"acao":"nao_encontrada","motivo":"pedir ao comercial"}'
check "Painel conta boletos sem nota"         GET  "$API_BASE/resumo" 200
grep -q '"boletos_sem_nota":{"n":[1-9]' "$BODY" && { echo "OK   card de boletos sem nota no painel"; pass=$((pass+1)); } || { echo "FAIL boletos_sem_nota"; fail=$((fail+1)); }
check "Nota: procurar de novo"                POST "$API_BASE/documentos/$dup1/nota" 200 '{"acao":"buscar"}'
check "Nota: ação inválida"                   POST "$API_BASE/documentos/$dup1/nota" 422 '{"acao":"apagar"}'
check "Titular com UF"                        POST "$API_BASE/empresas" 200 '{"nome":"Titular UF Smoke","cnpj":"11.444.777/0001-61","uf":"mg"}'
uf_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Titulares listam UF e certificado"     GET  "$API_BASE/empresas" 200
grep -q '"uf":"MG"' "$BODY" && grep -q '"certificado":null' "$BODY" && { echo "OK   UF gravada e situação do certificado"; pass=$((pass+1)); } || { echo "FAIL uf/certificado"; fail=$((fail+1)); }
[ -n "$uf_id" ] && check "Excluir titular UF" DELETE "$API_BASE/empresas/$uf_id" 200
check "Buscar notas agora (worker)"           POST "$API_BASE/tarefas/buscar-notas" 200
check "Excluir cobrança de teste (1a)"        DELETE "$API_BASE/documentos/$dup1" 200
check "Excluir cobrança de teste (2a)"        DELETE "$API_BASE/documentos/$dup2" 200
# --- Fornecedores ---
check "Criar fornecedor manual"               POST "$API_BASE/fornecedores" 200 '{"nome_identificacao":"Internet loja 2","razao_social":"Net Smoke Ltda","cnpj":"45.723.174/0001-10","telefones":"(35) 3821-0000"}'
forn_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "CNPJ repetido é recusado"              POST "$API_BASE/fornecedores" 422 '{"razao_social":"Outro","cnpj":"45723174000110"}'
check "Completar cadastro (contrato, CEP)"    PUT  "$API_BASE/fornecedores/$forn_id" 200 '{"contrato":"Código do cliente: 998877","cep":"37200000","uf":"mg"}'
grep -q '"cep":"37200-000"' "$BODY" && grep -q '"contrato":"manual"' "$BODY" && { echo "OK   CEP formatado e campo marcado como manual"; pass=$((pass+1)); } || { echo "FAIL edição de fornecedor: $(head -c 300 "$BODY")"; fail=$((fail+1)); }
check "CEP inválido é recusado"               PUT  "$API_BASE/fornecedores/$forn_id" 422 '{"cep":"123"}'
check "Listar fornecedores"                   GET  "$API_BASE/fornecedores?busca=998877" 200
grep -q "Internet loja 2" "$BODY" && { echo "OK   busca pelo contrato encontra o cadastro"; pass=$((pass+1)); } || { echo "FAIL busca fornecedor"; fail=$((fail+1)); }
check "Atualizar a partir dos documentos"     POST "$API_BASE/fornecedores/sincronizar" 200
check "Excluir fornecedor"                    DELETE "$API_BASE/fornecedores/$forn_id" 200


# --- Papéis, lançamento manual com aprovação de outra pessoa ---
check "Criar usuário operador"                POST "$API_BASE/usuarios" 200 '{"username":"smoke-operador","nome":"Operador","papel":"operador","senha":"operador-smoke-123"}'
op_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Criar usuário financeiro"              POST "$API_BASE/usuarios" 200 '{"username":"smoke-financeiro","nome":"Financeiro","papel":"financeiro","senha":"financeiro-smoke-123"}'
fin_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Senha fraca é recusada"                POST "$API_BASE/usuarios" 422 '{"username":"fraco","papel":"leitura","senha":"123"}'
check "Criar categoria"                       POST "$API_BASE/categorias" 200 '{"nome":"Smoke - despesas"}'
cat_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
venc=$(date -d "+5 days" +%Y-%m-%d)

# Sessão do operador (outro "navegador").
JAR2="$(mktemp)"; trap 'rm -f "$COOKIE_JAR" "$BODY" "$JAR2"' EXIT
login2=$(curl -s -c "$JAR2" -X POST -H "Content-Type: application/json" -d '{"username":"smoke-operador","password":"operador-smoke-123"}' "$API_BASE/auth/login")
csrf2=$(echo "$login2" | grep -o '"csrf_token":"[^"]*"' | cut -d'"' -f4)
op() { curl -s -b "$JAR2" -c "$JAR2" -o "$BODY" -w "%{http_code}" -X "$1" -H "X-CSRF-Token: $csrf2" -H "Content-Type: application/json" ${3:+-d "$3"} "$2"; }
code=$(op POST "$API_BASE/lancamentos" "{\"descricao\":\"Aluguel smoke\",\"valor\":\"1.234,56\",\"vencimento\":\"$venc\",\"categoria_id\":$cat_id}")
lanc_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
if [ "$code" = "200" ] && grep -q '"aprovacao":"aguardando"' "$BODY" && grep -q '"valor_centavos":123456' "$BODY"; then echo "OK   operador lança conta (aguardando aprovação, 123456 centavos)"; pass=$((pass+1)); else echo "FAIL lançamento: $code $(head -c 300 "$BODY")"; fail=$((fail+1)); fi
code=$(op PUT "$API_BASE/documentos/$lanc_id" '{"status":"pago"}')
[ "$code" = "403" ] && { echo "OK   [403] operador não pode marcar pago"; pass=$((pass+1)); } || { echo "FAIL operador marcou pago ($code)"; fail=$((fail+1)); }
code=$(op GET "$API_BASE/usuarios")
[ "$code" = "403" ] && { echo "OK   [403] operador não vê usuários"; pass=$((pass+1)); } || { echo "FAIL operador viu usuários ($code)"; fail=$((fail+1)); }
op POST "$API_BASE/auth/logout" >/dev/null

check "Admin aprova o lançamento do operador" POST "$API_BASE/documentos/$lanc_id/aprovar-pagamento" 200
check "Admin lança e tenta aprovar o próprio" POST "$API_BASE/lancamentos" 200 "{\"descricao\":\"DAS smoke\",\"valor\":\"500\",\"vencimento\":\"$venc\"}"
lanc2=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Quem lançou não aprova o próprio"      POST "$API_BASE/documentos/$lanc2/aprovar-pagamento" 422
check "Não marca pago antes de aprovar"       PUT  "$API_BASE/documentos/$lanc2" 422 '{"status":"pago"}'
# --- Vários CNPJs: empresa, conta bancária e de qual conta saiu o pagamento ---
check "Criar empresa (CNPJ) para o teste"     POST "$API_BASE/empresas" 200 '{"nome":"Smoke Matriz","cnpj":"11.222.333/0001-81"}'
emp_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Cadastrar conta bancária à mão"        POST "$API_BASE/contas-bancarias" 200 "{\"empresa_id\":$emp_id,\"banco_codigo\":\"341\",\"agencia\":\"1234\",\"conta\":\"56789-0\",\"apelido\":\"Itaú smoke\"}"
cb_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Conta duplicada é recusada"            POST "$API_BASE/contas-bancarias" 422 "{\"empresa_id\":$emp_id,\"banco_codigo\":\"341\",\"agencia\":\"1234\",\"conta\":\"56789-0\"}"
check "Listar contas bancárias"               GET  "$API_BASE/contas-bancarias" 200
check "Marcar pago informando a conta"        PUT  "$API_BASE/documentos/$lanc_id" 200 "{\"status\":\"pago\",\"pago_conta_id\":$cb_id}"
if grep -q '"pago_conta_apelido":"Itaú smoke"' "$BODY" && grep -q '"pago_empresa_nome":"Smoke Matriz"' "$BODY"; then echo "OK   boleto mostra a conta e a empresa que pagaram"; pass=$((pass+1)); else echo "FAIL conta pagadora: $(head -c 300 "$BODY")"; fail=$((fail+1)); fi
check "Filtrar boletos pela conta que pagou"  GET  "$API_BASE/documentos?grupo=boletos&status=pago&pago_conta=$cb_id" 200
grep -q "\"id\":$lanc_id," "$BODY" && { echo "OK   filtro por conta pagadora"; pass=$((pass+1)); } || { echo "FAIL filtro pago_conta"; fail=$((fail+1)); }
grep -q '"pago_por_nome":"admin"' "$BODY" && { echo "OK   registra quem deu baixa"; pass=$((pass+1)); } || { echo "FAIL pago_por: $(head -c 200 "$BODY")"; fail=$((fail+1)); }

# --- Recorrentes, relatórios e Excel ---
check "Criar conta recorrente manual"         POST "$API_BASE/recorrentes" 200 '{"nome":"Folha smoke","modo":"manual","dia_vencimento":5,"valor_estimado":"8000,00","categoria_id":'"$cat_id"'}'
rec_id=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
check "Recorrente por e-mail sem fornecedor é recusada" POST "$API_BASE/recorrentes" 422 '{"nome":"X","modo":"email","dia_vencimento":10}'
check "Listar recorrentes"                    GET  "$API_BASE/recorrentes" 200
check "Sugestões de recorrentes"              GET  "$API_BASE/recorrentes/sugestoes" 200
check "Verificar recorrentes agora"           POST "$API_BASE/recorrentes/verificar" 200
check "Relatório de despesas por categoria"   GET  "$API_BASE/relatorios/despesas?agrupar=categoria" 200
grep -q "Smoke - despesas" "$BODY" && { echo "OK   lançamento aparece na categoria"; pass=$((pass+1)); } || { echo "FAIL relatório: $(head -c 300 "$BODY")"; fail=$((fail+1)); }
check "Fluxo de caixa 8 semanas"              GET  "$API_BASE/relatorios/fluxo?semanas=8" 200
hdr=$(curl -s -b "$COOKIE_JAR" -D - -o "$BODY" "$API_BASE/relatorios/exportar?tipo=despesas")
if head -c 2 "$BODY" | grep -q "PK" && echo "$hdr" | grep -qi "content-disposition: attachment"; then echo "OK   exportar Excel (.xlsx, download)"; pass=$((pass+1)); else echo "FAIL exportar xlsx"; fail=$((fail+1)); fi
check "Suspeitos (lista)"                     GET  "$API_BASE/documentos?grupo=boletos&suspeitos=1" 200
check "Auditoria registra as ações"           GET  "$API_BASE/auditoria?acao=lancamento" 200
grep -q "lancamento.aprovado" "$BODY" && { echo "OK   auditoria tem a aprovação"; pass=$((pass+1)); } || { echo "FAIL auditoria"; fail=$((fail+1)); }
check "Lista de backups"                      GET  "$API_BASE/backups" 200
echo "$hdr" | grep -qi "x-content-type-options: nosniff" && { echo "OK   cabeçalho nosniff"; pass=$((pass+1)); } || { echo "FAIL sem nosniff"; fail=$((fail+1)); }

# --- Excel: texto vindo de fora que parece fórmula fica como TEXTO ---
check "Lançar conta com nome '=1+1'"          POST "$API_BASE/lancamentos" 200 "{\"descricao\":\"=1+1\",\"valor\":\"10\",\"vencimento\":\"$venc\"}"
lanc3=$(grep -o '"id":[0-9]*' "$BODY" | head -1 | cut -d: -f2)
curl -s -b "$COOKIE_JAR" -o "$BODY" "$API_BASE/relatorios/exportar?tipo=contas"
if python3 -c "
import zipfile,sys,re; x=zipfile.ZipFile(sys.argv[1]).read('xl/worksheets/sheet1.xml').decode()
c=re.search(r'<c [^>]*>(?:(?!</c>).)*=1\+1', x); sys.exit(0 if c and 's=\"4\"' in c.group(0) and 'inlineStr' in c.group(0) else 1)" "$BODY"; then
  echo "OK   '=1+1' exportado como texto (não vira fórmula)"; pass=$((pass+1)); else echo "FAIL injeção de fórmula no Excel"; fail=$((fail+1)); fi
check "Excluir lançamento '=1+1'"             DELETE "$API_BASE/documentos/$lanc3" 200
curl -s -b "$COOKIE_JAR" -o "$BODY" "$API_BASE/relatorios/exportar?tipo=piloto"
python3 -c "import zipfile,sys; n=zipfile.ZipFile(sys.argv[1]).namelist(); sys.exit(0 if 'xl/worksheets/sheet3.xml' in n else 1)" "$BODY" \
  && { echo "OK   planilha do piloto (3 abas)"; pass=$((pass+1)); } || { echo "FAIL planilha do piloto"; fail=$((fail+1)); }
check "Despesas por conta bancária que pagou" GET  "$API_BASE/relatorios/despesas?agrupar=conta" 200
grep -q "Smoke Matriz" "$BODY" && { echo "OK   relatório mostra a conta pagadora"; pass=$((pass+1)); } || { echo "FAIL relatório por conta"; fail=$((fail+1)); }

# --- Aprovação própria: desligada por padrão ---
check "Configuração: aprovação própria desligada" GET "$API_BASE/config" 200
grep -q '"permitir_aprovacao_propria":"0"' "$BODY" && { echo "OK   aprovação própria vem desligada"; pass=$((pass+1)); } || { echo "FAIL aprovação própria"; fail=$((fail+1)); }
grep -q '"smtp_senha_cifrada"' "$BODY" && { echo "FAIL senha SMTP vazou para a tela"; fail=$((fail+1)); } || { echo "OK   senha SMTP nunca volta para a tela"; pass=$((pass+1)); }
check "Salvar e-mail de alerta e SMTP"        PUT  "$API_BASE/config" 200 '{"email_alertas_para":"alertas@exemplo.com.br","smtp_host":"smtp.exemplo.com.br","smtp_porta":"587","smtp_senha":"segredo-smtp-123"}'
grep -q '"smtp_senha_configurada":"1"' "$BODY" && ! grep -q "segredo-smtp-123" "$BODY" && { echo "OK   senha SMTP guardada cifrada"; pass=$((pass+1)); } || { echo "FAIL senha SMTP"; fail=$((fail+1)); }
check "E-mail de alerta inválido é recusado"  PUT  "$API_BASE/config" 422 '{"email_alertas_para":"nao-e-email"}'

# --- 2FA (código calculado aqui mesmo, como o app do celular faria) ---
check "Iniciar 2FA"                           POST "$API_BASE/auth/2fa/iniciar" 200
segredo=$(grep -o '"segredo":"[^"]*"' "$BODY" | cut -d'"' -f4 | tr -d ' ')
codigo=$(python3 -c "
import base64,hmac,hashlib,struct,time,sys
k=base64.b32decode(sys.argv[1]+'='*(-len(sys.argv[1])%8)); h=hmac.new(k,struct.pack('>Q',int(time.time())//30),hashlib.sha1).digest()
o=h[19]&15; print('%06d'%((struct.unpack('>I',h[o:o+4])[0]&0x7fffffff)%1000000))" "$segredo")
check "Código errado não ativa o 2FA"         POST "$API_BASE/auth/2fa/ativar" 422 '{"codigo":"000000"}'
check "Ativar 2FA com o código do app"        POST "$API_BASE/auth/2fa/ativar" 200 "{\"codigo\":\"$codigo\"}"
JAR3="$(mktemp)"
r=$(curl -s -c "$JAR3" -b "$JAR3" -X POST -H "Content-Type: application/json" -d "{\"username\":\"$LOGIN_USER\",\"password\":\"$LOGIN_PASS\"}" "$API_BASE/auth/login")
echo "$r" | grep -q precisa_2fa && { echo "OK   login pede o código do 2FA"; pass=$((pass+1)); } || { echo "FAIL 2FA no login: $r"; fail=$((fail+1)); }
r=$(curl -s -c "$JAR3" -b "$JAR3" -o /dev/null -w "%{http_code}" "$API_BASE/resumo")
[ "$r" = "401" ] && { echo "OK   [401] sem o código, continua sem acesso"; pass=$((pass+1)); } || { echo "FAIL acesso sem 2FA ($r)"; fail=$((fail+1)); }
rm -f "$JAR3"
check "Desativar 2FA (com a senha)"           POST "$API_BASE/auth/2fa/desativar" 200 "{\"senha\":\"$LOGIN_PASS\"}"

# Limpeza
[ -n "$rec_id" ] && check "Excluir recorrente" DELETE "$API_BASE/recorrentes/$rec_id" 200
check "Boleto PAGO não pode ser excluído (guarda fiscal de 5 anos)" DELETE "$API_BASE/documentos/$lanc_id" 422
grep -q "5 anos" "$BODY" && { echo "OK   mensagem do prazo fiscal"; pass=$((pass+1)); } || { echo "FAIL msg 5 anos"; fail=$((fail+1)); }
check "Excluir lançamento pendente de teste"  DELETE "$API_BASE/documentos/$lanc2" 200
[ -n "$op_id" ] && check "Desativar operador" PUT "$API_BASE/usuarios/$op_id" 200 '{"ativo":false}'
[ -n "$fin_id" ] && check "Desativar financeiro" PUT "$API_BASE/usuarios/$fin_id" 200 '{"ativo":false}'
[ -n "$cat_id" ] && check "Excluir categoria" DELETE "$API_BASE/categorias/$cat_id" 200
check "Limpar SMTP de teste"                  PUT  "$API_BASE/config" 200 '{"email_alertas_para":"","smtp_host":""}'

check "Logout"                                POST "$API_BASE/auth/logout" 200
check "Depois do logout, bloqueia de novo"    GET  "$API_BASE/resumo" 401

echo
echo "Resultado: $pass ok, $fail falha(s)"
[ "$fail" -eq 0 ]
