"""
Testa só a camada HTTP: monta um FastAPI() com apenas este router, sobrescreve
exigir_login (sem exigir Basic Auth real) e faz monkeypatch das funções de
app.db.clientes usadas pelo router — não toca no banco de verdade.
"""
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient

from app.auth import exigir_login
from app.db.connection import get_connection
from app.routers import clientes as router_clientes

app_teste = FastAPI()
app_teste.include_router(router_clientes.router)
app_teste.dependency_overrides[exigir_login] = lambda: "teste"
client = TestClient(app_teste, follow_redirects=False)
# Este app de teste não tem o middleware de CSRF (só o main.py real o monta).
# Simula um navegador que já tem o cookie definido: os testes de POST
# precisam mandar o mesmo valor no campo oculto "csrf_token".
CSRF_TESTE = "teste-csrf-token"
client.cookies.set("csrf_token", CSRF_TESTE)


@pytest.fixture(autouse=True)
def _sem_log_real(monkeypatch):
    """
    O router registra cada ação em LOG_PAINEL (app/db/log.py) — por padrão
    isso bateria no banco real. Substitui por um no-op nos testes que não
    são especificamente sobre o log (test_router_clientes não testa
    app/db/log.py, isso já é coberto em tests/test_db_log.py).
    """
    monkeypatch.setattr(router_clientes.db_log, "registrar", lambda *args, **kwargs: None)


@pytest.fixture(autouse=True)
def _limpar_cookies():
    """Limpa cookies entre testes para evitar compartilhamento de estado."""
    client.cookies.clear()
    client.cookies.set("csrf_token", CSRF_TESTE)
    yield
    # Limpa novamente após o teste
    client.cookies.clear()
    client.cookies.set("csrf_token", CSRF_TESTE)


def _form_valido(codigo: str = "000001") -> dict:
    """Monta um dict de formulário válido (todos os campos preenchidos)."""
    dados = {campo: "x" for campo in router_clientes.db_clientes.CAMPOS_CLIENTE}
    dados.update(
        {
            "CODIGO": codigo,
            "CNPJ": "11222333000181",
            "IMPLANTACAO": "0",
            "MENSALIDADE": "100",
            "JUROS_MORA": "0",
            "JUROS_MULTA": "0",
            "DATA_CONTRATO": "2026-01-01",
            "VENCIMENTO_CONTRATO": "2027-01-01",
            "DIA_VENCIMENTO": "10",
            "csrf_token": CSRF_TESTE,
        }
    )
    return dados


def test_resolver_por_pagina_usa_query_quando_valido():
    assert router_clientes._resolver_por_pagina(50, None) == 50


def test_resolver_por_pagina_ignora_query_invalida_usa_cookie():
    assert router_clientes._resolver_por_pagina(999, "30") == 30


def test_resolver_por_pagina_ignora_cookie_invalido_usa_padrao():
    assert router_clientes._resolver_por_pagina(None, "abc") == 15
    assert router_clientes._resolver_por_pagina(None, "999") == 15


def test_resolver_por_pagina_sem_query_nem_cookie_usa_padrao():
    assert router_clientes._resolver_por_pagina(None, None) == 15


def test_janela_paginas_poucas_paginas_mostra_todas():
    assert router_clientes._janela_paginas(1, 5) == [1, 2, 3, 4, 5]
    assert router_clientes._janela_paginas(3, 7) == [1, 2, 3, 4, 5, 6, 7]


def test_janela_paginas_no_meio_com_reticencias_dos_dois_lados():
    assert router_clientes._janela_paginas(5, 20) == [1, None, 4, 5, 6, None, 20]


def test_janela_paginas_primeira_pagina():
    assert router_clientes._janela_paginas(1, 20) == [1, 2, None, 20]


def test_janela_paginas_ultima_pagina():
    assert router_clientes._janela_paginas(20, 20) == [1, None, 19, 20]


def test_listar_clientes_por_pagina_padrao_e_15(monkeypatch):
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "listar_clientes",
        lambda busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc": capturado.setdefault("limite", limite) and [],
    )
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 3)

    resposta = client.get("/clientes")
    assert resposta.status_code == 200
    assert capturado["limite"] == 15


