from flask import (
    Flask,
    Response,
    flash,
    jsonify,
    redirect,
    render_template,
    request,
    url_for,
)
from flask_jwt_extended import (
    JWTManager,
    create_access_token,
    get_jwt_identity,
    jwt_required,
    set_access_cookies,
    unset_jwt_cookies,
)

from bdd.User import (
    afficherNotes,
    ajouterNote,
    ajouterNoteById,
    calculerMoyennesParUE,
    creerEleve,
    creerMatiere,
    creerUE,
    creerUtilisateur,
    getNotesEleve,
    getUserByLogin,
    isLoginAvalaible,
    listerEleves,
    listerMatieres,
    listerUE,
    verifierUtilisateur,
)

# les truc importants
app = Flask(__name__)
jwt = JWTManager(app)

app.config["JWT_SECRET_KEY"] = "super-secret"
app.config["JWT_TOKEN_LOCATION"] = ["cookies"]
app.config["JWT_COOKIE_CSRF_PROTECT"] = False
app.secret_key = "super-secret-flash-key"


@app.route("/login", methods=["GET", "POST"])
def pageConnection():
    if request.method == "GET":
        return render_template("login.html")
    else:
        login = request.form["login"]
        passw = request.form["pass"]

        user = verifierUtilisateur(login, passw)
        if user:
            access_token = create_access_token(identity=login)

            # Rediriger selon le rôle
            if user["role"] == "prof":
                resp = redirect(url_for("dashboardProf"))
            else:
                resp = redirect(url_for("pageNotes"))

            set_access_cookies(resp, access_token)
            return resp
        else:
            return render_template("login.html", message="Identifiants incorrects")


@app.route("/register", methods=["GET", "POST"])
def pageInscription():
    if request.method == "GET":
        return render_template("register.html")
    else:
        login = request.form["login"]
        passw = request.form["pass"]
        nom = request.form.get("nom", "")
        prenom = request.form.get("prenom", "")

        if isLoginAvalaible(login):
            # Par défaut, les inscriptions publiques créent des élèves
            creerUtilisateur(login, passw, "eleve", nom, prenom)
            return render_template("register.html", message="Compte créé")
        else:
            return render_template("register.html", message="Login existe déjà")


##############################
#                            #
#   Pages Élèves             #
#                            #
##############################


@app.route("/notes", methods=["GET"])
@jwt_required()
def pageNotes():
    """Page de visualisation des notes pour un élève"""
    login = get_jwt_identity()
    user = getUserByLogin(login)

    # Vérifier que c'est bien un élève
    if not user or user["role"] != "eleve":
        return redirect(url_for("dashboardProf"))

    notes = afficherNotes(login)
    moyennes_ue = calculerMoyennesParUE(login)

    return render_template(
        "notes_eleve.html", notes=notes, moyennes_ue=moyennes_ue, user=user
    )


##############################
#                            #
#   Pages Professeurs        #
#                            #
##############################


@app.route("/prof/dashboard")
@jwt_required()
def dashboardProf():
    """Dashboard principal pour les professeurs"""
    login = get_jwt_identity()
    user = getUserByLogin(login)

    # Vérifier que c'est bien un prof
    if not user or user["role"] != "prof":
        return redirect(url_for("pageNotes"))

    return render_template("prof_dashboard.html", user=user)


@app.route("/prof/eleves", methods=["GET"])
@jwt_required()
def listeEleves():
    """Liste et recherche d'élèves"""
    login = get_jwt_identity()
    user = getUserByLogin(login)

    if not user or user["role"] != "prof":
        return redirect(url_for("pageNotes"))

    search = request.args.get("search", "")
    eleves = listerEleves(search)

    return render_template("prof_eleves.html", eleves=eleves, search=search, user=user)


@app.route("/prof/eleves/creer", methods=["GET", "POST"])
@jwt_required()
def creerEleveForm():
    """Formulaire de création d'élève"""
    login = get_jwt_identity()
    user = getUserByLogin(login)

    if not user or user["role"] != "prof":
        return redirect(url_for("pageNotes"))

    if request.method == "GET":
        return render_template("prof_creer_eleve.html", user=user)

    # POST - créer l'élève
    login_eleve = request.form.get("login")
    password = request.form.get("password")
    nom = request.form.get("nom")
    prenom = request.form.get("prenom")

    if not login_eleve or not password:
        flash("Login et mot de passe requis", "error")
        return render_template("prof_creer_eleve.html", user=user)

    if not isLoginAvalaible(login_eleve):
        flash("Ce login existe déjà", "error")
        return render_template("prof_creer_eleve.html", user=user)

    if creerEleve(login_eleve, password, nom or "", prenom or ""):
        flash("Élève créé avec succès", "success")
        return redirect(url_for("listeEleves"))
    else:
        flash("Erreur lors de la création", "error")
        return render_template("prof_creer_eleve.html", user=user)


