server.py

# SGEA v0.35.14 — Servidor local: SQLite, autenticação, REST API, controle de estoque por lote (FEFO), backup automático
import http.server
import os
import json
import sqlite3
import hashlib
import ssl
import smtplib
import threading
import time
import subprocess
import sys
import urllib.request
import urllib.error
import uuid
import re
import csv
import io
import base64
import zipfile
import unicodedata
from xml.etree import ElementTree as ET
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from urllib.parse import urlparse, parse_qs

import sgx_base

# Windows: console pode usar cp1252/cp850 em vez de UTF-8, quebrando prints
# com caracteres especiais (╔═╗, emojis). Força UTF-8 para evitar UnicodeEncodeError.
for _stream in (sys.stdout, sys.stderr):
    if hasattr(_stream, 'reconfigure'):
        try:
            _stream.reconfigure(encoding='utf-8', errors='replace')
        except Exception:
            pass

# Versão do servidor — DEVE acompanhar o SGEA_VERSION do SGEA.html a cada release.
# Exposta em /health para o frontend detectar quando o processo em execução está
# desatualizado (HTML novo servido, mas server.py antigo ainda rodando em memória).
SERVER_VERSION = '0.36.0'

PORT        = int(os.environ.get('SGEA_PORT', 3003))
_BASE       = os.path.dirname(os.path.abspath(__file__))
# SGEA_DATA_DIR: usado pelos testes E2E para isolar banco/backups do sgea.db
# real sem precisar rodar o servidor a partir de outra pasta (os arquivos
# estáticos como SGEA.html continuam servidos a partir de _BASE).
_DATA_DIR   = os.environ.get('SGEA_DATA_DIR', _BASE)
DB_PATH     = os.path.join(_DATA_DIR, 'sgea.db')
BACKUP_DIR  = os.path.join(_DATA_DIR, 'backups')
# Perfil do navegador em %TEMP%, como nos irmaos: dentro da pasta do sistema
# ele inchava para gigabytes e ia junto em qualquer copia da pasta.
PROFILE_DIR = os.path.join(os.environ.get('TEMP', os.path.expanduser('~')), 'SGEA-Profile')
BACKUP_KEEP = 7      # número de backups automáticos mantidos
SESSION_TTL = 60     # renovado pelo ping a cada 5s (ver comentário em _watchdog mais abaixo)

# Motor de erros da família (log rotativo UTF-8 + classificação) — ver sgx_base.
_log = sgx_base.configurar_log('SGEA', _DATA_DIR)

os.chdir(_BASE)

_watchdog_paused  = False   # pausa o watchdog durante diálogos bloqueantes (ex: FolderBrowser)
_had_session      = False   # True após primeiro login; controla quando o backup pós-sessão pode disparar
_backup_pos_sess  = False   # True = backup pós-sessão já executado; aguarda nova sessão para resetar
_last_trash_purge = 0       # time.time() da última purga da lixeira (roda no máx. 1x/hora)
TRASH_RETENTION_DIAS = 30   # dias até um registro na lixeira ser apagado de vez

# ── Banco de dados ────────────────────────────────────────────────────────────

# Alias de compatibilidade: _ConnAutoClose é referenciada diretamente em vários
# pontos além de get_db() (backup manual, restore, integrity check) — manter o
# nome em vez de caçar cada call site.
_ConnAutoClose = sgx_base.ConnAutoClose

def get_db():
    return sgx_base.connect_db(DB_PATH)

# Ficha de manutenção do veículo: ano + catálogo de peças por veículo.
# Ordem = ordem das colunas na planilha "CONTROLE DE FROTA" (usada na migração,
# no CRUD e no importador). Todas TEXT, valor livre (referências cruzadas de marcas).
FROTA_PECAS_COLS = (
    'ano',
    'filtro_ar_cabine', 'filtro_ar_motor', 'filtro_ar_primario', 'filtro_ar_secundario',
    'filtro_combustivel', 'filtro_sedimentador', 'filtro_lubrificante', 'filtro_desumidificador',
    'filtro_hidraulico', 'filtro_transmissao', 'filtro_ureia',
    'oleo_motor', 'oleo_transmissao', 'bateria', 'pneu_dianteiro', 'pneu_traseiro',
)

# Identificação oficial do veículo (vinda do Fiorilli, consolidada na planilha
# CONTROLE DE FROTA). Também TEXT/valor livre. Separada das peças de propósito:
# os relatórios de pendência olham só as peças, não estes campos.
FROTA_DOC_COLS = (
    'renavam', 'chassi', 'cor', 'km_atual', 'categoria_cnh',
    'especie_tce', 'potencia_cilindrada', 'lotacao', 'situacao', 'observacao',
)

def init_db():
    with get_db() as conn:
        conn.executescript('''
            CREATE TABLE IF NOT EXISTS usuarios (
                id         INTEGER PRIMARY KEY AUTOINCREMENT,
                username   TEXT NOT NULL UNIQUE COLLATE NOCASE,
                nome       TEXT NOT NULL,
                senha_hash TEXT NOT NULL,
                admin      INTEGER DEFAULT 0,
                ativo      INTEGER DEFAULT 1,
                must_change_password INTEGER DEFAULT 0,
                criado_em  TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime'))
            );
            CREATE TABLE IF NOT EXISTS sessions (
                token   TEXT PRIMARY KEY,
                user_id INTEGER NOT NULL REFERENCES usuarios(id) ON DELETE CASCADE,
                expires REAL NOT NULL
            );
            CREATE TABLE IF NOT EXISTS audit_global (
                id TEXT PRIMARY KEY, ts TEXT NOT NULL, user_id INTEGER, user_nome TEXT,
                type TEXT, label TEXT, detail TEXT, process_id TEXT, process_obj TEXT
            );
            CREATE TABLE IF NOT EXISTS sys_settings (
                key TEXT PRIMARY KEY, value TEXT
            );

            CREATE TABLE IF NOT EXISTS centros_custo (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                codigo TEXT UNIQUE,
                nome TEXT NOT NULL,
                ativo INTEGER DEFAULT 1,
                created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime')),
                updated_at TEXT
            );
            CREATE TABLE IF NOT EXISTS fornecedores (
                id TEXT PRIMARY KEY,
                cnpj TEXT UNIQUE,
                razao_social TEXT NOT NULL,
                nome_fantasia TEXT,
                telefone TEXT,
                email TEXT,
                ativo INTEGER DEFAULT 1,
                created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime')),
                updated_at TEXT
            );
            CREATE TABLE IF NOT EXISTS funcionarios (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                nome TEXT NOT NULL,
                cargo TEXT,
                unidade TEXT,
                matricula TEXT,
                ativo INTEGER DEFAULT 1,
                created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime')),
                updated_at TEXT
            );
            CREATE TABLE IF NOT EXISTS frota (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                numero TEXT UNIQUE,
                placa TEXT,
                marca TEXT,
                modelo TEXT,
                combustivel TEXT,
                centro_custo_id INTEGER REFERENCES centros_custo(id),
                ativo INTEGER DEFAULT 1,
                created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime')),
                updated_at TEXT
            );
            CREATE TABLE IF NOT EXISTS produtos (
                id TEXT PRIMARY KEY,
                codigo_fiorilli TEXT NOT NULL UNIQUE,
                nome TEXT NOT NULL,
                centro_custo_id INTEGER REFERENCES centros_custo(id),
                unidade_licitada TEXT,
                qtd_por_embalagem INTEGER NOT NULL DEFAULT 1,
                unidade_consumo TEXT NOT NULL DEFAULT 'UN',
                situacao_licitacao TEXT,
                codigo_licitacao TEXT,
                objeto_licitacao TEXT,
                ativo INTEGER DEFAULT 1,
                created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime')),
                updated_at TEXT
            );
            CREATE TABLE IF NOT EXISTS pedidos (
                id TEXT PRIMARY KEY,
                numero TEXT NOT NULL,
                codigo_licitacao TEXT,
                data_pedido TEXT,
                fornecedor_id TEXT REFERENCES fornecedores(id),
                status TEXT DEFAULT 'aberto',
                created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime')),
                updated_at TEXT,
                UNIQUE(numero, codigo_licitacao)
            );
            CREATE TABLE IF NOT EXISTS entradas (
                id TEXT PRIMARY KEY,
                pedido_id TEXT REFERENCES pedidos(id),
                tipo TEXT NOT NULL DEFAULT 'pedido' CHECK(tipo IN ('pedido','compra_direta')),
                fornecedor_id TEXT REFERENCES fornecedores(id),
                nfe_numero TEXT,
                nfe_chave_acesso TEXT,
                data_entrega TEXT NOT NULL,
                recebedor_id INTEGER REFERENCES funcionarios(id),
                centro_custo_id INTEGER REFERENCES centros_custo(id),
                observacao TEXT,
                created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime')),
                created_by INTEGER REFERENCES usuarios(id),
                updated_at TEXT,
                deleted_at TEXT
            );
            CREATE TABLE IF NOT EXISTS entrada_itens (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                entrada_id TEXT NOT NULL REFERENCES entradas(id) ON DELETE CASCADE,
                produto_id TEXT NOT NULL REFERENCES produtos(id),
                quantidade_embalagem REAL,
                quantidade_unidades INTEGER NOT NULL,
                valor_unitario REAL NOT NULL,
                valor_total REAL NOT NULL,
                lote_numero TEXT,
                data_validade TEXT
            );
            CREATE TABLE IF NOT EXISTS pedido_itens (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                pedido_id TEXT NOT NULL REFERENCES pedidos(id) ON DELETE CASCADE,
                produto_id TEXT NOT NULL REFERENCES produtos(id),
                quantidade_pedida INTEGER NOT NULL CHECK(quantidade_pedida > 0),
                quantidade_anulada INTEGER NOT NULL DEFAULT 0,
                UNIQUE(pedido_id, produto_id)
            );
            CREATE TABLE IF NOT EXISTS lotes (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                produto_id TEXT NOT NULL REFERENCES produtos(id),
                lote_numero TEXT,
                data_validade TEXT,
                quantidade_recebida INTEGER NOT NULL,
                quantidade_atual INTEGER NOT NULL CHECK(quantidade_atual >= 0),
                valor_unitario_custo REAL NOT NULL DEFAULT 0,
                entrada_item_id INTEGER REFERENCES entrada_itens(id),
                created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime'))
            );
            CREATE INDEX IF NOT EXISTS idx_lotes_produto_validade ON lotes(produto_id, data_validade);

            CREATE TABLE IF NOT EXISTS saidas (
                id TEXT PRIMARY KEY,
                data TEXT NOT NULL,
                solicitante_id INTEGER REFERENCES funcionarios(id),
                solicitante_nome TEXT,
                solicitante_cargo TEXT,
                centro_custo_id INTEGER REFERENCES centros_custo(id),
                frota_id INTEGER REFERENCES frota(id),
                numero_solicitacao TEXT,
                observacao TEXT,
                created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%S','now','localtime')),
                created_by INTEGER REFERENCES usuarios(id),
                deleted_at TEXT
            );
            CREATE TABLE IF NOT EXISTS saida_itens (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                saida_id TEXT NOT NULL REFERENCES saidas(id) ON DELETE CASCADE,
                produto_id TEXT NOT NULL REFERENCES produtos(id),
                quantidade INTEGER NOT NULL CHECK(quantidade > 0),
                valor_unitario_medio REAL NOT NULL,
                valor_total REAL NOT NULL
            );
            CREATE TABLE IF NOT EXISTS saida_item_lotes (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                saida_item_id INTEGER NOT NULL REFERENCES saida_itens(id) ON DELETE CASCADE,
                lote_id INTEGER NOT NULL REFERENCES lotes(id),
                quantidade INTEGER NOT NULL CHECK(quantidade > 0),
                valor_unitario_custo REAL NOT NULL
            );

            CREATE INDEX IF NOT EXISTS idx_entradas_deleted ON entradas(deleted_at);
            CREATE INDEX IF NOT EXISTS idx_saidas_deleted ON saidas(deleted_at);
            CREATE INDEX IF NOT EXISTS idx_produtos_ativo ON produtos(ativo);
        ''')
        cols_usu = [r[1] for r in conn.execute('PRAGMA table_info(usuarios)').fetchall()]
        if 'cpf' not in cols_usu: conn.execute("ALTER TABLE usuarios ADD COLUMN cpf TEXT DEFAULT ''")
        if 'email' not in cols_usu: conn.execute("ALTER TABLE usuarios ADD COLUMN email TEXT DEFAULT ''")
        if 'cargo' not in cols_usu: conn.execute("ALTER TABLE usuarios ADD COLUMN cargo TEXT DEFAULT ''")
        if 'matricula' not in cols_usu: conn.execute("ALTER TABLE usuarios ADD COLUMN matricula TEXT DEFAULT ''")
        # Config SMTP por usuário (vazio = herda a do sistema em sys_settings) — paridade com SGCD/SGCA/SGDP
        for _sc in _USER_SMTP_COLS:
            if _sc not in cols_usu: conn.execute(f"ALTER TABLE usuarios ADD COLUMN {_sc} TEXT DEFAULT ''")

        # Dados extras do funcionário vindos da folha do Fiorilli (natureza/forma de
        # provimento do cargo, data e ato de admissão) — usados no cadastro e no import.
        cols_func = [r[1] for r in conn.execute('PRAGMA table_info(funcionarios)').fetchall()]
        for _fc in ('natureza', 'forma_provimento', 'data_admissao', 'ato_admissao'):
            if _fc not in cols_func: conn.execute(f"ALTER TABLE funcionarios ADD COLUMN {_fc} TEXT DEFAULT ''")

        # Ficha de manutenção do veículo (ano + catálogo de peças por veículo:
        # filtros, óleos, bateria, pneus — referências cruzadas entre marcas).
        cols_frota = [r[1] for r in conn.execute('PRAGMA table_info(frota)').fetchall()]
        for _vc in FROTA_PECAS_COLS + FROTA_DOC_COLS:
            if _vc not in cols_frota: conn.execute(f"ALTER TABLE frota ADD COLUMN {_vc} TEXT DEFAULT ''")

        # Campos da entrada alinhados ao Fiorilli: nº e data da requisição, e o tipo
        # de entrada do Fiorilli (TPREQUI, ex. "OUTRA"). Usados também pela importação.
        cols_ent = [r[1] for r in conn.execute('PRAGMA table_info(entradas)').fetchall()]
        for _ec in ('requisicao', 'data_requisicao', 'tipo_fiorilli'):
            if _ec not in cols_ent: conn.execute(f"ALTER TABLE entradas ADD COLUMN {_ec} TEXT DEFAULT ''")
        # Origem da entrada: '' (manual), 'reconciliacao' (saldo inicial do bootstrap) ou
        # 'fiorilli' (import de entradas). tipo (pedido/compra_direta) tem CHECK e não
        # comporta valor novo sem rebuild — origem é uma coluna à parte. Backfill das já
        # criadas pelo texto da observação.
        if 'origem' not in cols_ent:
            conn.execute("ALTER TABLE entradas ADD COLUMN origem TEXT DEFAULT ''")
            conn.execute("UPDATE entradas SET origem='reconciliacao' WHERE (origem IS NULL OR origem='') AND observacao LIKE 'Saldo inicial%'")
            conn.execute("UPDATE entradas SET origem='fiorilli' WHERE (origem IS NULL OR origem='') AND observacao LIKE 'Importado do Fiorilli%'")

        # Origem da saída: '' (manual) ou 'fiorilli' (import de requisições de saída).
        cols_sai = [r[1] for r in conn.execute('PRAGMA table_info(saidas)').fetchall()]
        if 'origem' not in cols_sai:
            conn.execute("ALTER TABLE saidas ADD COLUMN origem TEXT DEFAULT ''")

        # Campos do pedido que o Fiorilli exporta: previsão de entrega (DATENT), e por
        # item o valor unitário arrematado (PRCUNT) e a marca vencedora (MARCA).
        # origem: '' (manual) ou 'fiorilli' (import de pedidos).
        cols_ped = [r[1] for r in conn.execute('PRAGMA table_info(pedidos)').fetchall()]
        for _pc in ('data_entrega_prevista', 'origem'):
            if _pc not in cols_ped: conn.execute(f"ALTER TABLE pedidos ADD COLUMN {_pc} TEXT DEFAULT ''")
        cols_pi = [r[1] for r in conn.execute('PRAGMA table_info(pedido_itens)').fetchall()]
        if 'valor_unitario' not in cols_pi:
            conn.execute("ALTER TABLE pedido_itens ADD COLUMN valor_unitario REAL DEFAULT 0")
        if 'marca' not in cols_pi:
            conn.execute("ALTER TABLE pedido_itens ADD COLUMN marca TEXT DEFAULT ''")

        # Responsável e e-mail do centro de custo (vêm do cadastro do Fiorilli).
        cols_cc = [r[1] for r in conn.execute('PRAGMA table_info(centros_custo)').fetchall()]
        for _cc in ('responsavel', 'email'):
            if _cc not in cols_cc: conn.execute(f"ALTER TABLE centros_custo ADD COLUMN {_cc} TEXT DEFAULT ''")

        cols_forn = [r[1] for r in conn.execute('PRAGMA table_info(fornecedores)').fetchall()]
        if 'data' not in cols_forn:
            # Reescrita rica do fornecedor (paridade com SGCD): schema vira id/data(JSON)/
            # cnpj/razao_social/updated_at/deleted_at. Precisa recriar a tabela (não dá pra
            # só ADD COLUMN) porque o UNIQUE em cnpj tem que sair — com ele, o INSERT OR
            # REPLACE usado no upsert por CNPJ casaria por QUALQUER coluna UNIQUE/PK, podendo
            # apagar silenciosamente uma linha errada casada pelo cnpj em vez do id (o SGCD
            # nunca teve esse UNIQUE por isso). Constrói a substituta sob nome temporário e só
            # DEPOIS derruba a original e renomeia (ver [[feedback_sqlite_fk_rename_migration]])
            # — nunca renomear a original primeiro: o SQLite reescreve silenciosamente o
            # REFERENCES fornecedores(id) de pedidos/entradas para apontar pro nome novo,
            # deixando esses FKs órfãos assim que a tabela temporária é derrubada.
            old_rows = conn.execute('SELECT * FROM fornecedores').fetchall()
            conn.execute('''
                CREATE TABLE fornecedores_new (
                    id TEXT PRIMARY KEY,
                    data TEXT NOT NULL,
                    cnpj TEXT,
                    razao_social TEXT,
                    updated_at TEXT,
                    deleted_at TEXT
                )
            ''')
            for r in old_rows:
                blob = {
                    'id': r['id'], 'cnpj': r['cnpj'], 'razao_social': r['razao_social'],
                    'nome_fantasia': r['nome_fantasia'], 'telefone': r['telefone'],
                    'email': r['email'], 'ativo': r['ativo'], 'updatedAt': _now_precise(),
                }
                conn.execute(
                    'INSERT INTO fornecedores_new (id,data,cnpj,razao_social,updated_at,deleted_at) VALUES (?,?,?,?,?,NULL)',
                    (r['id'], json.dumps(blob, ensure_ascii=False), r['cnpj'], r['razao_social'], blob['updatedAt'])
                )
            conn.execute('DROP TABLE fornecedores')
            conn.execute('ALTER TABLE fornecedores_new RENAME TO fornecedores')
        conn.execute('CREATE INDEX IF NOT EXISTS idx_forn_cnpj ON fornecedores(cnpj)')
        conn.execute('CREATE INDEX IF NOT EXISTS idx_forn_deleted ON fornecedores(deleted_at)')

        conn.execute('''
            CREATE VIEW IF NOT EXISTS v_estoque AS
            SELECT p.id AS produto_id,
                   COALESCE(SUM(l.quantidade_atual), 0) AS estoque_fisico,
                   COALESCE(SUM(l.quantidade_atual * l.valor_unitario_custo), 0) AS estoque_financeiro,
                   MIN(CASE WHEN l.quantidade_atual > 0 THEN l.data_validade END) AS proxima_validade
            FROM produtos p LEFT JOIN lotes l ON l.produto_id = p.id
            GROUP BY p.id
        ''')
        # Sessões são descartadas a cada início do servidor (logout automático ao fechar janela)
        conn.execute('DELETE FROM sessions')
        conn.executemany('INSERT OR IGNORE INTO sys_settings VALUES (?,?)', [
            ('orgao', ''), ('municipio', ''), ('cnpj_orgao', ''), ('aut_nome', ''), ('aut_cargo', ''),
            ('backup_path', BACKUP_DIR),
            ('auto_backup_enabled', '1'),
            ('auto_backup_keep', str(BACKUP_KEEP)),
            ('smtp_host', ''), ('smtp_port', '587'), ('smtp_user', ''), ('smtp_pass', ''),
            ('smtp_secure', '0'), ('smtp_require_tls', '1'), ('smtp_ignore_ssl', '0'),
            ('smtp_from_name', ''), ('smtp_to', ''),
        ])
        conn.commit()
        if conn.execute('SELECT COUNT(*) FROM usuarios').fetchone()[0] == 0:
            conn.execute(
                'INSERT INTO usuarios (username,nome,senha_hash,admin,must_change_password) VALUES (?,?,?,1,1)',
                ('admin', 'Administrador', _hash_password('admin123'))
            )
            conn.commit()
            print('Usuário padrão criado: admin / admin123 — troque a senha no primeiro acesso.')
        if sgx_base.marcar_senha_padrao(conn):
            print('Atenção: há conta com a senha padrão — o sistema exigirá a troca no próximo acesso.')

# ── Segurança ─────────────────────────────────────────────────────────────────

_hash_password   = sgx_base.hash_password
_verify_password = sgx_base.verify_password

# ── Rate limit de login ─────────────────────────────────────────────────────
LOGIN_MAX_ATTEMPTS   = 5
LOGIN_LOCKOUT_WINDOW = 300   # 5 min — janela deslizante de tentativas falhas
_rate_limiter = sgx_base.LoginRateLimiter(LOGIN_MAX_ATTEMPTS, LOGIN_LOCKOUT_WINDOW)
_login_rate_limited   = _rate_limiter.is_locked
_record_login_failure = _rate_limiter.record_failure
_clear_login_failures  = _rate_limiter.clear

# create_session/delete_session/renew_session/active_sessions delegam pro
# sgx_base (mecânica idêntica nos 4 sistemas). get_session() fica local: faz
# um SELECT de colunas explícito (não u.*) por segurança — nunca deve devolver
# a coluna de hash de senha junto com os dados da sessão — e as colunas
# selecionadas divergem por sistema (schema de usuarios não é idêntico).
def create_session(user_id):
    return sgx_base.create_session(get_db, user_id, SESSION_TTL)

def get_session(token):
    if not token:
        return None
    with get_db() as conn:
        row = conn.execute(
            '''SELECT s.token, s.user_id, s.expires, u.nome, u.username, u.admin, u.ativo,
                   u.must_change_password
               FROM sessions s JOIN usuarios u ON u.id=s.user_id
               WHERE s.token=? AND s.expires>? AND u.ativo=1''',
            (token, time.time())
        ).fetchone()
    return dict(row) if row else None

def delete_session(token):
    sgx_base.delete_session(get_db, token)

def renew_session(token):
    sgx_base.renew_session(get_db, token, SESSION_TTL)

def active_sessions():
    return sgx_base.active_sessions(get_db)

def _check_shutdown():
    """Dispara um backup automático, uma única vez, depois que a última sessão
    ativa termina. O servidor nunca encerra sozinho — só via Ctrl+C."""
    global _backup_pos_sess
    if _had_session and active_sessions() == 0 and not _backup_pos_sess:
        _backup_pos_sess = True
        cfg = _get_backup_cfg()
        if cfg['enabled']:
            print('\nÚltima sessão encerrada. Executando backup automático...')
            _do_json_backup(cfg)
            _do_db_backup(cfg)

# ── Utilitários ───────────────────────────────────────────────────────────────

def _now():
    return time.strftime('%Y-%m-%dT%H:%M:%S')

def _now_precise():
    # Com precisão de milissegundo — usado especificamente em updatedAt para a
    # checagem de conflito de edição concorrente (_baseUpdatedAt) do fornecedor
    # rico. _now(), com precisão de segundo, colide facilmente entre duas
    # edições rápidas em sequência. Formato ainda parseável por new Date() no cliente.
    t = time.time()
    return time.strftime('%Y-%m-%dT%H:%M:%S', time.localtime(t)) + f'.{int((t % 1) * 1000):03d}'

def _float(v):
    # Regra única da família — ver sgx_base.parse_valor. Antes, este parser e o
    # do front discordavam: "1.234" virava 1,234 aqui e 1234 na tela.
    return sgx_base.parse_valor(v)

# ── Reconciliação com o Fiorilli (razão oficial; import read-only) ───────────
# O Fiorilli não converte unidade: exporta um número achatado na UNID1 dele. Todo
# o fator de conversão vive no SGEA (produtos.qtd_por_embalagem). Ver o desenho em
# memory/project_reconciliacao_fiorilli.md.
UNID_SINONIMOS = {
    'UN': 'UN', 'UND': 'UN', 'UNID': 'UN', 'UNIDADE': 'UN', 'UNIDADES': 'UN',
    'CX': 'CX', 'CAIXA': 'CX', 'CAIXAS': 'CX',
    'PC': 'PC', 'PCT': 'PC', 'PACOTE': 'PC', 'PACOTES': 'PC',
    'FR': 'FR', 'FRASCO': 'FR', 'FRASCOS': 'FR',
    'KG': 'KG', 'QUILO': 'KG', 'QUILOS': 'KG', 'KILO': 'KG',
    'L': 'L', 'LT': 'L', 'LITRO': 'L', 'LITROS': 'L',  # LATA != litro, fica fora
    'M': 'M', 'METRO': 'M', 'METROS': 'M',
    'RL': 'RL', 'ROLO': 'RL', 'ROLOS': 'RL',
    'PAR': 'PAR', 'PARES': 'PAR',
    'RESMA': 'RESMA', 'RESMAS': 'RESMA',
}
_CADPRO_RE = re.compile(r'^\d{3}\.\d{3}\.\d{3}$')
_RECON_EPS = 0.5  # tolerância no grão da unidade física (estoque é inteiro); absorve o ×fator do arredondamento do Fiorilli