def test_listar_clientes_por_pagina_da_query_e_usada_e_grava_cookie(monkeypatch):
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "listar_clientes",
        lambda busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc": capturado.setdefault("limite", limite) and [],
    )
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 3)

    resposta = client.get("/clientes?por_pagina=50")
    assert resposta.status_code == 200
    assert capturado["limite"] == 50
    assert resposta.cookies.get(router_clientes.POR_PAGINA_COOKIE) == "50"


def test_listar_clientes_usa_cookie_quando_sem_por_pagina_na_query(monkeypatch):
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "listar_clientes",
        lambda busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc": capturado.setdefault("limite", limite) and [],
    )
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 3)

    resposta = client.get("/clientes", cookies={router_clientes.POR_PAGINA_COOKIE: "30"})
    assert resposta.status_code == 200
    assert capturado["limite"] == 30


def test_listar_clientes_por_pagina_invalida_na_query_cai_no_padrao_e_nao_grava_cookie(monkeypatch):
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "listar_clientes",
        lambda busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc": capturado.setdefault("limite", limite) and [],
    )
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 3)

    resposta = client.get("/clientes?por_pagina=999")
    assert resposta.status_code == 200
    assert capturado["limite"] == 15
    assert router_clientes.POR_PAGINA_COOKIE not in resposta.cookies


def test_listar_clientes(monkeypatch):
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "listar_clientes",
        lambda busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc": [
            {"ID": 1, "CODIGO": "000001", "RAZAO": "Cliente Um", "FANTASIA": "Um", "CNPJ": "11222333000181"}
        ],
    )
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 1)
    resposta = client.get("/clientes")
    assert resposta.status_code == 200
    assert "Cliente Um" in resposta.text


def test_listar_clientes_pagina_com_controles_de_paginacao(monkeypatch):
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "listar_clientes",
        lambda busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc": [
            {"ID": i, "CODIGO": f"{i:06d}", "RAZAO": f"Cliente {i}", "FANTASIA": f"C{i}", "CNPJ": "11222333000181"}
            for i in range(1, 6)
        ],
    )
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 250)

    resposta = client.get("/clientes?pagina=2&por_pagina=100")
    assert resposta.status_code == 200
    assert "Exibindo 101 a 200 de 250 clientes" in resposta.text
    assert "pagina=1&ordenar_por=razao&direcao=asc&por_pagina=100" in resposta.text
    assert "pagina=3&ordenar_por=razao&direcao=asc&por_pagina=100" in resposta.text


def test_listar_clientes_footer_com_selecao_de_por_pagina(monkeypatch):
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "listar_clientes",
        lambda busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc": [
            {"ID": i, "CODIGO": f"{i:06d}", "RAZAO": f"Cliente {i}", "FANTASIA": f"C{i}", "CNPJ": "1"}
            for i in range(1, 16)
        ],
    )
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 98)

    resposta = client.get("/clientes?pagina=1")
    assert resposta.status_code == 200
    assert 'value="15" selected' in resposta.text
    assert "Exibindo 1 a 15 de 98 clientes" in resposta.text
    # 98 / 15 = 7 paginas -> <=7, sem reticencias, todas visiveis
    assert "pagina=7&ordenar_por=razao&direcao=asc&por_pagina=15" in resposta.text


def test_listar_clientes_paginacao_com_reticencias_quando_muitas_paginas(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "listar_clientes", lambda **kwargs: [])
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 500)

    # 500 / 5 = 100 paginas, pedindo a pagina 10 (no meio) -> tem reticencias
    resposta = client.get("/clientes?pagina=10&por_pagina=5")
    assert resposta.status_code == 200
    assert "&hellip;" in resposta.text


def test_listar_clientes_ordenar_por_invalido_cai_no_padrao(monkeypatch):
    capturado = {}

    def _listar_clientes(busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc"):
        capturado["ordenar_por"] = ordenar_por
        return []

    monkeypatch.setattr(router_clientes.db_clientes, "listar_clientes", _listar_clientes)
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 0)

    client.get("/clientes?ordenar_por=coisa_invalida_qualquer")
    assert capturado["ordenar_por"] == "razao"

    client.get("/clientes?ordenar_por=codigo")
    assert capturado["ordenar_por"] == "codigo"


