backend/app/routers/export.py

from fastapi import APIRouter, HTTPException
from fastapi.responses import JSONResponse, StreamingResponse
import json
import csv
import io
import os
from datetime import datetime
from ..benchmark import get_report, list_reports

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

@router.get("/json")
async def export_json(report_id: str = None):
    if report_id:
        rep = get_report(report_id)
        if not rep:
            raise HTTPException(status_code=404, detail="التقرير غير موجود")
        data = rep.model_dump()
        data["timestamp"] = rep.timestamp.isoformat()
        for r in data["results"]:
            pass
        json_str = json.dumps(data, ensure_ascii=False, indent=2)
        return StreamingResponse(
            io.BytesIO(json_str.encode('utf-8')),
            media_type="application/json",
            headers={"Content-Disposition": f"attachment; filename=report-{report_id}.json"}
        )
    else:
        reports = list_reports()
        data = []
        for rep in reports:
            d = rep.model_dump()
            d["timestamp"] = rep.timestamp.isoformat()
            data.append(d)
        json_str = json.dumps(data, ensure_ascii=False, indent=2)
        return StreamingResponse(
            io.BytesIO(json_str.encode('utf-8')),
            media_type="application/json",
            headers={"Content-Disposition": "attachment; filename=reports-all.json"}
        )

@router.get("/csv")
async def export_csv(report_id: str):
    rep = get_report(report_id)
    if not rep:
        raise HTTPException(status_code=404, detail="التقرير غير موجود")
    output = io.StringIO()
    writer = csv.writer(output)
    writer.writerow(["task_id", "name", "category", "prompt", "expected", "generation", "passed", "score", "latency_ms", "tokens_per_sec", "ttft_ms", "vram_peak_mb"])
    for r in rep.results:
        writer.writerow([r.task_id, r.name, r.category, r.prompt[:80], r.expected, r.generation[:200], r.passed, r.score, r.latency_ms, r.tokens_per_sec, r.ttft_ms, r.vram_peak_mb])
    writer.writerow([])
    writer.writerow(["summary", f"accuracy={rep.accuracy}", f"avg_tps={rep.avg_tokens_per_sec}", f"vram_peak={rep.vram_peak_mb}"])
    csv_bytes = output.getvalue().encode('utf-8-sig')
    return StreamingResponse(
        io.BytesIO(csv_bytes),
        media_type="text/csv",
        headers={"Content-Disposition": f"attachment; filename=report-{report_id}.csv"}
    )

def _find_arabic_font():
    candidates = [
        r"C:\Windows\Fonts\tahoma.ttf",
        r"C:\Windows\Fonts\arabtype.ttf",
        r"C:\Windows\Fonts\majalla.ttf",
        r"C:\Windows\Fonts\segoeui.ttf",
        r"C:\Windows\Fonts\arial.ttf",
        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
        "/usr/share/fonts/truetype/noto/NotoNaskhArabic-Regular.ttf",
    ]
    for p in candidates:
        if os.path.exists(p):
            return p
    return None

def _reshape_text(text: str) -> str:
    # Try to shape Arabic for proper display in PDF
    has_arabic = any('\u0600' <= c <= '\u06FF' for c in text)
    if not has_arabic:
        return text
    try:
        import arabic_reshaper
        from bidi.algorithm import get_display
        reshaped = arabic_reshaper.reshape(text)
        return get_display(reshaped)
    except ImportError:
        # No libs: return as is (fpdf may show disconnected but readable)
        return text
    except Exception:
        return text

