import asyncio
import os
from typing import Any, Dict

import requests
from fastapi import FastAPI, Request

from task2_rubric_utils import (
    approx_token_count,
    coerce_extra_info,
    compute_weighted_score,
    extract_proposed_plan,
    parse_rubric_items,
)


app = FastAPI()


def has_required_sections(plan_text: str) -> bool:
    lowered = (plan_text or "").lower()
    required_sections = (
        "objective:",
        "baseline setup:",
        "variants:",
        "fixed protocols & metrics:",
    )
    return all(section in lowered for section in required_sections)


def compute_rule_penalty(raw_response: str, plan_text: str) -> Dict[str, float]:
    format_penalty = 0.0
    if "<Proposed_Plan>" not in (raw_response or ""):
        format_penalty += 0.25
    if not has_required_sections(plan_text):
        format_penalty += 0.25

    length_threshold = int(os.environ.get("TASK2_LENGTH_THRESHOLD", "1024"))
    length_penalty_rate = float(os.environ.get("TASK2_LENGTH_PENALTY_RATE", "0.05"))
    token_count = approx_token_count(plan_text)
    overlong_tokens = max(0, token_count - length_threshold)
    length_penalty = (overlong_tokens / 100.0) * length_penalty_rate if overlong_tokens > 0 else 0.0

    return {
        "format_penalty": float(format_penalty),
        "length_penalty": float(length_penalty),
        "token_count": float(token_count),
    }


def call_task2_judge(payload: Dict[str, Any]) -> Dict[str, Any]:
    judge_url = os.environ.get("TASK2_JUDGE_URL", "http://127.0.0.1:8001/evaluate_task2")
    response = requests.post(judge_url, json=payload, timeout=int(os.environ.get("TASK2_JUDGE_TIMEOUT", "600")))
    response.raise_for_status()
    return response.json()


def build_reward_response(raw_request: Dict[str, Any]) -> Dict[str, Any]:
    extra_info = coerce_extra_info(raw_request.get("extra_info"))
    raw_response = raw_request.get("response_str", "")
    if isinstance(raw_response, list):
        raw_response = raw_response[0] if raw_response else ""

    plan_text = extract_proposed_plan(raw_response)
    rubric_items = parse_rubric_items(extra_info.get("rubric", ""))
    if not rubric_items:
        return {
            "score": 0.0,
            "rubric_score": 0.0,
            "format_penalty": 0.0,
            "length_penalty": 0.0,
            "token_count": 0.0,
            "error": "no_rubric_items",
        }

    judge_payload = {
        "paper_context": extra_info.get("paper_context", ""),
        "goal": extra_info.get("goal", ""),
        "generated_design": plan_text,
        "rubric_items": rubric_items,
    }
    judge_result = call_task2_judge(judge_payload)
    eval_items = judge_result.get("eval_items", [])
    rubric_score = compute_weighted_score(eval_items)
    if rubric_score is None:
        rubric_score = 0.0

    penalties = compute_rule_penalty(raw_response=raw_response, plan_text=plan_text)
    total_score = max(0.0, float(rubric_score) - penalties["format_penalty"] - penalties["length_penalty"])

    return {
        "score": total_score,
        "rubric_score": float(rubric_score),
        "format_penalty": penalties["format_penalty"],
        "length_penalty": penalties["length_penalty"],
        "token_count": penalties["token_count"],
        "eval_items": eval_items,
        "raw_judge_output": judge_result.get("raw_judge_output", ""),
    }


@app.post("/get_reward_task2")
async def get_reward_task2(request: Request):
    json_data = await request.json()
    result = await asyncio.to_thread(build_reward_response, json_data)
    return result


@app.post("/get_reward2")
async def get_reward2(request: Request):
    json_data = await request.json()
    result = await asyncio.to_thread(build_reward_response, json_data)
    return result


@app.get("/health")
async def health():
    return {"status": "ok"}


if __name__ == "__main__":
    import uvicorn

    port = int(os.environ.get("TASK2_REWARD_PORT", "6009"))
    uvicorn.run(app, host="0.0.0.0", port=port)