# app/routers/it_router.py

from fastapi import APIRouter, HTTPException
from app.models import it_module
from app.schemas.it_schema import StartITRequest, AnswerITRequest
from app.services.it_questions import get_it_questions, get_question_by_id, get_questions_by_level, get_level_name
from app.services.it_scoring import calculate_final_result
from app.services.goalskill_classifier import classify_and_save
from typing import List, Dict

router = APIRouter(
    prefix="",
    tags=["IT"]
)

MAX_LEVEL = 3
QUESTIONS_PER_LEVEL = 10


def _format_options(options: list) -> list:
    """選択肢を A, B, C, D 形式にフォーマット"""
    letters = ["A", "B", "C", "D", "E"]
    return [f"{letters[i]} {opt}" for i, opt in enumerate(options) if i < len(letters)]


@router.post("/start")
async def start_it_test(request: StartITRequest):
    """
    Python レベルテスト開始 — 初級(レベル1)の最初の問題を返す
    """
    try:
        # 以前の記録を初期化（再スタート用）
        it_module.clear_session_logs(request.session_id)

        level_questions = get_questions_by_level(1)
        if not level_questions:
            raise HTTPException(status_code=500, detail="No questions found for level 1")

        first_q = level_questions[0]
        total_questions = QUESTIONS_PER_LEVEL  # 現在のレベルの問題数を表示

        return {
            "question_id": first_q["id"],
            "question_text": first_q["question"],
            "options": _format_options(first_q["options"]),
            "current": 1,
            "total": total_questions,
            "current_level": 1,
            "current_level_name": get_level_name(1),
            "question_in_level": 1,
            "questions_per_level": QUESTIONS_PER_LEVEL
        }

    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))


