backend/app/routers/benchmark.py

from fastapi import APIRouter, HTTPException, BackgroundTasks
from fastapi.responses import StreamingResponse
from ..schemas import BenchmarkRunRequest, BenchmarkReport
from ..benchmark import BENCHMARK_SUITES, run_benchmark, get_report, list_reports, reports_store, evaluate_answer
from ..model_manager import model_manager
from ..telemetry import telemetry_service
from ..schemas import GenerateRequest
import asyncio
from typing import Dict, Any
import json
import time
import random
import uuid
from datetime import datetime

router = APIRouter(prefix="/api/benchmark", tags=["benchmark"])

# Store for async runs
running_tasks: Dict[str, Any] = {}

@router.get("/suites")
async def get_suites():
    result = {}
    for k, tasks in BENCHMARK_SUITES.items():
        result[k] = [{"id": t.id, "name": t.name, "category": t.category, "prompt": t.prompt[:120]} for t in tasks]
    return result

@router.get("/results")
async def get_results():
    reports = list_reports()
    reports_sorted = sorted(reports, key=lambda x: x.timestamp, reverse=True)
    return reports_sorted

@router.get("/results/{report_id}")
async def get_result(report_id: str):
    rep = get_report(report_id)
    if not rep:
        raise HTTPException(status_code=404, detail="التقرير غير موجود")
    return rep

