from flask import Flask, render_template, request, redirect, url_for, session, flash, jsonify
import mysql.connector
import random
import os
import json
import time
import google.generativeai as genai
from datetime import datetime
from collections import defaultdict

app = Flask(__name__)
app.secret_key = os.urandom(24)

# --- CONFIGURAÇÃO GEMINI AI ---
# ⚠️ MANTENHA A SUA CHAVE NOVA AQUI
GEMINI_API_KEY = "AIzaSyDplOOzkJyi_r6vAlMH5ZbayxSW9S9dSdk"

try:
    if GEMINI_API_KEY and "SUA_CHAVE" not in GEMINI_API_KEY:
        genai.configure(api_key=GEMINI_API_KEY)
    else:
        print("⚠️ AVISO: Chave da API não configurada.")
except Exception as e:
    print(f"❌ Erro API: {e}")

# --- ACESSOS ---
USERS = { "admin": "Admin_Apt_2@25", "tic": "Admin_Apt_2@25" }
SENHA_DO_EXAME = "Teste_Apt_2@25"

# --- BASE DE DADOS ---
db_config = {
    'host': '127.0.0.1', 'user': 'teste_app', 'password': 'N71j1ngl1c6n', 'database': 'insutec_acesso'
}

def get_db_connection():
    try:
        return mysql.connector.connect(**db_config)
    except mysql.connector.Error as err:
        print(f"Erro BD: {err}")
        return None

# --- IA: AVALIAÇÃO INDIVIDUAL ---
def avaliar_individual(pergunta_texto, justificativa_aluno):
    if not GEMINI_API_KEY or "SUA_CHAVE" in GEMINI_API_KEY: return 0.0
    justificativa_aluno = str(justificativa_aluno).strip()
    if len(justificativa_aluno) < 4: return 0.0

    print(f"   >>> IA a analisar: '{justificativa_aluno[:30]}...'")
    prompt = f"""Professor corretor: Avalie esta justificativa (0 ou 1).
    Pergunta: "{pergunta_texto}"
    Justificativa: "{justificativa_aluno}"
    Regras: 1 se tiver lógica/contexto. 0 se for chute/aleatório/cópia.
    SAÍDA: Só o número."""

    try:
        # Usando o modelo compatível (gemini-2.0-flash ou gemini-pro)
        model = genai.GenerativeModel('gemini-2.0-flash') 
        response = model.generate_content(prompt)
        texto = response.text.strip()
        
        if "1" in texto:
            print("   ✅ IA: Válida (+0.5)")
            return 0.5
        else:
            print("   ❌ IA: Inválida (0.0)")
            return 0.0
    except Exception as e:
        print(f"   ⚠️ Erro IA: {e}")
        return 0.0

# --- ROTAS ---
@app.route("/acesso-exame", methods=["GET", "POST"])
def acesso_exame():
    if request.method == "POST":
        if request.form.get('senha') == SENHA_DO_EXAME:
            session['acesso_permitido'] = True
            return redirect(url_for('pagina_inscricao'))
        else: flash('Senha incorreta.', 'error')
    return render_template("acesso_exame.html")

@app.route("/")
def pagina_inscricao():
    return render_template("inscricao.html") if session.get('acesso_permitido') else redirect(url_for('acesso_exame'))

@app.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        if USERS.get(request.form.get('username')) == request.form.get('password'):
            session['logged_in'] = True
            return redirect(url_for('painel_admin'))
    return render_template("login.html")

@app.route("/logout")
def logout():
    session.clear()
    return redirect(url_for('login'))

@app.route("/iniciar-teste", methods=["POST"])
def iniciar_teste():
    session['reinicios'] = 0 # Reseta o contador
    conn = get_db_connection()
    cursor = conn.cursor(dictionary=True)
    
    cursor.execute("SELECT id FROM candidatos WHERE numero_candidato = %s", (request.form['numero_candidato'],))
    existente = cursor.fetchone()
    
    if existente:
        c_id = existente['id']
        cursor.execute("SELECT id FROM resultados WHERE candidato_id = %s", (c_id,))
        if cursor.fetchone(): 
            conn.close()
            return render_template("acesso_negado.html")
    else:
        cursor.execute("INSERT INTO candidatos (numero_candidato, nome_completo, curso_desejado) VALUES (%s, %s, %s)", 
                       (request.form['numero_candidato'], request.form['nome_completo'], request.form['curso_desejado']))
        conn.commit()
        c_id = cursor.lastrowid

    cursor.execute("SELECT id FROM testes WHERE curso_associado = %s LIMIT 1", (request.form['curso_desejado'],))
    teste = cursor.fetchone()
    conn.close()
    
    if not teste: return "<h1>Erro: Curso sem teste configurado.</h1>"

    return render_template("regras.html", 
                           candidato_id=c_id, teste_id=teste['id'], 
                           nome_candidato=request.form['nome_completo'],
                           numero_candidato=request.form['numero_candidato'],
                           curso_desejado=request.form['curso_desejado'])