def _norm_unid(u):
    u = (u or '').strip().upper()
    return UNID_SINONIMOS.get(u, u)

def _parse_fiorilli_posicao(csv_text):
    """Parseia o export 'CSV (Dados)' do Fiorilli. Retorna {codigo: {...}}.
    Levanta ValueError se o cabeçalho não bater (arquivo errado)."""
    reader = csv.DictReader(io.StringIO(csv_text), delimiter=';')
    faltando = {'CADPRO', 'DISC1', 'UNID1', 'QUAN3', 'VATO3'} - set(reader.fieldnames or [])
    if faltando:
        raise ValueError('Não parece o "CSV (Dados)" do Fiorilli. Faltam colunas: ' + ', '.join(sorted(faltando)))
    itens = {}
    for row in reader:
        cod = (row.get('CADPRO') or '').strip()
        if not _CADPRO_RE.match(cod):
            continue  # grupo (NNN), subgrupo (NNN.NNN) ou linha vazia
        est = _float(row.get('QUAN3')) or 0.0
        val = _float(row.get('VATO3')) or 0.0
        itens[cod] = {
            'descricao': (row.get('DISC1') or '').strip(),
            'unidade': (row.get('UNID1') or '').strip().upper(),
            'estoque': round(est, 4),   # QUAN3 vem com lixo de float (até 15 casas)
            'valor': round(val, 2),
            'estoque_negativo': est < 0,
            'valor_negativo': val < 0,
        }
    return itens

def _data_br_iso(s):
    """dd/mm/aaaa -> aaaa-mm-dd (ISO). Vazio/inválido -> ''."""
    m = re.match(r'^\s*(\d{2})/(\d{2})/(\d{4})\s*$', s or '')
    return f'{m.group(3)}-{m.group(2)}-{m.group(1)}' if m else ''

def _parse_fiorilli_entrada(csv_text):
    """Parseia o CSV 'REQUISIÇÃO DE ENTRADA' do Fiorilli. Agrupa por REQUI
    (uma entrada, N itens). Levanta ValueError se o cabeçalho não bater."""
    reader = csv.DictReader(io.StringIO((csv_text or '').lstrip('')), delimiter=';')
    faltando = {'REQUI', 'DATAE', 'CADPRO', 'QUAN1'} - set(reader.fieldnames or [])
    if faltando:
        raise ValueError('Não parece a "REQUISIÇÃO DE ENTRADA" do Fiorilli. Faltam colunas: ' + ', '.join(sorted(faltando)))
    def g(row, k): return (row.get(k) or '').strip()
    reqs = {}
    for row in reader:
        requi = g(row, 'REQUI')
        if not requi:
            continue
        if requi not in reqs:
            reqs[requi] = {
                'requisicao': requi,
                'data_requisicao': _data_br_iso(g(row, 'DTLAN')),
                'data_entrega': _data_br_iso(g(row, 'DATAE')) or _data_br_iso(g(row, 'DTLAN')),
                'documento': g(row, 'DOCUM'),
                'cnpj': g(row, 'INSMF'),
                'fornecedor_nome': g(row, 'NOME'),
                'numped': g(row, 'NUMPED'),
                'centro_raw': g(row, 'COD_DESC_CCUSTOR') or g(row, 'CCUSTOR'),
                'responsavel': g(row, 'RESPONSA') or g(row, 'SOLICITANTE'),
                'proclic': g(row, 'PROCLIC'),
                'tprequi': g(row, 'TPREQUI'),
                'itens': [],
            }
        reqs[requi]['itens'].append({
            'cadpro': g(row, 'CADPRO'), 'desc': g(row, 'DISC1'), 'desc_tec': g(row, 'DISCR1'),
            'unid': g(row, 'UNID1'), 'qtd': _float(g(row, 'QUAN1')) or 0.0,
            'valor': _float(g(row, 'VAUN1')) or 0.0, 'lote': g(row, 'LOTE'),
            'validade': _data_br_iso(g(row, 'VALIDADE')), 'marca': g(row, 'MARCA'),
        })
    return list(reqs.values())

def _parse_fiorilli_saida(csv_text):
    """Parseia o CSV 'REQUISIÇÃO DE SAÍDA' do Fiorilli. Mesmo layout de colunas da
    entrada, mas é o outro lado do razão: quantidade em QUAN2, valor unitário em
    VAUN2 (QUAN1/VAUN1 vêm zerados), sem fornecedor nem NF. Agrupa por REQUI."""
    reader = csv.DictReader(io.StringIO((csv_text or '').lstrip('')), delimiter=';')
    faltando = {'REQUI', 'DTLAN', 'CADPRO', 'QUAN2'} - set(reader.fieldnames or [])
    if faltando:
        raise ValueError('Não parece a "REQUISIÇÃO DE SAÍDA" do Fiorilli. Faltam colunas: ' + ', '.join(sorted(faltando)))
    def g(row, k): return (row.get(k) or '').strip()
    reqs = {}
    for row in reader:
        requi = g(row, 'REQUI')
        if not requi:
            continue
        if requi not in reqs:
            reqs[requi] = {
                'requisicao': requi,
                'data': _data_br_iso(g(row, 'DTLAN')) or _data_br_iso(g(row, 'DTPAG')),
                'centro_raw': g(row, 'COD_DESC_CCUSTOR') or g(row, 'CCUSTOR'),
                'solicitante': g(row, 'RESPONSA') or g(row, 'SOLICITANTE'),
                'numorc': g(row, 'NUMORC'),
                'itens': [],
            }
        reqs[requi]['itens'].append({
            'cadpro': g(row, 'CADPRO'), 'desc': g(row, 'DISC1'), 'unid': g(row, 'UNID1'),
            'qtd': _float(g(row, 'QUAN2')) or 0.0, 'valor': _float(g(row, 'VAUN2')) or 0.0,
            'lote': g(row, 'LOTE'), 'validade': _data_br_iso(g(row, 'VALIDADE')),
        })
    return list(reqs.values())

def _parse_fiorilli_pedido(csv_text):
    """Parseia o CSV 'PEDIDO' do Fiorilli. Uma linha por item, cabeçalho repetido;
    agrupa por NUMPED. QTD vem na unidade licitada — quem chama converte para
    unidade de consumo usando a embalagem do produto."""
    reader = csv.DictReader(io.StringIO((csv_text or '').lstrip('')), delimiter=';')
    faltando = {'NUMPED', 'DATPED', 'CADPRO', 'QTD'} - set(reader.fieldnames or [])
    if faltando:
        raise ValueError('Não parece a exportação de "PEDIDO" do Fiorilli. Faltam colunas: ' + ', '.join(sorted(faltando)))
    def g(row, k): return (row.get(k) or '').strip()
    peds = {}
    for row in reader:
        num = g(row, 'NUMPED')
        if not num:
            continue
        if num not in peds:
            peds[num] = {
                'numero': num,
                'data_pedido': _data_br_iso(g(row, 'DATPED')),
                'data_entrega_prevista': _data_br_iso(g(row, 'DATENT')),
                'cnpj': g(row, 'INSMF'),
                'fornecedor_nome': g(row, 'NOME'),
                'proclic': g(row, 'PROCLIC') or g(row, 'NUMLICIT'),
                'modalidade': g(row, 'LICIT'),
                'centro_raw': g(row, 'CODCCUSTO'),
                'itens': [],
            }
        peds[num]['itens'].append({
            'cadpro': g(row, 'CADPRO'), 'desc': g(row, 'DISC1'), 'unid': g(row, 'UNID1'),
            'qtd': _float(g(row, 'QTD')) or 0.0, 'qtd_anulada': _float(g(row, 'QTDANU')) or 0.0,
            'qtd_entregue': _float(g(row, 'QTDENT')) or 0.0,
            'valor': _float(g(row, 'PRCUNT')) or 0.0, 'marca': g(row, 'MARCA'),
        })
    return list(peds.values())

# ── Importação da planilha "CONTROLE DE FROTA" ──────────────────────────────
def _norm_header(h):
    """Normaliza um cabeçalho de coluna: sem acento, maiúsculo, espaços colapsados."""
    h = unicodedata.normalize('NFKD', h or '').encode('ascii', 'ignore').decode()
    return ' '.join(h.upper().split())

# Cabeçalho da planilha (normalizado) -> campo da tabela frota.
_FROTA_HEADER_MAP = {
    'FROTA': 'numero', 'PLACA': 'placa', 'CENTRO DE CUSTO': '_centro_custo_nome',
    'MARCA': 'marca', 'MODELO': 'modelo', 'COMBUSTIVEL': 'combustivel',
    'FABRICACAO / MODELO': 'ano', 'FABRICACAO/MODELO': 'ano', 'ANO': 'ano',
    'FILTRO AR CABINE': 'filtro_ar_cabine', 'FILTRO AR MOTOR': 'filtro_ar_motor',
    'FILTRO AR PRIMARIO': 'filtro_ar_primario', 'FILTRO AR SECUNDARIO': 'filtro_ar_secundario',
    'FILTRO COMBUSTIVEL': 'filtro_combustivel', 'FILTRO SEDIMENTADOR': 'filtro_sedimentador',
    'FILTRO LUBRIFICANTE': 'filtro_lubrificante', 'FILTRO DESUMIDIFICADOR': 'filtro_desumidificador',
    'FILTRO HIDRAULICO': 'filtro_hidraulico', 'FILTRO TRANSMISSAO': 'filtro_transmissao',
    'FILTRO UREIA': 'filtro_ureia', 'OLEO DE MOTOR': 'oleo_motor',
    'OLEO DA TRANSMISSAO': 'oleo_transmissao', 'BATERIA': 'bateria',
    'PNEU DIANTEIRO': 'pneu_dianteiro', 'PNEU TRASEIRO': 'pneu_traseiro',
    # Identificação oficial (planilha aprimorada / Fiorilli)
    'RENAVAM': 'renavam', 'CHASSI': 'chassi', 'COR': 'cor',
    'KM ATUAL FIORILLI': 'km_atual', 'KM ATUAL': 'km_atual',
    'CATEGORIA CNH': 'categoria_cnh', 'ESPECIE TCE': 'especie_tce',
    'POTENCIA/CILINDRADA': 'potencia_cilindrada', 'POTENCIA / CILINDRADA': 'potencia_cilindrada',
    'LOTACAO FIORILLI': 'lotacao', 'LOTACAO': 'lotacao',
    'SITUACAO FIORILLI': 'situacao', 'SITUACAO': 'situacao',
    'OBSERVACAO DE QUALIDADE': 'observacao', 'OBSERVACAO': 'observacao',
}

def _frota_registros(rows):
    """Recebe linhas (lista de listas) — de CSV ou XLSX — mapeia colunas por
    cabeçalho (sem acento/caixa) e deduplica por número de frota (última vence).
    Retorna lista de dicts (campo -> valor)."""
    rows = [r for r in rows if r]
    if not rows:
        raise ValueError('Planilha vazia.')
    header = [_norm_header(str(h)) for h in rows[0]]
    idx = {}
    for i, h in enumerate(header):
        campo = _FROTA_HEADER_MAP.get(h)
        if campo and campo not in idx:
            idx[campo] = i
    if 'numero' not in idx:
        raise ValueError('Não encontrei a coluna "FROTA" (número do veículo) na planilha.')
    dedup = {}  # numero -> registro (última linha vence)
    for r in rows[1:]:
        if not any(str(c or '').strip() for c in r):
            continue
        reg = {campo: (str(r[i]).strip() if i < len(r) and r[i] is not None else '') for campo, i in idx.items()}
        num = (reg.get('numero') or '').strip()
        if not num:
            continue
        dedup[num] = reg
    return list(dedup.values())

def _parse_frota_csv(csv_text):
    """Parseia a planilha CONTROLE DE FROTA exportada em CSV (detecta ; ou ,)."""
    csv_text = (csv_text or '').lstrip('')
    linhas = csv_text.splitlines()
    if not linhas or not csv_text.strip():
        raise ValueError('CSV vazio.')
    delim = ';' if linhas[0].count(';') >= linhas[0].count(',') else ','
    rows = list(csv.reader(io.StringIO(csv_text), delimiter=delim))
    return _frota_registros(rows)

_XLSX_NS = '{http://schemas.openxmlformats.org/spreadsheetml/2006/main}'
_XLSX_R = '{http://schemas.openxmlformats.org/officeDocument/2006/relationships}'
_XLSX_REL = '{http://schemas.openxmlformats.org/package/2006/relationships}'

def _col_idx(ref):
    """Referência de célula ('B3') -> índice 0-based da coluna (1)."""
    letras = ''.join(ch for ch in ref if ch.isalpha())
    n = 0
    for ch in letras:
        n = n * 26 + (ord(ch.upper()) - 64)
    return n - 1

def _xlsx_para_linhas(raw, aba='DADOS'):
    """Lê um .xlsx (zip de XMLs) só com a stdlib e devolve as linhas da aba pedida
    (ou a primeira, se não achar) como lista de listas de strings. Sem dependência."""
    try:
        z = zipfile.ZipFile(io.BytesIO(raw))
    except Exception:
        raise ValueError('Arquivo .xlsx inválido ou corrompido.')
    nomes = z.namelist()
    # workbook: nome da aba -> r:id ; primeiro como fallback
    wb = ET.fromstring(z.read('xl/workbook.xml'))
    alvo_rid = primeiro_rid = None
    for sh in wb.iter(f'{_XLSX_NS}sheet'):
        rid = sh.get(f'{_XLSX_R}id')
        if primeiro_rid is None:
            primeiro_rid = rid
        if (sh.get('name') or '').strip().upper() == aba.upper():
            alvo_rid = rid
    rid = alvo_rid or primeiro_rid
    # rels: r:id -> arquivo da planilha
    rels = ET.fromstring(z.read('xl/_rels/workbook.xml.rels'))
    target = None
    for rel in rels.iter(f'{_XLSX_REL}Relationship'):
        if rel.get('Id') == rid:
            target = rel.get('Target')
    if not target:
        raise ValueError('Não consegui localizar a aba dentro do .xlsx.')
    path = target if target.startswith('xl/') else 'xl/' + target.lstrip('/')
    # textos compartilhados
    shared = []
    if 'xl/sharedStrings.xml' in nomes:
        sst = ET.fromstring(z.read('xl/sharedStrings.xml'))
        for si in sst.iter(f'{_XLSX_NS}si'):
            shared.append(''.join(t.text or '' for t in si.iter(f'{_XLSX_NS}t')))
    # linhas da aba
    ws = ET.fromstring(z.read(path))
    linhas = []
    for row in ws.iter(f'{_XLSX_NS}row'):
        cells, maxc = {}, -1
        for c in row.findall(f'{_XLSX_NS}c'):
            col = _col_idx(c.get('r') or 'A')
            t = c.get('t')
            v = c.find(f'{_XLSX_NS}v')
            if t == 's':
                val = shared[int(v.text)] if v is not None and v.text is not None else ''
            elif t == 'inlineStr':
                isn = c.find(f'{_XLSX_NS}is')
                val = ''.join(tt.text or '' for tt in isn.iter(f'{_XLSX_NS}t')) if isn is not None else ''
            else:
                val = v.text if v is not None and v.text is not None else ''
            cells[col] = val
            maxc = max(maxc, col)
        linhas.append([str(cells.get(i, '')) for i in range(maxc + 1)])
    return linhas

# ── Importação do "CADASTRO DE CENTROS DE CUSTO" (export do Fiorilli) ───────
# CODCCUSTO é o código único do centro (1..N); DESCR é a descrição usada como nome.
_CC_HEADER_MAP = {
    'CODCCUSTO': 'codigo', 'CODIGO': 'codigo', 'COD': 'codigo',
    'DESCR': 'nome', 'DESCRICAO': 'nome', 'NOME': 'nome',
    'RESPONSA': 'responsavel', 'RESPONSAVEL': 'responsavel',
    'EMAIL': 'email', 'E-MAIL': 'email',
}

def _norm_nome(s):
    """Nome sem acento, maiúsculo e com espaços colapsados — usado para casar
    um centro do arquivo com um já cadastrado (que pode ter vindo sem código)."""
    s = unicodedata.normalize('NFKD', s or '').encode('ascii', 'ignore').decode()
    return ' '.join(s.upper().split())

def _parse_centros_csv(csv_text):
    """Parseia o CSV de centros de custo do Fiorilli. Detecta o delimitador,
    mapeia colunas por cabeçalho e deduplica por código. Retorna lista de dicts."""
    csv_text = csv_text.lstrip('')
    linhas = csv_text.splitlines()
    if not linhas or not csv_text.strip():
        raise ValueError('CSV vazio.')
    delim = ';' if linhas[0].count(';') >= linhas[0].count(',') else ','
    rows = list(csv.reader(io.StringIO(csv_text), delimiter=delim))
    header = [_norm_header(h) for h in rows[0]]
    idx = {}
    for i, h in enumerate(header):
        campo = _CC_HEADER_MAP.get(h)
        if campo and campo not in idx:
            idx[campo] = i
    if 'nome' not in idx:
        raise ValueError('Não encontrei a coluna de descrição do centro de custo (DESCR) no CSV.')
    dedup = {}
    for r in rows[1:]:
        if not any((c or '').strip() for c in r):
            continue
        reg = {campo: (r[i].strip() if i < len(r) and r[i] is not None else '') for campo, i in idx.items()}
        if not (reg.get('nome') or '').strip():
            continue
        chave = (reg.get('codigo') or '').strip() or _norm_nome(reg['nome'])
        dedup[chave] = reg
    return list(dedup.values())

def _classificar_reconciliacao(fiorilli, produtos, data_corte):
    """Cruza o Fiorilli (só itens com saldo; zerados omitidos) com os produtos do
    SGEA (saldo inteiro em unidade_consumo) por codigo_fiorilli. Um balde por código."""
    by_cod = {}
    for p in produtos:
        c = (p.get('codigo_fiorilli') or '').strip()
        if c:
            by_cod[c] = p
    resumo = {'confere': 0, 'diverge': 0, 'so_fiorilli': 0, 'so_sgea': 0, 'unidade': 0}
    itens = []
    for cod in sorted(set(fiorilli) | set(by_cod)):
        F, S = fiorilli.get(cod), by_cod.get(cod)
        flags = []
        if F and F['estoque_negativo']: flags.append('fiorilli_estoque_negativo')
        if F and F['valor_negativo']:   flags.append('fiorilli_valor_negativo')
        qf = qs = delta = None

        if S is None:                                   # Fiorilli tem saldo, SGEA não cadastrou
            balde, qf, unid = 'so_fiorilli', F['estoque'], F['unidade']
        elif F is None:                                 # ausente do Fiorilli => saldo 0 lá (omite zerados)
            qs = float(S['estoque_fisico'] or 0)
            unid = S.get('unidade_consumo') or 'UN'
            if abs(qs) <= _RECON_EPS:
                balde, qf, delta = 'confere', 0.0, 0.0  # zero implícito
            else:
                balde, qf, delta = 'so_sgea', 0.0, qs
        else:                                           # ambos presentes
            qs = float(S['estoque_fisico'] or 0)
            unid = S.get('unidade_consumo') or 'UN'
            uf = _norm_unid(F['unidade'])
            uc, ul = _norm_unid(unid), _norm_unid(S.get('unidade_licitada') or '')
            fator = 1.0 if uf == uc else (float(S.get('qtd_por_embalagem') or 1) if ul and uf == ul else None)
            if fator is None:                           # unidade não casa nem com consumo nem com licitada
                balde, qf = 'unidade', F['estoque']
            else:
                qf = round(F['estoque'] * fator, 4)     # Fiorilli trazido p/ unidade de consumo
                delta = round(qs - qf, 4)
                if abs(delta) < _RECON_EPS:
                    balde = 'confere'
                    if abs((F['valor'] or 0) - float(S['estoque_financeiro'] or 0)) > 0.02:
                        flags.append('valor_divergente')
                else:
                    balde = 'diverge'
        resumo[balde] += 1
        itens.append({
            'codigo': cod, 'balde': balde,
            'descricao': (S['nome'] if S else F['descricao']),
            'fiorilli_qtd': qf, 'sgea_qtd': qs, 'delta': delta, 'unidade': unid,
            'valor_fiorilli': (F['valor'] if F else None), 'flags': flags,
        })
    resumo['total'] = len(itens)
    return {'data_corte': data_corte, 'resumo': resumo, 'itens': itens}


def _require(data, *fields):
    for f in fields:
        v = data.get(f)
        if v is None or (isinstance(v, str) and not v.strip()):
            raise ValueError(f'Campo obrigatório: {f}')

class EstoqueInsuficiente(Exception):
    def __init__(self, produto_id, solicitado, disponivel):
        self.produto_id, self.solicitado, self.disponivel = produto_id, solicitado, disponivel
        super().__init__(f'Estoque insuficiente para o produto (solicitado: {solicitado}, disponível: {disponivel})')

class SaldoPedidoExcedido(Exception):
    def __init__(self, mensagem):
        super().__init__(mensagem)

def _pedido_item_status(pedida, recebida, anulada):
    if anulada > 0:
        return 'encerrado_parcial'
    if recebida >= pedida:
        return 'atendido'
    if recebida > 0:
        return 'parcial'
    return 'aberto'

def _pedido_itens_com_saldo(conn, pedido_id, ignorar_entrada_id=None):
    """Itens do pedido com quantidade_recebida/saldo/status calculados a partir das
    entradas vinculadas — quantidade_recebida nunca é armazenada, só derivada, pra não
    correr o risco de um contador desalinhar da soma real de entrada_itens.

    `ignorar_entrada_id` tira uma entrada da conta. Serve à edição: ao regravar os
    itens de uma entrada já lançada, o que ela mesma trouxe não pode contar contra
    o saldo do pedido — senão editar qualquer coisa nela acusaria excesso."""
    rows = conn.execute('''
        SELECT pi.id, pi.produto_id, pi.quantidade_pedida, pi.quantidade_anulada,
               pi.valor_unitario, pi.marca,
               p.nome AS produto_nome, p.unidade_consumo,
               COALESCE((
                   SELECT SUM(ei.quantidade_unidades)
                   FROM entrada_itens ei JOIN entradas e ON e.id = ei.entrada_id
                   WHERE e.pedido_id = pi.pedido_id AND ei.produto_id = pi.produto_id
                     AND e.deleted_at IS NULL AND (? IS NULL OR e.id <> ?)
               ), 0) AS quantidade_recebida
        FROM pedido_itens pi JOIN produtos p ON p.id = pi.produto_id
        WHERE pi.pedido_id = ?
        ORDER BY pi.id
    ''', (ignorar_entrada_id, ignorar_entrada_id, pedido_id)).fetchall()
    itens = []
    for r in rows:
        d = dict(r)
        d['saldo'] = max(d['quantidade_pedida'] - d['quantidade_recebida'] - d['quantidade_anulada'], 0)
        d['status'] = _pedido_item_status(d['quantidade_pedida'], d['quantidade_recebida'], d['quantidade_anulada'])
        itens.append(d)
    return itens

def _pedido_status_agregado(status_coluna, itens):
    """Status exibido do pedido: 'cancelado' é o único valor manual (setado só por
    _cancelar_pedido); qualquer outra coisa é sempre recalculada a partir dos itens,
    nunca lida da coluna — evita a coluna e os itens saírem de sincronia."""
    if status_coluna == 'cancelado':
        return 'cancelado'
    if not itens:
        return 'aberto'
    if any(i['status'] in ('aberto', 'parcial') for i in itens):
        return 'aberto'
    if all(i['status'] == 'atendido' for i in itens):
        return 'atendido'
    return 'encerrado_parcial'

def _lote_norm(x):
    """Normaliza nº de lote para comparação: o Fiorilli exporta zero-padded
    ('00000001'), a digitação manual não ('1'). '00000000'/'' = sem lote."""
    return (x or '').strip().lstrip('0').upper()