def test_cabecalhos_da_lista_alternam_direcao(monkeypatch):
    monkeypatch.setattr(
        router_clientes.db_clientes, "listar_clientes", lambda **kwargs: []
    )
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 0)

    # Sem ordenar_por/direcao na URL: padrão é razao/asc. Clicar de novo em
    # "Razão" deve levar pra desc; clicar em "Código" (coluna diferente da
    # atual) deve levar pra asc (não continua o desc de outra coluna).
    resposta = client.get("/clientes")
    assert 'ordenar_por=razao&direcao=desc' in resposta.text
    assert 'ordenar_por=codigo&direcao=asc' in resposta.text

    # Já ordenado por codigo/desc: clicar em "Código" de novo deve voltar pra asc.
    resposta = client.get("/clientes?ordenar_por=codigo&direcao=desc")
    assert 'ordenar_por=codigo&direcao=asc' in resposta.text
    # E as outras colunas oferecem asc (primeira vez que seriam clicadas).
    assert 'ordenar_por=razao&direcao=asc' in resposta.text


def test_busca_com_e_comercial_nao_quebra_links_de_paginacao_e_ordenacao(monkeypatch):
    # "&" cru dentro de busca, sem urlencode, corta o resto da query string
    # do link (ex.: "busca=A&B&pagina=2" vira busca="A", parâmetro solto
    # "B", perdendo "pagina=2") — reprodução do bug corrigido em
    # clientes_lista.html.
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "listar_clientes",
        lambda busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc": [
            {"ID": i, "CODIGO": f"{i:06d}", "RAZAO": f"Cliente {i}", "FANTASIA": f"C{i}", "CNPJ": "1"}
            for i in range(1, 6)
        ],
    )
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 250)

    resposta = client.get("/clientes?pagina=2&busca=A%26B")
    assert resposta.status_code == 200
    assert "busca=A%26B" in resposta.text
    assert "busca=A&B" not in resposta.text


def test_listar_clientes_direcao_invalida_cai_no_padrao(monkeypatch):
    capturado = {}

    def _listar_clientes(busca=None, limite=100, offset=0, ordenar_por="razao", direcao="asc"):
        capturado["direcao"] = direcao
        return []

    monkeypatch.setattr(router_clientes.db_clientes, "listar_clientes", _listar_clientes)
    monkeypatch.setattr(router_clientes.db_clientes, "contar_clientes", lambda busca=None, ordenar_por="razao": 0)

    client.get("/clientes?direcao=coisa_invalida")
    assert capturado["direcao"] == "asc"

    client.get("/clientes?direcao=desc")
    assert capturado["direcao"] == "desc"


def test_consulta_cnpj_encontrado(monkeypatch):
    monkeypatch.setattr(
        router_clientes.cnpj_lookup,
        "consultar_cnpj",
        lambda cnpj: {"RAZAO": "EMPRESA TESTE LTDA", "FANTASIA": "EMPRESA TESTE"},
    )
    resposta = client.get("/clientes/consulta-cnpj/11222333000181")
    assert resposta.status_code == 200
    corpo = resposta.json()
    assert corpo["encontrado"] is True
    assert corpo["dados"]["RAZAO"] == "EMPRESA TESTE LTDA"


def test_consulta_cnpj_nao_encontrado(monkeypatch):
    monkeypatch.setattr(router_clientes.cnpj_lookup, "consultar_cnpj", lambda cnpj: None)
    resposta = client.get("/clientes/consulta-cnpj/11222333000181")
    assert resposta.status_code == 404
    assert resposta.json()["encontrado"] is False


def test_consulta_cnpj_rejeita_cpf(monkeypatch):
    chamou = {}
    monkeypatch.setattr(
        router_clientes.cnpj_lookup, "consultar_cnpj", lambda cnpj: chamou.setdefault("ok", True)
    )
    # CPF válido (mesma fixture usada em test_normalize.py) — nunca deve
    # chamar a consulta de CNPJ, é dado pessoal.
    resposta = client.get("/clientes/consulta-cnpj/11144477735")
    assert resposta.status_code == 404
    assert "ok" not in chamou


def test_consulta_cnpj_rejeita_formato_invalido(monkeypatch):
    chamou = {}
    monkeypatch.setattr(
        router_clientes.cnpj_lookup, "consultar_cnpj", lambda cnpj: chamou.setdefault("ok", True)
    )
    resposta = client.get("/clientes/consulta-cnpj/123")
    assert resposta.status_code == 404
    assert "ok" not in chamou