@app.route("/prof/matieres", methods=["GET"])
@jwt_required()
def listeMatieres():
    """Liste et recherche de matières"""
    login = get_jwt_identity()
    user = getUserByLogin(login)

    if not user or user["role"] != "prof":
        return redirect(url_for("pageNotes"))

    search = request.args.get("search", "")
    matieres = listerMatieres(search)

    return render_template(
        "prof_matieres.html", matieres=matieres, search=search, user=user
    )


@app.route("/prof/ue/creer", methods=["GET", "POST"])
@jwt_required()
def creerUEForm():
    """Formulaire de création d'UE"""
    login = get_jwt_identity()
    user = getUserByLogin(login)

    if not user or user["role"] != "prof":
        return redirect(url_for("pageNotes"))

    if request.method == "GET":
        return render_template("prof_creer_ue.html", user=user)

    code = request.form.get("code")
    nom = request.form.get("nom")
    description = request.form.get("description", "")

    if not code or not nom:
        flash("Code et nom requis", "error")
        return render_template("prof_creer_ue.html", user=user)

    if creerUE(code, nom, description):
        flash("UE créée avec succès", "success")
        return redirect(url_for("listeMatieres"))
    else:
        flash("Erreur lors de la création (code déjà existant?)", "error")
        return render_template("prof_creer_ue.html", user=user)


@app.route("/prof/matieres/creer", methods=["GET", "POST"])
@jwt_required()
def creerMatiereForm():
    """Formulaire de création de matière"""
    login = get_jwt_identity()
    user = getUserByLogin(login)

    if not user or user["role"] != "prof":
        return redirect(url_for("pageNotes"))

    ues = listerUE()

    if request.method == "GET":
        return render_template("prof_creer_matiere.html", ues=ues, user=user)

    code = request.form.get("code")
    nom = request.form.get("nom")
    ue_id = request.form.get("ue_id")
    coefficient = request.form.get("coefficient", 1.0)

    if not code or not nom or not ue_id:
        flash("Code, nom et UE requis", "error")
        return render_template("prof_creer_matiere.html", ues=ues, user=user)

    try:
        coefficient = float(coefficient)
        ue_id = int(ue_id)
    except:
        flash("Coefficient ou UE invalide", "error")
        return render_template("prof_creer_matiere.html", ues=ues, user=user)

    if creerMatiere(code, nom, ue_id, coefficient):
        flash("Matière créée avec succès", "success")
        return redirect(url_for("listeMatieres"))
    else:
        flash("Erreur lors de la création (code déjà existant?)", "error")
        return render_template("prof_creer_matiere.html", ues=ues, user=user)


@app.route("/prof/notes/ajouter", methods=["GET", "POST"])
@jwt_required()
def ajouterNoteForm():
    """Formulaire d'ajout de note"""
    login = get_jwt_identity()
    user = getUserByLogin(login)

    if not user or user["role"] != "prof":
        return redirect(url_for("pageNotes"))

    eleves = listerEleves()
    matieres = listerMatieres()

    if request.method == "GET":
        return render_template(
            "prof_ajouter_note.html", eleves=eleves, matieres=matieres, user=user
        )

    eleve_id = request.form.get("eleve_id")
    matiere_id = request.form.get("matiere_id")
    note = request.form.get("note")

    if not eleve_id or not matiere_id or not note:
        flash("Tous les champs sont requis", "error")
        return render_template(
            "prof_ajouter_note.html", eleves=eleves, matieres=matieres, user=user
        )

    try:
        eleve_id = int(eleve_id)
        matiere_id = int(matiere_id)
        note = float(note)
    except:
        flash("Valeurs invalides", "error")
        return render_template(
            "prof_ajouter_note.html", eleves=eleves, matieres=matieres, user=user
        )

    if ajouterNoteById(eleve_id, matiere_id, note):
        flash("Note ajoutée avec succès", "success")
        return redirect(url_for("ajouterNoteForm"))
    else:
        flash("Erreur lors de l'ajout de la note", "error")
        return render_template(
            "prof_ajouter_note.html", eleves=eleves, matieres=matieres, user=user
        )


@app.route("/prof/eleves/<int:eleve_id>/notes")
@jwt_required()
def voirNotesEleve(eleve_id):
    """Voir les notes d'un élève spécifique"""
    login = get_jwt_identity()
    user = getUserByLogin(login)

    if not user or user["role"] != "prof":
        return redirect(url_for("pageNotes"))

    from bdd.User import getUserById

    eleve = getUserById(eleve_id)

    if not eleve or eleve["role"] != "eleve":
        flash("Élève non trouvé", "error")
        return redirect(url_for("listeEleves"))

    notes = getNotesEleve(eleve_id)

    return render_template(
        "prof_voir_notes_eleve.html", eleve=eleve, notes=notes, user=user
    )


##############################
#                            #
#   Routes communes          #
#                            #
##############################


@app.route("/logout", methods=["GET", "POST"])
@jwt_required()
def logout():
    resp = Response(render_template("login.html", message="Déconnecté"))
    unset_jwt_cookies(resp)
    return resp


@app.route("/")
def accueil():
    return render_template("index.html")


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