@router.post("/answer")
async def answer_it_test(request: AnswerITRequest):
    """
    Python レベルテスト回答処理

    ロジック:
    - 正解/不正解に関係なく、同じレベルの次の問題へ進む (強制終了なし)
    - レベルの10問をすべて回答した後:
      - 全問正解 → 次のレベルへ (上級クリアなら完了)
      - 1問でも不正解 → 結果パネル表示
    """
    try:
        # 現在の問題情報を取得
        current_question = get_question_by_id(request.question_id)
        if not current_question:
            raise HTTPException(status_code=400, detail=f"Question {request.question_id} not found")

        current_level = current_question["level"]

        # ============================================
        # 正解判定 (先頭のアルファベット文字でのみ判定)
        # ============================================
        try:
            correct_idx = current_question["options"].index(current_question["answer"])
            letters = ["A", "B", "C", "D", "E"]
            correct_letter = letters[correct_idx]
        except ValueError:
            correct_letter = None

        user_letter = ""
        if request.selected_answer:
            import re
            match = re.search(r"^([A-E])\b", request.selected_answer.strip(), re.IGNORECASE)
            if match:
                user_letter = match.group(1).upper()
            else:
                user_letter = request.selected_answer[0].upper()
        
        is_correct = (correct_letter is not None and user_letter == correct_letter)

        # 保存用
        selected_answer_clean = request.selected_answer
        if " " in selected_answer_clean:
            selected_answer_clean = selected_answer_clean.split(" ", 1)[1]

        # 回答をDBに保存
        it_module.save_answer(
            session_id=request.session_id,
            question_id=request.question_id,
            selected_answer=selected_answer_clean,
            is_correct=is_correct
        )

        # ============================================
        # 同じレベルの問題一覧を取得
        # ============================================
        level_questions = get_questions_by_level(current_level)
        level_question_ids = [q["id"] for q in level_questions]
        current_index_in_level = level_question_ids.index(request.question_id)

        # ============================================
        # まだ同じレベルの次の問題がある場合 → 続行
        # ============================================
        if current_index_in_level < QUESTIONS_PER_LEVEL - 1:
            answer_count = it_module.get_answer_count(request.session_id)
            next_q = level_questions[current_index_in_level + 1]
            return {
                "status": "continue",
                "is_correct": is_correct,
                "next_question": {
                    "question_id": next_q["id"],
                    "question_text": next_q["question"],
                    "options": _format_options(next_q["options"]),
                    "current": current_index_in_level + 2,
                    "total": QUESTIONS_PER_LEVEL,
                    "current_level": current_level,
                    "current_level_name": get_level_name(current_level),
                    "question_in_level": current_index_in_level + 2,
                    "questions_per_level": QUESTIONS_PER_LEVEL
                }
            }

        # ============================================
        # このレベルの最後の問題を回答した → レベル完了判定
        # ============================================
        # このレベルの全回答を取得して正解数をカウント
        all_answers = it_module.get_all_answers(request.session_id)
        level_answers = [a for a in all_answers if a["question_id"] in level_question_ids]
        correct_count = sum(1 for a in level_answers if a["is_correct"])
        wrong_answers = [a for a in level_answers if not a["is_correct"]]

        # 不正解の詳細情報を収集
        wrong_details = []
        for wa in wrong_answers:
            q = get_question_by_id(wa["question_id"])
            if q:
                wrong_details.append({
                    "question": q["question"],
                    "correct_answer": q["answer"],
                    "user_answer": wa["selected_answer"],
                    "reason": q.get("reason", "")
                })

        # ============================================
        # 全問正解 → 次のレベルへ or 全クリア
        # ============================================
        if correct_count == QUESTIONS_PER_LEVEL:
            if current_level >= MAX_LEVEL:
                # ========================================
                # 上級クリア → 全クリア完了
                # ========================================
                result = calculate_final_result(
                    request.session_id,
                    assigned_level=3,
                    correct_count=correct_count,
                    total_in_level=QUESTIONS_PER_LEVEL,
                    wrong_details=[]
                )

                it_module.save_or_update_output(
                    session_id=request.session_id,
                    total_score=result["total_score"],
                    level=result["level"],
                    description=result["message"]
                )

                result_text = f"Pythonレベルテスト: 全レベルクリア → 上級付与 - {result['message']}"
                await classify_and_save(
                    session_id=request.session_id,
                    sender="I",
                    part="A",
                    text=result_text
                )

                return {
                    "status": "completed",
                    "is_correct": is_correct,
                    "level_cleared": current_level,
                    "level_cleared_name": get_level_name(current_level),
                    "result": result
                }
            else:
                # ========================================
                # 次のレベルの最初の問題を返す
                # ========================================
                next_level = current_level + 1
                next_level_questions = get_questions_by_level(next_level)

                if not next_level_questions:
                    raise HTTPException(status_code=500, detail=f"No questions for level {next_level}")

                next_q = next_level_questions[0]
                return {
                    "status": "continue",
                    "is_correct": is_correct,
                    "level_cleared": current_level,
                    "level_cleared_name": get_level_name(current_level),
                    "next_question": {
                        "question_id": next_q["id"],
                        "question_text": next_q["question"],
                        "options": _format_options(next_q["options"]),
                        "current": 1,
                        "total": QUESTIONS_PER_LEVEL,
                        "current_level": next_level,
                        "current_level_name": get_level_name(next_level),
                        "question_in_level": 1,
                        "questions_per_level": QUESTIONS_PER_LEVEL
                    }
                }

        # ============================================
        # 不合格 → 結果パネル表示
        # ============================================
        # 到達レベルは一つ前のレベル (初級失敗 → レベル0)
        assigned_level = max(0, current_level - 1)
        result = calculate_final_result(
            request.session_id,
            assigned_level=assigned_level,
            correct_count=correct_count,
            total_in_level=QUESTIONS_PER_LEVEL,
            wrong_details=wrong_details,
            failed_at_level=current_level
        )

        # DB保存
        it_module.save_or_update_output(
            session_id=request.session_id,
            total_score=result["total_score"],
            level=result["level"],
            description=result["message"]
        )

        failed_level_name = get_level_name(current_level)
        result_text = f"Pythonレベルテスト: {failed_level_name}で{correct_count}/{QUESTIONS_PER_LEVEL}問正解 → {result['level']}付与 - {result['message']}"
        await classify_and_save(
            session_id=request.session_id,
            sender="I",
            part="A",
            text=result_text
        )

        return {
            "status": "completed",
            "is_correct": is_correct,
            "correct_count": correct_count,
            "total_in_level": QUESTIONS_PER_LEVEL,
            "failed_at_level": current_level,
            "failed_at_level_name": failed_level_name,
            "wrong_details": wrong_details,
            "result": result
        }

    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@router.get("/result/{session_id}")
async def get_it_result(session_id: str):
    """
    IT 결과 조회
    """
    try:
        output = it_module.get_output(session_id)
        if not output:
             raise HTTPException(status_code=404, detail="No result found")
             
        all_answers = it_module.get_all_answers(session_id)
        wrong_answers = [a for a in all_answers if not a.get("is_correct")]
        wrong_details = []
        for wa in wrong_answers:
            q = get_question_by_id(wa["question_id"])
            if q:
                wrong_details.append({
                    "question": q["question"],
                    "correct_answer": q["answer"],
                    "user_answer": wa["selected_answer"],
                    "reason": q.get("reason", "")
                })

        result = {
            "total_score": output.get("total_score", 0),
            "level": output.get("level", "入門"),
            "message": output.get("description", ""),
            "total_questions": 30,
            "correct_count": sum(1 for a in all_answers if a.get("is_correct")),
            "wrong_details": wrong_details
        }

        return {
            "status": "success",
            "result": result
        }
    except Exception as e:
        logger.error(f"IT Result Get Error: {e}")
        raise HTTPException(status_code=500, detail=str(e))