@app.route("/comecar-exame", methods=["POST"])
def comecar_exame():
    # --- NOVO: BLOQUEIO POR EXCESSO DE F5 ---
    reinicios = session.get('reinicios', 0)
    
    # Se já reiniciou 10 vezes (10 * 2 = 20 pontos de penalização), bloqueia.
    if reinicios >= 10:
        session.pop('reinicios', None) # Limpa para não ficar preso eternamente (opcional)
        flash("TESTE BLOQUEADO: Você atualizou a página demasiadas vezes e atingiu a penalização máxima.", "error")
        return redirect(url_for('acesso_exame'))

    aviso_penalizacao = f"ATENÇÃO: Você atualizou a página. Penalização acumulada: {reinicios * 2} valores." if reinicios > 0 else ""
    session['reinicios'] = reinicios + 1 # Incrementa contador

    conn = get_db_connection()
    cursor = conn.cursor(dictionary=True)
    
    cats = {'Matemática': 8, 'Lógica': 8, 'Especialidade': 4}
    perguntas_finais = []
    
    sql = f"SELECT id, enunciado, opcao_a, opcao_b, opcao_c, opcao_d, categoria FROM perguntas WHERE teste_id = %s AND categoria IN ({','.join(['%s']*3)})"
    cursor.execute(sql, tuple([request.form['teste_id']] + list(cats.keys())))
    pool = defaultdict(list)
    for p in cursor.fetchall(): pool[p['categoria']].append(p)

    for cat, qtd in cats.items():
        if len(pool[cat]) < qtd: return f"Erro: Faltam perguntas de {cat}"
        perguntas_finais.extend(random.sample(pool[cat], qtd))

    random.shuffle(perguntas_finais)
    conn.close()

    return render_template("teste.html", 
                           perguntas=perguntas_finais, 
                           candidato_id=request.form['candidato_id'], teste_id=request.form['teste_id'], curso=request.form['curso_desejado'],
                           nome_candidato=request.form.get('nome_candidato'), numero_candidato=request.form.get('numero_candidato'),
                           aviso_penalizacao=aviso_penalizacao)

@app.route("/submeter-teste", methods=["POST"])
def submeter_teste():
    conn = get_db_connection()
    cursor = conn.cursor(dictionary=True)
    
    ordem = request.form.get('ordem_perguntas', '').split(',')
    ids = [x for x in ordem if x]
    if not ids: return "Erro envio"
    
    sql = f"SELECT id, enunciado, resposta_correta FROM perguntas WHERE id IN ({','.join(['%s']*len(ids))})"
    cursor.execute(sql, tuple(ids))
    db_p = {str(p['id']): p for p in cursor.fetchall()}
    
    processadas = []
    total_pontos = 0.0
    
    print(f"\n--- A SUBMETER ({len(ids)} questões) ---")

    for i, pid in enumerate(ids):
        info = db_p.get(pid)
        resp = request.form.get(f'pergunta_{pid}')
        just = request.form.get(f'justificativa_{pid}', '').strip()
        tempo = int(request.form.get(f'tempo_{pid}', 0))
        
        # Correção minúsculas
        resp_limpa = str(resp).strip().lower() if resp else ""
        correta_limpa = str(info['resposta_correta']).strip().lower()
        foi_correta = (resp_limpa == correta_limpa)
        
        nota_just = 0.0
        
        # Só avalia se acertou seleção e escreveu algo
        if foi_correta and len(just) > 3:
            nota_just = avaliar_individual(info['enunciado'], just)
            time.sleep(0.5) # Pausa técnica para a API
        
        pontos_pergunta = (0.5 if foi_correta else 0.0) + nota_just
        total_pontos += pontos_pergunta
        
        processadas.append({'pid': pid, 'resp': resp, 'corr': foi_correta, 'ordem': i+1, 'tempo': tempo, 'just': just, 'nota_just': nota_just})

    nota_final = (total_pontos / len(ids)) * 20 if ids else 0
    
    # Aplicação da Penalização
    reinicios = session.get('reinicios', 1) - 1
    if reinicios > 0: 
        desconto = reinicios * 2
        print(f"Penalização aplicada: -{desconto} valores")
        nota_final = max(0, nota_final - desconto)

    fraude = request.form.get('tentativa_fraude') == '1'
    if fraude: nota_final = 0
    
    cursor.execute("INSERT INTO resultados (candidato_id, teste_id, nota_final, status, tentativa_fraude, data_submissao) VALUES (%s, %s, %s, %s, %s, NOW())",
                   (request.form['candidato_id'], request.form['teste_id'], nota_final, "Aprovado" if nota_final >= 10 else "Reprovado", fraude))
    res_id = cursor.lastrowid
    
    dados = [(res_id, r['pid'], r['resp'] or 'N/A', r['corr'], r['ordem'], r['tempo'], r['just'], r['nota_just']) for r in processadas]
    cursor.executemany("INSERT INTO respostas_candidato (resultado_id, pergunta_id, resposta_dada, foi_correta, ordem, tempo_gasto, justificativa, nota_justificativa) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)", dados)
    
    conn.commit()
    conn.close()
    session.pop('reinicios', None)
    
    return render_template("fraude.html") if fraude else render_template("conclusao.html", nota_final=nota_final)

