"""
main.py
AIGO - AI Growth Gap Finder
Backend FastAPI utama: menerima URL, menjalankan pipeline analisis,
dan mengembalikan hasil audit growth gap secara lengkap.
Tanpa login/auth, tanpa database wajib -- 100% gratis untuk dijalankan.
"""
import time
import uuid
from pathlib import Path

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse
from pydantic import BaseModel, Field

from scraper import scrape_website, ScrapeError
from rule_engine import run_rules
from scoring import compute_growth_score
from priority_engine import prioritize
from ai_explainer import generate_explanation
from simulator import simulate

app = FastAPI(title="AIGO - AI Growth Gap Finder", version="1.0.0")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# In-memory cache sederhana: {url: (timestamp, hasil_analisis)}
CACHE: dict[str, tuple[float, dict]] = {}
CACHE_TTL_SECONDS = 60 * 30  # 30 menit


class AnalyzeRequest(BaseModel):
    url: str = Field(..., description="URL website yang ingin dianalisis")


class SimulateRequest(BaseModel):
    analysis_id: str
    selected_recommendation_ids: list[str]


@app.get("/api/health")
async def health():
    return {"status": "ok", "service": "AIGO backend"}


@app.post("/api/analyze")
async def analyze(req: AnalyzeRequest):
    url = req.url.strip()
    if not url:
        raise HTTPException(status_code=400, detail="URL cannot be empty.")

    cache_key = url.lower()
    now = time.time()
    if cache_key in CACHE:
        ts, cached_result = CACHE[cache_key]
        if now - ts < CACHE_TTL_SECONDS:
            return cached_result

    try:
        raw_data = await scrape_website(url)
    except ScrapeError as e:
        raise HTTPException(status_code=422, detail=str(e))
    except Exception:
        raise HTTPException(status_code=500, detail="Something went wrong while analyzing this website.")

    category_scores, recommendations, issues_count = run_rules(raw_data)
    score_result = compute_growth_score(category_scores)
    ranked_recommendations = prioritize(recommendations)

    ai_summary = await generate_explanation(
        url=raw_data["final_url"],
        growth_score=score_result["growth_score"],
        category_breakdown=score_result["category_breakdown"],
        top_recommendations=ranked_recommendations,
    )

    analysis_id = str(uuid.uuid4())

    result = {
        "analysis_id": analysis_id,
        "url": raw_data["final_url"],
        "growth_score": score_result["growth_score"],
        "grade": score_result["grade"],
        "category_breakdown": score_result["category_breakdown"],
        "recommendations": ranked_recommendations,
        "issues_count": issues_count,
        "ai_summary": ai_summary,
        "raw_signals": {
            "load_time_seconds": raw_data["load_time_seconds"],
            "is_https": raw_data["is_https"],
            "title": raw_data["title"],
            "meta_description": raw_data["meta_description"],
            "h1_count": raw_data["h1_count"],
            "cta_count": raw_data["cta_count"],
            "form_count": raw_data["form_count"],
            "has_faq": raw_data["has_faq"],
            "has_testimonial": raw_data["has_testimonial"],
            "social_links": raw_data["social_links"],
            "images_total": raw_data["images_total"],
            "images_missing_alt": raw_data["images_missing_alt"],
            "word_count": raw_data["word_count"],
        },
        # Disimpan untuk keperluan simulasi (tidak untuk ditampilkan mentah di UI)
        "_category_scores": category_scores,
    }

    CACHE[cache_key] = (now, result)
    CACHE[f"id:{analysis_id}"] = (now, result)

    return result


@app.post("/api/simulate")
async def simulate_endpoint(req: SimulateRequest):
    entry = CACHE.get(f"id:{req.analysis_id}")
    if not entry:
        raise HTTPException(status_code=404, detail="Analysis data not found or has expired. Please run the scan again.")

    _, result = entry
    category_scores = result["_category_scores"]
    all_recs = result["recommendations"]

    simulation = simulate(category_scores, all_recs, req.selected_recommendation_ids)
    return simulation


# ---------------- Serve frontend (static, tanpa login) ----------------
FRONTEND_DIR = Path(__file__).resolve().parent.parent / "frontend"

if FRONTEND_DIR.exists():
    app.mount("/static", StaticFiles(directory=str(FRONTEND_DIR / "static")), name="static")

    @app.get("/")
    async def serve_index():
        return FileResponse(str(FRONTEND_DIR / "index.html"))