@router.get("/pdf")
async def export_pdf(report_id: str):
    rep = get_report(report_id)
    if not rep:
        raise HTTPException(status_code=404, detail="التقرير غير موجود")
    try:
        from fpdf import FPDF
    except ImportError:
        raise HTTPException(status_code=500, detail="مكتبة fpdf2 غير مثبتة")

    pdf = FPDF()
    pdf.add_page()
    pdf.set_auto_page_break(auto=True, margin=15)

    # Try to add Unicode font for Arabic
    font_path = _find_arabic_font()
    use_unicode = False
    font_name = "Helvetica"
    if font_path:
        try:
            pdf.add_font("Arabic", "", font_path, uni=True)
            # Try bold variant if exists
            bold_path = font_path.replace(".ttf", "bd.ttf").replace("tahoma.ttf", "tahomabd.ttf").replace("arial.ttf","arialbd.ttf")
            if os.path.exists(bold_path):
                pdf.add_font("Arabic", "B", bold_path, uni=True)
            else:
                pdf.add_font("Arabic", "B", font_path, uni=True)
            font_name = "Arabic"
            use_unicode = True
        except Exception as e:
            # fallback to Helvetica
            font_name = "Helvetica"
            use_unicode = False

    def _safe(text: str) -> str:
        if use_unicode:
            try:
                return _reshape_text(text)
            except:
                return text
        else:
            # Sanitize to latin-1
            try:
                text.encode('latin-1')
                return text
            except:
                s=""
                for ch in text:
                    try:
                        ch.encode('latin-1')
                        s+=ch
                    except:
                        s+="?"
                return s

    # Header
    pdf.set_font(font_name, "B", 16)
    pdf.cell(0, 10, _safe("Safetensors Studio - Benchmark Report"), align="C", new_x="LMARGIN", new_y="NEXT")
    pdf.set_font(font_name, "", 10)
    pdf.cell(0, 8, _safe(f"Report ID: {rep.id}  |  Model: {rep.model_path}"), new_x="LMARGIN", new_y="NEXT")
    pdf.cell(0, 8, _safe(f"Date: {rep.timestamp.isoformat()}  |  Accuracy: {rep.accuracy*100:.1f}%  |  Passed: {rep.passed}/{rep.total_tasks}"), new_x="LMARGIN", new_y="NEXT")
    pdf.cell(0, 8, _safe(f"Avg TPS: {rep.avg_tokens_per_sec}  |  Avg TTFT: {rep.avg_ttft_ms}ms  |  VRAM Peak: {rep.vram_peak_mb} MB"), new_x="LMARGIN", new_y="NEXT")
    pdf.ln(4)
    # Table header
    pdf.set_font(font_name, "B", 9)
    pdf.set_fill_color(240, 240, 240)
    headers = ["Task", "Category", "Passed", "TPS", "Latency"]
    col_w = [70, 35, 25, 30, 30]
    for i, h in enumerate(headers):
        pdf.cell(col_w[i], 8, _safe(h), border=1, fill=True, align="C")
    pdf.ln()

    pdf.set_font(font_name, "", 8)
    for r in rep.results:
        name = _safe(r.name[:35])
        cat = _safe(r.category[:12])
        passed = "YES" if r.passed else "NO"
        pdf.cell(col_w[0], 7, name, border=1)
        pdf.cell(col_w[1], 7, cat, border=1, align="C")
        pdf.cell(col_w[2], 7, passed, border=1, align="C")
        pdf.cell(col_w[3], 7, str(r.tokens_per_sec), border=1, align="C")
        pdf.cell(col_w[4], 7, str(r.latency_ms), border=1, align="C")
        pdf.ln()
        if pdf.get_y() > 270:
            pdf.add_page()
    if pdf.get_y() > 240:
        pdf.add_page()
    pdf.ln(4)
    pdf.set_font(font_name, "B", 10)
    pdf.cell(0, 8, _safe("By Category:"), new_x="LMARGIN", new_y="NEXT")
    pdf.set_font(font_name, "", 9)
    for cat, stats in rep.by_category.items():
        if pdf.get_y() > 270:
            pdf.add_page()
        pdf.cell(0, 6, _safe(f"{cat}: {stats['passed']}/{stats['total']}  acc={stats['accuracy']}  tps={stats['avg_tps']}"), new_x="LMARGIN", new_y="NEXT")
    if pdf.get_y() > 250:
        pdf.add_page()
    pdf.ln(2)
    pdf.set_font(font_name, "B", 10)
    pdf.cell(0, 8, _safe("Insights:"), new_x="LMARGIN", new_y="NEXT")
    pdf.set_font(font_name, "", 9)
    best_cat = max(rep.by_category.items(), key=lambda x: x[1]["accuracy"]) if rep.by_category else None
    worst_cat = min(rep.by_category.items(), key=lambda x: x[1]["accuracy"]) if rep.by_category else None
    if best_cat:
        if pdf.get_y() > 270:
            pdf.add_page()
        pdf.multi_cell(0, 5, _safe(f"Strength: {best_cat[0]} with {best_cat[1]['accuracy']*100:.1f}% accuracy"), new_x="LMARGIN", new_y="NEXT")
    if worst_cat:
        if pdf.get_y() > 270:
            pdf.add_page()
        pdf.multi_cell(0, 5, _safe(f"Weakness: {worst_cat[0]} with {worst_cat[1]['accuracy']*100:.1f}% accuracy - needs improvement"), new_x="LMARGIN", new_y="NEXT")
    if pdf.get_y() > 270:
        pdf.add_page()
    pdf.multi_cell(0, 5, _safe(f"VRAM Peak {rep.vram_peak_mb} MB - {'High usage, consider 4-bit quantization' if rep.vram_peak_mb>8000 else 'Efficient usage'}"), new_x="LMARGIN", new_y="NEXT")
    # Footer note about Arabic
    pdf.ln(3)
    pdf.set_font(font_name, "", 7)
    # Use _safe for Arabic note
    pdf.cell(0, 5, _safe("Generated by Safetensors Studio & Bench - يدعم العربية والإنجليزية"), align="C")

    pdf_bytes = pdf.output()
    return StreamingResponse(
        io.BytesIO(pdf_bytes),
        media_type="application/pdf",
        headers={"Content-Disposition": f"attachment; filename=report-{report_id}.pdf"}
    )

@router.get("/pdf/preview")
async def pdf_preview_info():
    font = _find_arabic_font()
    has_reshaper = False
    try:
        import arabic_reshaper
        has_reshaper = True
    except:
        pass
    return {"font_path": font, "has_reshaper": has_reshaper, "supports_arabic": font is not None}