@app.route("/admin")
def painel_admin():
    if not session.get('logged_in'): return redirect(url_for('login'))
    conn = get_db_connection()
    cursor = conn.cursor(dictionary=True)
    sql = "SELECT r.id AS resultado_id, r.candidato_id, c.numero_candidato, c.nome_completo, c.curso_desejado, r.nota_final, r.status, r.data_submissao, r.tentativa_fraude FROM resultados r JOIN candidatos c ON r.candidato_id = c.id ORDER BY r.data_submissao DESC"
    cursor.execute(sql)
    res = cursor.fetchall()
    conn.close()
    return render_template("admin.html", resultados=res)

@app.route("/admin/ver_prova/<int:resultado_id>")
def ver_prova(resultado_id):
    if not session.get('logged_in'): return redirect(url_for('login'))
    conn = get_db_connection()
    cursor = conn.cursor(dictionary=True)
    cursor.execute("SELECT r.*, c.nome_completo, c.numero_candidato, c.curso_desejado FROM resultados r JOIN candidatos c ON r.candidato_id = c.id WHERE r.id = %s", (resultado_id,))
    res = cursor.fetchone()
    cursor.execute("SELECT p.enunciado, p.resposta_correta, rc.pergunta_id, rc.resposta_dada, rc.foi_correta, rc.justificativa, rc.nota_justificativa FROM respostas_candidato rc JOIN perguntas p ON rc.pergunta_id = p.id WHERE rc.resultado_id = %s ORDER BY rc.ordem", (resultado_id,))
    prova = cursor.fetchall()
    conn.close()
    return render_template("ver_prova.html", resultado=res, prova=prova)

@app.route("/admin/alterar_nota", methods=["POST"])
def alterar_nota():
    if not session.get('logged_in'): return jsonify({'success': False}), 401
    conn = get_db_connection()
    cursor = conn.cursor(dictionary=True)
    cursor.execute("UPDATE respostas_candidato SET nota_justificativa = %s WHERE resultado_id = %s AND pergunta_id = %s", 
                   (0.5 if request.json['acao'] == 'validar' else 0.0, request.json['resultado_id'], request.json['pergunta_id']))
    cursor.execute("SELECT SUM(CASE WHEN foi_correta = 1 THEN 0.5 ELSE 0 END) + SUM(nota_justificativa) as pts, COUNT(*) as qtd FROM respostas_candidato WHERE resultado_id = %s", (request.json['resultado_id'],))
    st = cursor.fetchone()
    nf = (st['pts'] / st['qtd']) * 20
    cursor.execute("UPDATE resultados SET nota_final = %s, status = %s WHERE id = %s", (nf, "Aprovado" if nf >= 10 else "Reprovado", request.json['resultado_id']))
    conn.commit()
    conn.close()
    return jsonify({'success': True, 'nova_nota_final': round(nf, 2)})

@app.route("/admin/estatisticas")
def estatisticas_page():
    if not session.get('logged_in'): return redirect(url_for('login'))
    return render_template("estatisticas.html")

@app.route("/admin/estatisticas_data")
def estatisticas_data():
    if not session.get('logged_in'): return jsonify({"error": "401"}), 401
    conn = get_db_connection()
    cursor = conn.cursor(dictionary=True)
    cursor.execute("SELECT c.curso_desejado, COUNT(r.id) as total_testes, SUM(CASE WHEN r.status = 'Aprovado' THEN 1 ELSE 0 END) as total_aprovados FROM resultados r JOIN candidatos c ON r.candidato_id = c.id GROUP BY c.curso_desejado")
    quant = cursor.fetchall()
    cursor.execute("SELECT SUM(CASE WHEN nota_final < 5 THEN 1 ELSE 0 END) AS '0-4', SUM(CASE WHEN nota_final >= 5 AND nota_final < 10 THEN 1 ELSE 0 END) AS '5-9', SUM(CASE WHEN nota_final >= 10 AND nota_final < 15 THEN 1 ELSE 0 END) AS '10-14', SUM(CASE WHEN nota_final >= 15 THEN 1 ELSE 0 END) AS '15-20' FROM resultados")
    hist = cursor.fetchone()
    conn.close()
    dist = {"labels": ["0-4", "5-9", "10-14", "15-20"], "data": [int(hist['0-4'] or 0), int(hist['5-9'] or 0), int(hist['10-14'] or 0), int(hist['15-20'] or 0)] if hist else []}
    return jsonify({"dadosQuantitativos": quant, "distribuicaoNotas": dist})

@app.route("/apagar_candidato/<int:candidato_id>", methods=["POST"])
def apagar_candidato(candidato_id):
    if not session.get('logged_in'): return redirect(url_for('login'))
    conn = get_db_connection()
    conn.cursor().execute("DELETE FROM candidatos WHERE id = %s", (candidato_id,))
    conn.commit()
    conn.close()
    return redirect(url_for('painel_admin'))

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