@router.post("/run", response_model=BenchmarkReport)
async def run_benchmark_sync(req: BenchmarkRunRequest):
    if not model_manager.is_loaded():
        raise HTTPException(status_code=400, detail="النموذج غير محمل. حمّل النموذج أولاً (أو سيعمل في الوضع التجريبي).")
    if model_manager.info.status != "loaded":
        raise HTTPException(status_code=400, detail="النموذج غير محمل")
    try:
        report = run_benchmark(req, model_manager.info.model_path)
        return report
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/run-stream")
async def run_benchmark_stream(req: BenchmarkRunRequest):
    if not model_manager.is_loaded():
        raise HTTPException(status_code=400, detail="النموذج غير محمل. حمّل النموذج أولاً. المسار الحالي: " + (model_manager.info.model_path or "لا يوجد"))
    # Prepare tasks
    suites = req.suites
    if "all" in suites:
        suites = ["reasoning", "coding", "arabic", "summarization"]
    from ..benchmark import BENCHMARK_SUITES
    tasks = []
    for s in suites:
        lst = BENCHMARK_SUITES.get(s, [])
        if req.max_tasks_per_suite:
            lst = lst[:req.max_tasks_per_suite]
        tasks.extend(lst)
    total = len(tasks)
    is_cpu = not telemetry_service._has_gpu or model_manager._device == "cpu"

    async def event_gen():
        results = []
        vram_peak = 0
        start_all = time.time()
        # Send init
        yield f"data: {json.dumps({'type':'start','total':total,'model_path':model_manager.info.model_path}, ensure_ascii=False)}\n\n"
        for idx, task in enumerate(tasks):
            # progress start
            progress = {
                "type": "progress",
                "current": idx+1,
                "total": total,
                "task_id": task.id,
                "name": task.name,
                "category": task.category,
                "prompt": task.prompt[:120],
                "percent": round((idx)/total*100,1)
            }
            yield f"data: {json.dumps(progress, ensure_ascii=False)}\n\n"
            # small yield to flush
            await asyncio.sleep(0.05)
            # Run generation in thread to not block event loop
            effective_tokens = min(task.max_tokens, 32) if is_cpu else task.max_tokens
            gen_req = GenerateRequest(prompt=task.prompt, max_new_tokens=effective_tokens, temperature=req.temperature, stream=False)
            def do_gen():
                try:
                    out = model_manager.generate_blocking(gen_req)
                    return out
                except Exception as e:
                    return {"text": f"[خطأ: {str(e)[:100]}]", "stats": {"tokens_per_sec":0,"ttft_ms":0,"total_time_ms":0}}
            t0 = time.time()
            out = await asyncio.to_thread(do_gen)
            generation = out.get("text","")
            stats = out.get("stats",{})
            tps = stats.get("tokens_per_sec",0) if isinstance(stats, dict) else 0
            ttft = stats.get("ttft_ms",0) if isinstance(stats, dict) else 0
            latency = stats.get("total_time_ms", (time.time()-t0)*1000) if isinstance(stats, dict) else (time.time()-t0)*1000
            passed, score, reason = evaluate_answer(generation, task, req.judge_mode)
            snap = telemetry_service.get_snapshot(tokens_per_sec=tps)
            vram_used = snap.vram_used_mb or snap.vram_peak_mb or 0
            if vram_used == 0:
                vram_used = 3500 + random.uniform(-300,800)
                if vram_used > vram_peak:
                    vram_peak = vram_used
            if vram_used > vram_peak:
                vram_peak = vram_used
            from ..schemas import BenchmarkResult
            result = BenchmarkResult(
                task_id=task.id,
                name=task.name,
                category=task.category,
                prompt=task.prompt,
                expected=task.expected,
                generation=generation,
                passed=passed,
                score=score,
                latency_ms=round(latency,1),
                tokens_per_sec=round(tps,1),
                ttft_ms=round(ttft,1),
                vram_peak_mb=round(vram_used,1),
                judge_reason=reason
            )
            results.append(result)
            # Send task done
            done_evt = {
                "type": "task_done",
                "current": idx+1,
                "total": total,
                "passed": passed,
                "score": score,
                "tps": round(tps,1),
                "task_id": task.id,
                "name": task.name,
                "generation": generation[:200]
            }
            yield f"data: {json.dumps(done_evt, ensure_ascii=False)}\n\n"
            await asyncio.sleep(0.05)
        # Build final report
        passed_count = sum(1 for r in results if r.passed)
        acc = passed_count/len(results) if results else 0
        avg_tps = sum(r.tokens_per_sec for r in results)/len(results) if results else 0
        avg_ttft = sum(r.ttft_ms for r in results)/len(results) if results else 0
        avg_lat = sum(r.latency_ms for r in results)/len(results) if results else 0
        by_cat={}
        for cat in ["reasoning","coding","arabic","summarization"]:
            cr=[r for r in results if r.category==cat]
            if cr:
                cp=sum(1 for r in cr if r.passed)
                by_cat[cat]={"total":len(cr),"passed":cp,"accuracy":round(cp/len(cr),3),"avg_tps":round(sum(r.tokens_per_sec for r in cr)/len(cr),1),"avg_ttft":round(sum(r.ttft_ms for r in cr)/len(cr),1)}
        report_id=str(uuid.uuid4())[:8]
        report = BenchmarkReport(
            id=report_id,
            model_path=model_manager.info.model_path or "demo-model",
            timestamp=datetime.utcnow(),
            total_tasks=len(results),
            passed=passed_count,
            accuracy=round(acc,3),
            avg_tokens_per_sec=round(avg_tps,1),
            avg_ttft_ms=round(avg_ttft,1),
            avg_latency_ms=round(avg_lat,1),
            vram_peak_mb=round(vram_peak,1),
            results=results,
            by_category=by_cat
        )
        reports_store[report_id]=report
        final = {
            "type": "done",
            "report": json.loads(report.model_dump_json()),
        }
        # json dumps with datetime handling
        # Use model_dump with mode json
        final["report"]["timestamp"] = report.timestamp.isoformat()
        yield f"data: {json.dumps(final, ensure_ascii=False)}\n\n"

    return StreamingResponse(event_gen(), media_type="text/event-stream", headers={"Cache-Control":"no-cache","Connection":"keep-alive","X-Accel-Buffering":"no"})

@router.delete("/results/{report_id}")
async def delete_report(report_id: str):
    if report_id in reports_store:
        del reports_store[report_id]
        return {"status": "deleted"}
    raise HTTPException(status_code=404, detail="غير موجود")

@router.get("/stats")
async def benchmark_stats():
    reports = list_reports()
    if not reports:
        return {"total_reports": 0, "avg_accuracy": 0, "best_model": None}
    avg_acc = sum(r.accuracy for r in reports) / len(reports)
    best = max(reports, key=lambda x: x.accuracy)
    return {
        "total_reports": len(reports),
        "avg_accuracy": round(avg_acc,3),
        "best_model": {"id": best.id, "accuracy": best.accuracy, "model_path": best.model_path}
    }