GTI_GERENCIADOR_FISCAL/app/routers/funcionarios.py

"""
Rotas de gestão de FUNCIONARIO_PAINEL: listar, criar (com senha e perfil),
editar nome/login/perfil, redefinir senha, ativar/desativar (nunca exclui
de verdade). Router inteiro protegido por exigir_admin — só administradores
acessam qualquer rota daqui (ver app/auth.py).
"""
from typing import Optional

from fastapi import APIRouter, Depends, Form, Request
from fastapi.responses import HTMLResponse, RedirectResponse
from fastapi.templating import Jinja2Templates

from ..auth import UsuarioLogado, exigir_admin
from ..csrf import exigir_csrf, token_do_contexto
from ..db import funcionarios as db_funcionarios
from ..db import log as db_log

PERFIS_VALIDOS = {"ADMIN", "PADRAO"}

router = APIRouter(prefix="/funcionarios", dependencies=[Depends(exigir_admin)])
templates = Jinja2Templates(directory="app/templates")


def _redirect_com_mensagem(mensagem: str, tipo: str = "success") -> RedirectResponse:
    from urllib.parse import urlencode

    return RedirectResponse(f"/funcionarios?{urlencode({'mensagem': mensagem, 'mensagem_tipo': tipo})}", status_code=303)


@router.get("", response_class=HTMLResponse)
def listar(
    request: Request,
    mensagem: Optional[str] = None,
    mensagem_tipo: Optional[str] = None,
    usuario: UsuarioLogado = Depends(exigir_admin),
):
    funcionarios = db_funcionarios.listar_funcionarios()
    return templates.TemplateResponse(
        request,
        "funcionarios_lista.html",
        {
            "funcionarios": funcionarios, "csrf_token": token_do_contexto(request),
            "mensagem": mensagem, "mensagem_tipo": mensagem_tipo,
        },
    )


@router.get("/novo", response_class=HTMLResponse)
def form_novo(request: Request, usuario: UsuarioLogado = Depends(exigir_admin)):
    return templates.TemplateResponse(
        request, "funcionario_form.html", {"funcionario": None, "csrf_token": token_do_contexto(request)}
    )


@router.post("/novo", dependencies=[Depends(exigir_csrf)])
def criar(
    request: Request,
    nome: str = Form(...),
    login: str = Form(...),
    senha: str = Form(...),
    confirmar_senha: str = Form(...),
    perfil: str = Form(...),
    usuario: UsuarioLogado = Depends(exigir_admin),
):
    nome = nome.strip()
    login = login.strip()

    erro = None
    if not nome or not login or not senha:
        erro = "Preencha nome, login e senha."
    elif senha != confirmar_senha:
        erro = "As senhas digitadas não coincidem."
    elif perfil not in PERFIS_VALIDOS:
        erro = "Perfil inválido."
    elif db_funcionarios.login_em_uso(login):
        erro = f"O login \"{login}\" já está em uso."

    if erro:
        return templates.TemplateResponse(
            request,
            "funcionario_form.html",
            {
                "funcionario": None, "erro": erro, "dados": {"NOME": nome, "LOGIN": login, "PERFIL": perfil},
                "csrf_token": token_do_contexto(request),
            },
        )

    novo_id = db_funcionarios.criar_funcionario(nome, login, senha, perfil)
    db_log.registrar(str(usuario), "criar", "funcionario", str(novo_id), True)
    return _redirect_com_mensagem("Funcionário cadastrado.")


@router.get("/{funcionario_id}/editar", response_class=HTMLResponse)
def form_editar(request: Request, funcionario_id: int, usuario: UsuarioLogado = Depends(exigir_admin)):
    funcionario = db_funcionarios.obter_funcionario(funcionario_id)
    if funcionario is None:
        return _redirect_com_mensagem("Funcionário não encontrado.", "danger")
    return templates.TemplateResponse(
        request, "funcionario_form.html", {"funcionario": funcionario, "csrf_token": token_do_contexto(request)}
    )