def _consumir_fefo(conn, produto_id, quantidade_solicitada, preferir_lote=None):
    """Consome `quantidade_solicitada` unidades do produto, priorizando o lote
    com validade mais próxima (FEFO); lotes sem validade (incl. saldo inicial)
    são consumidos por último, em ordem de chegada. `preferir_lote` (nº, validade)
    põe na frente o lote que o Fiorilli baixou, quando ele existe aqui — o resto
    da fila segue FEFO. Levanta EstoqueInsuficiente sem alterar nenhuma linha se o
    total disponível não cobrir o pedido — quem chama roda isso dentro do mesmo
    `with get_db()` do resto da operação, então qualquer exceção desfaz tudo via
    _ConnAutoClose."""
    lotes = conn.execute('''
        SELECT id, quantidade_atual, valor_unitario_custo, lote_numero, data_validade
        FROM lotes
        WHERE produto_id = ? AND quantidade_atual > 0
        ORDER BY (data_validade IS NULL) ASC, data_validade ASC, id ASC
    ''', (produto_id,)).fetchall()

    if preferir_lote:
        _num, _val = preferir_lote
        _num = _lote_norm(_num)
        if _num or _val:
            # sorted é estável: o que não casa mantém a ordem FEFO acima
            lotes = sorted(lotes, key=lambda l: 0 if (
                _lote_norm(l['lote_numero']) == _num if _num else l['data_validade'] == _val
            ) else 1)

    disponivel = sum(l['quantidade_atual'] for l in lotes)
    if disponivel < quantidade_solicitada:
        raise EstoqueInsuficiente(produto_id, quantidade_solicitada, disponivel)

    restante, consumos = quantidade_solicitada, []
    for l in lotes:
        if restante <= 0:
            break
        qtd = min(l['quantidade_atual'], restante)
        conn.execute('UPDATE lotes SET quantidade_atual = quantidade_atual - ? WHERE id = ?', (qtd, l['id']))
        consumos.append((l['id'], qtd, l['valor_unitario_custo']))
        restante -= qtd

    valor_total = sum(q * c for _, q, c in consumos)
    valor_medio = valor_total / quantidade_solicitada if quantidade_solicitada else 0
    return consumos, valor_medio, valor_total

def _lotes_vencendo(dias):
    """Lotes com saldo vencidos ou vencendo dentro de `dias`. Compartilhado entre
    GET /api/alertas/validade e o alerta diário por e-mail (_send_daily_alerts)."""
    limite = time.strftime('%Y-%m-%d', time.localtime(time.time() + dias * 86400))
    hoje = time.strftime('%Y-%m-%d')
    with get_db() as conn:
        rows = conn.execute('''
            SELECT l.*, p.nome AS produto_nome, p.codigo_fiorilli, p.unidade_consumo,
                   c.nome AS centro_custo_nome
            FROM lotes l
            JOIN produtos p ON p.id=l.produto_id
            LEFT JOIN centros_custo c ON c.id=p.centro_custo_id
            WHERE l.quantidade_atual > 0 AND l.data_validade IS NOT NULL AND l.data_validade <= ?
            ORDER BY l.data_validade ASC
        ''', (limite,)).fetchall()
    items = []
    for r in rows:
        d = dict(r)
        d['vencido'] = d['data_validade'] < hoje
        items.append(d)
    return items

def _movimentacao_mensal(conn):
    """Série de 6 meses (mais antigo → mais recente) de valor_total de entradas e
    saídas, agrupada por mês com zero-fill — mês sem movimento aparece com 0, não
    some da série (senão o gráfico do dashboard distorceria a escala)."""
    meses = []
    hoje = time.localtime()
    for i in range(5, -1, -1):
        ano, mes = hoje.tm_year, hoje.tm_mon - i
        while mes <= 0:
            mes += 12; ano -= 1
        meses.append(f'{ano:04d}-{mes:02d}')
    entradas_por_mes = dict(conn.execute('''
        SELECT strftime('%Y-%m', e.data_entrega) AS m, SUM(ei.valor_total)
        FROM entrada_itens ei JOIN entradas e ON e.id = ei.entrada_id
        WHERE e.deleted_at IS NULL AND strftime('%Y-%m', e.data_entrega) >= ?
        GROUP BY m
    ''', (meses[0],)).fetchall())
    saidas_por_mes = dict(conn.execute('''
        SELECT strftime('%Y-%m', s.data) AS m, SUM(si.valor_total)
        FROM saida_itens si JOIN saidas s ON s.id = si.saida_id
        WHERE s.deleted_at IS NULL AND strftime('%Y-%m', s.data) >= ?
        GROUP BY m
    ''', (meses[0],)).fetchall())
    return [
        {'mes': m, 'entradas': entradas_por_mes.get(m, 0) or 0, 'saidas': saidas_por_mes.get(m, 0) or 0}
        for m in meses
    ]

def _find_browser():
    for c in [
        os.path.expandvars(r'%ProgramFiles%\Google\Chrome\Application\chrome.exe'),
        os.path.expandvars(r'%ProgramFiles(x86)%\Google\Chrome\Application\chrome.exe'),
        os.path.expandvars(r'%LocalAppData%\Google\Chrome\Application\chrome.exe'),
        os.path.expandvars(r'%ProgramFiles(x86)%\Microsoft\Edge\Application\msedge.exe'),
    ]:
        if os.path.isfile(c):
            return c
    return None

# ── CRUD genérico de cadastros mestre ───────────────────────────────────────
# centros_custo/funcionarios/frota/pedidos têm a mesma forma (id + colunas
# simples + ativo/status + created_at/updated_at), então um único motor
# parametrizado evita reescrever list/get/create/update 4 vezes.
# fornecedores NÃO está mais aqui — ganhou handlers dedicados (ver seção
# "Fornecedores" abaixo) porque o cadastro rico (data JSON, certidões,
# sanções, CNPJ/CEIS/CNEP) não cabe no motor genérico de campos escalares.

CRUD_TABLES = {
    'centros_custo': {
        'id_type': 'int', 'fields': ['codigo', 'nome', 'ativo', 'responsavel', 'email'],
        'required': ['nome'], 'order': 'nome ASC',
        'search_fields': ['nome', 'codigo', 'responsavel', 'email'],
    },
    'funcionarios': {
        'id_type': 'int',
        'fields': ['nome', 'cargo', 'unidade', 'matricula', 'natureza', 'forma_provimento',
                   'data_admissao', 'ato_admissao', 'ativo'],
        'required': ['nome'], 'order': 'nome ASC',
        'search_fields': ['nome', 'cargo', 'unidade', 'matricula'],
    },
    'frota': {
        'id_type': 'int',
        'fields': ['numero', 'placa', 'marca', 'modelo', 'combustivel', 'centro_custo_id', 'ativo', *FROTA_PECAS_COLS, *FROTA_DOC_COLS],
        'required': ['numero'], 'order': 'numero ASC', 'search_fields': ['numero', 'placa', 'modelo', 'renavam', 'chassi'],
    },
}
_USER_SMTP_COLS = ('smtp_host', 'smtp_port', 'smtp_secure', 'smtp_require_tls',
                   'smtp_ignore_ssl', 'smtp_user', 'smtp_pass', 'smtp_from_name')

CRUD_ROUTES = {  # segmento da URL -> tabela
    'centros-custo': 'centros_custo',
    'funcionarios': 'funcionarios', 'frota': 'frota',
    # pedidos e fornecedores NÃO estão aqui — pedidos tem itens, fornecedores
    # tem o cadastro rico (data JSON) — ambos com handlers dedicados abaixo
    # (_get_pedido_dict/_create_pedido/etc. e _list_fornecedores/etc.).
}

def _crud_list(table, qs):
    cfg = CRUD_TABLES[table]
    q = (qs.get('q', [''])[0] or '').strip()
    where, params = [], []
    if q and cfg['search_fields']:
        ors = ' OR '.join(f'{f} LIKE ?' for f in cfg['search_fields'])
        where.append(f'({ors})')
        params += [f'%{q}%'] * len(cfg['search_fields'])
    w = ('WHERE ' + ' AND '.join(where)) if where else ''
    with get_db() as conn:
        rows = conn.execute(f'SELECT * FROM {table} {w} ORDER BY {cfg["order"]}', params).fetchall()
    return [dict(r) for r in rows]

def _crud_get(table, id_):
    with get_db() as conn:
        row = conn.execute(f'SELECT * FROM {table} WHERE id=?', (id_,)).fetchone()
    return dict(row) if row else None

def _crud_create(table, data):
    cfg = CRUD_TABLES[table]
    _require(data, *cfg['required'])
    fields = {k: data[k] for k in cfg['fields'] if k in data}
    cols, vals = list(fields.keys()), list(fields.values())
    with get_db() as conn:
        if cfg['id_type'] == 'uuid':
            new_id = str(uuid.uuid4())
            conn.execute(f'INSERT INTO {table} (id,{",".join(cols)}) VALUES (?,{",".join("?" * len(cols))})',
                         [new_id] + vals)
        else:
            cur = conn.execute(f'INSERT INTO {table} ({",".join(cols)}) VALUES ({",".join("?" * len(cols))})', vals)
            new_id = cur.lastrowid
        row = conn.execute(f'SELECT * FROM {table} WHERE id=?', (new_id,)).fetchone()
    return dict(row)

def _crud_update(table, id_, data):
    cfg = CRUD_TABLES[table]
    fields = {k: data[k] for k in cfg['fields'] if k in data}
    with get_db() as conn:
        if fields:
            fields['updated_at'] = _now()
            conn.execute(f'UPDATE {table} SET {",".join(f"{k}=?" for k in fields)} WHERE id=?',
                         list(fields.values()) + [id_])
        row = conn.execute(f'SELECT * FROM {table} WHERE id=?', (id_,)).fetchone()
    return dict(row) if row else None

def _crud_bulk_delete(table, ids):
    """Exclui em lote. Sucesso parcial: o que dá é excluído; o que a FK barra vai
    para 'bloqueados' com o motivo (mesmo texto do delete individual)."""
    excluidos, bloqueados = [], []
    for id_ in ids:
        try:
            with get_db() as conn:
                cur = conn.execute(f'DELETE FROM {table} WHERE id=?', (id_,))
            if cur.rowcount:
                excluidos.append(id_)
        except sqlite3.IntegrityError:
            bloqueados.append({'id': id_, 'motivo': _motivo_em_uso(table, id_)})
    return {'excluidos': excluidos, 'bloqueados': bloqueados}

def _crud_bulk_update(table, ids, patch):
    """Aplica o mesmo patch (só colunas conhecidas do módulo) a vários ids."""
    cfg = CRUD_TABLES[table]
    fields = {k: patch[k] for k in cfg['fields'] if k in patch}
    if not fields or not ids:
        return {'atualizados': 0}
    fields['updated_at'] = _now()
    sets = ','.join(f'{k}=?' for k in fields)
    n = 0
    with get_db() as conn:
        for id_ in ids:
            cur = conn.execute(f'UPDATE {table} SET {sets} WHERE id=?', list(fields.values()) + [id_])
            n += cur.rowcount
    return {'atualizados': n}

def _crud_delete(table, id_):
    with get_db() as conn:
        conn.execute(f'DELETE FROM {table} WHERE id=?', (id_,))

# Quem referencia cada cadastro por FK — usado para explicar por que a exclusão
# foi bloqueada (em vez do genérico "registro em uso"). (tabela, coluna, rótulo).
_DEP_EXCLUSAO = {
    'centros_custo': [('frota', 'centro_custo_id', 'veículo(s) da frota'),
                      ('produtos', 'centro_custo_id', 'produto(s)'),
                      ('entradas', 'centro_custo_id', 'entrada(s) de estoque'),
                      ('saidas', 'centro_custo_id', 'saída(s) de estoque')],
    'funcionarios': [('entradas', 'recebedor_id', 'entrada(s) de estoque'),
                     ('saidas', 'solicitante_id', 'saída(s) de estoque')],
    'frota': [('saidas', 'frota_id', 'saída(s) de estoque')],
    'produtos': [('lotes', 'produto_id', 'lote(s) de estoque'),
                 ('entrada_itens', 'produto_id', 'item(ns) de entrada'),
                 ('saida_itens', 'produto_id', 'item(ns) de saída'),
                 ('pedido_itens', 'produto_id', 'item(ns) de pedido')],
}

def _motivo_em_uso(table, id_):
    """Mensagem 409 explicando quais registros vinculados impedem a exclusão.
    tabela/coluna vêm de _DEP_EXCLUSAO (literais nossos, não entrada do usuário)."""
    partes = []
    with get_db() as conn:
        for ref_tbl, ref_col, rotulo in _DEP_EXCLUSAO.get(table, []):
            n = conn.execute(f'SELECT COUNT(*) FROM {ref_tbl} WHERE {ref_col}=?', (id_,)).fetchone()[0]
            if n:
                partes.append(f'{n} {rotulo}')
    if not partes:
        return 'Não é possível excluir: registro em uso.'
    return ('Não é possível excluir: vinculado a ' + ', '.join(partes)
            + '. Remova ou reatribua esses registros antes de excluir.')

# ── HTTP Handler ──────────────────────────────────────────────────────────────