def test_form_novo_preenche_codigo_sugerido(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "proximo_codigo_sugerido", lambda: "000243")
    resposta = client.get("/clientes/novo")
    assert resposta.status_code == 200
    assert 'value="000243"' in resposta.text


def test_detalhe_cliente_mostra_formulario_de_edicao_de_contato(monkeypatch):
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "obter_cliente",
        lambda cid: {"ID": cid, "CODIGO": "000001", "RAZAO": "Cliente Um", "FANTASIA": "Um", "CNPJ": "11222333000181"},
    )
    monkeypatch.setattr(
        router_clientes.db_contatos,
        "listar_contatos_por_cliente",
        lambda cid: [{"ID": 7, "NOME": "Fulano", "TELEFONE": "75999090001", "EMAIL": None}],
    )
    monkeypatch.setattr(router_clientes.db_chaves, "status_chaves", lambda codigo: None)

    resposta = client.get("/clientes/1")
    assert resposta.status_code == 200
    assert '/clientes/1/contatos/7/editar' in resposta.text
    assert 'value="Fulano"' in resposta.text
    assert 'value="75999090001"' in resposta.text


def test_criar_cliente_codigo_duplicado_bloqueia_sem_bypass(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: True)
    criado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: criado.setdefault("ok", True) and 42
    )

    dados_form = _form_valido()

    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 200
    assert "já está em uso" in resposta.text
    assert "ok" not in criado

    # Não existe mais bypass: mesmo insistindo, sem trocar o código, continua bloqueado.
    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 200
    assert "já está em uso" in resposta.text
    assert "ok" not in criado


def test_criar_cliente_campo_obrigatorio_faltando_bloqueia(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    criado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: criado.setdefault("ok", True) and 42
    )

    dados_form = _form_valido()
    dados_form["RAZAO"] = ""

    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 200
    assert "RAZAO" in resposta.text
    assert "ok" not in criado


def test_criar_cliente_campos_administrativos_em_branco_usa_defaults(monkeypatch):
    """
    IMPLANTACAO/MENSALIDADE/JUROS_MORA/JUROS_MULTA/DATA_CONTRATO/
    VENCIMENTO_CONTRATO não são mais obrigatórios — em branco, o cliente é
    criado mesmo assim, com defaults (0,00 / hoje).
    """
    import datetime

    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: capturado.setdefault("dados", dados) and 42
    )

    dados_form = _form_valido()
    for campo in ("IMPLANTACAO", "MENSALIDADE", "JUROS_MORA", "JUROS_MULTA", "DATA_CONTRATO", "VENCIMENTO_CONTRATO"):
        dados_form[campo] = ""

    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 303
    dados = capturado["dados"]
    assert dados["IMPLANTACAO"] == "0.00"
    assert dados["MENSALIDADE"] == "0.00"
    assert dados["JUROS_MORA"] == "0.00"
    assert dados["JUROS_MULTA"] == "0.00"
    hoje = datetime.date.today().isoformat()
    assert dados["DATA_CONTRATO"] == hoje
    assert dados["VENCIMENTO_CONTRATO"] == hoje


def test_criar_cliente_normaliza_cnpj_e_telefones(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: capturado.setdefault("dados", dados) and 42
    )

    dados_form = _form_valido()
    dados_form.update(
        {
            "CNPJ": "11.222.333/0001-81",
            "TELEFONE": "(75) 3333-4444",
            "CELULAR": "(75) 99909-1780",
        }
    )

    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 303
    assert capturado["dados"]["CNPJ"] == "11222333000181"
    assert capturado["dados"]["TELEFONE"] == "557533334444"
    assert capturado["dados"]["CELULAR"] == "5575999091780"


def test_editar_cliente_normaliza_cnpj_e_telefones(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "obter_cliente", lambda cliente_id: {"ID": cliente_id})
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "atualizar_cliente",
        lambda cliente_id, dados: capturado.setdefault("dados", dados),
    )

    dados_form = _form_valido()
    dados_form.update(
        {
            "CNPJ": "111.444.777-35",
            "TELEFONE": "(75) 3333-4444",
            "CELULAR": "(75) 99909-1780",
        }
    )

    resposta = client.post("/clientes/1/editar", data=dados_form)
    assert resposta.status_code == 303
    assert capturado["dados"]["CNPJ"] == "11144477735"
    assert capturado["dados"]["TELEFONE"] == "557533334444"
    assert capturado["dados"]["CELULAR"] == "5575999091780"