@router.post("/{funcionario_id}/editar", dependencies=[Depends(exigir_csrf)])
def editar(
    request: Request,
    funcionario_id: int,
    nome: str = Form(...),
    login: str = Form(...),
    perfil: str = Form(...),
    usuario: UsuarioLogado = Depends(exigir_admin),
):
    nome = nome.strip()
    login = login.strip()

    erro = None
    if not nome or not login:
        erro = "Preencha nome e login."
    elif perfil not in PERFIS_VALIDOS:
        erro = "Perfil inválido."
    elif db_funcionarios.login_em_uso(login, ignorar_id=funcionario_id):
        erro = f"O login \"{login}\" já está em uso."
    else:
        atual = db_funcionarios.obter_funcionario(funcionario_id)
        if atual is None:
            erro = "Funcionário não encontrado."
        else:
            rebaixando_ultimo_admin = (
                atual["PERFIL"] == "ADMIN"
                and atual["ATIVO"] == 1
                and perfil == "PADRAO"
                and db_funcionarios.contar_admins_ativos() <= 1
            )
            if rebaixando_ultimo_admin:
                erro = "Não é possível — este é o único administrador ativo."

    if erro:
        return templates.TemplateResponse(
            request,
            "funcionario_form.html",
            {
                "funcionario": {"ID": funcionario_id}, "erro": erro,
                "dados": {"NOME": nome, "LOGIN": login, "PERFIL": perfil},
                "csrf_token": token_do_contexto(request),
            },
        )

    db_funcionarios.atualizar_funcionario(funcionario_id, nome, login, perfil)
    db_log.registrar(str(usuario), "editar", "funcionario", str(funcionario_id), True)
    return _redirect_com_mensagem("Funcionário atualizado.")


@router.post("/{funcionario_id}/redefinir-senha", dependencies=[Depends(exigir_csrf)])
def redefinir_senha(
    funcionario_id: int,
    nova_senha: str = Form(...),
    confirmar_nova_senha: str = Form(...),
    usuario: UsuarioLogado = Depends(exigir_admin),
):
    if not nova_senha or nova_senha != confirmar_nova_senha:
        db_log.registrar(str(usuario), "redefinir_senha", "funcionario", str(funcionario_id), False, "senhas não coincidem")
        return _redirect_com_mensagem("As senhas digitadas não coincidem.", "danger")

    atualizado = db_funcionarios.redefinir_senha(funcionario_id, nova_senha)
    if not atualizado:
        db_log.registrar(str(usuario), "redefinir_senha", "funcionario", str(funcionario_id), False, "funcionário não encontrado")
        return _redirect_com_mensagem("Funcionário não encontrado.", "danger")

    db_log.registrar(str(usuario), "redefinir_senha", "funcionario", str(funcionario_id), True)
    return _redirect_com_mensagem("Senha redefinida.")


@router.post("/{funcionario_id}/alternar-ativo", dependencies=[Depends(exigir_csrf)])
def alternar_ativo(funcionario_id: int, usuario: UsuarioLogado = Depends(exigir_admin)):
    atual = db_funcionarios.obter_funcionario(funcionario_id)
    if atual is None:
        # Sem essa checagem, um ID inexistente caía direto no UPDATE (que
        # não afeta nenhuma linha, sem erro do MySQL) e ainda registrava
        # "sucesso" no log.
        db_log.registrar(str(usuario), "alternar_ativo", "funcionario", str(funcionario_id), False, "funcionário não encontrado")
        return _redirect_com_mensagem("Funcionário não encontrado.", "danger")

    if atual["ATIVO"] == 1:
        # Só desativações (ATIVO 1 -> 0) de um admin passam pela checagem —
        # reativar (0 -> 1) nunca reduz a contagem de admins ativos.
        vai_desativar_ultimo_admin = atual["PERFIL"] == "ADMIN" and db_funcionarios.contar_admins_ativos() <= 1
        if vai_desativar_ultimo_admin:
            db_log.registrar(
                str(usuario), "alternar_ativo", "funcionario", str(funcionario_id), False, "único administrador ativo"
            )
            return _redirect_com_mensagem("Não é possível desativar — este é o único administrador ativo.", "danger")

    db_funcionarios.alternar_ativo(funcionario_id)
    db_log.registrar(str(usuario), "alternar_ativo", "funcionario", str(funcionario_id), True)
    return _redirect_com_mensagem("Status do funcionário atualizado.")