class SGEAHandler(http.server.SimpleHTTPRequestHandler):

    def do_OPTIONS(self):
        self.send_response(200)
        self._cors()
        self.end_headers()

    def end_headers(self):
        # SGEA.html muda com frequência entre versões; sem isso o navegador
        # pode servir do cache sem revalidar com o servidor.
        if self.command == 'GET' and urlparse(self.path).path.rstrip('/').endswith(('.html', '.js', '.css')):
            self.send_header('Cache-Control', 'no-cache, must-revalidate')
        super().end_headers()

    def _safe_dispatch(self, inner):
        # handle_error (do socketserver.BaseServer) nunca é chamado de verdade
        # para exceções dentro do request handler — sem isto, um erro não
        # tratado só derrubaria a conexão em silêncio, sem nada no log.
        try:
            inner()
        except Exception as e:
            status, corpo = sgx_base.tratar_excecao_request(_log, self.command, self.path, e)
            try:
                self._json(status, corpo)
            except Exception:
                pass

    def do_GET(self):
        self._safe_dispatch(self._do_GET)

    def _do_GET(self):
        parsed = urlparse(self.path)
        p = parsed.path.rstrip('/')
        qs = parse_qs(parsed.query)

        if p == '/health':
            self._json(200, {'ok': True, 'version': SERVER_VERSION})
        elif p == '/api/public/org-info':
            with get_db() as conn:
                row = conn.execute("SELECT value FROM sys_settings WHERE key='orgao'").fetchone()
            self._json(200, {'orgao': row['value'] if row else ''})
        elif p == '/api/public/last-backup':
            with get_db() as conn:
                row = conn.execute("SELECT value FROM sys_settings WHERE key='auto_backup_last'").fetchone()
            self._json(200, {'ts': row['value'] if row else None})
        elif p == '/api/auth/logout':
            tok = qs.get('token', [None])[0] or self._token()
            delete_session(tok)
            self._json(200, {'ok': True})
            threading.Thread(target=_check_shutdown, daemon=True).start()
        elif p.startswith('/cnpj/'):
            self._proxy_cnpj(p[6:].strip('/'))
        elif p.startswith('/api/'):
            s = self._auth()
            if s:
                self._route_get(p, qs, s)
        else:
            super().do_GET()

    def do_POST(self):
        self._safe_dispatch(self._do_POST)

    def _do_POST(self):
        parsed = urlparse(self.path)
        p = parsed.path.rstrip('/')

        if p == '/api/auth/login':
            self._login(self._body())
            return
        if p == '/api/auth/logout':
            qs_tok = parse_qs(parsed.query).get('token', [None])[0]
            delete_session(qs_tok or self._token())
            self._json(200, {'ok': True})
            threading.Thread(target=_check_shutdown, daemon=True).start()
            return

        # Erro de JavaScript reportado pelo navegador (sem auth, throttled no motor).
        if p == '/api/log/client':
            try:
                sgx_base.registrar_erro_cliente_js(_log, json.loads(self._body() or '{}'))
            except Exception:
                pass
            self._sem_conteudo(); return

        s = self._auth()
        if not s:
            return
        self._route_post(p, self._body(), s)

    def do_PUT(self):
        self._safe_dispatch(self._do_PUT)

    def _do_PUT(self):
        p = urlparse(self.path).path.rstrip('/')
        s = self._auth()
        if not s:
            return
        self._route_put(p, self._body(), s)

    def do_DELETE(self):
        self._safe_dispatch(self._do_DELETE)

    def _do_DELETE(self):
        parsed = urlparse(self.path)
        p = parsed.path.rstrip('/')
        qs = parse_qs(parsed.query)
        s = self._auth()
        if not s:
            return
        self._route_delete(p, qs, s)

    # ── Roteamento ────────────────────────────────────────────────────────────

    def _route_get(self, p, qs, s):
        def qp(k, d=None):
            v = qs.get(k)
            return v[0] if v else d

        if p == '/api/auth/ping':
            renew_session(self._token())
            self._json(200, {'ok': True})
        elif p == '/api/auth/me':
            self._json(200, self._user_dict(s))

        elif p == '/api/produtos':
            self._list_produtos(qs)
        elif re.fullmatch(r'/api/produtos/[^/]+/lotes', p):
            self._list_lotes(p.split('/')[3])
        elif re.fullmatch(r'/api/produtos/[^/]+', p):
            self._get_produto(p.split('/')[-1])

        elif p == '/api/alertas/validade':
            self._alertas_validade(qs)

        elif p == '/api/dashboard':
            self._dashboard()

        elif p == '/api/relatorio/movimentacao':
            self._relatorio_movimentacao(qs)
        elif p == '/api/relatorio/pedidos-abertos':
            self._relatorio_pedidos_abertos()

        elif p == '/api/fornecedores/export':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._export_fornecedores()
        elif p == '/api/fornecedores':
            self._list_fornecedores(qs)
        elif re.fullmatch(r'/api/fornecedores/[^/]+', p):
            self._get_fornecedor(p.split('/')[-1])
        elif p == '/api/ceis-cnep':
            self._proxy_ceis_cnep(qs)

        elif p == '/api/pedidos':
            self._list_pedidos(qs)
        elif re.fullmatch(r'/api/pedidos/[^/]+', p):
            item = self._get_pedido_dict(p.split('/')[-1])
            self._json(200, item) if item else self._json(404, {'error': 'Não encontrado'})

        elif p == '/api/entradas':
            self._list_entradas(qs.get('trash', ['0'])[0] == '1')
        elif re.fullmatch(r'/api/entradas/[^/]+', p):
            item = self._get_entrada_dict(p.split('/')[-1])
            self._json(200, item) if item else self._json(404, {'error': 'Não encontrada'})

        elif p == '/api/saidas':
            self._list_saidas(qs.get('trash', ['0'])[0] == '1')
        elif re.fullmatch(r'/api/saidas/[^/]+', p):
            item = self._get_saida_dict(p.split('/')[-1])
            self._json(200, item) if item else self._json(404, {'error': 'Não encontrada'})

        elif p == '/api/audit':
            self._list_audit(qs)

        elif p == '/api/usuarios':
            if not s['admin']:
                self._json(403, {'error': 'Acesso restrito'}); return
            with get_db() as conn:
                rows = conn.execute('SELECT id,username,nome,admin,ativo,cpf,email,cargo,matricula,criado_em FROM usuarios').fetchall()
            self._json(200, [dict(r) for r in rows])

        elif re.fullmatch(r'/api/usuarios/\d+/smtp', p):
            # Config SMTP de um usuário (sem a senha): o próprio usuário ou admin
            uid = int(p.split('/')[3])
            if uid != s['user_id'] and not s['admin']:
                self._json(403, {'error': 'Acesso restrito'}); return
            with get_db() as conn:
                row = conn.execute(f"SELECT {', '.join(_USER_SMTP_COLS)} FROM usuarios WHERE id=?", (uid,)).fetchone()
                if not row: self._json(404, {'error': 'Usuário não encontrado'}); return
                sysc = {r['key']: r['value'] for r in conn.execute("SELECT key,value FROM sys_settings WHERE key LIKE 'smtp_%'").fetchall()}
            out = {c: (row[c] or '') for c in _USER_SMTP_COLS if c != 'smtp_pass'}
            out['smtp_pass_set'] = bool((row['smtp_pass'] or '').strip())
            # defaults do sistema para o "Copiar do sistema" (sem a senha)
            out['system'] = {c: sysc.get(c, '') for c in ('smtp_host', 'smtp_port', 'smtp_secure', 'smtp_require_tls', 'smtp_ignore_ssl', 'smtp_from_name')}
            self._json(200, out)

        elif p == '/api/relatorio/integridade':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._relatorio_integridade()

        elif p == '/api/diagnostico/erros':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._json(200, sgx_base.ler_diagnostico_erros(_DATA_DIR, 'SGEA'))

        elif p == '/api/settings':
            with get_db() as conn:
                rows = conn.execute(
                    "SELECT key,value FROM sys_settings WHERE key IN "
                    "('orgao','municipio','cnpj_orgao','aut_nome','aut_cargo',"
                    "'auto_backup_enabled','auto_backup_keep','portal_transparencia_key')"
                ).fetchall()
            self._json(200, _settings_para({r['key']: r['value'] for r in rows}, s))

        elif p in ('/api/settings/smtp', '/api/settings/smtp/'):
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            with get_db() as conn:
                rows = conn.execute("SELECT key,value FROM sys_settings WHERE key LIKE 'smtp_%'").fetchall()
            cfg = {r['key']: r['value'] for r in rows}
            cfg.pop('smtp_pass', None)  # senha nunca volta pro cliente depois de salva
            self._json(200, cfg)

        elif p in ('/api/settings/brasao', '/api/settings/brasao/'):
            # Endpoint separado de /api/settings: o brasão em base64 pode ter alguns
            # MB, incluí-lo na rota geral deixaria toda tela inicial mais lenta.
            with get_db() as conn:
                row = conn.execute("SELECT value FROM sys_settings WHERE key='brasao_dataurl'").fetchone()
            self._json(200, {'brasao_dataurl': row['value'] if row else ''})

        elif p == '/api/backup':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._export_backup()
        elif p == '/api/backup/db':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._export_db_backup()
        elif p == '/api/backups/cfg':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._json(200, _get_backup_cfg())
        elif p == '/api/backups/db':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._list_db_backups()
        elif p.startswith('/api/backups/db/download'):
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._download_db_backup(qp('name'))
        elif p == '/api/dialog/folder':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._dialog_folder()

        else:
            # Cadastros mestre (CRUD genérico)
            for seg, table in CRUD_ROUTES.items():
                if p == f'/api/{seg}':
                    self._json(200, {'items': _crud_list(table, qs)}); return
                if re.fullmatch(rf'/api/{seg}/[^/]+', p):
                    item = _crud_get(table, p.split('/')[-1])
                    self._json(200, item) if item else self._json(404, {'error': 'Não encontrado'})
                    return
            self._json(404, {'error': 'Rota não encontrada'})

    def _route_post(self, p, body, s):
        if p == '/api/backups/db/restore':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._restore_db_backup(body, s)
            return

        data = self._parse_json(body)

        for seg, table in CRUD_ROUTES.items():
            if p == f'/api/{seg}/bulk-delete':
                ids = data.get('ids') if isinstance(data.get('ids'), list) else []
                self._json(200, _crud_bulk_delete(table, ids)); return
            if p == f'/api/{seg}/bulk-update':
                ids = data.get('ids') if isinstance(data.get('ids'), list) else []
                patch = data.get('patch') if isinstance(data.get('patch'), dict) else {}
                self._json(200, _crud_bulk_update(table, ids, patch)); return

        if p == '/api/produtos/bulk-delete':
            # reaproveita o mesmo motor das telas de cadastro: sucesso parcial, e
            # o que a FK barra volta em 'bloqueados' com o motivo (_DEP_EXCLUSAO)
            ids = data.get('ids') if isinstance(data.get('ids'), list) else []
            self._json(200, _crud_bulk_delete('produtos', ids))
        elif p == '/api/produtos/bulk-update':
            # produto não está em CRUD_TABLES (tem handler próprio por causa de
            # lote/estoque), então a lista de campos em massa é explícita aqui
            ids = data.get('ids') if isinstance(data.get('ids'), list) else []
            patch = data.get('patch') if isinstance(data.get('patch'), dict) else {}
            self._json(200, self._bulk_update_produtos(ids, patch))
        elif p == '/api/pedidos/bulk-cancelar':
            ids = data.get('ids') if isinstance(data.get('ids'), list) else []
            self._json(200, self._bulk_cancelar_pedidos(ids))
        elif p == '/api/produtos':
            self._create_produto(data)
        elif p == '/api/fornecedores':
            self._create_fornecedor(data)
        elif p == '/api/fornecedores/sync/preview':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._sync_forn_preview(data)
        elif p == '/api/fornecedores/sync/apply':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._sync_forn_apply(data)
        elif p == '/api/fornecedores/import':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._import_fornecedores(data)
        elif p == '/api/funcionarios/import':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._import_funcionarios(data)
        elif p == '/api/frota/import':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._import_frota(data)
        elif p == '/api/entradas/import':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._import_entradas_fiorilli(data, s)
        elif p == '/api/saidas/import':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._import_saidas_fiorilli(data, s)
        elif p == '/api/pedidos/import':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._import_pedidos_fiorilli(data, s)
        elif p == '/api/centros-custo/import':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._import_centros(data)
        elif p == '/api/pedidos':
            self._create_pedido(data)
        elif p == '/api/entradas':
            self._create_entrada(data, s)
        elif p == '/api/saidas':
            self._create_saida(data, s)
        elif p == '/api/usuarios':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._create_user(data)
        elif p == '/api/audit':
            self._add_audit(data, s)
        elif p == '/api/reconciliacao':
            # Restrita ao administrador como as demais importações: apesar de não
            # alterar produto nem saldo, ela recebe um arquivo, lê o estoque inteiro
            # e grava o evento na trilha de auditoria. Antes, só o botão era
            # escondido — a rota respondia a qualquer usuário logado.
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._reconciliacao(data, s)
        elif p == '/api/reconciliacao/cadastrar':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._reconciliacao_cadastrar(data, s)
        elif p == '/send-email':
            self._send_email(data)
        elif p == '/api/backup/restore':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            self._restore_backup(data, s)
        elif p == '/api/backups/db/now':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            name = _do_db_backup()
            self._json(200, {'ok': bool(name), 'name': name})
        else:
            for seg, table in CRUD_ROUTES.items():
                if p == f'/api/{seg}':
                    try:
                        self._json(201, _crud_create(table, data))
                    except ValueError as e:
                        self._json(400, {'error': str(e)})
                    except sqlite3.IntegrityError:
                        self._json(409, {'error': 'Já existe um registro com esses dados'})
                    return
            self._json(404, {'error': 'Rota não encontrada'})

    def _route_put(self, p, body, s):
        data = self._parse_json(body)

        if re.fullmatch(r'/api/entradas/[^/]+/restore', p):
            self._restore_entrada(p.split('/')[-2])
        elif re.fullmatch(r'/api/saidas/[^/]+/restore', p):
            self._restore_saida(p.split('/')[-2])
        elif re.fullmatch(r'/api/fornecedores/[^/]+/restore', p):
            self._restore_fornecedor(p.split('/')[-2])
        elif re.fullmatch(r'/api/fornecedores/[^/]+', p):
            self._update_fornecedor(p.split('/')[-1], data)
        elif re.fullmatch(r'/api/produtos/[^/]+', p):
            self._update_produto(p.split('/')[-1], data)
        elif re.fullmatch(r'/api/pedidos/[^/]+/cancelar', p):
            self._cancelar_pedido(p.split('/')[-2])
        elif re.fullmatch(r'/api/pedidos/[^/]+/itens/[^/]+/anular', p):
            self._anular_saldo_pedido_item(p.split('/')[-2])
        elif re.fullmatch(r'/api/pedidos/[^/]+', p):
            self._update_pedido(p.split('/')[-1], data)
        elif re.fullmatch(r'/api/entradas/[^/]+', p):
            self._update_entrada(p.split('/')[-1], data)
        elif re.fullmatch(r'/api/saidas/[^/]+', p):
            self._update_saida(p.split('/')[-1], data)
        elif p in ('/api/settings', '/api/settings/'):
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            # portal_transparencia_key é credencial: fica aqui, não na rota de
            # Dados de Organização, que é aberta a qualquer usuário autenticado.
            allowed = {'backup_path', 'auto_backup_enabled', 'auto_backup_keep',
                       'portal_transparencia_key'}
            self._save_settings({k: v for k, v in data.items() if k in allowed})
        elif p in ('/api/settings/org', '/api/settings/org/'):
            allowed = {'orgao', 'municipio', 'cnpj_orgao', 'aut_nome', 'aut_cargo'}
            gravados = {k: v for k, v in data.items() if k in allowed and str(v or '').strip()}
            # Gravação e trilha na MESMA transação, antes de responder: só o que
            # mudou de fato vira evento (a tela reenvia todos os campos a cada
            # "Salvar"). Auditar depois de _save_settings não serve — ela já
            # despacha a resposta, e o evento acabava gravado após o cliente
            # receber o 200.
            with get_db() as conn:
                atuais = {r['key']: r['value'] for r in
                          conn.execute('SELECT key,value FROM sys_settings').fetchall()}
                mudou = sorted(k for k, v in gravados.items() if str(v) != atuais.get(k, ''))
                for k, v in gravados.items():
                    conn.execute('INSERT OR REPLACE INTO sys_settings (key,value) VALUES (?,?)',
                                 (k, v if isinstance(v, str) else json.dumps(v, ensure_ascii=False)))
                if mudou:
                    _audit_config(conn, s, 'Dados da organização alterados', ', '.join(mudou))
            self._json(200, {'ok': True})
        elif p in ('/api/settings/smtp', '/api/settings/smtp/'):
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            allowed = {'smtp_host', 'smtp_port', 'smtp_secure', 'smtp_require_tls',
                       'smtp_ignore_ssl', 'smtp_user', 'smtp_pass', 'smtp_from_name', 'smtp_to'}
            # _save_settings ignora valores vazios, então smtp_pass em branco preserva a senha salva
            self._save_settings({k: v for k, v in data.items() if k in allowed})
        elif p in ('/api/settings/brasao', '/api/settings/brasao/'):
            # Vazio aqui é o sinal explícito de "remover o brasão", ao contrário de
            # /api/settings/org onde um campo vazio nunca sobrescreve o valor salvo.
            dataurl = data.get('brasao_dataurl', '')
            with get_db() as conn:
                if dataurl:
                    conn.execute('INSERT OR REPLACE INTO sys_settings (key,value) VALUES (?,?)', ('brasao_dataurl', dataurl))
                else:
                    conn.execute("DELETE FROM sys_settings WHERE key='brasao_dataurl'")
                _audit_config(conn, s, 'Brasão alterado',
                              'removido' if not dataurl else f'{len(dataurl)} bytes')
            self._json(200, {'ok': True})
        elif re.fullmatch(r'/api/usuarios/[^/]+', p):
            uid = int(p.split('/')[-1])
            if not s['admin']:
                if uid != s['user_id']:
                    self._json(403, {'error': 'Acesso restrito'}); return
                # não-admin: só a própria senha e a própria config SMTP
                data = {k: data[k] for k in ('password', 'old_password', *_USER_SMTP_COLS) if k in data}
            self._update_user(uid, data)
        else:
            for seg, table in CRUD_ROUTES.items():
                if re.fullmatch(rf'/api/{seg}/[^/]+', p):
                    try:
                        item = _crud_update(table, p.split('/')[-1], data)
                        self._json(200, item) if item else self._json(404, {'error': 'Não encontrado'})
                    except sqlite3.IntegrityError:
                        self._json(409, {'error': 'Já existe um registro com esses dados'})
                    return
            self._json(404, {'error': 'Rota não encontrada'})

    def _route_delete(self, p, qs, s):
        if re.fullmatch(r'/api/produtos/[^/]+', p):
            try:
                _crud_delete('produtos', p.split('/')[-1])
                self._json(200, {'ok': True})
            except sqlite3.IntegrityError:
                self._json(409, {'error': 'Não é possível excluir: produto possui lotes/movimentações'})
        elif re.fullmatch(r'/api/fornecedores/[^/]+', p):
            self._delete_fornecedor(p.split('/')[-1], qs.get('purge', ['0'])[0] == '1', s['admin'])
        elif re.fullmatch(r'/api/entradas/[^/]+', p):
            self._delete_entrada(p.split('/')[-1])
        elif re.fullmatch(r'/api/saidas/[^/]+', p):
            self._delete_saida(p.split('/')[-1])
        elif re.fullmatch(r'/api/usuarios/[^/]+', p):
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            uid = int(p.split('/')[-1])
            if uid == s['user_id']:
                self._json(400, {'error': 'Não é possível excluir o próprio usuário'}); return
            with get_db() as conn:
                conn.execute('DELETE FROM usuarios WHERE id=?', (uid,))
            self._json(200, {'ok': True})
        elif p == '/api/wipe':
            if not s['admin']: self._json(403, {'error': 'Acesso restrito'}); return
            with get_db() as conn:
                # Mesma ordem (filho antes do pai) de _BACKUP_TABLES invertida — já
                # validada para respeitar FKs — só tirando sys_settings (mantido) e
                # somando audit_global (não faz parte do backup, mas some no wipe).
                for tbl in reversed(_BACKUP_TABLES):
                    if tbl != 'sys_settings':
                        conn.execute(f'DELETE FROM {tbl}')
                conn.execute('DELETE FROM audit_global')
                _insert_audit_raw(conn, {'type': 'FACTORY_RESET', 'ts': _now(),
                                          'user_id': s['user_id'], 'user_nome': s['nome'],
                                          'label': 'Todos os dados apagados', 'detail': 'Reset de fábrica'})
            self._json(200, {'ok': True})
        else:
            for seg, table in CRUD_ROUTES.items():
                if re.fullmatch(rf'/api/{seg}/[^/]+', p):
                    try:
                        _crud_delete(table, p.split('/')[-1])
                        self._json(200, {'ok': True})
                    except sqlite3.IntegrityError:
                        self._json(409, {'error': _motivo_em_uso(table, p.split('/')[-1])})
                    return
            self._json(404, {'error': 'Rota não encontrada'})

    # ── Auth ──────────────────────────────────────────────────────────────────

    def _token(self):
        auth = self.headers.get('Authorization', '')
        if auth.startswith('Bearer '):
            return auth[7:]
        return parse_qs(urlparse(self.path).query).get('token', [None])[0]

    def _auth(self):
        s = get_session(self._token())
        if not s:
            self._json(401, {'error': 'Não autenticado'})
            return s
        # Troca de senha obrigatória valia só no navegador — ver
        # sgx_base.rota_liberada_sem_trocar_senha.
        if s.get('must_change_password') and not sgx_base.rota_liberada_sem_trocar_senha(
                self.path, self.command, s['user_id']):
            self._json(403, {'error': 'Troque a senha padrão antes de usar o sistema.'})
            return None
        # Sessão deslizante — ver comentário equivalente nos sistemas irmãos:
        # renovar só no ping deixava a sessão morrer com a aba em segundo plano.
        renew_session(self._token())
        return s

    def _user_dict(self, s):
        return {'id': s['user_id'], 'username': s['username'], 'nome': s['nome'], 'admin': bool(s['admin'])}

    def _login(self, body):
        try:
            data = json.loads(body)
            username = data.get('username', '').strip()
            password = data.get('password', '')
        except Exception:
            self._json(400, {'error': 'JSON inválido'}); return

        if _login_rate_limited(username):
            self._json(429, {'error': 'Muitas tentativas de login. Aguarde alguns minutos e tente novamente.'}); return

        with get_db() as conn:
            row = conn.execute('SELECT * FROM usuarios WHERE username=? COLLATE NOCASE AND ativo=1', (username,)).fetchone()

        if not row or not _verify_password(password, row['senha_hash']):
            _record_login_failure(username)
            self._json(401, {'error': 'Usuário ou senha incorretos'}); return

        _clear_login_failures(username)
        global _had_session, _backup_pos_sess
        _had_session = True
        _backup_pos_sess = False
        token = create_session(row['id'])
        self._json(200, {
            'token': token,
            'user': {
                'id': row['id'], 'username': row['username'], 'nome': row['nome'], 'admin': bool(row['admin']),
                'mustChangePassword': bool(row['must_change_password'])
            }
        })

    def _create_user(self, data):
        nome, username, password = (data.get('nome') or '').strip(), (data.get('username') or '').strip(), data.get('password') or ''
        if not nome or not username or not password:
            self._json(400, {'error': 'Nome, usuário e senha são obrigatórios'}); return
        if len(password) < 6:
            self._json(400, {'error': 'Senha mínima: 6 caracteres'}); return
        try:
            with get_db() as conn:
                conn.execute('INSERT INTO usuarios (username,nome,senha_hash,admin,cpf,email,cargo,matricula) VALUES (?,?,?,?,?,?,?,?)',
                             (username, nome, _hash_password(password), int(bool(data.get('admin'))),
                              (data.get('cpf') or '').strip(), (data.get('email') or '').strip(),
                              (data.get('cargo') or '').strip(), (data.get('matricula') or '').strip()))
                uid = conn.execute('SELECT last_insert_rowid()').fetchone()[0]
            self._json(201, {'id': uid, 'username': username, 'nome': nome})
        except sqlite3.IntegrityError:
            self._json(409, {'error': f'Usuário "{username}" já existe'})

    def _update_user(self, uid, data):
        with get_db() as conn:
            if not conn.execute('SELECT 1 FROM usuarios WHERE id=?', (uid,)).fetchone():
                self._json(404, {'error': 'Usuário não encontrado'}); return
            fields, params = [], []
            if 'nome' in data: fields.append('nome=?'); params.append(data['nome'])
            if 'admin' in data: fields.append('admin=?'); params.append(int(bool(data['admin'])))
            if 'ativo' in data: fields.append('ativo=?'); params.append(int(bool(data['ativo'])))
            if 'cpf' in data: fields.append('cpf=?'); params.append((data['cpf'] or '').strip())
            if 'email' in data: fields.append('email=?'); params.append((data['email'] or '').strip())
            if 'cargo' in data: fields.append('cargo=?'); params.append((data['cargo'] or '').strip())
            if 'matricula' in data: fields.append('matricula=?'); params.append((data['matricula'] or '').strip())
            # Config SMTP do usuário — smtp_pass em branco preserva a senha salva
            for col in _USER_SMTP_COLS:
                if col == 'smtp_pass':
                    if data.get('smtp_pass'): fields.append('smtp_pass=?'); params.append(data['smtp_pass'])
                elif col in data:
                    fields.append(f'{col}=?'); params.append(str(data[col] or '').strip())
            if data.get('password'):
                if len(data['password']) < 6:
                    self._json(400, {'error': 'Senha mínima: 6 caracteres'}); return
                if sgx_base.eh_senha_padrao(data['password']):
                    self._json(400, {'error': 'Escolha uma senha diferente da padrão de fábrica.'}); return
                if 'old_password' in data:
                    row = conn.execute('SELECT senha_hash FROM usuarios WHERE id=?', (uid,)).fetchone()
                    if not row or not _verify_password(data['old_password'], row['senha_hash']):
                        self._json(403, {'error': 'Senha atual incorreta'}); return
                fields.append('senha_hash=?'); params.append(_hash_password(data['password']))
                fields.append('must_change_password=0')
            if fields:
                conn.execute(f'UPDATE usuarios SET {",".join(fields)} WHERE id=?', params + [uid])
        self._json(200, {'ok': True})

    def _import_funcionarios(self, data):
        """Importa funcionários de uma lista já parseada no cliente (ex.: folha do
        Fiorilli). Upsert por matrícula (idempotente): matrícula já existente é
        atualizada, nova é inserida. Linhas sem nome são ignoradas."""
        lista = data.get('funcionarios') or []
        cols = ('nome', 'cargo', 'unidade', 'matricula', 'natureza',
                'forma_provimento', 'data_admissao', 'ato_admissao')
        inseridos = atualizados = ignorados = 0
        with get_db() as conn:
            for f in lista:
                vals = {c: str(f.get(c) or '').strip() for c in cols}
                if not vals['nome']:
                    ignorados += 1; continue
                mat = vals['matricula']
                existing = conn.execute(
                    "SELECT id FROM funcionarios WHERE matricula=? AND matricula<>''",
                    (mat,)).fetchone() if mat else None
                if existing:
                    conn.execute(
                        f"UPDATE funcionarios SET {','.join(f'{c}=?' for c in cols)},updated_at=? WHERE id=?",
                        [vals[c] for c in cols] + [_now(), existing['id']])
                    atualizados += 1
                else:
                    conn.execute(
                        f"INSERT INTO funcionarios ({','.join(cols)}) VALUES ({','.join('?' * len(cols))})",
                        [vals[c] for c in cols])
                    inseridos += 1
        self._json(200, {'inseridos': inseridos, 'atualizados': atualizados, 'ignorados': ignorados})

    def _import_frota(self, data):
        """Importa a planilha CONTROLE DE FROTA (CSV ou XLSX). Upsert por número de frota
        (idempotente). O centro de custo vem por nome; casa com o cadastro existente
        (case-insensitive) e, se criar_centros!=False, cria o que faltar."""
        csv_text = data.get('csv') or ''
        xlsx_b64 = data.get('xlsx_b64') or ''
        criar_cc = data.get('criar_centros', True)
        try:
            if xlsx_b64:
                try:
                    raw = base64.b64decode(xlsx_b64)
                except Exception:
                    raise ValueError('Arquivo .xlsx inválido.')
                registros = _frota_registros(_xlsx_para_linhas(raw, 'DADOS'))
            elif csv_text.strip():
                registros = _parse_frota_csv(csv_text)
            else:
                self._json(400, {'error': 'Envie um arquivo CSV ou XLSX.'}); return
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        import_cols = ('numero', 'placa', 'marca', 'modelo', 'combustivel') + FROTA_PECAS_COLS + FROTA_DOC_COLS
        inseridos = atualizados = ignorados = cc_criados = 0
        with get_db() as conn:
            # A planilha traz o centro como "N - NOME" (código + descrição). Casa
            # primeiro pelo CÓDIGO (robusto a variações de grafia do nome) e só
            # depois pelo nome, evitando duplicar centros com o prefixo "N - ".
            cc_by_cod, cc_by_nome = {}, {}
            for r in conn.execute('SELECT id, codigo, nome FROM centros_custo').fetchall():
                if r['codigo'] is not None and str(r['codigo']).strip():
                    cc_by_cod[str(r['codigo']).strip()] = r['id']
                cc_by_nome[(r['nome'] or '').strip().upper()] = r['id']
            for reg in registros:
                numero = (reg.get('numero') or '').strip()
                if not numero:
                    ignorados += 1; continue
                raw_cc = (reg.pop('_centro_custo_nome', '') or '').strip()
                m = re.match(r'^\s*(\d+)\s*-\s*(.*)$', raw_cc)
                cc_cod = m.group(1) if m else None
                cc_nome = (m.group(2).strip() if m else raw_cc)
                cc_id = None
                if cc_cod and cc_cod in cc_by_cod:
                    cc_id = cc_by_cod[cc_cod]
                elif cc_nome and cc_nome.upper() in cc_by_nome:
                    cc_id = cc_by_nome[cc_nome.upper()]
                if cc_id is None and (cc_cod or cc_nome) and criar_cc:
                    cur = conn.execute('INSERT INTO centros_custo (codigo, nome, ativo) VALUES (?, ?, 1)',
                                       (cc_cod, cc_nome or raw_cc))
                    cc_id = cur.lastrowid
                    if cc_cod: cc_by_cod[cc_cod] = cc_id
                    cc_by_nome[(cc_nome or raw_cc).upper()] = cc_id
                    cc_criados += 1
                vals = {c: reg[c] for c in import_cols if c in reg}
                if cc_id is not None:
                    vals['centro_custo_id'] = cc_id
                existing = conn.execute('SELECT id FROM frota WHERE numero=?', (numero,)).fetchone()
                if existing:
                    # Célula em branco NÃO apaga o que já está cadastrado: a planilha é
                    # atualizada aos poucos e reimportada inteira, e uma coluna que o
                    # setor ainda não preencheu chegava aqui como '' zerando a peça que
                    # já estava lá. Para limpar um campo de propósito, editar o veículo
                    # na tela de Frota — o importador só acrescenta e corrige.
                    setc = [c for c in vals if c != 'numero' and str(vals[c] or '').strip()]
                    if setc:
                        conn.execute(f"UPDATE frota SET {','.join(f'{c}=?' for c in setc)},updated_at=? WHERE id=?",
                                     [vals[c] for c in setc] + [_now(), existing['id']])
                    atualizados += 1
                else:
                    cols = list(vals.keys())
                    conn.execute(f"INSERT INTO frota ({','.join(cols)}) VALUES ({','.join('?' * len(cols))})",
                                 [vals[c] for c in cols])
                    inseridos += 1
        self._json(200, {'inseridos': inseridos, 'atualizados': atualizados,
                         'ignorados': ignorados, 'centros_criados': cc_criados})

    def _import_centros(self, data):
        """Importa o cadastro de centros de custo do Fiorilli (CSV).
        Concilia em duas etapas para não duplicar o que já existe: casa primeiro
        pelo CÓDIGO; não achando, casa pelo NOME normalizado e ADOTA esse registro,
        gravando nele o código do arquivo (é o caso dos centros criados sem código
        pela importação da frota, que já têm veículos vinculados)."""
        csv_text = data.get('csv') or ''
        if not csv_text.strip():
            self._json(400, {'error': 'CSV vazio.'}); return
        try:
            registros = _parse_centros_csv(csv_text)
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        cols = ('codigo', 'nome', 'responsavel', 'email')
        inseridos = atualizados = adotados = ignorados = 0
        with get_db() as conn:
            atuais = conn.execute('SELECT id, codigo, nome FROM centros_custo').fetchall()
            por_codigo = {(r['codigo'] or '').strip(): r['id'] for r in atuais if (r['codigo'] or '').strip()}
            # Só os centros que JÁ EXISTIAM entram na busca por nome, e cada um é
            # adotado no máximo uma vez (por isso o pop). Sem isso, duas linhas do
            # arquivo com o mesmo nome mas códigos diferentes (ex.: TRANSPORTE 14 e 15)
            # se fundiriam numa só, descartando um dos códigos do Fiorilli.
            por_nome = {_norm_nome(r['nome']): r['id'] for r in atuais}
            for reg in registros:
                nome = (reg.get('nome') or '').strip()
                if not nome:
                    ignorados += 1; continue
                codigo = (reg.get('codigo') or '').strip()
                vals = {c: (reg.get(c) or '').strip() for c in cols}
                alvo = por_codigo.get(codigo) if codigo else None
                adocao = False
                if alvo is None:
                    alvo = por_nome.pop(_norm_nome(nome), None)   # consome: adota uma vez só
                    adocao = alvo is not None
                if alvo is not None:
                    setc = [c for c in cols if vals[c]]   # não apaga dado existente com string vazia
                    conn.execute(f"UPDATE centros_custo SET {','.join(f'{c}=?' for c in setc)},updated_at=? WHERE id=?",
                                 [vals[c] for c in setc] + [_now(), alvo])
                    if adocao: adotados += 1
                    else: atualizados += 1
                else:
                    cur = conn.execute(f"INSERT INTO centros_custo ({','.join(cols)}) VALUES ({','.join('?' * len(cols))})",
                                       [vals[c] for c in cols])
                    alvo = cur.lastrowid
                    inseridos += 1
                if codigo: por_codigo[codigo] = alvo
        # Nomes repetidos são legítimos no Fiorilli (mesmo nome, códigos distintos):
        # importa fiel e avisa, em vez de fundir e perder um código.
        with get_db() as conn:
            repetidos = [r['nome'] for r in conn.execute(
                'SELECT nome FROM centros_custo GROUP BY nome HAVING COUNT(*) > 1').fetchall()]
        self._json(200, {'inseridos': inseridos, 'atualizados': atualizados,
                         'adotados': adotados, 'ignorados': ignorados,
                         'nomes_repetidos': repetidos})

    def _save_settings(self, data):
        # ponytail: string vazia nunca sobrescreve um valor já salvo — evita que um
        # formulário em branco (ex.: senha SMTP não recarregada) apague a configuração
        # real ao salvar. Para limpar um campo de propósito, edite o banco direto.
        with get_db() as conn:
            for key, value in data.items():
                if value == '' or value is None:
                    continue
                conn.execute('INSERT OR REPLACE INTO sys_settings (key,value) VALUES (?,?)', (key, str(value)))
        self._json(200, {'ok': True})

    # ── Auditoria ────────────────────────────────────────────────────────────

    def _add_audit(self, data, s):
        # user_id/user_nome sempre vêm da sessão autenticada, nunca do body —
        # senão qualquer chamada poderia forjar auditoria em nome de outro usuário.
        with get_db() as conn:
            conn.execute(
                '''INSERT INTO audit_global (id,ts,user_id,user_nome,type,label,detail,process_id)
                   VALUES (?,?,?,?,?,?,?,?)''',
                (str(uuid.uuid4()), _now(), s['user_id'], s['nome'],
                 data.get('type'), data.get('type'), data.get('detail'), data.get('processId'))
            )
        self._json(200, {'ok': True})

    def _list_audit(self, qs):
        def qp(k, d=None):
            v = qs.get(k)
            return v[0] if v else d
        page = sgx_base.int_param(qs, 'page', 1, minimo=1); per = sgx_base.int_param(qs, 'per', 50, minimo=1, maximo=2000)
        q, tipo, de, ate = (qp('q') or '').strip(), qp('tipo') or '', qp('de') or '', qp('ate') or ''
        process_id = qp('processId') or qp('process_id') or ''
        where, params = [], []
        if q:    where.append('(user_nome LIKE ? OR detail LIKE ?)'); params += [f'%{q}%', f'%{q}%']
        if tipo: where.append('type=?'); params.append(tipo)
        if de:   where.append('ts >= ?'); params.append(de)
        if ate:  where.append('ts <= ?'); params.append(ate + 'T23:59:59')
        if process_id: where.append('process_id=?'); params.append(process_id)
        w = ('WHERE ' + ' AND '.join(where)) if where else ''
        with get_db() as conn:
            total = conn.execute(f'SELECT COUNT(*) FROM audit_global {w}', params).fetchone()[0]
            rows = conn.execute(
                f'SELECT * FROM audit_global {w} ORDER BY ts DESC LIMIT ? OFFSET ?',
                params + [per, (page - 1) * per]
            ).fetchall()
        self._json(200, {'total': total, 'page': page, 'per': per, 'items': [dict(r) for r in rows]})

    # ── Produtos / Estoque ───────────────────────────────────────────────────

    def _list_produtos(self, qs):
        q = (qs.get('q', [''])[0] or '').strip()
        somente_ativos = qs.get('somente_ativos', ['0'])[0] == '1'
        where, params = [], []
        if q:
            where.append('(p.nome LIKE ? OR p.codigo_fiorilli LIKE ?)')
            params += [f'%{q}%', f'%{q}%']
        if somente_ativos:
            where.append('p.ativo=1')
        w = ('WHERE ' + ' AND '.join(where)) if where else ''
        with get_db() as conn:
            rows = conn.execute(f'''
                SELECT p.*, c.nome AS centro_custo_nome,
                       COALESCE(v.estoque_fisico,0) AS estoque_fisico,
                       COALESCE(v.estoque_financeiro,0) AS estoque_financeiro,
                       v.proxima_validade
                FROM produtos p
                LEFT JOIN centros_custo c ON c.id=p.centro_custo_id
                LEFT JOIN v_estoque v ON v.produto_id=p.id
                {w} ORDER BY p.nome ASC
            ''', params).fetchall()
        self._json(200, {'items': [dict(r) for r in rows]})

    def _reconciliacao(self, data, s):
        csv_text = data.get('csv') or ''
        data_corte = (data.get('data_corte') or '').strip()
        nome_arq = (data.get('nome') or 'extrato.csv').strip()
        if not csv_text.strip():
            self._json(400, {'error': 'CSV vazio.'}); return
        try:
            fiorilli = _parse_fiorilli_posicao(csv_text)
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        with get_db() as conn:
            # Todos os produtos (não só ativos): item inativo com saldo ainda precisa reconciliar.
            rows = conn.execute('''
                SELECT p.codigo_fiorilli, p.nome, p.unidade_consumo, p.unidade_licitada, p.qtd_por_embalagem,
                       COALESCE(v.estoque_fisico,0) AS estoque_fisico,
                       COALESCE(v.estoque_financeiro,0) AS estoque_financeiro
                FROM produtos p LEFT JOIN v_estoque v ON v.produto_id=p.id
            ''').fetchall()
        resultado = _classificar_reconciliacao(fiorilli, [dict(r) for r in rows], data_corte)
        r = resultado['resumo']
        detalhe = (f"{nome_arq} · corte {data_corte or '—'} · {r['total']} itens: "
                   f"{r['confere']} confere, {r['diverge']} diverge, {r['so_fiorilli']} só Fiorilli, "
                   f"{r['so_sgea']} só SGEA, {r['unidade']} unidade")
        with get_db() as conn:
            conn.execute(
                '''INSERT INTO audit_global (id,ts,user_id,user_nome,type,label,detail,process_id)
                   VALUES (?,?,?,?,?,?,?,?)''',
                (str(uuid.uuid4()), _now(), s['user_id'], s['nome'],
                 'RECONCILIACAO_IMPORTADA', 'RECONCILIACAO_IMPORTADA', detalhe, None))
        self._json(200, resultado)

    def _reconciliacao_cadastrar(self, data, s):
        """Bootstrap: cria produtos (e, opcional, o saldo inicial) a partir dos itens
        do extrato do Fiorilli selecionados. Idempotente por codigo_fiorilli; o saldo
        inicial é uma entrada de abertura (compra_direta, lote sem validade) —
        reversível pela tela de Entradas. Só itens ainda não cadastrados."""
        csv_text = data.get('csv') or ''
        codigos = data.get('codigos') if isinstance(data.get('codigos'), list) else []
        criar_saldo = bool(data.get('criar_saldo', True))
        data_corte = (data.get('data_corte') or '').strip()
        if not csv_text.strip() or not codigos:
            self._json(400, {'error': 'Envie o CSV e ao menos um item.'}); return
        try:
            fiorilli = _parse_fiorilli_posicao(csv_text)
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        data_ent = data_corte if re.fullmatch(r'\d{4}-\d{2}-\d{2}', data_corte) else time.strftime('%Y-%m-%d')
        alvo = set(codigos)
        criados = com_saldo = ignorados = arredondados = 0
        with get_db() as conn:
            existentes = {r['codigo_fiorilli'] for r in conn.execute('SELECT codigo_fiorilli FROM produtos').fetchall()}
            for cod in sorted(alvo):
                F = fiorilli.get(cod)
                if not F or not _CADPRO_RE.match(cod):
                    continue
                if cod in existentes:                 # idempotente: já cadastrado, não recria nem re-lança saldo
                    ignorados += 1; continue
                pid = str(uuid.uuid4())
                unid = _norm_unid(F['unidade']) or 'UN'
                conn.execute(
                    '''INSERT INTO produtos (id, codigo_fiorilli, nome, unidade_consumo, unidade_licitada, qtd_por_embalagem, ativo)
                       VALUES (?,?,?,?,?,1,1)''',
                    (pid, cod, F['descricao'] or cod, unid, unid))
                existentes.add(cod)
                criados += 1
                if criar_saldo:
                    q = int(round(F['estoque']))
                    if abs(F['estoque'] - q) > 1e-9:
                        arredondados += 1
                    if q > 0:                          # estoque zero/negativo do Fiorilli: cria só o cadastro
                        custo = round((F['valor'] or 0) / q, 4)
                        eid = str(uuid.uuid4())
                        conn.execute(
                            '''INSERT INTO entradas (id, tipo, data_entrega, observacao, created_by, origem)
                               VALUES (?, 'compra_direta', ?, ?, ?, 'reconciliacao')''',
                            (eid, data_ent, 'Saldo inicial — importação Fiorilli', s['user_id']))
                        cur = conn.execute(
                            '''INSERT INTO entrada_itens
                               (entrada_id, produto_id, quantidade_unidades, valor_unitario, valor_total, lote_numero, data_validade)
                               VALUES (?,?,?,?,?,?,NULL)''',
                            (eid, pid, q, custo, round(custo * q, 2), 'SALDO INICIAL'))
                        conn.execute(
                            '''INSERT INTO lotes
                               (produto_id, lote_numero, data_validade, quantidade_recebida, quantidade_atual, valor_unitario_custo, entrada_item_id)
                               VALUES (?,?,NULL,?,?,?,?)''',
                            (pid, 'SALDO INICIAL', q, q, custo, cur.lastrowid))
                        com_saldo += 1
            detalhe = (f"corte {data_ent} · {criados} produto(s) criado(s), {com_saldo} com saldo inicial, "
                       f"{ignorados} já existente(s) ignorado(s), {arredondados} quantidade(s) arredondada(s)")
            _insert_audit_raw(conn, {'type': 'RECON_ITENS_CADASTRADOS', 'ts': _now(),
                                     'user_id': s['user_id'], 'user_nome': s['nome'],
                                     'label': 'Itens cadastrados do Fiorilli', 'detail': detalhe})
        self._json(200, {'criados': criados, 'com_saldo': com_saldo,
                         'ignorados': ignorados, 'arredondados': arredondados})

    def _get_produto(self, pid):
        with get_db() as conn:
            row = conn.execute('''
                SELECT p.*, c.nome AS centro_custo_nome,
                       COALESCE(v.estoque_fisico,0) AS estoque_fisico,
                       COALESCE(v.estoque_financeiro,0) AS estoque_financeiro,
                       v.proxima_validade
                FROM produtos p
                LEFT JOIN centros_custo c ON c.id=p.centro_custo_id
                LEFT JOIN v_estoque v ON v.produto_id=p.id
                WHERE p.id=?
            ''', (pid,)).fetchone()
        self._json(200, dict(row)) if row else self._json(404, {'error': 'Produto não encontrado'})

    def _list_lotes(self, pid):
        with get_db() as conn:
            rows = conn.execute('''
                SELECT * FROM lotes WHERE produto_id=? AND quantidade_atual > 0
                ORDER BY (data_validade IS NULL) ASC, data_validade ASC, id ASC
            ''', (pid,)).fetchall()
        self._json(200, {'items': [dict(r) for r in rows]})

    def _create_produto(self, data):
        try:
            _require(data, 'codigo_fiorilli', 'nome')
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        pid = str(uuid.uuid4())
        qtd_emb = int(data.get('qtd_por_embalagem') or 1)
        saldo_inicial = int(data['saldo_inicial']) if data.get('saldo_inicial') else 0
        valor_inicial = _float(data.get('valor_unitario_inicial')) or 0
        try:
            with get_db() as conn:
                conn.execute('''INSERT INTO produtos
                    (id,codigo_fiorilli,nome,centro_custo_id,unidade_licitada,qtd_por_embalagem,
                     unidade_consumo,situacao_licitacao,codigo_licitacao,objeto_licitacao,ativo)
                    VALUES (?,?,?,?,?,?,?,?,?,?,?)''',
                    (pid, data['codigo_fiorilli'].strip(), data['nome'].strip(), data.get('centro_custo_id'),
                     data.get('unidade_licitada'), qtd_emb, data.get('unidade_consumo') or 'UN',
                     data.get('situacao_licitacao'), data.get('codigo_licitacao'), data.get('objeto_licitacao'),
                     int(bool(data.get('ativo', True)))))
                if saldo_inicial > 0:
                    conn.execute('''INSERT INTO lotes
                        (produto_id,lote_numero,data_validade,quantidade_recebida,quantidade_atual,valor_unitario_custo,entrada_item_id)
                        VALUES (?,?,?,?,?,?,NULL)''',
                        (pid, 'SALDO INICIAL', None, saldo_inicial, saldo_inicial, valor_inicial))
        except sqlite3.IntegrityError:
            self._json(409, {'error': f"Já existe produto com código Fiorilli \"{data['codigo_fiorilli']}\""}); return
        with get_db() as conn:
            row = conn.execute('SELECT * FROM produtos WHERE id=?', (pid,)).fetchone()
        self._json(201, dict(row))

    def _update_produto(self, pid, data):
        cols = ['nome', 'centro_custo_id', 'unidade_licitada', 'qtd_por_embalagem', 'unidade_consumo',
                'situacao_licitacao', 'codigo_licitacao', 'objeto_licitacao', 'ativo', 'codigo_fiorilli']
        fields = {k: data[k] for k in cols if k in data}
        if 'ativo' in fields:
            fields['ativo'] = int(bool(fields['ativo']))
        try:
            with get_db() as conn:
                if fields:
                    fields['updated_at'] = _now()
                    conn.execute(f'UPDATE produtos SET {",".join(f"{k}=?" for k in fields)} WHERE id=?',
                                 list(fields.values()) + [pid])
                row = conn.execute('SELECT * FROM produtos WHERE id=?', (pid,)).fetchone()
        except sqlite3.IntegrityError:
            self._json(409, {'error': 'Código Fiorilli já usado por outro produto'}); return
        self._json(200, dict(row)) if row else self._json(404, {'error': 'Produto não encontrado'})

    def _alertas_validade(self, qs):
        dias = int((qs.get('dias', ['30'])[0]) or 30)
        self._json(200, {'items': _lotes_vencendo(dias), 'dias': dias})

    # ── Fornecedores ─────────────────────────────────────────────────────────
    # Cadastro rico (paridade com SGCD): a linha do banco só guarda id/cnpj/
    # razao_social/updated_at/deleted_at como cópia desnormalizada pra JOIN e
    # busca — o objeto inteiro (endereço, QSA, certidões, sanções, etc.) vive
    # em `data` (JSON). Diferente do SGCD, o SGEA tem FK real (pedidos/entradas
    # .fornecedor_id) — não existe `processos[]` embutido pra preservar no
    # upsert, só `certidoes`/`sancoes`.

    def _list_fornecedores(self, qs):
        def qp(k, d=None): v = qs.get(k); return v[0] if v else d
        q = (qp('q', '') or '').strip()
        page = sgx_base.int_param(qs, 'page', 1, minimo=1)
        per = sgx_base.int_param(qs, 'per', 500, minimo=1, maximo=2000)
        trash = qp('trash') == '1'

        where, params = [], []
        where.append('deleted_at IS NOT NULL' if trash else 'deleted_at IS NULL')
        if q:
            where.append('(razao_social LIKE ? OR cnpj LIKE ?)')
            params += [f'%{q}%', f'%{q}%']
        wc = 'WHERE ' + ' AND '.join(where)
        order = 'deleted_at DESC' if trash else 'razao_social ASC'
        with get_db() as conn:
            total = conn.execute(f'SELECT COUNT(*) FROM fornecedores {wc}', params).fetchone()[0]
            rows = conn.execute(
                f'SELECT data,deleted_at FROM fornecedores {wc} ORDER BY {order} LIMIT ? OFFSET ?',
                params + [per, (page - 1) * per]
            ).fetchall()
        items = []
        for r in rows:
            item = json.loads(r['data'])
            item['deletedAt'] = r['deleted_at']
            items.append(item)
        self._json(200, {'total': total, 'items': items})

    def _get_fornecedor(self, fid):
        with get_db() as conn:
            row = conn.execute('SELECT data FROM fornecedores WHERE id=?', (fid,)).fetchone()
        if not row:
            self._json(404, {'error': 'Fornecedor não encontrado'}); return
        self._json(200, json.loads(row['data']))

    def _create_fornecedor(self, data):
        fid = data.get('id') or str(uuid.uuid4())
        data['id'] = fid
        data.setdefault('updatedAt', _now_precise())
        with get_db() as conn:
            # deleted_at por subconsulta: sem isso o REPLACE zerava a coluna e um
            # fornecedor que estava na Lixeira voltava sozinho ao cadastro.
            conn.execute(
                '''INSERT OR REPLACE INTO fornecedores (id,data,cnpj,razao_social,updated_at,deleted_at)
                   VALUES (?,?,?,?,?,(SELECT deleted_at FROM fornecedores WHERE id=?))''',
                (fid, json.dumps(data, ensure_ascii=False),
                 data.get('cnpj'), data.get('razao_social'), data['updatedAt'], fid)
            )
        self._json(200, data)

    # ── Sync peer de fornecedores (cadastro compartilhado da família) ───────────
    # Espelha SGCD/SGCA; ver sgx_base.classificar_merge. SGEA não edita compliance
    # (ceis/cnep/sancoes) — só carrega o que vem do SGCD. Campos locais do SGEA
    # (ex. `ativo`) são preservados no merge (não estão em CAMPOS_FORNECEDOR).
    def _export_fornecedores(self):
        with get_db() as conn:
            rows = conn.execute("SELECT data FROM fornecedores WHERE deleted_at IS NULL").fetchall()
        itens = []
        for r in rows:
            d = json.loads(r['data'])
            if not sgx_base.cnpj_digits(d.get('cnpj')):
                continue
            itens.append({c: d[c] for c in sgx_base.CAMPOS_FORNECEDOR if c in d})
        payload = {'_sgx': 'SGEA', 'tipo': 'fornecedores', 'exportedAt': _now(), 'fornecedores': itens}
        body = json.dumps(payload, ensure_ascii=False).encode('utf-8')
        self.send_response(200); self._cors()
        self.send_header('Content-Type', 'application/json')
        self.send_header('Content-Length', str(len(body)))
        self.send_header('Content-Disposition',
                         f'attachment; filename="SGX_FORN_{time.strftime("%Y-%m-%d_%H-%M-%S")}.json"')
        self.end_headers(); self.wfile.write(body)

    def _forn_entrada_valida(self, data):
        if not isinstance(data, dict) or data.get('tipo') != 'fornecedores' or not isinstance(data.get('fornecedores'), list):
            return None
        return data['fornecedores']

    def _forn_locais(self, conn):
        locais = {}
        for r in conn.execute("SELECT id,data FROM fornecedores WHERE deleted_at IS NULL").fetchall():
            d = json.loads(r['data'])
            dig = sgx_base.cnpj_digits(d.get('cnpj'))
            if dig:
                d['_id'] = r['id']
                locais[dig] = d
        return locais

    def _sync_forn_preview(self, data):
        entrada = self._forn_entrada_valida(data)
        if entrada is None:
            self._json(400, {'error': 'Arquivo não é um cadastro de fornecedores válido'}); return
        with get_db() as conn:
            plano = sgx_base.planejar_sync_fornecedores(self._forn_locais(conn), entrada)
        conflitos = [{'cnpj': c['cnpj'],
                      'local':   {'razao_social': c['local'].get('razao_social'),   'updatedAt': c['local'].get('updatedAt')},
                      'arquivo': {'razao_social': c['entrada'].get('razao_social'), 'updatedAt': c['entrada'].get('updatedAt')}}
                     for c in plano['conflitos']]
        self._json(200, {'inserir': len(plano['inserir']), 'atualizar': len(plano['atualizar']),
                         'conflitos': conflitos, 'ignorados': plano['ignorados'], 'sem_cnpj': plano['sem_cnpj']})

    def _forn_upsert(self, conn, local, item):
        canon = {c: item[c] for c in sgx_base.CAMPOS_FORNECEDOR if c in item}
        if local:
            fid = local['_id']
            base = {k: v for k, v in local.items() if k != '_id'}
            merged = {**base, **canon}   # preserva campos locais (ex. ativo)
        else:
            fid = str(uuid.uuid4())
            merged = dict(canon)
            merged.setdefault('ativo', 1)
        merged['id'] = fid
        merged['syncedAt'] = item.get('updatedAt') or _now_precise()
        merged.setdefault('updatedAt', merged['syncedAt'])
        conn.execute(
            '''INSERT OR REPLACE INTO fornecedores (id,data,cnpj,razao_social,updated_at,deleted_at)
               VALUES (?,?,?,?,?,(SELECT deleted_at FROM fornecedores WHERE id=?))''',
            (fid, json.dumps(merged, ensure_ascii=False),
             merged.get('cnpj'), merged.get('razao_social'), merged.get('updatedAt'), fid))

    def _forn_marcar_synced(self, conn, local, ate):
        fid = local['_id']
        d = {k: v for k, v in local.items() if k != '_id'}
        d['syncedAt'] = ate or d.get('updatedAt')
        conn.execute('UPDATE fornecedores SET data=? WHERE id=?', (json.dumps(d, ensure_ascii=False), fid))

    def _sync_forn_apply(self, data):
        entrada = self._forn_entrada_valida(data)
        if entrada is None:
            self._json(400, {'error': 'Arquivo não é um cadastro de fornecedores válido'}); return
        resolver = data.get('resolver') or {}
        with get_db() as conn:
            locais = self._forn_locais(conn)
            plano = sgx_base.planejar_sync_fornecedores(locais, entrada)
            novos = atualizados = conflitos_aplicados = 0
            for item in plano['inserir']:
                self._forn_upsert(conn, None, item); novos += 1
            for item in plano['atualizar']:
                dig = sgx_base.cnpj_digits(item.get('cnpj'))
                self._forn_upsert(conn, locais.get(dig), item); atualizados += 1
            for c in plano['conflitos']:
                local = locais.get(c['cnpj'])
                if resolver.get(c['cnpj']) == 'arquivo':
                    self._forn_upsert(conn, local, c['entrada']); conflitos_aplicados += 1
                elif local:
                    self._forn_marcar_synced(conn, local, c['entrada'].get('updatedAt'))
            conn.commit()
        self._json(200, {'ok': True, 'novos': novos, 'atualizados': atualizados,
                         'conflitos_aplicados': conflitos_aplicados})

    def _update_fornecedor(self, fid, data):
        with get_db() as conn:
            row = conn.execute('SELECT data FROM fornecedores WHERE id=?', (fid,)).fetchone()
            if not row:
                self._create_fornecedor({**data, 'id': fid}); return
            existing = json.loads(row['data'])
            base_updated_at = data.pop('_baseUpdatedAt', None)
            if base_updated_at is not None and base_updated_at != existing.get('updatedAt'):
                self._json(409, {
                    'error': 'Este fornecedor foi alterado por outro usuário. Recarregue antes de salvar.',
                    'current': existing,
                })
                return
            existing.update(data)
            existing['updatedAt'] = _now_precise()
            conn.execute(
                'UPDATE fornecedores SET data=?,cnpj=?,razao_social=?,updated_at=? WHERE id=?',
                (json.dumps(existing, ensure_ascii=False),
                 existing.get('cnpj'), existing.get('razao_social'), existing['updatedAt'], fid)
            )
        self._json(200, existing)

    def _delete_fornecedor(self, fid, purge, is_admin):
        if purge:
            if not is_admin:
                self._json(403, {'error': 'Acesso restrito'}); return
            with get_db() as conn:
                try:
                    conn.execute('DELETE FROM fornecedores WHERE id=?', (fid,))
                except sqlite3.IntegrityError:
                    self._json(409, {'error': 'Não é possível excluir: fornecedor em uso em pedido/entrada'}); return
            self._json(200, {'ok': True}); return
        with get_db() as conn:
            conn.execute('UPDATE fornecedores SET deleted_at=? WHERE id=?', (_now(), fid))
        self._json(200, {'ok': True})

    def _restore_fornecedor(self, fid):
        with get_db() as conn:
            conn.execute('UPDATE fornecedores SET deleted_at=NULL WHERE id=?', (fid,))
        self._json(200, {'ok': True})

    def _import_fornecedores(self, data):
        # Importa fornecedores de um backup (SGCA/SGCD, mesma forma de dado):
        # upsert por CNPJ. Ao atualizar um existente, preserva certidões e
        # sanções LOCAIS do SGEA e sobrepõe o resto com os dados do arquivo.
        incoming = data.get('fornecedores') if isinstance(data, dict) else None
        if not isinstance(incoming, list):
            self._json(400, {'error': 'Formato inválido: esperado {"fornecedores": [...]} (backup do SGCA/SGCD)'}); return
        novos = atualizados = ignorados = 0
        with get_db() as conn:
            existentes = {}
            for r in conn.execute('SELECT id,cnpj FROM fornecedores WHERE deleted_at IS NULL').fetchall():
                dig = re.sub(r'\D', '', r['cnpj'] or '')
                if dig: existentes[dig] = r['id']
            for f in incoming:
                if not isinstance(f, dict):
                    ignorados += 1; continue
                cnpj_d = re.sub(r'\D', '', f.get('cnpj') or '')
                if len(cnpj_d) != 14:
                    ignorados += 1; continue
                if cnpj_d in existentes:
                    fid = existentes[cnpj_d]
                    row = conn.execute('SELECT data FROM fornecedores WHERE id=?', (fid,)).fetchone()
                    existing = json.loads(row['data']) if row else {}
                    f = {**existing, **f, 'id': fid,
                         'certidoes': existing.get('certidoes', []),
                         'sancoes': existing.get('sancoes', [])}
                    atualizados += 1
                else:
                    fid = f.get('id') or str(uuid.uuid4())
                    existentes[cnpj_d] = fid
                    f['id'] = fid
                    novos += 1
                f['cnpj_digits'] = cnpj_d
                f['updatedAt'] = _now_precise()
                conn.execute(
                    '''INSERT OR REPLACE INTO fornecedores (id,data,cnpj,razao_social,updated_at,deleted_at)
                       VALUES (?,?,?,?,?,(SELECT deleted_at FROM fornecedores WHERE id=?))''',
                    (fid, json.dumps(f, ensure_ascii=False),
                     f.get('cnpj'), f.get('razao_social'), f['updatedAt'], fid)
                )
            conn.commit()
        self._json(200, {'ok': True, 'novos': novos, 'atualizados': atualizados, 'ignorados': ignorados})

    # ── Pedidos ──────────────────────────────────────────────────────────────
    # Fora do motor CRUD genérico (CRUD_TABLES/_crud_*) porque tem itens — o
    # motor só sabe renderizar/gravar campos escalares (ver openCrudModal/
    # saveCrudModal no SGEA.html).

    def _list_pedidos(self, qs):
        q = (qs.get('q', [''])[0] or '').strip()
        where, params = [], []
        if q:
            where.append('(numero LIKE ? OR codigo_licitacao LIKE ?)')
            params += [f'%{q}%', f'%{q}%']
        w = ('WHERE ' + ' AND '.join(where)) if where else ''
        with get_db() as conn:
            rows = conn.execute(f'''
                SELECT pe.*, f.razao_social AS fornecedor_nome
                FROM pedidos pe LEFT JOIN fornecedores f ON f.id=pe.fornecedor_id
                {w} ORDER BY pe.created_at DESC''', params).fetchall()
            items = []
            for r in rows:
                d = dict(r)
                itens = _pedido_itens_com_saldo(conn, d['id'])
                d['status'] = _pedido_status_agregado(d['status'], itens)
                items.append(d)
        self._json(200, {'items': items})

    def _get_pedido_dict(self, pid):
        with get_db() as conn:
            pe = conn.execute('''
                SELECT pe.*, f.razao_social AS fornecedor_nome
                FROM pedidos pe LEFT JOIN fornecedores f ON f.id=pe.fornecedor_id
                WHERE pe.id=?''', (pid,)).fetchone()
            if not pe:
                return None
            itens = _pedido_itens_com_saldo(conn, pid)
        result = dict(pe)
        result['itens'] = itens
        result['status'] = _pedido_status_agregado(result['status'], itens)
        return result

    def _create_pedido(self, data):
        try:
            _require(data, 'numero')
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        itens = data.get('itens') or []
        if not itens:
            self._json(400, {'error': 'Informe ao menos um item'}); return

        pid = str(uuid.uuid4())
        try:
            with get_db() as conn:
                conn.execute('''INSERT INTO pedidos
                    (id,numero,codigo_licitacao,data_pedido,fornecedor_id,status,data_entrega_prevista)
                    VALUES (?,?,?,?,?,'aberto',?)''',
                    (pid, data['numero'], data.get('codigo_licitacao'), data.get('data_pedido'),
                     data.get('fornecedor_id'), data.get('data_entrega_prevista')))
                for it in itens:
                    pid_prod = it.get('produto_id')
                    qtd = int(it.get('quantidade_pedida') or 0)
                    if not pid_prod or qtd <= 0:
                        raise ValueError('Item inválido: produto e quantidade pedida são obrigatórios')
                    conn.execute('''INSERT INTO pedido_itens
                        (pedido_id,produto_id,quantidade_pedida,valor_unitario,marca)
                        VALUES (?,?,?,?,?)''',
                        (pid, pid_prod, qtd, float(it.get('valor_unitario') or 0), it.get('marca') or ''))
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        except sqlite3.IntegrityError:
            self._json(409, {'error': 'Já existe um pedido com esse número/licitação, ou item duplicado'}); return
        self._json(201, self._get_pedido_dict(pid))

    def _import_pedidos_fiorilli(self, data, s):
        """Importa pedidos do CSV 'PEDIDO' do Fiorilli: cria o pedido com seus itens,
        criando fornecedor (por CNPJ) e produto (por codigo_fiorilli) que faltarem.
        Idempotente pelo número do pedido.

        Dois cuidados que não são óbvios:
        - a quantidade do Fiorilli vem na unidade LICITADA e `quantidade_pedida` é
          comparada com as entradas, que estão em unidade de CONSUMO — daí a
          multiplicação pela embalagem do produto;
        - `UNIQUE(pedido_id, produto_id)` obriga a somar as linhas que repetem o mesmo
          CADPRO (itens diferentes da licitação podem cair no mesmo produto)."""
        csv_text = data.get('csv') or ''
        if not csv_text.strip():
            self._json(400, {'error': 'CSV vazio.'}); return
        try:
            peds = _parse_fiorilli_pedido(csv_text)
        except ValueError as e:
            self._json(400, {'error': str(e)}); return

        r = {'pedidos': 0, 'itens': 0, 'produtos_criados': 0, 'fornecedores_criados': 0,
             'ja_existentes': 0, 'itens_pulados': 0, 'com_entrega_no_fiorilli': []}
        with get_db() as conn:
            forn_by_cnpj = {re.sub(r'\D', '', (x['cnpj'] or '')): x['id']
                            for x in conn.execute('SELECT id, cnpj FROM fornecedores WHERE deleted_at IS NULL').fetchall() if x['cnpj']}
            prod = {x['codigo_fiorilli']: (x['id'], x['qtd_por_embalagem'] or 1)
                    for x in conn.execute('SELECT id, codigo_fiorilli, qtd_por_embalagem FROM produtos').fetchall()}
            existentes = {x['numero'] for x in conn.execute('SELECT numero FROM pedidos').fetchall()}
            for ped in peds:
                if ped['numero'] in existentes:
                    r['ja_existentes'] += 1; continue
                cnpjd = re.sub(r'\D', '', ped['cnpj'])
                fid = forn_by_cnpj.get(cnpjd)
                if not fid and cnpjd:
                    fid = str(uuid.uuid4())
                    blob = {'id': fid, 'razao_social': ped['fornecedor_nome'], 'cnpj': ped['cnpj'],
                            'cnpj_digits': cnpjd, 'updatedAt': _now_precise()}
                    conn.execute('INSERT INTO fornecedores (id,data,cnpj,razao_social,updated_at) VALUES (?,?,?,?,?)',
                                 (fid, json.dumps(blob, ensure_ascii=False), ped['cnpj'], ped['fornecedor_nome'], _now()))
                    forn_by_cnpj[cnpjd] = fid; r['fornecedores_criados'] += 1

                # agrega por produto antes de gravar (UNIQUE(pedido_id, produto_id))
                agregado = {}
                for it in ped['itens']:
                    cad = it['cadpro']
                    if not _CADPRO_RE.match(cad):
                        r['itens_pulados'] += 1; continue
                    if cad not in prod:
                        pid_prod = str(uuid.uuid4()); unid = _norm_unid(it['unid']) or 'UN'
                        conn.execute('''INSERT INTO produtos (id,codigo_fiorilli,nome,unidade_consumo,unidade_licitada,qtd_por_embalagem,ativo)
                                        VALUES (?,?,?,?,?,1,1)''',
                                     (pid_prod, cad, it['desc'] or cad, unid, unid))
                        prod[cad] = (pid_prod, 1); r['produtos_criados'] += 1
                    pid_prod, emb = prod[cad]
                    qtd = int(round(it['qtd'] * (emb or 1)))
                    if qtd <= 0:
                        r['itens_pulados'] += 1; continue
                    a = agregado.setdefault(pid_prod, {'qtd': 0, 'anulada': 0, 'valor': 0.0, 'marca': ''})
                    a['qtd'] += qtd
                    a['anulada'] += int(round(it['qtd_anulada'] * (emb or 1)))
                    a['valor'] = round(it['valor'] / (emb or 1), 4)   # por unidade de consumo
                    a['marca'] = a['marca'] or it['marca']
                    if it['qtd_entregue'] > 0:
                        r['com_entrega_no_fiorilli'].append(f"{ped['numero']} — {cad}: {it['qtd_entregue']:g} já entregue(s) no Fiorilli")
                if not agregado:
                    continue

                pid = str(uuid.uuid4())
                conn.execute('''INSERT INTO pedidos
                    (id,numero,codigo_licitacao,data_pedido,fornecedor_id,status,data_entrega_prevista,origem)
                    VALUES (?,?,?,?,?,'aberto',?,'fiorilli')''',
                    (pid, ped['numero'], ped['proclic'] or None, ped['data_pedido'], fid,
                     ped['data_entrega_prevista']))
                r['pedidos'] += 1
                for pid_prod, a in agregado.items():
                    conn.execute('''INSERT INTO pedido_itens
                        (pedido_id,produto_id,quantidade_pedida,quantidade_anulada,valor_unitario,marca)
                        VALUES (?,?,?,?,?,?)''',
                        (pid, pid_prod, a['qtd'], a['anulada'], a['valor'], a['marca']))
                    r['itens'] += 1
            _insert_audit_raw(conn, {'type': 'PEDIDO_IMPORTADO', 'ts': _now(),
                'user_id': s['user_id'], 'user_nome': s['nome'], 'label': 'Pedidos importados do Fiorilli',
                'detail': (f"{r['pedidos']} pedido(s), {r['itens']} item(ns); "
                           f"{r['produtos_criados']} produto(s), {r['fornecedores_criados']} fornecedor(es) criado(s); "
                           f"{r['ja_existentes']} já existente(s)")})
        self._json(200, r)

    def _update_pedido(self, pid, data):
        # Só cabeçalho — itens são imutáveis após criação (o saldo de outras
        # entradas já pode depender da quantidade_pedida original) e status
        # não é mais editável aqui, só via _cancelar_pedido.
        cols = ['numero', 'codigo_licitacao', 'data_pedido', 'fornecedor_id', 'data_entrega_prevista']
        fields = {k: data[k] for k in cols if k in data}
        with get_db() as conn:
            row = conn.execute('SELECT id FROM pedidos WHERE id=?', (pid,)).fetchone()
            if not row:
                self._json(404, {'error': 'Não encontrado'}); return
            if fields:
                fields['updated_at'] = _now()
                conn.execute(f'UPDATE pedidos SET {",".join(f"{k}=?" for k in fields)} WHERE id=?',
                             list(fields.values()) + [pid])
        self._json(200, self._get_pedido_dict(pid))

    def _anular_saldo_pedido_item(self, item_id):
        with get_db() as conn:
            item = conn.execute('SELECT * FROM pedido_itens WHERE id=?', (item_id,)).fetchone()
            if not item:
                self._json(404, {'error': 'Item de pedido não encontrado'}); return
            itens = _pedido_itens_com_saldo(conn, item['pedido_id'])
            alvo = next((i for i in itens if i['id'] == int(item_id)), None)
            if not alvo or alvo['saldo'] <= 0:
                self._json(409, {'error': 'Este item não tem saldo remanescente para anular'}); return
            conn.execute('UPDATE pedido_itens SET quantidade_anulada = quantidade_anulada + ? WHERE id=?',
                         (alvo['saldo'], item_id))
        self._json(200, self._get_pedido_dict(item['pedido_id']))

    def _bulk_update_produtos(self, ids, patch):
        """Ativar/inativar e reatribuir centro de custo em massa. Só essas duas
        colunas: o resto do cadastro (embalagem, unidade, código) muda o cálculo de
        estoque e não faz sentido aplicar em lote sem olhar produto a produto."""
        fields = {}
        if 'ativo' in patch:
            fields['ativo'] = int(bool(patch['ativo']))
        if 'centro_custo_id' in patch:
            fields['centro_custo_id'] = patch['centro_custo_id'] or None
        if not fields or not ids:
            return {'atualizados': 0}
        fields['updated_at'] = _now()
        sets = ','.join(f'{k}=?' for k in fields)
        n = 0
        with get_db() as conn:
            for id_ in ids:
                n += conn.execute(f'UPDATE produtos SET {sets} WHERE id=?',
                                  list(fields.values()) + [id_]).rowcount
        return {'atualizados': n}

    def _bulk_cancelar_pedidos(self, ids):
        """Cancela vários pedidos. Pedido não tem exclusão — cancelar anula o saldo
        pendente de cada item. Quem já está atendido ou cancelado volta em
        'bloqueados', como na exclusão em massa dos cadastros."""
        cancelados, bloqueados = [], []
        with get_db() as conn:
            for pid in ids:
                row = conn.execute('SELECT * FROM pedidos WHERE id=?', (pid,)).fetchone()
                if not row:
                    bloqueados.append({'id': pid, 'motivo': 'Pedido não encontrado.'}); continue
                itens = _pedido_itens_com_saldo(conn, pid)
                status_atual = _pedido_status_agregado(row['status'], itens)
                if status_atual in ('atendido', 'cancelado'):
                    bloqueados.append({'id': pid, 'motivo': f'Pedido já está {status_atual}.'}); continue
                for it in itens:
                    if it['saldo'] > 0:
                        conn.execute('UPDATE pedido_itens SET quantidade_anulada = quantidade_anulada + ? WHERE id=?',
                                     (it['saldo'], it['id']))
                conn.execute("UPDATE pedidos SET status='cancelado', updated_at=? WHERE id=?", (_now(), pid))
                cancelados.append(pid)
        return {'cancelados': cancelados, 'bloqueados': bloqueados}

    def _cancelar_pedido(self, pid):
        with get_db() as conn:
            row = conn.execute('SELECT * FROM pedidos WHERE id=?', (pid,)).fetchone()
            if not row:
                self._json(404, {'error': 'Não encontrado'}); return
            itens = _pedido_itens_com_saldo(conn, pid)
            status_atual = _pedido_status_agregado(row['status'], itens)
            if status_atual in ('atendido', 'cancelado'):
                self._json(409, {'error': f'Pedido já está {status_atual}, não há o que cancelar'}); return
            for it in itens:
                if it['saldo'] > 0:
                    conn.execute('UPDATE pedido_itens SET quantidade_anulada = quantidade_anulada + ? WHERE id=?',
                                 (it['saldo'], it['id']))
            conn.execute("UPDATE pedidos SET status='cancelado', updated_at=? WHERE id=?", (_now(), pid))
        self._json(200, self._get_pedido_dict(pid))

    # ── Entradas ─────────────────────────────────────────────────────────────

    def _list_entradas(self, trash=False):
        cmp = 'IS NOT NULL' if trash else 'IS NULL'
        order = 'e.deleted_at DESC' if trash else 'e.data_entrega DESC, e.created_at DESC'
        with get_db() as conn:
            rows = conn.execute(f'''
                SELECT e.*, f.razao_social AS fornecedor_nome, pe.numero AS pedido_numero,
                       c.nome AS centro_custo_nome, fu.nome AS recebedor_nome
                FROM entradas e
                LEFT JOIN fornecedores f ON f.id=e.fornecedor_id
                LEFT JOIN pedidos pe ON pe.id=e.pedido_id
                LEFT JOIN centros_custo c ON c.id=e.centro_custo_id
                LEFT JOIN funcionarios fu ON fu.id=e.recebedor_id
                WHERE e.deleted_at {cmp}
                ORDER BY {order}
            ''').fetchall()
        self._json(200, {'items': [dict(r) for r in rows]})

    def _get_entrada_dict(self, eid):
        with get_db() as conn:
            e = conn.execute('''
                SELECT e.*, f.razao_social AS fornecedor_nome, pe.numero AS pedido_numero,
                       c.nome AS centro_custo_nome, fu.nome AS recebedor_nome
                FROM entradas e
                LEFT JOIN fornecedores f ON f.id=e.fornecedor_id
                LEFT JOIN pedidos pe ON pe.id=e.pedido_id
                LEFT JOIN centros_custo c ON c.id=e.centro_custo_id
                LEFT JOIN funcionarios fu ON fu.id=e.recebedor_id
                WHERE e.id=?''', (eid,)).fetchone()
            if not e:
                return None
            itens = conn.execute('''
                SELECT ei.*, p.nome AS produto_nome, p.unidade_consumo
                FROM entrada_itens ei JOIN produtos p ON p.id=ei.produto_id
                WHERE ei.entrada_id=?''', (eid,)).fetchall()
        result = dict(e)
        result['itens'] = [dict(i) for i in itens]
        return result

    # ── Itens: mesmos passos na criacao e na edicao ──────────────────────────
    # Extraidos do _create_entrada/_create_saida para a edicao nao virar uma
    # segunda implementacao das mesmas regras (conversao de embalagem, saldo do
    # pedido, FEFO). Editar = trocar os itens pelos novos, com o mesmo codigo que
    # os gravou da primeira vez.

    @staticmethod
    def _resolver_itens_entrada(conn, itens):
        """Valida e normaliza os itens da entrada (embalagem -> unidades)."""
        resolvidos = []
        for it in itens:
            pid = it.get('produto_id')
            if not pid:
                raise ValueError('Item sem produto_id')
            produto = conn.execute('SELECT qtd_por_embalagem FROM produtos WHERE id=?', (pid,)).fetchone()
            if not produto:
                raise ValueError(f'Produto {pid} não encontrado')
            qtd_emb = _float(it.get('quantidade_embalagem'))
            qtd_un = it.get('quantidade_unidades')
            if qtd_un is None:
                if qtd_emb is None:
                    raise ValueError('Informe quantidade_embalagem ou quantidade_unidades')
                qtd_un = round(qtd_emb * produto['qtd_por_embalagem'])
            qtd_un = int(qtd_un)
            if qtd_un <= 0:
                raise ValueError('Quantidade deve ser maior que zero')
            resolvidos.append({
                'produto_id': pid, 'qtd_emb': qtd_emb, 'qtd_un': qtd_un,
                'valor_unit': _float(it.get('valor_unitario')) or 0,
                'lote_numero': it.get('lote_numero'), 'data_validade': it.get('data_validade'),
            })
        return resolvidos

    @staticmethod
    def _validar_saldo_pedido(conn, pedido_id, resolvidos, ignorar_entrada_id=None):
        if not pedido_id:
            return
        agregado = {}
        for r in resolvidos:
            agregado[r['produto_id']] = agregado.get(r['produto_id'], 0) + r['qtd_un']
        pedido_itens = {i['produto_id']: i for i in _pedido_itens_com_saldo(conn, pedido_id, ignorar_entrada_id)}
        for produto_id, qtd_solicitada in agregado.items():
            pi = pedido_itens.get(produto_id)
            if not pi:
                raise SaldoPedidoExcedido(f'Produto {produto_id} não faz parte deste pedido')
            if qtd_solicitada > pi['saldo']:
                raise SaldoPedidoExcedido(
                    f'Quantidade solicitada ({qtd_solicitada}) excede o saldo do pedido '
                    f'para {pi["produto_nome"]} (saldo: {pi["saldo"]})')

    @staticmethod
    def _gravar_itens_entrada(conn, eid, resolvidos):
        """Grava entrada_itens + o lote correspondente de cada item."""
        for r in resolvidos:
            valor_total = round(r['valor_unit'] * r['qtd_un'], 2)
            cur = conn.execute("""INSERT INTO entrada_itens
                (entrada_id,produto_id,quantidade_embalagem,quantidade_unidades,valor_unitario,valor_total,lote_numero,data_validade)
                VALUES (?,?,?,?,?,?,?,?)""",
                (eid, r['produto_id'], r['qtd_emb'], r['qtd_un'], r['valor_unit'], valor_total,
                 r['lote_numero'], r['data_validade']))
            conn.execute("""INSERT INTO lotes
                (produto_id,lote_numero,data_validade,quantidade_recebida,quantidade_atual,valor_unitario_custo,entrada_item_id)
                VALUES (?,?,?,?,?,?,?)""",
                (r['produto_id'], r['lote_numero'], r['data_validade'], r['qtd_un'], r['qtd_un'],
                 r['valor_unit'], cur.lastrowid))

    @staticmethod
    def _entrada_tem_lote_consumido(conn, eid):
        return conn.execute("""
            SELECT COUNT(*) FROM lotes l JOIN entrada_itens ei ON ei.id=l.entrada_item_id
            WHERE ei.entrada_id=? AND l.quantidade_atual < l.quantidade_recebida
        """, (eid,)).fetchone()[0] > 0

    @staticmethod
    def _saida_estornar(conn, sid):
        """Devolve aos lotes tudo que esta saida consumiu (mesmo passo da exclusao)."""
        rows = conn.execute("""
            SELECT sil.lote_id, sil.quantidade FROM saida_item_lotes sil
            JOIN saida_itens si ON si.id=sil.saida_item_id
            WHERE si.saida_id=?""", (sid,)).fetchall()
        for r in rows:
            conn.execute('UPDATE lotes SET quantidade_atual = quantidade_atual + ? WHERE id=?',
                         (r['quantidade'], r['lote_id']))

    @staticmethod
    def _gravar_itens_saida(conn, sid, itens):
        """Grava saida_itens consumindo do estoque por FEFO."""
        for it in itens:
            pid = it.get('produto_id')
            qtd = int(it.get('quantidade') or 0)
            if not pid or qtd <= 0:
                raise ValueError('Item inválido: produto e quantidade são obrigatórios')
            consumos, valor_medio, valor_total = _consumir_fefo(conn, pid, qtd)
            cur = conn.execute("""INSERT INTO saida_itens
                (saida_id,produto_id,quantidade,valor_unitario_medio,valor_total)
                VALUES (?,?,?,?,?)""", (sid, pid, qtd, valor_medio, valor_total))
            for lote_id, qtd_consumida, custo in consumos:
                conn.execute("""INSERT INTO saida_item_lotes
                    (saida_item_id,lote_id,quantidade,valor_unitario_custo)
                    VALUES (?,?,?,?)""", (cur.lastrowid, lote_id, qtd_consumida, custo))

    def _create_entrada(self, data, s):
        tipo = data.get('tipo') or ('pedido' if data.get('pedido_id') else 'compra_direta')
        if tipo not in ('pedido', 'compra_direta'):
            self._json(400, {'error': 'Tipo inválido'}); return
        itens = data.get('itens') or []
        if not itens:
            self._json(400, {'error': 'Informe ao menos um item'}); return
        try:
            _require(data, 'data_entrega')
        except ValueError as e:
            self._json(400, {'error': str(e)}); return

        eid = str(uuid.uuid4())
        pedido_id = data.get('pedido_id') if tipo == 'pedido' else None
        try:
            with get_db() as conn:
                # 1ª passada: resolve quantidade_unidades de cada item (conversão
                # embalagem→unidade incluída) antes de inserir qualquer coisa —
                # precisamos do total por produto pra validar contra o saldo do
                # pedido (passo seguinte) sem já ter gravado nada.
                resolvidos = self._resolver_itens_entrada(conn, itens)

                self._validar_saldo_pedido(conn, pedido_id, resolvidos)

                conn.execute('''INSERT INTO entradas
                    (id,pedido_id,tipo,fornecedor_id,nfe_numero,nfe_chave_acesso,data_entrega,
                     recebedor_id,centro_custo_id,observacao,created_by,requisicao,data_requisicao,tipo_fiorilli)
                    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)''',
                    (eid, data.get('pedido_id'), tipo, data.get('fornecedor_id'), data.get('nfe_numero'),
                     data.get('nfe_chave_acesso'), data['data_entrega'], data.get('recebedor_id'),
                     data.get('centro_custo_id'), data.get('observacao'), s['user_id'],
                     (data.get('requisicao') or '').strip(), (data.get('data_requisicao') or '').strip(),
                     (data.get('tipo_fiorilli') or '').strip()))
                self._gravar_itens_entrada(conn, eid, resolvidos)
        except SaldoPedidoExcedido as e:
            self._json(409, {'error': str(e)}); return
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        self._json(201, self._get_entrada_dict(eid))

    def _import_entradas_fiorilli(self, data, s):
        """Importa entradas a partir do CSV 'REQUISIÇÃO DE ENTRADA' do Fiorilli:
        cria a entrada + itens + lotes (com validade). Idempotente por nº de
        requisição (REQUI). Produto (por codigo_fiorilli), fornecedor (por CNPJ) e
        centro de custo (por código) que faltarem são criados a partir do próprio CSV."""
        csv_text = data.get('csv') or ''
        if not csv_text.strip():
            self._json(400, {'error': 'CSV vazio.'}); return
        criar_prod = data.get('criar_produtos', True)
        criar_forn = data.get('criar_fornecedores', True)
        try:
            reqs = _parse_fiorilli_entrada(csv_text)
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        r = {'entradas': 0, 'itens': 0, 'produtos_criados': 0, 'fornecedores_criados': 0,
             'centros_criados': 0, 'ja_existentes': 0, 'itens_pulados': 0}
        with get_db() as conn:
            forn_by_cnpj = {re.sub(r'\D', '', (x['cnpj'] or '')): x['id']
                            for x in conn.execute('SELECT id, cnpj FROM fornecedores WHERE deleted_at IS NULL').fetchall() if x['cnpj']}
            prod_by_cad = {x['codigo_fiorilli']: x['id'] for x in conn.execute('SELECT id, codigo_fiorilli FROM produtos').fetchall()}
            cc_by_cod = {str(x['codigo']).strip(): x['id'] for x in conn.execute('SELECT id, codigo FROM centros_custo').fetchall() if x['codigo']}
            func_by_nome = {(x['nome'] or '').strip().upper(): x['id'] for x in conn.execute('SELECT id, nome FROM funcionarios').fetchall()}
            existentes = {x['requisicao'] for x in conn.execute("SELECT requisicao FROM entradas WHERE requisicao IS NOT NULL AND requisicao<>''").fetchall()}
            for req in reqs:
                if req['requisicao'] in existentes:
                    r['ja_existentes'] += 1; continue
                # fornecedor por CNPJ
                cnpjd = re.sub(r'\D', '', req['cnpj'])
                fid = forn_by_cnpj.get(cnpjd)
                if not fid and cnpjd and criar_forn:
                    fid = str(uuid.uuid4())
                    blob = {'id': fid, 'razao_social': req['fornecedor_nome'], 'cnpj': req['cnpj'],
                            'cnpj_digits': cnpjd, 'updatedAt': _now_precise()}
                    conn.execute('INSERT INTO fornecedores (id,data,cnpj,razao_social,updated_at) VALUES (?,?,?,?,?)',
                                 (fid, json.dumps(blob, ensure_ascii=False), req['cnpj'], req['fornecedor_nome'], _now()))
                    forn_by_cnpj[cnpjd] = fid; r['fornecedores_criados'] += 1
                # centro por código ("N - NOME" ou "N")
                m = re.match(r'^\s*(\d+)', req['centro_raw'])
                cc_cod = m.group(1) if m else None
                cc_id = cc_by_cod.get(cc_cod) if cc_cod else None
                if not cc_id and cc_cod:
                    nome_cc = re.sub(r'^\s*\d+\s*-\s*', '', req['centro_raw']).strip() or req['centro_raw']
                    cur = conn.execute('INSERT INTO centros_custo (codigo,nome,ativo) VALUES (?,?,1)', (cc_cod, nome_cc))
                    cc_id = cur.lastrowid; cc_by_cod[cc_cod] = cc_id; r['centros_criados'] += 1
                receb_id = func_by_nome.get(req['responsavel'].upper()) if req['responsavel'] else None
                eid = str(uuid.uuid4())
                obs = f"Importado do Fiorilli — requisição {req['requisicao']}"
                if req['proclic']: obs += f"; processo licitatório {req['proclic']}"
                conn.execute('''INSERT INTO entradas
                    (id,tipo,fornecedor_id,nfe_numero,data_entrega,recebedor_id,centro_custo_id,observacao,created_by,requisicao,data_requisicao,tipo_fiorilli,origem)
                    VALUES (?, 'compra_direta', ?,?,?,?,?,?,?,?,?,?,'fiorilli')''',
                    (eid, fid, req['documento'], req['data_entrega'], receb_id, cc_id, obs, s['user_id'],
                     req['requisicao'], req['data_requisicao'], req['tprequi']))
                r['entradas'] += 1
                for it in req['itens']:
                    cad = it['cadpro']
                    if not _CADPRO_RE.match(cad):
                        r['itens_pulados'] += 1; continue
                    pid = prod_by_cad.get(cad)
                    if not pid:
                        if not criar_prod:
                            r['itens_pulados'] += 1; continue
                        pid = str(uuid.uuid4()); unid = _norm_unid(it['unid']) or 'UN'
                        conn.execute('''INSERT INTO produtos (id,codigo_fiorilli,nome,unidade_consumo,unidade_licitada,qtd_por_embalagem,ativo)
                                        VALUES (?,?,?,?,?,1,1)''',
                                     (pid, cad, it['desc'] or cad, unid, unid))
                        prod_by_cad[cad] = pid; r['produtos_criados'] += 1
                    q = int(round(it['qtd']))
                    if q <= 0:
                        r['itens_pulados'] += 1; continue
                    custo = round(it['valor'], 4)
                    lote = it['lote'] or None
                    val = it['validade'] or None
                    cur = conn.execute('''INSERT INTO entrada_itens
                        (entrada_id,produto_id,quantidade_unidades,valor_unitario,valor_total,lote_numero,data_validade)
                        VALUES (?,?,?,?,?,?,?)''',
                        (eid, pid, q, custo, round(custo * q, 2), lote, val))
                    conn.execute('''INSERT INTO lotes
                        (produto_id,lote_numero,data_validade,quantidade_recebida,quantidade_atual,valor_unitario_custo,entrada_item_id)
                        VALUES (?,?,?,?,?,?,?)''',
                        (pid, lote, val, q, q, custo, cur.lastrowid))
                    r['itens'] += 1
            _insert_audit_raw(conn, {'type': 'ENTRADA_IMPORTADA', 'ts': _now(),
                'user_id': s['user_id'], 'user_nome': s['nome'], 'label': 'Entradas importadas do Fiorilli',
                'detail': (f"{r['entradas']} entrada(s), {r['itens']} item(ns); "
                           f"{r['produtos_criados']} produto(s), {r['fornecedores_criados']} fornecedor(es), "
                           f"{r['centros_criados']} centro(s) criado(s); {r['ja_existentes']} requisição(ões) já existente(s)")})
        self._json(200, r)

    def _update_entrada(self, eid, data):
        """Edita a entrada. Cabeçalho sempre; itens só enquanto o lote está intacto.

        Item de entrada VIRA lote — mexer nele mexe no estoque. Enquanto nenhuma
        saída consumiu daquele lote, regravar é seguro: apaga os lotes desta entrada
        (todos com quantidade_atual == quantidade_recebida) e recria pelo mesmo
        caminho da criação. Depois que alguém consumiu, não dá: reduzir a quantidade
        deixaria saída baixada de estoque que não existiu. Aí a resposta é 409, com a
        mesma regra da exclusão — quem precisa corrigir estorna a saída antes.
        """
        cols = ['nfe_numero', 'nfe_chave_acesso', 'observacao', 'recebedor_id', 'fornecedor_id',
                'centro_custo_id', 'data_entrega', 'requisicao', 'data_requisicao']
        fields = {k: data[k] for k in cols if k in data}
        itens = data.get('itens')
        try:
            with get_db() as conn:
                row = conn.execute('SELECT id, pedido_id FROM entradas WHERE id=? AND deleted_at IS NULL', (eid,)).fetchone()
                if not row:
                    self._json(404, {'error': 'Não encontrada'}); return

                if itens is not None:
                    if not itens:
                        raise ValueError('Informe ao menos um item')
                    if self._entrada_tem_lote_consumido(conn, eid):
                        self._json(409, {'error': 'Não é possível editar os itens: já há saída consumindo lote(s) desta entrada. '
                                                  'Estorne a saída antes, ou corrija apenas os dados do cabeçalho.'}); return
                    resolvidos = self._resolver_itens_entrada(conn, itens)
                    # o que ESTA entrada trouxe sai da conta do saldo do pedido: o
                    # confronto é entre os itens novos e o saldo sem ela
                    self._validar_saldo_pedido(conn, row['pedido_id'], resolvidos, ignorar_entrada_id=eid)
                    conn.execute('DELETE FROM lotes WHERE entrada_item_id IN '
                                 '(SELECT id FROM entrada_itens WHERE entrada_id=?)', (eid,))
                    conn.execute('DELETE FROM entrada_itens WHERE entrada_id=?', (eid,))
                    self._gravar_itens_entrada(conn, eid, resolvidos)

                fields['updated_at'] = _now()
                conn.execute(f'UPDATE entradas SET {",".join(f"{k}=?" for k in fields)} WHERE id=?',
                             list(fields.values()) + [eid])
        except SaldoPedidoExcedido as e:
            self._json(409, {'error': str(e)}); return
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        self._json(200, self._get_entrada_dict(eid))

    def _update_saida(self, sid, data):
        """Edita a saída. Cabeçalho sempre; itens estornam e voltam a consumir.

        Editar item de saída é devolver aos lotes o que ela tinha baixado e consumir
        de novo por FEFO, com os itens novos — a mesma dupla que a Lixeira já usa ao
        excluir e restaurar. Se faltar saldo para a nova composição, a transação
        inteira volta atrás e a saída fica exatamente como estava.

        A composição por lote pode mudar em relação à original, se o estoque mudou
        nesse meio-tempo. É o mesmo comportamento (e a mesma justificativa) da
        restauração pela Lixeira: o efeito no saldo é o correto, e é o que importa.
        """
        cols = ['data', 'solicitante_id', 'solicitante_nome', 'solicitante_cargo',
                'centro_custo_id', 'frota_id', 'numero_solicitacao', 'observacao']
        fields = {k: data[k] for k in cols if k in data}
        itens = data.get('itens')
        try:
            with get_db() as conn:
                row = conn.execute('SELECT id FROM saidas WHERE id=? AND deleted_at IS NULL', (sid,)).fetchone()
                if not row:
                    self._json(404, {'error': 'Não encontrada'}); return

                if itens is not None:
                    if not itens:
                        raise ValueError('Informe ao menos um item')
                    self._saida_estornar(conn, sid)
                    conn.execute('DELETE FROM saida_itens WHERE saida_id=?', (sid,))  # cascata limpa saida_item_lotes
                    self._gravar_itens_saida(conn, sid, itens)

                if fields:
                    conn.execute(f'UPDATE saidas SET {",".join(f"{k}=?" for k in fields)} WHERE id=?',
                                 list(fields.values()) + [sid])
        except EstoqueInsuficiente as e:
            self._json(409, {'error': str(e)}); return
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        self._json(200, self._get_saida_dict(sid))

    def _delete_entrada(self, eid):
        with get_db() as conn:
            row = conn.execute('SELECT id FROM entradas WHERE id=? AND deleted_at IS NULL', (eid,)).fetchone()
            if not row:
                self._json(404, {'error': 'Não encontrada'}); return
            if self._entrada_tem_lote_consumido(conn, eid):
                self._json(409, {'error': 'Não é possível excluir: já há saída consumindo lote(s) desta entrada'}); return
            # O bloqueio acima garante que, neste ponto, todo lote desta entrada
            # está intacto (quantidade_atual == quantidade_recebida) — zera para
            # que o estoque reflita de fato a exclusão, não só some da listagem.
            conn.execute('''
                UPDATE lotes SET quantidade_atual = 0
                WHERE entrada_item_id IN (SELECT id FROM entrada_itens WHERE entrada_id=?)
            ''', (eid,))
            conn.execute('UPDATE entradas SET deleted_at=? WHERE id=?', (_now(), eid))
        self._json(200, {'ok': True})

    def _restore_entrada(self, eid):
        with get_db() as conn:
            row = conn.execute('SELECT id FROM entradas WHERE id=? AND deleted_at IS NOT NULL', (eid,)).fetchone()
            if not row:
                self._json(404, {'error': 'Não encontrada na lixeira'}); return
            conn.execute('''
                UPDATE lotes SET quantidade_atual = quantidade_recebida
                WHERE entrada_item_id IN (SELECT id FROM entrada_itens WHERE entrada_id=?)
            ''', (eid,))
            conn.execute('UPDATE entradas SET deleted_at=NULL WHERE id=?', (eid,))
        self._json(200, self._get_entrada_dict(eid))

    # ── Saídas ───────────────────────────────────────────────────────────────

    def _list_saidas(self, trash=False):
        cmp = 'IS NOT NULL' if trash else 'IS NULL'
        order = 'sa.deleted_at DESC' if trash else 'sa.data DESC, sa.created_at DESC'
        with get_db() as conn:
            rows = conn.execute(f'''
                SELECT sa.*, c.nome AS centro_custo_nome, fr.numero AS frota_numero
                FROM saidas sa
                LEFT JOIN centros_custo c ON c.id=sa.centro_custo_id
                LEFT JOIN frota fr ON fr.id=sa.frota_id
                WHERE sa.deleted_at {cmp}
                ORDER BY {order}
            ''').fetchall()
        self._json(200, {'items': [dict(r) for r in rows]})

    def _get_saida_dict(self, sid):
        with get_db() as conn:
            sa = conn.execute('''
                SELECT sa.*, c.nome AS centro_custo_nome, fr.numero AS frota_numero
                FROM saidas sa
                LEFT JOIN centros_custo c ON c.id=sa.centro_custo_id
                LEFT JOIN frota fr ON fr.id=sa.frota_id
                WHERE sa.id=?''', (sid,)).fetchone()
            if not sa:
                return None
            itens = conn.execute('''
                SELECT si.*, p.nome AS produto_nome, p.unidade_consumo
                FROM saida_itens si JOIN produtos p ON p.id=si.produto_id
                WHERE si.saida_id=?''', (sid,)).fetchall()
            item_ids = [i['id'] for i in itens]
            lotes_map = {}
            if item_ids:
                qmarks = ','.join('?' * len(item_ids))
                lrows = conn.execute(f'''
                    SELECT sil.*, l.lote_numero, l.data_validade FROM saida_item_lotes sil
                    JOIN lotes l ON l.id=sil.lote_id
                    WHERE sil.saida_item_id IN ({qmarks})''', item_ids).fetchall()
                for lr in lrows:
                    lotes_map.setdefault(lr['saida_item_id'], []).append(dict(lr))
        result = dict(sa)
        result['itens'] = []
        for i in itens:
            d = dict(i)
            d['lotes'] = lotes_map.get(i['id'], [])
            result['itens'].append(d)
        return result

    def _create_saida(self, data, s):
        itens = data.get('itens') or []
        if not itens:
            self._json(400, {'error': 'Informe ao menos um item'}); return
        try:
            _require(data, 'data')
        except ValueError as e:
            self._json(400, {'error': str(e)}); return

        sid = str(uuid.uuid4())
        try:
            with get_db() as conn:
                conn.execute('''INSERT INTO saidas
                    (id,data,solicitante_id,solicitante_nome,solicitante_cargo,centro_custo_id,frota_id,
                     numero_solicitacao,observacao,created_by)
                    VALUES (?,?,?,?,?,?,?,?,?,?)''',
                    (sid, data['data'], data.get('solicitante_id'), data.get('solicitante_nome'),
                     data.get('solicitante_cargo'), data.get('centro_custo_id'), data.get('frota_id'),
                     data.get('numero_solicitacao'), data.get('observacao'), s['user_id']))
                self._gravar_itens_saida(conn, sid, itens)
        except EstoqueInsuficiente as e:
            self._json(409, {'error': str(e)}); return
        except ValueError as e:
            self._json(400, {'error': str(e)}); return
        self._json(201, self._get_saida_dict(sid))

    def _import_saidas_fiorilli(self, data, s):
        """Importa saídas do CSV 'REQUISIÇÃO DE SAÍDA' do Fiorilli. Idempotente por
        nº de requisição (REQUI). Ao contrário da entrada, produto não é criado: sem
        produto cadastrado e sem saldo em lote não há o que baixar, então a
        importação é toda-ou-nada e devolve a lista do que falta (400). O lote que o
        Fiorilli baixou é honrado quando existe aqui; senão vale o FEFO."""
        csv_text = data.get('csv') or ''
        if not csv_text.strip():
            self._json(400, {'error': 'CSV vazio.'}); return
        try:
            reqs = _parse_fiorilli_saida(csv_text)
        except ValueError as e:
            self._json(400, {'error': str(e)}); return

        r = {'saidas': 0, 'itens': 0, 'centros_criados': 0, 'ja_existentes': 0}
        faltantes, pendentes = [], []
        with get_db() as conn:  # passe 1: só leitura — resolve e valida antes de gravar
            prod_by_cad = {x['codigo_fiorilli']: x['id'] for x in conn.execute('SELECT id, codigo_fiorilli FROM produtos').fetchall()}
            cc_by_cod = {str(x['codigo']).strip(): x['id'] for x in conn.execute('SELECT id, codigo FROM centros_custo').fetchall() if x['codigo']}
            func_by_nome = {(x['nome'] or '').strip().upper(): x['id'] for x in conn.execute('SELECT id, nome FROM funcionarios').fetchall()}
            existentes = {x['numero_solicitacao'] for x in conn.execute(
                "SELECT numero_solicitacao FROM saidas WHERE deleted_at IS NULL AND numero_solicitacao IS NOT NULL AND numero_solicitacao<>''").fetchall()}
            precisa = {}  # produto_id -> total pedido no CSV inteiro (o mesmo produto pode repetir)
            for req in reqs:
                if req['requisicao'] in existentes:
                    r['ja_existentes'] += 1; continue
                pendentes.append(req)
                for it in req['itens']:
                    q = int(round(it['qtd']))
                    if q <= 0:
                        continue
                    pid = prod_by_cad.get(it['cadpro'])
                    if not pid:
                        faltantes.append(f"{it['cadpro']} {it['desc']} — produto não cadastrado")
                        continue
                    precisa[pid] = precisa.get(pid, 0) + q
            for pid, q in precisa.items():
                row = conn.execute('SELECT COALESCE(SUM(quantidade_atual),0) t FROM lotes WHERE produto_id=?', (pid,)).fetchone()
                if row['t'] < q:
                    p = conn.execute('SELECT codigo_fiorilli, nome FROM produtos WHERE id=?', (pid,)).fetchone()
                    faltantes.append(f"{p['codigo_fiorilli']} {p['nome']} — saldo {row['t']} de {q}")
        if faltantes:
            self._json(400, {'error': 'Nada foi importado: itens sem estoque no SGEA.', 'faltantes': sorted(faltantes)}); return
        if not pendentes:
            self._json(200, r); return

        with get_db() as conn:  # passe 2: escrita
            for req in pendentes:
                # centro por código ("N - NOME"): é o destino da saída, então criar o que
                # falta (mesma regra do import de entrada) em vez de perder o destino
                m = re.match(r'^\s*(\d+)', req['centro_raw'])
                cc_cod = m.group(1) if m else None
                cc_id = cc_by_cod.get(cc_cod) if cc_cod else None
                if not cc_id and cc_cod:
                    nome_cc = re.sub(r'^\s*\d+\s*-\s*', '', req['centro_raw']).strip() or req['centro_raw']
                    cur = conn.execute('INSERT INTO centros_custo (codigo,nome,ativo) VALUES (?,?,1)', (cc_cod, nome_cc))
                    cc_id = cur.lastrowid; cc_by_cod[cc_cod] = cc_id; r['centros_criados'] += 1
                sol_nome = req['solicitante'] or None
                sol_id = func_by_nome.get(sol_nome.upper()) if sol_nome else None
                sid = str(uuid.uuid4())
                obs = f"Importado do Fiorilli — requisição {req['requisicao']}"
                if req['numorc']: obs += f"; orçamento {req['numorc']}"
                conn.execute('''INSERT INTO saidas
                    (id,data,solicitante_id,solicitante_nome,centro_custo_id,numero_solicitacao,observacao,created_by,origem)
                    VALUES (?,?,?,?,?,?,?,?,'fiorilli')''',
                    (sid, req['data'], sol_id, sol_nome, cc_id, req['requisicao'], obs, s['user_id']))
                r['saidas'] += 1
                for it in req['itens']:
                    q = int(round(it['qtd']))
                    pid = prod_by_cad.get(it['cadpro'])
                    if q <= 0 or not pid:
                        continue
                    consumos, valor_medio, valor_total = _consumir_fefo(
                        conn, pid, q, preferir_lote=(it['lote'], it['validade']))
                    cur = conn.execute('''INSERT INTO saida_itens
                        (saida_id,produto_id,quantidade,valor_unitario_medio,valor_total)
                        VALUES (?,?,?,?,?)''', (sid, pid, q, valor_medio, valor_total))
                    for lote_id, qtd_consumida, custo in consumos:
                        conn.execute('''INSERT INTO saida_item_lotes
                            (saida_item_id,lote_id,quantidade,valor_unitario_custo)
                            VALUES (?,?,?,?)''', (cur.lastrowid, lote_id, qtd_consumida, custo))
                    r['itens'] += 1
            _insert_audit_raw(conn, {'type': 'SAIDA_IMPORTADA', 'ts': _now(),
                'user_id': s['user_id'], 'user_nome': s['nome'], 'label': 'Saídas importadas do Fiorilli',
                'detail': (f"{r['saidas']} saída(s), {r['itens']} item(ns), "
                           f"{r['centros_criados']} centro(s) criado(s); "
                           f"{r['ja_existentes']} requisição(ões) já existente(s)")})
        self._json(200, r)

    def _delete_saida(self, sid):
        with get_db() as conn:
            row = conn.execute('SELECT id FROM saidas WHERE id=? AND deleted_at IS NULL', (sid,)).fetchone()
            if not row:
                self._json(404, {'error': 'Não encontrada'}); return
            self._saida_estornar(conn, sid)
            conn.execute('UPDATE saidas SET deleted_at=? WHERE id=?', (_now(), sid))
        self._json(200, {'ok': True})

    def _restore_saida(self, sid):
        # ponytail: restaurar reconsome via FEFO no momento da restauração, em vez
        # de tentar "desfazer o desfazer" com os lotes exatos de origem — mais simples,
        # e o efeito no estoque final é idêntico; só a composição por lote pode diferir
        # se o saldo mudou nesse meio-tempo (aceitável: é uma saída nova em espírito).
        try:
            with get_db() as conn:
                row = conn.execute('SELECT id FROM saidas WHERE id=? AND deleted_at IS NOT NULL', (sid,)).fetchone()
                if not row:
                    self._json(404, {'error': 'Não encontrada na lixeira'}); return
                itens = conn.execute('SELECT id, produto_id, quantidade FROM saida_itens WHERE saida_id=?', (sid,)).fetchall()
                for it in itens:
                    conn.execute('DELETE FROM saida_item_lotes WHERE saida_item_id=?', (it['id'],))
                    consumos, valor_medio, valor_total = _consumir_fefo(conn, it['produto_id'], it['quantidade'])
                    conn.execute('UPDATE saida_itens SET valor_unitario_medio=?, valor_total=? WHERE id=?',
                                 (valor_medio, valor_total, it['id']))
                    for lote_id, qtd_consumida, custo in consumos:
                        conn.execute('''INSERT INTO saida_item_lotes
                            (saida_item_id,lote_id,quantidade,valor_unitario_custo)
                            VALUES (?,?,?,?)''', (it['id'], lote_id, qtd_consumida, custo))
                conn.execute('UPDATE saidas SET deleted_at=NULL WHERE id=?', (sid,))
        except EstoqueInsuficiente as e:
            self._json(409, {'error': f'Não é possível restaurar: {e}'}); return
        self._json(200, self._get_saida_dict(sid))

    # ── Proxy CNPJ ───────────────────────────────────────────────────────────

    def _proxy_cnpj(self, digits):
        if not digits.isdigit() or len(digits) != 14:
            self._json(400, {'status': 'ERROR', 'message': 'CNPJ inválido'}); return
        url = f'https://receitaws.com.br/v1/cnpj/{digits}'
        req = urllib.request.Request(url, headers={'User-Agent': 'SGEA/1.0'})
        try:
            with urllib.request.urlopen(req, timeout=10) as resp:
                body = resp.read()
                self.send_response(resp.status); self._cors()
                self.send_header('Content-Type', 'application/json')
                self.send_header('Content-Length', str(len(body)))
                self.end_headers(); self.wfile.write(body)
        except urllib.error.HTTPError as e:
            body = e.read()
            self.send_response(e.code); self._cors()
            self.send_header('Content-Type', 'application/json')
            self.send_header('Content-Length', str(len(body)))
            self.end_headers(); self.wfile.write(body)
        except Exception as e:
            self._json(502, {'status': 'ERROR', 'message': str(e)})

    # ── CEIS/CNEP (Portal da Transparência/CGU) ───────────────────────────────
    # Consulta automatizada de sanções federais por CNPJ, complementando as
    # sanções manuais no cadastro de Fornecedores. Exige chave de API gratuita
    # (cadastro em api.portaldatransparencia.gov.br), salva em Configurações e
    # lida via sys_settings.
    def _proxy_ceis_cnep(self, qs):
        def qp(k): v = qs.get(k); return (v[0] if v else '').strip()
        cnpj = re.sub(r'\D', '', qp('cnpj'))
        if len(cnpj) != 14:
            self._json(400, {'error': 'CNPJ inválido'}); return
        with get_db() as conn:
            row = conn.execute(
                "SELECT value FROM sys_settings WHERE key='portal_transparencia_key'"
            ).fetchone()
        api_key = row['value'] if row else ''
        if not api_key:
            self._json(400, {'error': 'Chave de API do Portal da Transparência não configurada (Configurações → Organização)'}); return

        resultado = {'ceis': [], 'cnep': [], 'erro': None}
        for tipo in ('ceis', 'cnep'):
            url = f'https://api.portaldatransparencia.gov.br/api-de-dados/{tipo}?cnpjSancionado={cnpj}&pagina=1'
            req = urllib.request.Request(url, headers={'chave-api-dados': api_key, 'User-Agent': 'SGEA/1.0'})
            try:
                with urllib.request.urlopen(req, timeout=10) as resp:
                    resultado[tipo] = json.loads(resp.read())
            except urllib.error.HTTPError as e:
                resultado['erro'] = f'{tipo.upper()}: HTTP {e.code} (verifique a chave de API)'
            except Exception as e:
                resultado['erro'] = f'{tipo.upper()}: {e}'
        self._json(200, resultado)

    # ── E-mail ───────────────────────────────────────────────────────────────

    def _send_email(self, data):
        # Autenticado (não precisa admin) — usado tanto pelo "Testar conexão"
        # da aba Comunicação quanto por qualquer envio futuro no app.
        try:
            _send_email_raw(data['smtp'], data['from'], data['to'], data['subject'], data['html'], data.get('text', ''))
            self._json(200, {'ok': True})
        except Exception as e:
            self._json(500, {'ok': False, 'error': str(e)})

    # ── Backup ───────────────────────────────────────────────────────────────

    def _export_backup(self):
        payload = _build_backup_payload()
        body = json.dumps(payload, ensure_ascii=False).encode('utf-8')
        name = time.strftime('SYNC_SGEA_BACKUP_%Y-%m-%d_%H-%M-%S.json')
        self.send_response(200); self._cors()
        self.send_header('Content-Type', 'application/json')
        self.send_header('Content-Length', str(len(body)))
        self.send_header('Content-Disposition', f'attachment; filename="{name}"')
        self.end_headers(); self.wfile.write(body)

    def _export_db_backup(self):
        import tempfile
        tmpdir = tempfile.mkdtemp()
        try:
            name = time.strftime('DB_SGEA_BACKUP_%Y-%m-%d_%H-%M-%S.zip')
            dst = os.path.join(tmpdir, name)
            sgx_base.escrever_cofre(DB_PATH, None, dst)   # SGEA não tem anexos
            with open(dst, 'rb') as f:
                data_bytes = f.read()
            self.send_response(200); self._cors()
            self.send_header('Content-Type', 'application/zip')
            self.send_header('Content-Length', str(len(data_bytes)))
            self.send_header('Content-Disposition', f'attachment; filename="{name}"')
            self.end_headers(); self.wfile.write(data_bytes)
        finally:
            import shutil as _sh
            _sh.rmtree(tmpdir, ignore_errors=True)

    def _list_db_backups(self):
        cfg = _get_backup_cfg()
        bdir = cfg['path']
        files = sorted(
            (f for f in os.listdir(bdir) if f.startswith('DB_SGEA_BACKUP_') and f.endswith(_COFRE_EXTS)), reverse=True
        ) if os.path.isdir(bdir) else []
        items = [{'name': f, 'size': os.path.getsize(os.path.join(bdir, f)), 'ts': sgx_base.backup_ts(f)} for f in files]
        with get_db() as conn:
            last_row = conn.execute("SELECT value FROM sys_settings WHERE key='auto_backup_last'").fetchone()
        self._json(200, {'items': items, 'path': bdir, 'cfg': cfg, 'last_backup': last_row['value'] if last_row else None})

    def _download_db_backup(self, name):
        if not name or not name.startswith('DB_SGEA_BACKUP_') or not name.endswith(_COFRE_EXTS) or '/' in name or '\\' in name:
            self._json(400, {'error': 'Nome inválido'}); return
        cfg = _get_backup_cfg()
        fp = os.path.join(cfg['path'], name)
        if not os.path.exists(fp):
            self._json(404, {'error': 'Arquivo não encontrado'}); return
        with open(fp, 'rb') as f:
            data_bytes = f.read()
        self.send_response(200); self._cors()
        self.send_header('Content-Type', 'application/octet-stream')
        self.send_header('Content-Length', str(len(data_bytes)))
        self.send_header('Content-Disposition', f'attachment; filename="{name}"')
        self.end_headers(); self.wfile.write(data_bytes)

    def _dialog_folder(self):
        global _watchdog_paused
        _watchdog_paused = True
        try:
            path = sgx_base.pick_folder_dialog("Selecione a pasta de backup do SGEA")
            self._json(200, {'path': path or None})
        except Exception as e:
            self._json(500, {'error': str(e)})
        finally:
            _watchdog_paused = False

    def _restore_backup(self, data, s):
        if not sgx_base.eh_backup(data, _SGX_SIGLA):
            self._json(400, {'error': 'Arquivo não é um backup SGEA válido'}); return
        _do_db_backup()  # segurança antes de substituir tudo
        try:
            with get_db() as conn:
                # sys_settings é apagado inteiro e repovoado pelo arquivo; como as
                # credenciais não viajam nele (_CHAVES_SIGILOSAS), guardá-las antes
                # e devolvê-las depois é o que impede a restauração de zerar a
                # senha do SMTP e a chave do Portal da Transparência.
                sigilosas = {r['key']: r['value'] for r in conn.execute(
                    f"SELECT key,value FROM sys_settings WHERE key IN ({','.join('?' * len(_CHAVES_SIGILOSAS))})",
                    _CHAVES_SIGILOSAS).fetchall()}
                for t in reversed(_BACKUP_TABLES):
                    conn.execute(f'DELETE FROM {t}')
                for t in _BACKUP_TABLES:
                    for row in (data.get(t) or []):
                        cols = list(row.keys())
                        conn.execute(f'INSERT INTO {t} ({",".join(cols)}) VALUES ({",".join("?" * len(cols))})',
                                     [row[c] for c in cols])
                for chave, valor in sigilosas.items():
                    conn.execute('INSERT OR REPLACE INTO sys_settings (key,value) VALUES (?,?)', (chave, valor))
                _insert_audit_raw(conn, {'type': 'RESTAURAR_BACKUP', 'ts': _now(),
                                          'user_id': s['user_id'], 'user_nome': s['nome'],
                                          'label': 'Backup do sistema restaurado', 'detail': 'Restauração via arquivo JSON'})
        except Exception as e:
            _log.error('Erro ao restaurar backup JSON: %s', e)
            self._json(500, {'error': f'Falha ao restaurar: {e}'}); return
        self._json(200, {'ok': True})

    def _restore_db_backup(self, raw_bytes, s):
        # Aceita o pacote .zip novo e o .db legado. SGEA não tem anexos, então os
        # membros uploads/ (se houver, de um pacote de outro sistema) são ignorados.
        import tempfile, shutil
        tmpdir = tempfile.mkdtemp()
        try:
            try:
                dbfile, anexos = sgx_base.abrir_cofre(raw_bytes, tmpdir)
            except ValueError as e:
                self._json(400, {'error': str(e)}); return
            with sqlite3.connect(dbfile, factory=_ConnAutoClose) as test_conn:
                tables = {r[0] for r in test_conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
            required = {'produtos', 'lotes', 'entradas', 'saidas', 'sys_settings'}
            if not required.issubset(tables):
                self._json(400, {'error': 'Banco inválido: tabelas obrigatórias ausentes'}); return
            _do_db_backup()  # ponto de recuperação antes de substituir
            with sqlite3.connect(dbfile, factory=_ConnAutoClose) as src, get_db() as dst:
                src.backup(dst)
                # Registrado na conexão já restaurada — o backup() acima substitui todo o
                # banco, então logar antes seria sobrescrito pelo conteúdo do arquivo restaurado.
                _insert_audit_raw(dst, {'type': 'RESTAURAR_DB', 'ts': _now(),
                                         'user_id': s['user_id'], 'user_nome': s['nome'],
                                         'label': 'Banco de dados restaurado',
                                         'detail': 'Restauração via pacote .zip' if anexos is not None else 'Restauração via arquivo .db legado'})
            self._json(200, {'ok': True})
        except Exception as e:
            _log.error('Erro ao restaurar banco: %s', e)
            self._json(500, {'error': str(e)})
        finally:
            import shutil as _sh
            _sh.rmtree(tmpdir, ignore_errors=True)

    def _relatorio_integridade(self):
        cfg = _get_backup_cfg()
        bdir = cfg['path']
        backups_db = sorted(
            (f for f in os.listdir(bdir) if f.startswith('DB_SGEA_BACKUP_') and f.endswith(_COFRE_EXTS)),
            reverse=True
        ) if os.path.isdir(bdir) else []
        backups_json = sorted(
            (f for f in os.listdir(bdir) if f.startswith(_SYNC_PREFIXOS) and f.endswith('.json')),
            reverse=True
        ) if os.path.isdir(bdir) else []

        with get_db() as conn:
            # fornecedores foi reescrito para o schema rico (id/data JSON) e usa
            # deleted_at em vez de ativo — contado à parte pra não quebrar o relatório.
            cadastros_apoio = (
                sum(conn.execute(f'SELECT COUNT(*) FROM {t} WHERE ativo=1').fetchone()[0]
                    for t in ('centros_custo', 'funcionarios', 'frota'))
                + conn.execute('SELECT COUNT(*) FROM fornecedores WHERE deleted_at IS NULL').fetchone()[0]
            )
            contagens = {
                'produtos_ativos': conn.execute('SELECT COUNT(*) FROM produtos WHERE ativo=1').fetchone()[0],
                'entradas_ativas': conn.execute('SELECT COUNT(*) FROM entradas WHERE deleted_at IS NULL').fetchone()[0],
                'saidas_ativas': conn.execute('SELECT COUNT(*) FROM saidas WHERE deleted_at IS NULL').fetchone()[0],
                'lotes': conn.execute('SELECT COUNT(*) FROM lotes').fetchone()[0],
                'usuarios_ativos': conn.execute('SELECT COUNT(*) FROM usuarios WHERE ativo=1').fetchone()[0],
                'cadastros_apoio': cadastros_apoio,
            }
            eventos = [dict(r) for r in conn.execute(
                '''SELECT * FROM audit_global WHERE type IN
                   ('RESTAURAR_BACKUP','RESTAURAR_DB','FACTORY_RESET')
                   ORDER BY ts DESC LIMIT 15''').fetchall()]
            last_row = conn.execute("SELECT value FROM sys_settings WHERE key='auto_backup_last'").fetchone()

        self._json(200, {
            'auto_backup_enabled': cfg['enabled'], 'auto_backup_keep': cfg['keep'], 'backup_path': bdir,
            'last_backup': last_row['value'] if last_row else None,
            'db_size_bytes': os.path.getsize(DB_PATH) if os.path.isfile(DB_PATH) else 0,
            'backups_db_count': len(backups_db), 'backups_json_count': len(backups_json),
            'backups_db_size_bytes': sum(os.path.getsize(os.path.join(bdir, f)) for f in backups_db),
            'contagens': contagens, 'eventos_recentes': eventos,
        })

    def _dashboard(self):
        with get_db() as conn:
            estoque_valor_total = conn.execute('''
                SELECT COALESCE(SUM(v.estoque_financeiro), 0)
                FROM v_estoque v JOIN produtos p ON p.id = v.produto_id
                WHERE p.ativo = 1
            ''').fetchone()[0]
            produtos_ativos = conn.execute('SELECT COUNT(*) FROM produtos WHERE ativo=1').fetchone()[0]
            produtos_zerados = conn.execute('''
                SELECT COUNT(*) FROM v_estoque v JOIN produtos p ON p.id = v.produto_id
                WHERE p.ativo = 1 AND v.estoque_fisico = 0
            ''').fetchone()[0]
            lotes = _lotes_vencendo(30)
            pedidos_abertos = 0
            for pe in conn.execute('SELECT id, status FROM pedidos').fetchall():
                itens = _pedido_itens_com_saldo(conn, pe['id'])
                if _pedido_status_agregado(pe['status'], itens) == 'aberto':
                    pedidos_abertos += 1
            movimentacao_mensal = _movimentacao_mensal(conn)
        self._json(200, {
            'estoque_valor_total': estoque_valor_total,
            'produtos_ativos': produtos_ativos,
            'produtos_zerados': produtos_zerados,
            'lotes_vencendo': sum(1 for l in lotes if not l['vencido']),
            'lotes_vencidos': sum(1 for l in lotes if l['vencido']),
            'pedidos_abertos': pedidos_abertos,
            'movimentacao_mensal': movimentacao_mensal,
        })

    def _relatorio_movimentacao(self, qs):
        de = (qs.get('de', [''])[0] or '0000-01-01')
        ate = (qs.get('ate', [''])[0] or '9999-12-31')
        with get_db() as conn:
            entradas = [dict(r) for r in conn.execute('''
                SELECT e.data_entrega AS data, e.nfe_numero, p.nome AS produto_nome,
                       ei.quantidade_unidades, ei.valor_unitario, ei.valor_total
                FROM entrada_itens ei JOIN entradas e ON e.id = ei.entrada_id
                JOIN produtos p ON p.id = ei.produto_id
                WHERE e.deleted_at IS NULL AND e.data_entrega BETWEEN ? AND ?
                ORDER BY e.data_entrega ASC
            ''', (de, ate)).fetchall()]
            saidas = [dict(r) for r in conn.execute('''
                SELECT s.data AS data, s.numero_solicitacao, p.nome AS produto_nome,
                       si.quantidade, si.valor_unitario_medio, si.valor_total
                FROM saida_itens si JOIN saidas s ON s.id = si.saida_id
                JOIN produtos p ON p.id = si.produto_id
                WHERE s.deleted_at IS NULL AND s.data BETWEEN ? AND ?
                ORDER BY s.data ASC
            ''', (de, ate)).fetchall()]
        self._json(200, {
            'entradas': entradas, 'saidas': saidas,
            'totais': {
                'entradas_valor': sum(e['valor_total'] for e in entradas),
                'saidas_valor': sum(s['valor_total'] for s in saidas),
            },
        })

    def _relatorio_pedidos_abertos(self):
        with get_db() as conn:
            rows = conn.execute('''
                SELECT pe.*, f.razao_social AS fornecedor_nome
                FROM pedidos pe LEFT JOIN fornecedores f ON f.id = pe.fornecedor_id
                ORDER BY pe.created_at DESC
            ''').fetchall()
            abertos = []
            for r in rows:
                d = dict(r)
                itens = _pedido_itens_com_saldo(conn, d['id'])
                if _pedido_status_agregado(d['status'], itens) != 'aberto':
                    continue
                d['itens'] = [i for i in itens if i['saldo'] > 0]
                abertos.append(d)
        self._json(200, {'items': abertos})

    # ── Helpers HTTP ─────────────────────────────────────────────────────────

    def _body(self):
        n = int(self.headers.get('Content-Length', 0))
        return self.rfile.read(n) if n else b''

    def _parse_json(self, body):
        try:
            return json.loads(body) if body else {}
        except Exception:
            return {}

    def _cors(self):
        self.send_header('Access-Control-Allow-Origin', '*')
        self.send_header('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,OPTIONS')
        self.send_header('Access-Control-Allow-Headers', 'Content-Type,Authorization')

    def _json(self, status, obj):
        payload = json.dumps(obj, ensure_ascii=False).encode('utf-8')
        self.send_response(status); self._cors()
        self.send_header('Content-Type', 'application/json')
        self.send_header('Content-Length', str(len(payload)))
        self.end_headers(); self.wfile.write(payload)

    def _sem_conteudo(self):
        """204 nao pode ter corpo: o waitress descarta e avisa no log
        ("application-written content was ignored"). Responde so o status."""
        self.send_response(204)
        self._cors()
        self.end_headers()

    def log_message(self, fmt, *args): pass

# ── E-mail ───────────────────────────────────────────────────────────────────

_send_email_raw = sgx_base.send_email_raw

def _send_daily_alerts():
    """Resumo diário por e-mail de lotes vencidos/vencendo. Só envia se SMTP
    estiver configurado e ainda não tiver enviado hoje (chamado a cada 5s pelo
    watchdog — o dedup por data é o que garante 1x/dia, não o intervalo)."""
    with get_db() as conn:
        cfg = {r['key']: r['value'] for r in conn.execute(
            "SELECT key,value FROM sys_settings WHERE key LIKE 'smtp_%' OR key='alert_email_last_sent'"
        ).fetchall()}
    if not (cfg.get('smtp_host') and cfg.get('smtp_user') and cfg.get('smtp_pass')):
        return
    hoje = time.strftime('%Y-%m-%d')       # chave de dedup (não exibir)
    hoje_br = time.strftime('%d/%m/%Y')    # exibição pt-BR
    if cfg.get('alert_email_last_sent') == hoje:
        return

    itens = _lotes_vencendo(7)
    if not itens:
        with get_db() as conn:
            conn.execute("INSERT OR REPLACE INTO sys_settings (key,value) VALUES ('alert_email_last_sent',?)", (hoje,))
        return

    smtp_cfg = {
        'host': cfg['smtp_host'], 'port': cfg.get('smtp_port', 587),
        'secure': cfg.get('smtp_secure') == '1', 'requireTLS': cfg.get('smtp_require_tls') != '0',
        'ignoreSSL': cfg.get('smtp_ignore_ssl') == '1',
        'auth': {'user': cfg['smtp_user'], 'pass': cfg['smtp_pass']},
    }
    frm = {'name': cfg.get('smtp_from_name') or 'SGEA', 'email': cfg['smtp_user']}

    if cfg.get('smtp_to'):
        linhas = ''.join(
            f"<li><strong>{l['produto_nome']}</strong> ({l['codigo_fiorilli']}) — lote {l.get('lote_numero') or 's/nº'} "
            f"— {'vencido em' if l['vencido'] else 'vence em'} {l['data_validade']} — saldo {l['quantidade_atual']} {l['unidade_consumo']}</li>"
            for l in sorted(itens, key=lambda x: x['data_validade'])
        )
        corpo = f"<p>Resumo automático do SGEA — {hoje_br}</p><p>Lotes vencidos ou vencendo nos próximos 7 dias:</p><ul>{linhas}</ul>"
        try:
            _send_email_raw(smtp_cfg, frm, cfg['smtp_to'], f'SGEA — Lotes vencendo ({hoje_br})', corpo)
            print(f'  [ALERTAS] E-mail de validade enviado ({len(itens)} lote(s))', flush=True)
        except Exception as e:
            sgx_base.registrar_operacional(_log, 'email-alertas', f'Falha ao enviar e-mail de alertas: {e}')

    with get_db() as conn:
        conn.execute("INSERT OR REPLACE INTO sys_settings (key,value) VALUES ('alert_email_last_sent',?)", (hoje,))

# ── Backup automático do banco ─────────────────────────────────────────────────
# Tabelas exportadas na íntegra no backup JSON — `usuarios` fica de fora de
# propósito (mesma decisão do SGCA): senha_hash não deve viajar num export
# casual, e uma restauração não deveria conseguir clonar contas de login.
_BACKUP_TABLES = ('centros_custo', 'fornecedores', 'funcionarios', 'frota', 'produtos', 'pedidos',
                   'entradas', 'entrada_itens', 'lotes', 'saidas', 'saida_itens', 'saida_item_lotes',
                   'sys_settings')

# Credenciais que NÃO viajam no backup JSON: o arquivo sai do servidor e o
# manual orienta enviá-lo a outra máquina. Restaurar não as perde — ver
# _restore_backup, que relê e regrava esses valores em torno do DELETE.
_CHAVES_SIGILOSAS = ('smtp_pass', 'portal_transparencia_key')

# Padronização do backup da família (2026-07): envelope único e Cofre .zip via
# sgx_base. SGEA não tem anexos (uploads_dir=None), então o Cofre é um .zip só
# com banco.db — uniforme com os irmãos. Flag de usuários = False.
_SGX_SIGLA = 'SGEA'
_BACKUP_SCHEMA = 1
_BACKUP_INCLUI_USUARIOS = False
_COFRE_EXTS = ('.zip', '.db')   # casa o .zip novo e o .db legado
# Prefixo do JSON portatil: SYNC_ desde 2026-08-02 (antes SIS_). A listagem e a
# rotacao casam os dois — arquivo gravado antes do renome continua aparecendo na
# tela de restauracao e continua entrando na conta dos N mantidos. Trocar so o
# prefixo novo deixaria os antigos orfaos no disco, fora de qualquer limpeza.
# A identificacao do conteudo nunca dependeu do nome: quem valida e o envelope
# (_sgx/schema), via sgx_base.eh_backup.
_SYNC_PREFIXOS = ('SYNC_SGEA_BACKUP_', 'SIS_SGEA_BACKUP_')

def _settings_para(result, s):
    """Recorta o que /api/settings devolve conforme quem pergunta.

    A rota é aberta a qualquer usuário autenticado — a tela de Configurações usa
    os dados de organização — e por ela saíam a chave de API do Portal da
    Transparência e a conta de e-mail do órgão. A senha do SMTP nunca esteve
    aqui; agora a config de e-mail inteira, a chave do Portal e o caminho de
    backup também só vão para o administrador. O SMTP pessoal de cada usuário
    tem endpoint próprio e não passa por aqui.
    """
    if s['admin']:
        return result
    return {k: v for k, v in result.items()
            if not k.startswith('smtp_') and k != 'backup_path' and k not in _CHAVES_SIGILOSAS}


def _build_backup_payload():
    with get_db() as conn:
        payload = {'_sgx': _SGX_SIGLA, 'schema': _BACKUP_SCHEMA, 'exportedAt': _now()}
        for t in _BACKUP_TABLES:
            linhas = [dict(r) for r in conn.execute(f'SELECT * FROM {t}').fetchall()]
            if t == 'sys_settings':
                linhas = [r for r in linhas if r.get('key') not in _CHAVES_SIGILOSAS]
            payload[t] = linhas
    return payload

def _do_json_backup(cfg=None):
    if cfg is None: cfg = _get_backup_cfg()
    bdir = cfg['path']
    os.makedirs(bdir, exist_ok=True)
    name = time.strftime('SYNC_SGEA_BACKUP_%Y-%m-%d_%H-%M-%S.json')
    dst = os.path.join(bdir, name)
    try:
        with open(dst, 'w', encoding='utf-8') as f:
            json.dump(_build_backup_payload(), f, ensure_ascii=False)
        print(f'Backup JSON automático: {name}')
        return name
    except Exception as e:
        _log.error('Falha no backup JSON automático: %s', e)
        return None

def _rotate_backups(cfg=None):
    if cfg is None: cfg = _get_backup_cfg()
    bdir, keep = cfg['path'], cfg['keep']
    if not os.path.isdir(bdir): return
    for prefix, ext in [('DB_SGEA_BACKUP_', _COFRE_EXTS), (_SYNC_PREFIXOS, '.json')]:
        files = sorted(f for f in os.listdir(bdir) if f.startswith(prefix) and f.endswith(ext))
        for old in (files[:-keep] if keep else files):
            fp = os.path.join(bdir, old)
            for attempt in range(6):  # tenta por até ~10s (OneDrive pode manter o arquivo aberto)
                try:
                    os.remove(fp)
                    print(f'Rotação: removido {old}')
                    break
                except PermissionError:
                    if attempt < 5: time.sleep(2)
                    else: sgx_base.registrar_operacional(_log, 'backup-bloqueado', f'Falha ao remover backup {old}: arquivo bloqueado (OneDrive/antivírus).')
                except Exception as e:
                    _log.error('Falha ao remover backup %s: %s', old, e)
                    break

def _insert_audit_raw(conn, a):
    conn.execute(
        '''INSERT INTO audit_global (id,ts,user_id,user_nome,type,label,detail,process_id)
           VALUES (?,?,?,?,?,?,?,?)''',
        (a.get('id') or str(uuid.uuid4()), a.get('ts'), a.get('user_id'), a.get('user_nome'),
         a.get('type'), a.get('label'), a.get('detail'), a.get('process_id'))
    )

def _audit_config(conn, s, label, detail):
    """Registra na trilha quem mexeu na identidade do órgão.

    Dados de Organização e brasão continuam abertos a qualquer usuário
    autenticado — decisão de projeto, não é config administrativa —, mas saem em
    todo documento gerado. Sem rastro, uma alteração no nome do órgão ou no
    brasão aparecia em documento oficial sem ninguém saber de onde veio.
    """
    _insert_audit_raw(conn, {'type': 'CONFIG_ALTERADA', 'ts': _now(),
                             'user_id': s['user_id'], 'user_nome': s['nome'],
                             'label': label, 'detail': detail})


def _get_backup_cfg():
    try:
        with get_db() as conn:
            rows = conn.execute(
                "SELECT key,value FROM sys_settings WHERE key IN ('backup_path','auto_backup_enabled','auto_backup_keep')"
            ).fetchall()
        cfg = {r['key']: r['value'] for r in rows}
    except Exception:
        cfg = {}
    try:
        keep = max(1, int(cfg.get('auto_backup_keep') or BACKUP_KEEP))
    except (TypeError, ValueError):
        keep = BACKUP_KEEP
    return {'path': cfg.get('backup_path') or BACKUP_DIR, 'enabled': cfg.get('auto_backup_enabled', '1') != '0', 'keep': keep}

def _do_db_backup(cfg=None):
    if cfg is None: cfg = _get_backup_cfg()
    bdir = cfg['path']
    os.makedirs(bdir, exist_ok=True)
    name = time.strftime('DB_SGEA_BACKUP_%Y-%m-%d_%H-%M-%S.zip')
    dst = os.path.join(bdir, name)
    try:
        sgx_base.escrever_cofre(DB_PATH, None, dst)   # SGEA não tem anexos
        with get_db() as conn:
            conn.execute("INSERT OR REPLACE INTO sys_settings (key,value) VALUES ('auto_backup_last',?)", (_now(),))
        print(f'Backup automático: {name}')
        _rotate_backups(cfg)
        return name
    except Exception as e:
        _log.error('Falha no backup automático: %s', e)
        try: os.remove(dst)
        except OSError: pass
        return None

def _purge_old_trash():
    """Apaga de vez entradas/saídas na lixeira há mais de TRASH_RETENTION_DIAS dias.
    ON DELETE CASCADE do schema cuida de entrada_itens/lotes e saida_itens/saida_item_lotes."""
    global _last_trash_purge
    _last_trash_purge = time.time()
    limite = time.strftime('%Y-%m-%dT%H:%M:%S', time.localtime(time.time() - TRASH_RETENTION_DIAS * 86400))
    with get_db() as conn:
        conn.execute('DELETE FROM entradas WHERE deleted_at IS NOT NULL AND deleted_at < ?', (limite,))
        conn.execute('DELETE FROM saidas WHERE deleted_at IS NOT NULL AND deleted_at < ?', (limite,))

def _watchdog():
    # Limpa sessões expiradas a cada 5s e dispara o backup pós-sessão.
    # SESSION_TTL=60s dá folga de sobra sobre o ping a cada 5s.
    while True:
        time.sleep(5)
        if _watchdog_paused:
            continue
        sgx_base.purge_expired_sessions(get_db)
        try:
            _check_shutdown()
        except Exception as e:
            _log.error('Erro em _check_shutdown: %s', e)
        if time.time() - _last_trash_purge > 3600:
            try:
                _purge_old_trash()
            except Exception as e:
                _log.error('Erro ao purgar lixeira: %s', e)
        try:
            _send_daily_alerts()
        except Exception as e:
            _log.error('Erro ao enviar alertas por e-mail: %s', e)

# ── Inicialização ─────────────────────────────────────────────────────────────

init_db()

def _check_db_integrity():
    try:
        with get_db() as conn:
            result = conn.execute('PRAGMA integrity_check').fetchone()[0]
            if result != 'ok':
                _log.error('INTEGRITY CHECK FALHOU: %s', result)
                print(f'[AVISO] Banco de dados com problema de integridade: {result}')
            else:
                print('[DB] Integridade verificada: ok')
    except Exception as e:
        _log.error('Erro ao verificar integridade do banco: %s', e)

def _selecionar_modo():
    print()
    print('  ╔══════════════════════════════════════════════════╗')
    print('  ║   SGEA — Sistema de Gestão de Estoque do Almox.   ║')
    print('  ╚══════════════════════════════════════════════════╝')
    print()
    print('  [1] Diagnóstico     — Verifica rede, porta e firewall')
    print('  [2] Iniciar Servidor')
    print()
    if not sys.stdin.isatty():
        op = '2'
    else:
        while True:
            try:
                op = input('  Opção [1/2]: ').strip()
            except (EOFError, KeyboardInterrupt):
                op = '2'
            if op in ('1', '2'):
                break
            print('  Digite 1 ou 2.')
    if op == '1':
        import subprocess as _sp
        diag = os.path.join(_BASE, 'diagnostico.py')
        _sp.run([sys.executable, diag])
        sys.exit(0)
    print()
    print('  ─────────────────────────────────────────────────')

if __name__ == '__main__':
    _selecionar_modo()
    sgx_base.instalar_captura_de_falhas(_DATA_DIR, 'SGEA')  # crash log que sobrevive à janela fechar
    _check_db_integrity()
    _rotate_backups(_get_backup_cfg())

    threading.Thread(target=_watchdog, daemon=True).start()

    print(f'  Servidor: http://localhost:{PORT}')
    import socket as _socket
    try:
        ip_local = _socket.gethostbyname(_socket.gethostname())
    except Exception:
        ip_local = 'desconhecido'
    print(f'  Rede:     http://{ip_local}:{PORT}/SGEA.html')
    print()

    # Instalacao que ja rodou a versao anterior deixou o perfil dentro da pasta
    # do sistema (podia passar de 4 GB). Nao apagamos por conta propria - so
    # avisamos onde esta.
    _perfil_antigo = os.path.join(_DATA_DIR, 'browser-profile')
    if os.path.isdir(_perfil_antigo):
        print(f'  Aviso: a pasta "browser-profile" nao e mais usada e pode ser apagada ({_perfil_antigo}).')

    browser = None if os.environ.get('SGEA_NO_BROWSER') else _find_browser()
    if browser:
        subprocess.Popen([
            browser, f'--app=http://localhost:{PORT}/SGEA.html', '--start-maximized',
            '--disable-background-mode',
            # O Chrome baixa ~4 GB de modelo de IA local para dentro do perfil. A
            # flag abaixo impede que ele seja instalado/usado, mas sozinha nao
            # impede o DOWNLOAD: o pacote ia parar no component_crx_cache, mesmo
            # tamanho em outra pasta. Desligar a atualizacao de componentes fecha
            # a torneira. Esta janela so abre o app local, entao nao ha perda.
            '--disable-features=OptimizationGuideOnDeviceModel',
            '--disable-component-update',
            f'--user-data-dir={PROFILE_DIR}',
        ])
        print('  App aberto no navegador.')
    else:
        print(f'  Chrome/Edge não encontrado. Abra manualmente: http://localhost:{PORT}/SGEA.html')

    print('  Aguardando conexões... (Ctrl+C para encerrar)')
    try:
        # Servidor de produção (waitress, puro-Python vendorizado) — ver sgx_base.servir_wsgi.
        sgx_base.servir_wsgi(SGEAHandler, '', PORT)
    except KeyboardInterrupt:
        print('\n  Encerrando servidor...')
    except Exception:
        import traceback as _tb
        _log.error('Servidor caiu (serve_wsgi): %s', _tb.format_exc())
        print('\n  ERRO FATAL no servidor — registrado em SGEA_crash.log.')
        print('  Pressione Enter para fechar.')
        try: input()
        except Exception: pass
        raise