import os
from typing import List
from openai import OpenAI
from sqlalchemy.orm import Session
from . import models
from .curriculum import QUESTIONS, SKILLS

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))


SYSTEM_PROMPT = """
Tu es Professeur TOP, un professeur virtuel français pour enfants de 8 à 12 ans.
Règles :
- Tu parles toujours en français simple et chaleureux.
- Tu donnes des explications très courtes, puis un mini exemple.
- Tu tiens compte du niveau de l'élève et de ses faiblesses indiquées dans le contexte.
- Tu n'inventes pas la progression : elle est fournie dans le contexte.
- Tu encourages sans infantiliser.
- Quand l'élève se trompe, tu expliques calmement puis proposes une question très simple.
- Tu enseignes principalement le programme national français niveau primaire/cycle 3.
""".strip()

TTS_PROFILES = [
    {
        "id": "rigolote",
        "label": "Rigolote",
        "description": "La plus joueuse et cartoon.",
        "voice": "coral",
        "speed": 1.08,
        "instructions": (
            "Parle en français avec une énergie joyeuse, malicieuse et très expressive. "
            "Tu es Professeur TOP, un professeur amusant, chaleureux et un peu théâtral. "
            "Le ton doit rester clair pour un enfant, avec des intonations souriantes, "
            "des fins de phrases dynamiques et une diction très vivante."
        ),
    },
    {
        "id": "petillante",
        "label": "Pétillante",
        "description": "Enjouée, dynamique et encourageante.",
        "voice": "shimmer",
        "speed": 1.03,
        "instructions": (
            "Parle en français avec une voix lumineuse, motivante et positive. "
            "Tu es Professeur TOP: enthousiaste, rassurant et très engageant, "
            "sans caricature excessive. Garde une diction nette et chaleureuse."
        ),
    },
    {
        "id": "douce",
        "label": "Douce",
        "description": "Calme, rassurante et patiente.",
        "voice": "sage",
        "speed": 0.98,
        "instructions": (
            "Parle en français avec une voix douce, calme et très rassurante. "
            "Tu es Professeur TOP dans une version posée, bienveillante et patiente. "
            "Le rythme est fluide, jamais pressé, avec une intonation apaisante."
        ),
    },
    {
        "id": "sobre",
        "label": "Sobre",
        "description": "La plus neutre et sérieuse.",
        "voice": "alloy",
        "speed": 1.0,
        "instructions": (
            "Parle en français avec une voix claire, naturelle et sobre. "
            "Tu es Professeur TOP dans une version très lisible, professionnelle et mesurée. "
            "Reste chaleureux, mais sans effet théâtral."
        ),
    },
]


def seed_skills(db: Session) -> None:
    for skill in SKILLS:
        existing = db.query(models.Skill).filter(models.Skill.code == skill["code"]).first()
        if not existing:
            db.add(models.Skill(**skill))
    db.commit()


def ensure_student_mastery(db: Session, student: models.Student) -> None:
    all_skills = db.query(models.Skill).all()
    for skill in all_skills:
        found = (
            db.query(models.StudentSkillMastery)
            .filter_by(student_id=student.id, skill_id=skill.id)
            .first()
        )
        if not found:
            db.add(models.StudentSkillMastery(student_id=student.id, skill_id=skill.id))
    db.commit()


def get_student_context(db: Session, student_id: int) -> str:
    student = db.query(models.Student).filter_by(id=student_id).first()
    mastery = (
        db.query(models.StudentSkillMastery, models.Skill)
        .join(models.Skill, models.Skill.id == models.StudentSkillMastery.skill_id)
        .filter(models.StudentSkillMastery.student_id == student_id)
        .all()
    )
    recent_messages = (
        db.query(models.Message)
        .filter_by(student_id=student_id)
        .order_by(models.Message.created_at.desc())
        .limit(6)
        .all()
    )

    lines: List[str] = [
        f"Élève: {student.first_name}, {student.age} ans, classe {student.grade}.",
        "Progression par compétence:",
    ]
    for mastery_row, skill in mastery:
        lines.append(
            f"- {skill.label}: score={mastery_row.mastery_score:.1f}, confiance={mastery_row.confidence:.2f}, preuves={mastery_row.evidence_count}"
        )
    lines.append("Historique récent:")
    for message in reversed(recent_messages):
        lines.append(f"- {message.role}: {message.content}")
    return "\n".join(lines)


def build_llm_reply(db: Session, student_id: int, user_message: str) -> str:
    context = get_student_context(db, student_id)
    response = client.responses.create(
        model="gpt-4.1-mini",
        input=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {
                "role": "user",
                "content": f"Contexte pédagogique:\n{context}\n\nMessage de l'élève:\n{user_message}",
            },
        ],
        temperature=0.7,
    )
    return response.output_text.strip()


def list_tts_profiles() -> list[dict]:
    return [
        {
            "id": profile["id"],
            "label": profile["label"],
            "description": profile["description"],
        }
        for profile in TTS_PROFILES
    ]


def synthesize_speech(text: str, profile_id: str) -> bytes:
    clean_text = text.strip()
    if not clean_text:
        raise ValueError("Texte à synthétiser manquant")

    profile = next((item for item in TTS_PROFILES if item["id"] == profile_id), None)
    if not profile:
        raise ValueError("Profil de voix inconnu")

    response = client.audio.speech.create(
        model="gpt-4o-mini-tts",
        voice=profile["voice"],
        input=clean_text[:4096],
        instructions=profile["instructions"],
        response_format="mp3",
        speed=profile["speed"],
    )
    return response.content


def transcribe_audio(filename: str, audio_bytes: bytes, content_type: str | None = None) -> str:
    file_payload = (filename, audio_bytes, content_type or "application/octet-stream")
    transcript = client.audio.transcriptions.create(
        model="gpt-4o-mini-transcribe",
        file=file_payload,
    )
    return (getattr(transcript, "text", "") or "").strip()


def pick_next_skill(db: Session, student_id: int) -> models.Skill:
    weakest = (
        db.query(models.StudentSkillMastery)
        .filter_by(student_id=student_id)
        .order_by(models.StudentSkillMastery.mastery_score.asc())
        .first()
    )
    return db.query(models.Skill).filter_by(id=weakest.skill_id).first()


def evaluate_answer(db: Session, student_id: int, skill_code: str, answer: str):
    q = QUESTIONS[skill_code]
    normalized_student = answer.strip().lower()
    normalized_expected = q["expected_answer"].strip().lower()
    correct = normalized_student == normalized_expected

    skill = db.query(models.Skill).filter_by(code=skill_code).first()
    mastery = (
        db.query(models.StudentSkillMastery)
        .filter_by(student_id=student_id, skill_id=skill.id)
        .first()
    )

    if correct:
        mastery.mastery_score = min(100.0, mastery.mastery_score + 8)
        mastery.confidence = min(1.0, mastery.confidence + 0.15)
        feedback = q["feedback_ok"]
    else:
        mastery.mastery_score = max(0.0, mastery.mastery_score - 6)
        mastery.confidence = min(1.0, mastery.confidence + 0.1)
        feedback = q["feedback_ko"]

    mastery.evidence_count += 1

    db.add(
        models.AssessmentAttempt(
            student_id=student_id,
            skill_code=skill_code,
            question=q["question"],
            expected_answer=q["expected_answer"],
            student_answer=answer,
            is_correct=1 if correct else 0,
            feedback=feedback,
        )
    )
    db.commit()
    db.refresh(mastery)
    return correct, feedback, mastery.mastery_score