def test_editar_cliente_codigo_duplicado_bloqueia_sem_bypass(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "obter_cliente", lambda cliente_id: {"ID": cliente_id})
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: True)
    atualizado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "atualizar_cliente",
        lambda cliente_id, dados: atualizado.setdefault("ok", True),
    )

    dados_form = _form_valido()
    resposta = client.post("/clientes/1/editar", data=dados_form)
    assert resposta.status_code == 200
    assert "já está em uso" in resposta.text
    assert "ok" not in atualizado


def test_criar_cliente_cnpj_duplicado_bloqueia(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: True)
    criado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: criado.setdefault("ok", True) and 42
    )

    resposta = client.post("/clientes/novo", data=_form_valido())
    assert resposta.status_code == 200
    assert "já está cadastrado" in resposta.text
    assert "ok" not in criado


def test_editar_cliente_cnpj_duplicado_bloqueia(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "obter_cliente", lambda cliente_id: {"ID": cliente_id})
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: True)
    atualizado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "atualizar_cliente",
        lambda cliente_id, dados: atualizado.setdefault("ok", True),
    )

    resposta = client.post("/clientes/1/editar", data=_form_valido())
    assert resposta.status_code == 200
    assert "já está cadastrado" in resposta.text
    assert "ok" not in atualizado


def test_editar_cliente_inexistente_nao_finge_sucesso(monkeypatch):
    # Sem a checagem de existência, isso caía direto no UPDATE (0 linhas
    # afetadas, sem erro do MySQL) e ainda registrava "sucesso" no log.
    monkeypatch.setattr(router_clientes.db_clientes, "obter_cliente", lambda cliente_id: None)
    atualizado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "atualizar_cliente",
        lambda cliente_id, dados: atualizado.setdefault("ok", True),
    )

    resposta = client.post("/clientes/999/editar", data=_form_valido())
    assert resposta.status_code == 303
    assert resposta.headers["location"].startswith("/clientes?")
    assert "ok" not in atualizado


def test_excluir_cliente_inexistente_nao_finge_sucesso(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "excluir_cliente", lambda cliente_id: False)

    resposta = client.post("/clientes/999/excluir", data={"csrf_token": CSRF_TESTE})
    assert resposta.status_code == 303
    assert resposta.headers["location"].startswith("/clientes?")
    assert "danger" in resposta.headers["location"]


def test_excluir_cliente_com_dependencia_mostra_erro(monkeypatch):
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "obter_cliente",
        lambda cliente_id: {"ID": cliente_id, "CODIGO": "000001", "RAZAO": "R", "FANTASIA": "F"},
    )
    monkeypatch.setattr(router_clientes.db_contatos, "listar_contatos_por_cliente", lambda cliente_id: [])
    monkeypatch.setattr(router_clientes.db_chaves, "status_chaves", lambda codigo: None)

    def _excluir(cliente_id):
        raise router_clientes.db_clientes.ClienteComDependenciasError("tem contato")

    monkeypatch.setattr(router_clientes.db_clientes, "excluir_cliente", _excluir)

    resposta = client.post("/clientes/1/excluir", data={"csrf_token": CSRF_TESTE}, follow_redirects=True)
    assert resposta.status_code == 200
    assert "tem contato" in resposta.text


def _limpar_codigo(codigo: str) -> None:
    conn = get_connection()
    try:
        with conn.cursor() as cur:
            cur.execute("DELETE FROM CLIENTE WHERE CODIGO = %s", (codigo,))
    finally:
        conn.close()


def test_criar_cliente_com_data_e_decimais_vazios_cria_com_defaults():
    """
    Integração com o banco real de dev: DATA_CONTRATO/decimais deixaram de
    ser obrigatórios — em branco, o router aplica defaults (0,00 / hoje)
    antes de gravar, então o cliente é criado normalmente (303), não gera
    erro nem 500.
    """
    codigo = "999906"
    dados_form = _form_valido(codigo)
    for campo in ("IMPLANTACAO", "MENSALIDADE", "JUROS_MORA", "JUROS_MULTA", "DATA_CONTRATO", "VENCIMENTO_CONTRATO"):
        dados_form[campo] = ""
    try:
        resposta = client.post("/clientes/novo", data=dados_form)
        assert resposta.status_code == 303
    finally:
        _limpar_codigo(codigo)


