app.py

import re
import logging
import time
from functools import wraps
from flask import Flask, request, jsonify, g
from flask_jwt_extended import JWTManager, jwt_required, create_access_token, get_jwt_identity
from datetime import datetime, timedelta
from sqlalchemy.exc import IntegrityError
from database import SessionLocal, init_db 
from models.formulario import Formulario
from models.propostas import Propostas
from models.resposta import Resposta
from models.respostas_formulario import RespostaFormulario
from models.usuario import Usuario
from config import Config
from flask_cors import CORS

# Configuração de logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('pic_backend.log', encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# Decorator para monitorar tempo de queries
def monitor_db_time(operation_name):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            start_time = time.time()
            logger.info(f"🔍 [DB] Iniciando operação: {operation_name}")
            
            try:
                result = func(*args, **kwargs)
                elapsed_time = time.time() - start_time
                logger.info(f"✅ [DB] {operation_name} concluída em {elapsed_time:.4f}s")
                return result
            except Exception as e:
                elapsed_time = time.time() - start_time
                logger.error(f"❌ [DB] {operation_name} falhou em {elapsed_time:.4f}s - Erro: {str(e)}")
                raise
        return wrapper
    return decorator

# Decorator para monitorar tempo total de endpoints
def monitor_endpoint_time(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        endpoint_name = func.__name__
        logger.info(f"🚀 [ENDPOINT] Iniciando {endpoint_name}")
        
        try:
            result = func(*args, **kwargs)
            elapsed_time = time.time() - start_time
            logger.info(f"✅ [ENDPOINT] {endpoint_name} concluído em {elapsed_time:.4f}s")
            return result
        except Exception as e:
            elapsed_time = time.time() - start_time
            logger.error(f"❌ [ENDPOINT] {endpoint_name} falhou em {elapsed_time:.4f}s - Erro: {str(e)}")
            raise
    return wrapper

# Inicializa o banco antes de subir a API
init_db()

app = Flask(__name__)
CORS(app)

# Configuração JWT
app.config['JWT_SECRET_KEY'] = Config.JWT_SECRET_KEY
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta(hours=12)
jwt = JWTManager(app)
app.config['JSON_AS_ASCII'] = False

# Middleware para log de requisições HTTP
@app.before_request
def log_request_info():
    logger.info(f"🌐 [HTTP] {request.method} {request.path} - IP: {request.remote_addr} - User-Agent: {request.headers.get('User-Agent', 'N/A')[:100]}")

@app.after_request
def log_response_info(response):
    logger.info(f"📤 [HTTP] {request.method} {request.path} - Status: {response.status_code}")
    return response

@jwt.invalid_token_loader
def token_invalido_callback(error_string):
    print(f"[JWT] Token inválido: {error_string}")
    return {"erro": "Token inválido", "detalhes": error_string}, 401

@jwt.unauthorized_loader
def token_ausente_callback(error_string):
    print(f"[JWT] Token ausente ou cabeçalho errado: {error_string}")
    return {"erro": "Token ausente", "detalhes": error_string}, 401

@jwt.expired_token_loader
def token_expirado_callback(jwt_header, jwt_payload):
    print(f"[JWT] Token expirado: {jwt_payload}")
    return {"erro": "Token expirado"}, 401

def get_session():
    """Obter sessão do banco com logging de tempo de criação"""
    start_time = time.time()
    try:
        db = SessionLocal()
        elapsed_time = time.time() - start_time
        logger.debug(f"🔌 [DB] Sessão criada em {elapsed_time:.4f}s")
        return db
    except Exception as e:
        elapsed_time = time.time() - start_time
        logger.error(f"❌ [DB] Falha ao criar sessão em {elapsed_time:.4f}s - Erro: {str(e)}")
        raise e
    
@app.route('/health', methods=['GET'])
def health_check():
    return jsonify({"status": "healthy", "service": "PIC Backend API"})

@app.route('/usuario/cadastrar', methods=['POST'])
@monitor_endpoint_time
@monitor_db_time("Cadastrar usuário")
def cadastrar():
    data = request.get_json()
    
    if not data:
        return jsonify({"erro": "Dados JSON são obrigatórios"}), 400
    
    # Validar campos obrigatórios
    campos_obrigatorios = ['nome', 'telefone', 'data_nascimento']
    for campo in campos_obrigatorios:
        if campo not in data:
            return jsonify({"erro": f"Campo obrigatório ausente: {campo}"}), 400
    
    try:
        data_nascimento = datetime.strptime(data['data_nascimento'], '%d/%m/%Y').date()
        telefone = re.sub(r'\D', '', data['telefone'])  # Remove caracteres não numéricos
    except ValueError:
        return jsonify({"erro": "Formato de data_nascimento inválido. Use DD/MM/AAAA"}), 400

    db = get_session()
    try:
        # Criar novo usuário
        start_query = time.time()
        novo_usuario = Usuario(
            nome=data['nome'],
            telefone=telefone,
            data_nascimento=data_nascimento,
            bairro=data.get('bairro'),
            cidade=data.get('cidade'),
            estado=data.get('estado')
        )
        
        db.add(novo_usuario)
        db.commit()
        db.refresh(novo_usuario)
        query_time = time.time() - start_query
        logger.info(f"📝 [DB] INSERT Usuario executado em {query_time:.4f}s")
        
        return jsonify({
            "mensagem": "Usuário registrado com sucesso",
            "usuario": {
                "nome": novo_usuario.nome,
                "telefone": novo_usuario.telefone,
                "bairro": novo_usuario.bairro,
                "cidade": novo_usuario.cidade,
                "estado": novo_usuario.estado,
                "level": novo_usuario.level
            }
        }), 201
        
    except IntegrityError:
        return jsonify({"erro": "Telefone já cadastrado"}), 409
    except Exception as e:
        print(e)
        return jsonify({"erro": str(e)}), 500

@app.route('/login', methods=['POST'])
@monitor_endpoint_time
@monitor_db_time("Login usuário")
def login():
    data = request.get_json()
    
    if not data:
        return jsonify({"erro": "Dados JSON são obrigatórios"}), 400
    
    # Validar campos obrigatórios
    campos_obrigatorios = ['telefone', 'data_nascimento']
    for campo in campos_obrigatorios:
        if campo not in data:
            return jsonify({"erro": f"Campo obrigatório ausente: {campo}"}), 400
    
    # Processar data de nascimento
    try:
        data_nascimento = datetime.strptime(data['data_nascimento'], '%d/%m/%Y').date()
        # Tratamento de dados para considerar somente os numeros do telefone
        telefone = re.sub(r'\D', '', data['telefone'])  # Remove caracteres não numéricos
    except ValueError:
        return jsonify({"erro": "Formato de data_nascimento inválido. Use DD/MM/AAAA"}), 400

    db = get_session()

    try:
        logger.info(f"🔑 [LOGIN] Tentativa de login para telefone: {data['telefone']}")
        
        # Encontrar usuário por telefone e data de nascimento
        start_query = time.time()
        usuario = db.query(Usuario).filter(
            Usuario.telefone == telefone,
            Usuario.data_nascimento == data_nascimento
        ).first()
        query_time = time.time() - start_query
        logger.info(f"🔍 [DB] SELECT Usuario executado em {query_time:.4f}s")
        
        if not usuario:
            return jsonify({"erro": "Credenciais inválidas"}), 401
        
        # Criar token de acesso
        token_acesso = create_access_token(identity=str(usuario.id))
        print(token_acesso)
        
        return jsonify({
            "mensagem": "Login realizado com sucesso",
            "token": token_acesso,
            "usuario": {
                "nome": usuario.nome,
                "data_nascimento": usuario.data_nascimento,
                "telefone": usuario.telefone,
                "bairro": usuario.bairro,
                "cidade": usuario.cidade,
                "estado": usuario.estado,
                "level": usuario.level
            }
        }), 200
        
    except Exception as e:
        return jsonify({"erro": str(e)}), 500

@app.route('/perfil', methods=['GET'])
@jwt_required()
@monitor_db_time("Obter perfil usuário")
def obter_perfil():
    db = get_session()
    try:
        id_usuario_atual = int(get_jwt_identity())
        
        start_query = time.time()
        usuario = db.query(Usuario).filter(Usuario.id == id_usuario_atual).first()
        query_time = time.time() - start_query
        logger.info(f"👤 [DB] SELECT perfil usuario executado em {query_time:.4f}s")
        
        if not usuario:
            return jsonify({"erro": "Usuário não encontrado"}), 404
        
        return jsonify({
            "usuario": {
                "id": usuario.id,
                "nome": usuario.nome,
                "telefone": usuario.telefone,
                "data_nascimento": usuario.data_nascimento.isoformat(),
                "bairro": usuario.bairro,
                "cidade": usuario.cidade,
                "estado": usuario.estado,
                "email": usuario.email,
                "cep": usuario.cep,
                "rua": usuario.rua,
                "criado_em": usuario.created_at.isoformat(),
                "atualizado_em": usuario.updated_at.isoformat()
            }
        }), 200
        
    except Exception as e:
        db.rollback()
        return jsonify({"error": str(e)}), 500
    finally:
        start_close = time.time()
        db.close()
        close_time = time.time() - start_close
        logger.debug(f"🔒 [DB] Sessão perfil fechada em {close_time:.4f}s")

@app.route('/usuario/formularios_respondidos', methods=['GET'])
@jwt_required()
@monitor_db_time("Buscar formulários respondidos")
def buscar_formularios_respondidos_usuario():
    try:
        id_usuario_atual = get_jwt_identity()
    except Exception as e:
        print("Erro ao validar token:", e)
        return jsonify({"erro": "Token inválido", "detalhes": str(e)}), 401
    
    db = get_session()
    try:
        # Busca todos os ids de formulario respondido pelo usuario
        start_query = time.time()
        ids_formularios = db.query(RespostaFormulario.id_formulario).filter(
            RespostaFormulario.id_usuario == id_usuario_atual
        ).distinct().all()
        query_time = time.time() - start_query
        logger.info(f"📋 [DB] SELECT formularios respondidos executado em {query_time:.4f}s")

        # Extrai apenas os IDs da tupla retornada pelo SQLAlchemy
        lista_ids = [id_form[0] for id_form in ids_formularios]

        logger.info(f"📊 [STATS] Usuário {id_usuario_atual} tem {len(lista_ids)} formulários respondidos")

        return jsonify({
            "mensagem": "Formulários respondidos encontrados",
            "ids_formularios": lista_ids
        }), 200
        
    except Exception as e:
        return jsonify({"erro": "Erro ao buscar formulários", "detalhes": str(e)}), 500
    finally:
        start_close = time.time()
        db.close()
        close_time = time.time() - start_close
        logger.debug(f"🔒 [DB] Sessão formulários respondidos fechada em {close_time:.4f}s")

@app.route('/formulario/responder', methods=['POST'])
@jwt_required()
@monitor_endpoint_time
@monitor_db_time("Responder formulário")
def responder_formulario():
    try:
        identidade = get_jwt_identity()
    except Exception as e:
        print("Erro ao validar token:", e)
        return {"valido": False, "erro": str(e)}, 401
    
    id_usuario_atual = get_jwt_identity()
    data = request.get_json()
    db = get_session()

    id_formulario = data.get('id_formulario')
    respostas = data.get('respostas')

    # Busca o formulario através do id no banco de dados
    start_query = time.time()
    formulario = db.query(Formulario).filter(Formulario.id == id_formulario).first()
    query_time = time.time() - start_query
    logger.info(f"🔍 [DB] SELECT formulario executado em {query_time:.4f}s")
    
    if not formulario:
        return jsonify({"status": "error", "message": "Formulário não encontrado"}), 404

    # Busca a resposta do usuario para esse formulario
    start_query = time.time()
    resposta_usuario_formulario = db.query(RespostaFormulario).filter(
        RespostaFormulario.id_formulario == id_formulario,
        RespostaFormulario.id_usuario == id_usuario_atual
    ).first()
    query_time = time.time() - start_query
    logger.info(f"🔍 [DB] SELECT resposta usuario formulario executado em {query_time:.4f}s")

    # Verifica se o usuário já respondeu o formulário
    if resposta_usuario_formulario:
        return jsonify({
            "status": "error",
            "message": f"formulario ja respondido"
        }), 400

    # 💾 Processar respostas
    start_batch = time.time()
    for i, r in enumerate(respostas):
        pergunta = r.get('pergunta')
        resposta = r.get('resposta')
        tipo_pergunta = r.get('tipo_pergunta', 'texto')

        start_insert = time.time()
        resposta_obj = Resposta(
            id_formulario=id_formulario,
            id_usuario=id_usuario_atual,
            pergunta=pergunta,
            resposta=resposta,
            tipo_pergunta=tipo_pergunta
        )
        db.add(resposta_obj)
        db.commit()
        db.refresh(resposta_obj)
        insert_time = time.time() - start_insert
        logger.debug(f"💾 [DB] INSERT resposta {i+1}/{len(respostas)} executado em {insert_time:.4f}s")

    batch_time = time.time() - start_batch
    logger.info(f"📦 [DB] Batch INSERT {len(respostas)} respostas executado em {batch_time:.4f}s")

    # Adiciona a resposta na tabela respostasformulario
    start_query = time.time()
    resposta_formulario = RespostaFormulario(
        id_formulario=id_formulario,
        id_usuario=id_usuario_atual,
        respondido=datetime.utcnow(),
        status="respondido"
    )
    db.add(resposta_formulario)
    db.commit()
    db.refresh(resposta_formulario)
    query_time = time.time() - start_query
    logger.info(f"💾 [DB] INSERT resposta formulario executado em {query_time:.4f}s") 

    # Ajuste para a mensagem ir com utf-8

    return jsonify({
        "status": "success",
        "message": f"Respostas do formulário {id_formulario} registradas com sucesso para o usuário {id_usuario_atual}"
    }), 200

@app.route('/formulario/respostas/all', methods=['GET'])
@jwt_required()
@monitor_db_time("Obter todas respostas formulários")
def obter_todas_respostas_formularios():
    id_usuario_atual = get_jwt_identity()

    db = get_session()

    try:
        start_query = time.time()
        respostas = db.query(Resposta).all()
        query_time = time.time() - start_query
        logger.info(f"📋 [DB] SELECT todas respostas executado em {query_time:.4f}s - {len(respostas)} registros")
        
        respostas_lista = []
        for resposta in respostas:
            respostas_lista.append({
                "id_formulario": int(resposta.id_formulario),
                "id_usuario": resposta.id_usuario,
                "pergunta": resposta.pergunta,
                "resposta": resposta.resposta,
                "tipo_pergunta": resposta.tipo_pergunta,
                "created_at": resposta.created_at.isoformat(),
                "updated_at": resposta.updated_at.isoformat()
            })
        
        return jsonify(
            respostas_lista
        ), 200

    except Exception as e:
        return jsonify({
            "status": "error",
            "message": str(e)
        }), 500

@app.route('/propostas/usuario', methods=['GET'])
@jwt_required()
@monitor_db_time("Obter propostas do usuário")
def obter_propostas():
    id_usuario_atual = get_jwt_identity()
    db = get_session()

    try:
        start_query = time.time()
        propostas = db.query(Propostas).filter(Propostas.id_usuario == id_usuario_atual).all()
        query_time = time.time() - start_query
        logger.info(f"💡 [DB] SELECT propostas usuario executado em {query_time:.4f}s - {len(propostas)} registros")
        return jsonify([{
            "id": proposta.id,
            "titulo": proposta.titulo,
            "descricao": proposta.descricao,
            "anexo": proposta.anexo,
            "tema": proposta.tema,
            "status": proposta.status,
            "created_at": proposta.created_at,
            "updated_at": proposta.updated_at
        } for proposta in propostas]), 200

    except Exception as e:
        return jsonify({
            "status": "error",
            "message": str(e)
        }), 500
    
@app.route('/propostas', methods=['POST'])
@jwt_required()
@monitor_db_time("Criar proposta")
def criar_proposta():
    id_usuario_atual = get_jwt_identity()
    db = get_session()

    data = request.get_json()
    titulo = data.get('titulo')
    descricao = data.get('descricao')
    anexo = data.get('anexo')
    tema = data.get('tema')

    # Verifica se a proposta já existe para o usuário
    start_query = time.time()
    proposta_existente = db.query(Propostas).filter(
        Propostas.tema == tema,
        Propostas.id_usuario == id_usuario_atual
    ).first()
    query_time = time.time() - start_query
    logger.info(f"🔍 [DB] SELECT verificar proposta existente executado em {query_time:.4f}s")

    if proposta_existente:
        logger.warning(f"⚠️ [BUSINESS] Tentativa de criar proposta duplicada - Tema: {tema}, Usuário: {id_usuario_atual}")
        return jsonify({
            "status": "error",
            "message": "Proposta com este tema já existe para o usuário"
        }), 400

    start_query = time.time()
    nova_proposta = Propostas(
        id_usuario=id_usuario_atual,
        titulo=titulo,
        descricao=descricao,
        anexo=anexo,
        tema=tema
    )

    db.add(nova_proposta)
    db.commit()
    db.refresh(nova_proposta)
    query_time = time.time() - start_query
    logger.info(f"💾 [DB] INSERT nova proposta executado em {query_time:.4f}s")

    return jsonify({
        "status": "success",
        "message": "Proposta criada com sucesso",
        "proposta": {
            "id": nova_proposta.id,
            "titulo": nova_proposta.titulo,
            "descricao": nova_proposta.descricao,
            "anexo": nova_proposta.anexo,
            "tema": nova_proposta.tema,
            "created_at": nova_proposta.created_at,
            "updated_at": nova_proposta.updated_at
        }
    }), 201

@app.route('/propostas/<int:proposta_id>', methods=['PUT'])
@jwt_required()
@monitor_db_time("Atualizar proposta")
def atualizar_proposta(proposta_id):
    id_usuario_atual = get_jwt_identity()
    db = get_session()

    try:
        start_query = time.time()
        proposta = db.query(Propostas).filter(
            Propostas.id == proposta_id,
            Propostas.id_usuario == id_usuario_atual
        ).first()
        query_time = time.time() - start_query
        logger.info(f"🔍 [DB] SELECT proposta para atualizar executado em {query_time:.4f}s")

        if not proposta:
            return jsonify({"status": "error", "message": "Proposta não encontrada"}), 404

        data = request.get_json()
        
        # Atualiza apenas os campos que não são None/null
        if data.get('titulo') is not None:
            proposta.titulo = data.get('titulo')
        if data.get('descricao') is not None:
            proposta.descricao = data.get('descricao')
            print(data.get('descricao'))
        if data.get('anexo') is not None:
            proposta.anexo = data.get('anexo')
        if data.get('tema') is not None:
            proposta.tema = data.get('tema')

        start_query = time.time()
        db.commit()
        db.refresh(proposta)
        query_time = time.time() - start_query
        logger.info(f"💾 [DB] UPDATE proposta executado em {query_time:.4f}s")

        return jsonify({
            "status": "success",
            "message": "Proposta atualizada com sucesso",
            "proposta": {
                "id": proposta.id,
                "titulo": proposta.titulo,
                "descricao": proposta.descricao,
                "anexo": proposta.anexo,
                "tema": proposta.tema,
                "created_at": proposta.created_at,
                "updated_at": proposta.updated_at
            }
        }), 200

    except Exception as e:
        db.rollback()
        logger.error(f"❌ [DB] Erro ao atualizar proposta {proposta_id}: {str(e)}")
        return jsonify({"status": "error", "message": str(e)}), 500
    finally:
        db.close()

@app.route('/propostas/<int:proposta_id>', methods=['DELETE'])
@jwt_required()
def deletar_proposta(proposta_id):
    id_usuario_atual = get_jwt_identity()
    db = get_session()

    proposta = db.query(Propostas).filter(
        Propostas.id == proposta_id,
        Propostas.id_usuario == id_usuario_atual
    ).first()

    if not proposta:
        return jsonify({"status": "error", "message": "Proposta não encontrada"}), 404

    db.delete(proposta)
    db.commit()

    return jsonify({
        "status": "success",
        "message": "Proposta deletada com sucesso"
    }), 200

@app.route('/propostas/all', methods=['GET'])
@jwt_required()
def obter_todas_propostas():
    id_usuario_atual = get_jwt_identity()
    db = get_session()

    usuario_admin = db.query(Usuario).filter(Usuario.id == id_usuario_atual).first()
    if not usuario_admin or usuario_admin.level < 5:
        return jsonify({"status": "error", "message": "Acesso negado"}), 403

    try:
        propostas = db.query(Propostas).all()
        return jsonify([{
            "id": proposta.id,
            "titulo": proposta.titulo,
            "descricao": proposta.descricao,
            "anexo": proposta.anexo,
            "tema": proposta.tema,
            "created_at": proposta.created_at,
            "updated_at": proposta.updated_at
        } for proposta in propostas]), 200

    except Exception as e:
        return jsonify({
            "status": "error",
            "message": str(e)
        }), 500

@app.route('/propostas/tema', methods=['GET'])
@jwt_required()
def obter_propostas_por_tema():
    id_usuario_atual = get_jwt_identity()
    db = get_session()

    tema = request.args.get('tema')
    if not tema:
        return jsonify({"status": "error", "message": "Tema não fornecido"}), 400

    propostas = db.query(Propostas).filter(
        Propostas.tema == tema,
        Propostas.id_usuario == id_usuario_atual
    ).first()

    return jsonify({
        "id": propostas.id,
        "titulo": propostas.titulo,
        "descricao": propostas.descricao,
        "anexo": propostas.anexo,
        "tema": propostas.tema,
        "created_at": propostas.created_at,
        "updated_at": propostas.updated_at
    }), 200


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)