def test_criar_cliente_com_dv_invalido_exige_confirmacao(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    criado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: criado.setdefault("ok", True) and 42
    )

    dados_form = _form_valido()
    dados_form["CNPJ"] = "11144477734"  # CPF com DV inválido (1 dígito diferente do válido "...735")

    # Sem confirmar: pede confirmação, não cria.
    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 200
    assert "não confere" in resposta.text
    assert "ok" not in criado

    # Confirmando: cria.
    dados_form["confirmar_dv_invalido"] = "1"
    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 303
    assert criado.get("ok") is True


def test_criar_cliente_com_cnpj_dv_invalido_bloqueia_sempre(monkeypatch):
    """
    Diferente de CPF: CNPJ com DV inválido bloqueia sempre, sem opção de
    "cadastrar mesmo assim" — nem com confirmar_dv_invalido=1.
    """
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    criado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: criado.setdefault("ok", True) and 42
    )

    dados_form = _form_valido()
    dados_form["CNPJ"] = "11222333000180"  # último dígito trocado: DV inválido

    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 200
    assert "não confere" in resposta.text
    assert "ok" not in criado

    # Mesmo confirmando, continua bloqueando (diferente do fluxo de CPF).
    dados_form["confirmar_dv_invalido"] = "1"
    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 200
    assert "ok" not in criado


def test_editar_cliente_com_cnpj_dv_invalido_bloqueia(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "obter_cliente", lambda cliente_id: {"ID": cliente_id})
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    atualizado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes,
        "atualizar_cliente",
        lambda cliente_id, dados: atualizado.setdefault("ok", True),
    )

    dados_form = _form_valido()
    dados_form["CNPJ"] = "11222333000180"

    resposta = client.post("/clientes/1/editar", data=dados_form)
    assert resposta.status_code == 200
    assert "não confere" in resposta.text
    assert "ok" not in atualizado


def test_criar_cliente_com_cpf_dv_invalido_continua_permitindo_confirmar(monkeypatch):
    """Regressão: CPF com DV inválido não muda de comportamento."""
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    criado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: criado.setdefault("ok", True) and 42
    )

    dados_form = _form_valido()
    dados_form["CNPJ"] = "11144477734"  # CPF com DV inválido

    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 200
    assert "não confere" in resposta.text
    assert "ok" not in criado

    dados_form["confirmar_dv_invalido"] = "1"
    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 303
    assert criado.get("ok") is True


def test_criar_cliente_grava_telefone_com_ddi_55(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: capturado.setdefault("dados", dados) and 42
    )

    dados_form = _form_valido()
    dados_form.update({"TELEFONE": "(75) 3333-4444", "CELULAR": "(75) 99909-1780"})

    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 303
    assert capturado["dados"]["TELEFONE"] == "557533334444"
    assert capturado["dados"]["CELULAR"] == "5575999091780"


def test_criar_cliente_telefone_ja_com_55_nao_duplica(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: capturado.setdefault("dados", dados) and 42
    )

    dados_form = _form_valido()
    dados_form["CELULAR"] = "5575999091780"

    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 303
    assert capturado["dados"]["CELULAR"] == "5575999091780"


def test_criar_cliente_grava_uf_maiuscula_e_cep_sem_traco(monkeypatch):
    monkeypatch.setattr(router_clientes.db_clientes, "codigo_em_uso", lambda codigo, ignorar_id=None: False)
    monkeypatch.setattr(router_clientes.db_clientes, "cnpj_em_uso", lambda documento, ignorar_id=None: False)
    capturado = {}
    monkeypatch.setattr(
        router_clientes.db_clientes, "criar_cliente", lambda dados: capturado.setdefault("dados", dados) and 42
    )

    dados_form = _form_valido()
    dados_form.update({"UF": "ba", "CEP": "44430-174"})

    resposta = client.post("/clientes/novo", data=dados_form)
    assert resposta.status_code == 303
    assert capturado["dados"]["UF"] == "BA"
    assert capturado["dados"]["CEP"] == "44430174"