server.py

import re
from dotenv import load_dotenv
from pathlib import Path

from services.seo import is_indexable

# CRITICAL: load .env BEFORE importing provider modules — they read env vars at import time.
ROOT_DIR = Path(__file__).parent
load_dotenv(ROOT_DIR / ".env", override=True)

from fastapi import (
    FastAPI,
    APIRouter,
    HTTPException,
    Request,
    Response,
    Cookie,
    Header,
    BackgroundTasks,
)
from starlette.middleware.cors import CORSMiddleware
from motor.motor_asyncio import AsyncIOMotorClient
import os
import json
import logging
import uuid
import asyncio
import secrets
import httpx
from pydantic import BaseModel, Field
from typing import List, Optional, Literal
from datetime import datetime, timezone, timedelta

from llm_provider import run_llm, run_llm_cheap
from auth_provider import (
    attach_auth_routes,
    get_current_user_from_token,
    extract_token,
    AUTH_PROVIDER,
)

# Mongo
mongo_url = os.environ["MONGO_URL"]
client = AsyncIOMotorClient(mongo_url)
db = client[os.environ["DB_NAME"]]

EMERGENT_LLM_KEY = os.environ.get("EMERGENT_LLM_KEY", "")

app = FastAPI()
api = APIRouter(prefix="/api")

logging.basicConfig(
    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

JSON_REPAIR_SYSTEM_PROMPT = """You repair malformed JSON.

Return ONLY valid JSON.
- Preserve the original meaning and fields.
- Do not add commentary or markdown fences.
- Escape quotes and newlines correctly inside string values.
- Keep arrays, numbers, booleans, and nulls as proper JSON types."""


# ---------- Rate limiting ----------
RL_IDEA_COOLDOWN_SEC = int(os.environ.get("RL_IDEA_COOLDOWN_SEC", "60"))
RL_DIAGNOSE_COOLDOWN_SEC = int(os.environ.get("RL_DIAGNOSE_COOLDOWN_SEC", "1800"))
RL_DIAGNOSE_PER_WEEK = int(os.environ.get("RL_DIAGNOSE_PER_WEEK", "5"))
IST = timezone(timedelta(hours=5, minutes=30))


async def _has_unlimited_access(user_id: str) -> bool:
    """Return True for users who should bypass product rate limits."""
    users = getattr(db, "users", None)
    if users is None:
        return False
    user = await users.find_one({"user_id": user_id}, {"_id": 0, "access_tier": 1})
    return (user or {}).get("access_tier") == "unlimited"


async def _check_rate_limit(user_id: str, action: str, cooldown_sec: int = 0):
    """Mongo-backed per-user cooldown. Records the accepted call."""
    if cooldown_sec <= 0:
        return
    if await _has_unlimited_access(user_id):
        return
    now = datetime.now(timezone.utc)
    last = await db.rate_limits.find_one(
        {"user_id": user_id, "action": action},
        {"_id": 0, "ts": 1},
        sort=[("ts", -1)],
    )

    if action == "create_idea":
        await _check_new_idea_gate(user_id)

    if last:
        last_ts = last["ts"]
        if isinstance(last_ts, str):
            last_ts = datetime.fromisoformat(last_ts)
        if last_ts.tzinfo is None:
            last_ts = last_ts.replace(tzinfo=timezone.utc)
        wait = cooldown_sec - int((now - last_ts).total_seconds())
        if wait > 0:
            raise HTTPException(
                status_code=429, detail=f"Slow down. Try again in {wait}s."
            )
    await db.rate_limits.insert_one(
        {"user_id": user_id, "action": action, "ts": now.isoformat()}
    )


async def _check_new_idea_gate(user_id: str):
    """Enforce weekly diagnosis limit before allowing new ideas."""
    if await _has_unlimited_access(user_id):
        return
    usage = await _diagnosis_usage(user_id)
    weekly_count = usage["weekly_used"]
    if weekly_count >= RL_DIAGNOSE_PER_WEEK:
        raise HTTPException(
            status_code=429,
            detail={
                "message": "Come back after making progress.",
                "code": "diagnosis_weekly_limit",
                **usage,
            },
        )


async def _check_diagnosis_gate(user_id: str, idea_id: str):
    """Enforce cheap product gates before spending tokens on another diagnosis."""
    if await _has_unlimited_access(user_id):
        return
    usage = await _diagnosis_usage(user_id)
    weekly_count = usage["weekly_used"]
    if weekly_count >= RL_DIAGNOSE_PER_WEEK:
        raise HTTPException(
            status_code=429,
            detail={
                "message": "Come back after making progress.",
                "code": "diagnosis_weekly_limit",
                **usage,
            },
        )

    latest_diag = await db.diagnoses.find_one(
        {"idea_id": idea_id, "user_id": user_id}, {"_id": 0}, sort=[("created_at", -1)]
    )
    if latest_diag:
        actions = latest_diag.get("this_week_actions", [])
        if not any(a.get("done") for a in actions):
            raise HTTPException(
                status_code=400,
                detail={
                    "message": "Complete 1 task to unlock.",
                    "code": "diagnosis_action_required",
                    **usage,
                },
            )

        if usage["cooldown_remaining_seconds"] > 0:
            detail = (
                "This only improves if your situation changes. Go execute."
                if weekly_count >= 2
                else f"Wait {max(1, usage['cooldown_remaining_seconds'] // 60)}m before re-checking."
            )
            raise HTTPException(
                status_code=429,
                detail={
                    "message": detail,
                    "code": "diagnosis_cooldown",
                    **usage,
                },
            )

    await db.rate_limits.insert_one(
        {
            "user_id": user_id,
            "action": "diagnose",
            "ts": datetime.now(timezone.utc).isoformat(),
        }
    )


def _coerce_dt(value):
    if not value:
        return None
    if isinstance(value, str):
        value = datetime.fromisoformat(value)
    if value.tzinfo is None:
        value = value.replace(tzinfo=timezone.utc)
    return value


def _to_ist_iso(value):
    dt = _coerce_dt(value)
    return dt.astimezone(IST).isoformat() if dt else None


def _add_ist_fields(doc: dict, fields: List[str]) -> dict:
    for field in fields:
        if field in doc:
            doc[f"{field}_ist"] = _to_ist_iso(doc.get(field))
    return doc


async def _diagnosis_usage(user_id: str) -> dict:
    now = datetime.now(timezone.utc)
    week_ago = (now - timedelta(days=7)).isoformat()
    weekly_count = await db.rate_limits.count_documents(
        {"user_id": user_id, "action": "diagnose", "ts": {"$gte": week_ago}}
    )
    last = await db.rate_limits.find_one(
        {"user_id": user_id, "action": "diagnose"},
        {"_id": 0, "ts": 1},
        sort=[("ts", -1)],
    )
    last_ts = _coerce_dt(last.get("ts")) if last else None
    unlimited = await _has_unlimited_access(user_id)
    cooldown_remaining = 0
    next_recheck_at = None
    if last_ts and not unlimited:
        cooldown_remaining = max(
            0, RL_DIAGNOSE_COOLDOWN_SEC - int((now - last_ts).total_seconds())
        )
        next_recheck_at = (
            last_ts + timedelta(seconds=RL_DIAGNOSE_COOLDOWN_SEC)
        ).astimezone(IST)
    return {
        "unlimited": unlimited,
        "weekly_used": weekly_count,
        "weekly_limit": None if unlimited else RL_DIAGNOSE_PER_WEEK,
        "weekly_remaining": (
            None if unlimited else max(0, RL_DIAGNOSE_PER_WEEK - weekly_count)
        ),
        "cooldown_seconds": 0 if unlimited else RL_DIAGNOSE_COOLDOWN_SEC,
        "cooldown_remaining_seconds": cooldown_remaining,
        "last_diagnosis_at_ist": (
            last_ts.astimezone(IST).isoformat() if last_ts else None
        ),
        "next_recheck_at_ist": next_recheck_at.isoformat() if next_recheck_at else None,
        "timezone": "Asia/Kolkata",
    }


# ---------- Cheap prefilter ----------
PREFILTER_SYSTEM = """You are a sharp triage filter for a startup-idea evaluation tool.

Your ONLY job: decide whether the submission is worth running through the expensive deep-diagnosis pipeline.
When you reject, the reason must be a savage, sarcastic one-liner. Be funny and sharp, but no slurs,
threats, profanity, or personal attacks. Roast the submission, not the founder.

REJECT (passes=false) when:
- gibberish: the text is empty, single random words, keyboard mashing ("asdf", "test test"), or filler ipsum
- non_startup: the submission is clearly not a startup idea
- duplicate: the submission is essentially the same idea as one this founder already submitted

ACCEPT (passes=true) when:
- It's a real attempt at describing a startup/product idea, even if rough or vague.

OUTPUT CONTRACT - return ONLY this JSON, no prose, no fences:
{
  "passes": true | false,
  "category": "ok" | "gibberish" | "non_startup" | "duplicate",
  "reason": "one short sentence. If passes=false, make it savage and sarcastic. If duplicate, name the existing idea."
}"""


async def _prefilter_idea(payload: "IdeaCreate", existing_ideas: List[dict]) -> dict:
    existing_block = (
        "\n".join(
            f"- {i.get('title', '')}: {i.get('one_liner', '')}" for i in existing_ideas
        )
        or "(none - first idea)"
    )
    user_msg = (
        "NEW SUBMISSION:\n"
        f"Title: {payload.title}\n"
        f"One-liner: {payload.one_liner}\n"
        f"Problem: {payload.problem}\n"
        f"Target user: {payload.target_user}\n"
        f"Access to users: {payload.access_to_users}\n"
        f"Domain experience: {payload.domain_experience}\n"
        f"Motivation: {payload.motivation}\n"
        f"Extra: {payload.extra_context or '(none)'}\n\n"
        f"FOUNDER'S EXISTING IDEAS:\n{existing_block}\n\n"
        "Return ONLY the JSON object."
    )
    try:
        raw = await run_llm_cheap(PREFILTER_SYSTEM, user_msg)
    except Exception as e:
        logger.warning("prefilter call failed, allowing through: %s", e)
        return {"passes": True, "category": "ok", "reason": "prefilter unavailable"}

    text = raw.strip()
    if text.startswith("```"):
        text = text.strip("`")
        if text.lower().startswith("json"):
            text = text[4:].strip()
    start = text.find("{")
    end = text.rfind("}")
    if start == -1 or end == -1:
        logger.warning("prefilter returned non-JSON, allowing through: %s", raw[:160])
        return {"passes": True, "category": "ok", "reason": "prefilter unparseable"}
    try:
        parsed = json.loads(text[start : end + 1])
    except json.JSONDecodeError:
        return {"passes": True, "category": "ok", "reason": "prefilter unparseable"}
    return {
        "passes": bool(parsed.get("passes", True)),
        "category": parsed.get("category", "ok"),
        "reason": parsed.get("reason", ""),
    }


# ---------- Models ----------
class User(BaseModel):
    user_id: str
    email: str
    name: str
    picture: Optional[str] = None
    access_tier: Optional[str] = "free"
    founder_type: Optional[str] = (
        None  # first_time | technical | non_technical | repeat
    )
    created_at: datetime


class IdeaCreate(BaseModel):
    title: str
    one_liner: str
    problem: str
    target_user: str
    access_to_users: str  # how you'll reach them
    domain_experience: str
    motivation: str
    extra_context: Optional[str] = ""


class Idea(BaseModel):
    idea_id: str
    user_id: str
    title: str
    one_liner: str
    problem: str
    target_user: str
    access_to_users: str
    domain_experience: str
    motivation: str
    extra_context: str
    status: str = "active"  # active | killed | pivoted | archived
    latest_verdict: Optional[str] = None  # pursue | pivot | kill
    latest_fmf_score: Optional[int] = None
    latest_wtp_score: Optional[int] = None
    latest_momentum_score: Optional[int] = None
    streak: int = 0
    last_checkin_at: Optional[datetime] = None
    created_at: datetime
    updated_at: datetime


class CheckinCreate(BaseModel):
    actions_completed: List[str] = []  # list of action ids
    what_changed: str = ""
    new_learnings: str = ""
    blockers: str = ""


class Action(BaseModel):
    action_id: str
    title: str
    why: str
    how: str  # hyper-specific steps/script
    assumption: str  # assumption it validates
    effort: str  # S/M/L
    done: bool = False


class Diagnosis(BaseModel):
    diagnosis_id: str
    idea_id: str
    user_id: str
    verdict: Literal["pursue", "pivot", "kill"]
    verdict_headline: str  # one sharp sentence
    diagnosis: str  # 2-3 sentences, what's really going on
    key_insight: str  # what they're missing
    kill_conditions: List[str]  # hard truths, triggers to kill
    momentum_signals: List[str]  # what would prove traction
    fmf_score: int  # 0-100 founder-market fit
    fmf_reason: str
    wtp_score: int  # 0-100 willingness to pay
    wtp_reason: str
    execution_risk: int  # 0-100
    execution_risk_reason: str
    momentum_score: int  # 0-100
    momentum_reason: str
    competitor_signal: str  # one crisp paragraph
    this_week_actions: List[Action]
    created_at: datetime


class Checkin(BaseModel):
    checkin_id: str
    idea_id: str
    user_id: str
    actions_completed: List[str]
    what_changed: str
    new_learnings: str
    blockers: str
    delta_summary: str = ""  # AI-generated "what changed since last week"
    created_at: datetime


# ---------- Auth ----------
async def get_current_user(
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
) -> User:
    token = extract_token(session_token_cookie, authorization)
    if not token:
        raise HTTPException(status_code=401, detail="Not authenticated")
    user_doc = await get_current_user_from_token(token, db)
    if not user_doc:
        raise HTTPException(status_code=401, detail="Invalid or expired session")
    if isinstance(user_doc.get("created_at"), str):
        user_doc["created_at"] = datetime.fromisoformat(user_doc["created_at"])
    # strip fields not in User model (e.g. password_hash)
    user_doc.pop("password_hash", None)
    return User(**user_doc)


# Mount provider-specific auth routes (login/register OR /auth/session)
attach_auth_routes(api, db)


@api.get("/auth/me")
async def auth_me(
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    return _add_ist_fields(user.model_dump(), ["created_at"])


@api.post("/auth/founder-type")
async def set_founder_type(
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    body = await request.json()
    ftype = body.get("founder_type")
    if ftype not in ["first_time", "technical", "non_technical", "repeat"]:
        raise HTTPException(status_code=400, detail="Invalid founder_type")
    await db.users.update_one(
        {"user_id": user.user_id}, {"$set": {"founder_type": ftype}}
    )
    return {"ok": True, "founder_type": ftype}


# ---------- Ideas ----------
def _serialize_idea(doc: dict) -> dict:
    for k in ["created_at", "updated_at", "last_checkin_at", "archived_at"]:
        v = doc.get(k)
        if isinstance(v, str):
            try:
                doc[k] = datetime.fromisoformat(v)
            except Exception:
                pass
    return _add_ist_fields(
        doc, ["created_at", "updated_at", "last_checkin_at", "archived_at"]
    )


def _serialize_timeline_doc(doc: Optional[dict]) -> Optional[dict]:
    if not doc:
        return doc
    return _add_ist_fields(
        doc, ["created_at", "updated_at", "last_checkin_at", "archived_at"]
    )


@api.post("/ideas")
async def create_idea(
    payload: IdeaCreate,
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    await _check_rate_limit(
        user.user_id, "create_idea", cooldown_sec=RL_IDEA_COOLDOWN_SEC
    )

    existing_ideas = (
        await db.ideas.find(
            {"user_id": user.user_id, "status": {"$ne": "archived"}},
            {"_id": 0, "title": 1, "one_liner": 1},
        )
        .sort("created_at", -1)
        .to_list(50)
    )
    prefilter = await _prefilter_idea(payload, existing_ideas)
    if not prefilter.get("passes", True):
        raise HTTPException(
            status_code=400,
            detail={
                "code": "idea_prefilter_failed",
                "category": prefilter.get("category", "rejected"),
                "reason": prefilter.get("reason", "Submission was rejected."),
            },
        )

    now = datetime.now(timezone.utc)
    idea_id = f"idea_{uuid.uuid4().hex[:12]}"
    doc = {
        "idea_id": idea_id,
        "user_id": user.user_id,
        **payload.model_dump(),
        "status": "active",
        "latest_verdict": None,
        "latest_fmf_score": None,
        "latest_wtp_score": None,
        "latest_momentum_score": None,
        "streak": 0,
        "last_checkin_at": None,
        "created_at": now.isoformat(),
        "updated_at": now.isoformat(),
    }
    await db.ideas.insert_one(doc)
    doc.pop("_id", None)
    return _serialize_idea({**doc})


@api.get("/ideas")
async def list_ideas(
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    ideas = (
        await db.ideas.find(
            {"user_id": user.user_id, "status": {"$ne": "archived"}}, {"_id": 0}
        )
        .sort("created_at", -1)
        .to_list(200)
    )
    return [_serialize_idea(i) for i in ideas]


@api.get("/ideas/{idea_id}")
async def get_idea(
    idea_id: str,
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    idea = await db.ideas.find_one(
        {"idea_id": idea_id, "user_id": user.user_id, "status": {"$ne": "archived"}},
        {"_id": 0},
    )
    if not idea:
        raise HTTPException(404, "Idea not found")

    diag = await db.diagnoses.find_one(
        {"idea_id": idea_id}, {"_id": 0}, sort=[("created_at", -1)]
    )
    checkins = (
        await db.checkins.find({"idea_id": idea_id}, {"_id": 0})
        .sort("created_at", -1)
        .to_list(50)
    )
    diagnoses = (
        await db.diagnoses.find({"idea_id": idea_id}, {"_id": 0})
        .sort("created_at", -1)
        .to_list(50)
    )

    return {
        "idea": _serialize_idea(idea),
        "latest_diagnosis": _serialize_timeline_doc(diag),
        "checkins": [_serialize_timeline_doc(c) for c in checkins],
        "diagnoses": [_serialize_timeline_doc(d) for d in diagnoses],
        "diagnosis_limits": await _diagnosis_usage(user.user_id),
    }


@api.get("/usage/limits")
async def usage_limits(
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    return {"diagnosis": await _diagnosis_usage(user.user_id)}


@api.delete("/ideas/{idea_id}")
async def delete_idea(
    idea_id: str,
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    now = datetime.now(timezone.utc).isoformat()
    await db.ideas.update_one(
        {"idea_id": idea_id, "user_id": user.user_id},
        {"$set": {"status": "archived", "archived_at": now, "updated_at": now}},
    )
    return {"ok": True, "archived": True}


# ---------- AI: Diagnose ----------
SYSTEM_PROMPT = """You are a brutally honest, highly intelligent startup advisor. Think like Paul Graham meets a no-BS angel investor who has seen 1000 founders.

YOUR JOB:
- Diagnose BEFORE prescribing.
- Be ruthlessly honest, but constructive. Never a motivational coach.
- Never give generic advice. Every sentence must be specific to THIS founder and THIS idea.
- Cut through vague thinking. Call out delusion. Surface the one thing they're missing.
- Every action must include exact people to talk to, exact messages to send, exact assumptions to validate.

OUTPUT CONTRACT:
You MUST respond with ONLY valid JSON matching this schema. No prose before or after. No markdown fences.
All string values must be valid JSON strings: escape any inner double quotes and use \\n instead of literal line breaks inside strings.

{
  "verdict": "pursue" | "pivot" | "kill",
  "verdict_headline": "one sharp sentence, max 14 words, that lands like a punch",
  "diagnosis": "2-3 sentences: what is REALLY going on with this idea and this founder. Be specific.",
  "key_insight": "the one non-obvious thing they're missing. Start with 'You're missing...' or 'The real question is...'",
  "kill_conditions": ["hard, specific conditions where they should kill this", "max 3"],
  "momentum_signals": ["specific leading indicators that would prove real traction", "max 3"],
  "fmf_score": 0-100,
  "fmf_reason": "one sentence why (founder-market fit, based on domain experience + access to users + motivation)",
  "wtp_score": 0-100,
  "wtp_reason": "one sentence why (willingness to pay — is this a painkiller or vitamin?)",
  "execution_risk": 0-100,
  "execution_risk_reason": "one sentence why",
  "momentum_score": 0-100,
  "momentum_reason": "one sentence why (current traction/evidence velocity based on actions, check-ins, or lack of proof)",
  "competitor_signal": "one crisp paragraph: who exists, what's the honest positioning gap, is the space hot or crowded",
  "this_week_actions": [
    {
      "action_id": "a1",
      "title": "short punchy title",
      "why": "one sentence why this matters THIS week",
      "how": "hyper-specific: exact steps, exact DM/email scripts in quotes, exact names/channels to target. No generic 'talk to users' — say 'post in r/X with this hook: ...' or 'message these 5 archetypes on LinkedIn: ...'",
      "assumption": "the exact assumption this validates or invalidates",
      "effort": "S" | "M" | "L"
    }
  ]
}

Rules for this_week_actions: produce exactly 3-5 actions. Each must be doable in under 7 days. At least one must be a user-facing validation action with an exact script.

Adapt tone to founder_type:
- first_time: extra bluntness about assumptions, less jargon
- technical: push hard on distribution/users, not features
- non_technical: push hard on validation without building, scrappy paths
- repeat: skip basics, go deeper on strategic risks"""


def _extract_json_candidate(raw: str) -> str:
    text = raw.strip()
    if text.startswith("```"):
        text = text.strip("`")
        if text.lower().startswith("json"):
            text = text[4:].strip()
    start = text.find("{")
    end = text.rfind("}")
    if start == -1 or end == -1 or end <= start:
        raise ValueError(f"Model did not return JSON: {raw[:200]}")
    return text[start : end + 1]


async def _parse_or_repair_json(raw: str, session_id: str) -> dict:
    candidate = _extract_json_candidate(raw)
    try:
        return json.loads(candidate)
    except json.JSONDecodeError as e:
        logger.warning("diagnosis JSON parse failed, attempting repair: %s", e)
        repair_user_msg = (
            "Repair this malformed JSON so it becomes valid JSON with the same structure "
            "and content. Return ONLY the repaired JSON.\n\n"
            f"Parse error: {e}\n\n"
            f"{candidate}"
        )
        repaired_raw = await run_llm_cheap(
            JSON_REPAIR_SYSTEM_PROMPT,
            repair_user_msg,
            session_id=f"{session_id}_repair",
        )
        repaired_candidate = _extract_json_candidate(repaired_raw)
        try:
            return json.loads(repaired_candidate)
        except json.JSONDecodeError as repair_error:
            raise ValueError(
                "LLM produced invalid JSON and repair failed: "
                f"{repair_error}. Original error: {e}. "
                f"Excerpt: {candidate[:200]}"
            ) from repair_error


def _build_idea_brief(
    user: User, idea: dict, prior_diag: Optional[dict], last_checkin: Optional[dict]
) -> str:
    lines = [
        f"FOUNDER: {user.name}",
        f"FOUNDER_TYPE: {user.founder_type or 'unknown'}",
        "",
        f"IDEA TITLE: {idea['title']}",
        f"ONE-LINER: {idea['one_liner']}",
        f"PROBLEM: {idea['problem']}",
        f"TARGET USER: {idea['target_user']}",
        f"ACCESS TO USERS: {idea['access_to_users']}",
        f"DOMAIN EXPERIENCE: {idea['domain_experience']}",
        f"MOTIVATION: {idea['motivation']}",
        f"EXTRA CONTEXT: {idea.get('extra_context', '') or '(none)'}",
    ]
    if prior_diag:
        lines += [
            "",
            "PRIOR DIAGNOSIS:",
            f"- Previous verdict: {prior_diag.get('verdict')}",
            f"- Previous key insight: {prior_diag.get('key_insight')}",
        ]
    if last_checkin:
        lines += [
            "",
            "LAST CHECK-IN:",
            f"- Actions completed: {last_checkin.get('actions_completed')}",
            f"- What changed: {last_checkin.get('what_changed')}",
            f"- New learnings: {last_checkin.get('new_learnings')}",
            f"- Blockers: {last_checkin.get('blockers')}",
            "",
            "IMPORTANT: Re-diagnose based on new evidence. Verdict MAY change. Reference what they learned. If they didn't complete actions, call it out.",
        ]
    return "\n".join(lines)


async def _run_diagnosis_llm(brief: str, session_id: str) -> dict:
    user_msg = (
        f"Diagnose this idea. Return ONLY the JSON object per the contract.\n\n{brief}"
    )
    raw = await run_llm(SYSTEM_PROMPT, user_msg, session_id=session_id)
    parsed = await _parse_or_repair_json(raw, session_id)
    # ensure action_ids are unique
    for i, a in enumerate(parsed.get("this_week_actions", []), 1):
        a["action_id"] = a.get("action_id") or f"a{i}"
        a["done"] = False
    return parsed


@api.post("/ideas/{idea_id}/diagnose")
async def diagnose(
    idea_id: str,
    request: Request,
    background_tasks: BackgroundTasks,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    """Kick off an async diagnosis job. Returns immediately with a job_id.
    Poll GET /api/ideas/{idea_id}/diagnose/jobs/{job_id} for status."""
    user = await get_current_user(request, session_token_cookie, authorization)
    idea = await db.ideas.find_one(
        {"idea_id": idea_id, "user_id": user.user_id, "status": {"$ne": "archived"}},
        {"_id": 0},
    )
    if not idea:
        raise HTTPException(404, "Idea not found")
    await _check_diagnosis_gate(user.user_id, idea_id)

    job_id = f"job_{uuid.uuid4().hex[:12]}"
    now = datetime.now(timezone.utc)
    await db.diagnosis_jobs.insert_one(
        {
            "job_id": job_id,
            "idea_id": idea_id,
            "user_id": user.user_id,
            "status": "pending",  # pending | done | error
            "error": None,
            "diagnosis_id": None,
            "created_at": now.isoformat(),
        }
    )

    background_tasks.add_task(_run_diagnosis_job, job_id, idea_id, user.user_id)
    return {"job_id": job_id, "status": "pending"}


async def _run_diagnosis_job(job_id: str, idea_id: str, user_id: str):
    try:
        user_doc = await db.users.find_one({"user_id": user_id}, {"_id": 0})
        idea = await db.ideas.find_one(
            {"idea_id": idea_id, "user_id": user_id, "status": {"$ne": "archived"}},
            {"_id": 0},
        )
        if not user_doc or not idea:
            raise RuntimeError("idea or user vanished")
        if isinstance(user_doc.get("created_at"), str):
            user_doc["created_at"] = datetime.fromisoformat(user_doc["created_at"])
        user = User(**user_doc)

        prior = await db.diagnoses.find_one(
            {"idea_id": idea_id}, {"_id": 0}, sort=[("created_at", -1)]
        )
        last_checkin = await db.checkins.find_one(
            {"idea_id": idea_id}, {"_id": 0}, sort=[("created_at", -1)]
        )
        brief = _build_idea_brief(user, idea, prior, last_checkin)

        parsed = await asyncio.wait_for(
            _run_diagnosis_llm(brief, f"diag_{idea_id}_{uuid.uuid4().hex[:8]}"),
            timeout=240.0,
        )

        now = datetime.now(timezone.utc)
        diag = {
            "diagnosis_id": f"diag_{uuid.uuid4().hex[:12]}",
            "idea_id": idea_id,
            "user_id": user_id,
            "verdict": parsed["verdict"],
            "verdict_headline": parsed["verdict_headline"],
            "diagnosis": parsed["diagnosis"],
            "key_insight": parsed["key_insight"],
            "kill_conditions": parsed.get("kill_conditions", []),
            "momentum_signals": parsed.get("momentum_signals", []),
            "fmf_score": int(parsed.get("fmf_score", 0)),
            "fmf_reason": parsed.get("fmf_reason", ""),
            "wtp_score": int(parsed.get("wtp_score", 0)),
            "wtp_reason": parsed.get("wtp_reason", ""),
            "execution_risk": int(parsed.get("execution_risk", 0)),
            "execution_risk_reason": parsed.get("execution_risk_reason", ""),
            "momentum_score": int(parsed.get("momentum_score", 0)),
            "momentum_reason": parsed.get("momentum_reason", ""),
            "competitor_signal": parsed.get("competitor_signal", ""),
            "this_week_actions": parsed.get("this_week_actions", []),
            "share_slug": None,
            "created_at": now.isoformat(),
        }
        await db.diagnoses.insert_one({**diag})
        await db.ideas.update_one(
            {"idea_id": idea_id},
            {
                "$set": {
                    "latest_verdict": diag["verdict"],
                    "latest_fmf_score": diag["fmf_score"],
                    "latest_wtp_score": diag["wtp_score"],
                    "latest_momentum_score": diag["momentum_score"],
                    "updated_at": now.isoformat(),
                }
            },
        )
        await db.diagnosis_jobs.update_one(
            {"job_id": job_id},
            {"$set": {"status": "done", "diagnosis_id": diag["diagnosis_id"]}},
        )
    except Exception as e:
        logger.exception("diagnosis job failed")
        await db.diagnosis_jobs.update_one(
            {"job_id": job_id},
            {"$set": {"status": "error", "error": str(e)[:400]}},
        )


@api.get("/ideas/{idea_id}/diagnose/jobs/{job_id}")
async def get_diagnosis_job(
    idea_id: str,
    job_id: str,
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    job = await db.diagnosis_jobs.find_one(
        {"job_id": job_id, "idea_id": idea_id, "user_id": user.user_id}, {"_id": 0}
    )
    if not job:
        raise HTTPException(404, "Job not found")
    out = {"job_id": job_id, "status": job["status"], "error": job.get("error")}
    if job["status"] == "done" and job.get("diagnosis_id"):
        diag = await db.diagnoses.find_one(
            {"diagnosis_id": job["diagnosis_id"]}, {"_id": 0}
        )
        out["diagnosis"] = _serialize_timeline_doc(diag)
    return out


@api.post("/ideas/{idea_id}/actions/{action_id}/toggle")
async def toggle_action(
    idea_id: str,
    action_id: str,
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    diag = await db.diagnoses.find_one(
        {"idea_id": idea_id, "user_id": user.user_id},
        {"_id": 0},
        sort=[("created_at", -1)],
    )
    if not diag:
        raise HTTPException(404, "No diagnosis")
    actions = diag.get("this_week_actions", [])
    for a in actions:
        if a.get("action_id") == action_id:
            a["done"] = not a.get("done", False)
            break
    await db.diagnoses.update_one(
        {"diagnosis_id": diag["diagnosis_id"]},
        {"$set": {"this_week_actions": actions}},
    )
    return {"ok": True, "actions": actions}


# ---------- Weekly Check-in ----------
@api.post("/ideas/{idea_id}/checkins")
async def create_checkin(
    idea_id: str,
    payload: CheckinCreate,
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    idea = await db.ideas.find_one(
        {"idea_id": idea_id, "user_id": user.user_id, "status": {"$ne": "archived"}},
        {"_id": 0},
    )
    if not idea:
        raise HTTPException(404, "Idea not found")

    now = datetime.now(timezone.utc)
    last_cki = await db.checkins.find_one(
        {"idea_id": idea_id}, {"_id": 0}, sort=[("created_at", -1)]
    )
    # streak: if last check-in within 14 days of now, increment; else reset to 1
    streak = idea.get("streak", 0) or 0
    if last_cki:
        last_at = last_cki.get("created_at")
        if isinstance(last_at, str):
            last_at = datetime.fromisoformat(last_at)
        if last_at and last_at.tzinfo is None:
            last_at = last_at.replace(tzinfo=timezone.utc)
        delta_days = (now - last_at).days if last_at else 999
        streak = streak + 1 if delta_days <= 14 else 1
    else:
        streak = 1

    checkin_id = f"cki_{uuid.uuid4().hex[:12]}"
    doc = {
        "checkin_id": checkin_id,
        "idea_id": idea_id,
        "user_id": user.user_id,
        "actions_completed": payload.actions_completed,
        "what_changed": payload.what_changed,
        "new_learnings": payload.new_learnings,
        "blockers": payload.blockers,
        "delta_summary": "",
        "created_at": now.isoformat(),
    }
    await db.checkins.insert_one({**doc})
    await db.ideas.update_one(
        {"idea_id": idea_id},
        {
            "$set": {
                "last_checkin_at": now.isoformat(),
                "streak": streak,
                "updated_at": now.isoformat(),
            }
        },
    )
    # Also mark completed actions as done in latest diagnosis
    latest_diag = await db.diagnoses.find_one(
        {"idea_id": idea_id}, {"_id": 0}, sort=[("created_at", -1)]
    )
    if latest_diag:
        actions = latest_diag.get("this_week_actions", [])
        completed = set(payload.actions_completed or [])
        for a in actions:
            if a.get("action_id") in completed:
                a["done"] = True
        await db.diagnoses.update_one(
            {"diagnosis_id": latest_diag["diagnosis_id"]},
            {"$set": {"this_week_actions": actions}},
        )
    return _serialize_timeline_doc({**doc, "streak": streak})


@api.get("/dashboard/summary")
async def dashboard_summary(
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    ideas = (
        await db.ideas.find(
            {"user_id": user.user_id, "status": {"$ne": "archived"}}, {"_id": 0}
        )
        .sort("updated_at", -1)
        .to_list(100)
    )
    total = len(ideas)
    pursue = sum(1 for i in ideas if i.get("latest_verdict") == "pursue")
    pivot = sum(1 for i in ideas if i.get("latest_verdict") == "pivot")
    kill = sum(1 for i in ideas if i.get("latest_verdict") == "kill")
    top_streak = max((i.get("streak", 0) or 0 for i in ideas), default=0)
    return {
        "total": total,
        "pursue": pursue,
        "pivot": pivot,
        "kill": kill,
        "top_streak": top_streak,
        "ideas": [_serialize_idea(i) for i in ideas],
    }


@api.get("/")
async def root():
    return {"ok": True, "service": "founder-advisor"}


# ---------- Share (public, virality) ----------
def slugify(text: str) -> str:
    return re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")


@api.post("/diagnoses/{diagnosis_id}/share")
async def create_share_link(
    diagnosis_id: str,
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)

    diag = await db.diagnoses.find_one(
        {"diagnosis_id": diagnosis_id, "user_id": user.user_id},
        {"_id": 0, "share_slug": 1, "idea_id": 1},
    )
    if not diag:
        raise HTTPException(404, "Diagnosis not found")

    if diag.get("share_slug"):
        return {"share_slug": diag["share_slug"]}

    # fetch idea
    idea = await db.ideas.find_one(
        {"idea_id": diag["idea_id"]},
        {"_id": 0, "title": 1, "one_liner": 1},
    )

    base_text = (
        "-".join(
            filter(
                None,
                [
                    ((idea or {}).get("title") or "").strip(),
                    ((idea or {}).get("one_liner") or "").strip(),
                ],
            )
        )
        or "startup-idea"
    )

    base = slugify(base_text)
    if len(base) > 60:
        base = base[:60].rsplit("-", 1)[0]

    slug = None

    for _ in range(5):
        token = secrets.token_urlsafe(6)
        candidate = f"{base}-{token}"

        exists = await db.diagnoses.find_one(
            {"share_slug": candidate},
            {"_id": 1},
        )

        if not exists:
            slug = candidate
            break

    if not slug:
        raise HTTPException(500, "Could not generate slug")

    await db.diagnoses.update_one(
        {"diagnosis_id": diagnosis_id},
        {"$set": {"share_slug": slug}},
    )

    return {"share_slug": slug}


@api.delete("/diagnoses/{diagnosis_id}/share")
async def revoke_share_link(
    diagnosis_id: str,
    request: Request,
    session_token_cookie: Optional[str] = Cookie(None, alias="session_token"),
    authorization: Optional[str] = Header(None),
):
    user = await get_current_user(request, session_token_cookie, authorization)
    await db.diagnoses.update_one(
        {"diagnosis_id": diagnosis_id, "user_id": user.user_id},
        {"$set": {"share_slug": None}},
    )
    return {"ok": True}


async def build_shared_diagnosis_content(slug: str) -> dict:
    diag = await db.diagnoses.find_one(
        {"share_slug": slug},
        {"_id": 0},
    )

    if not diag:
        raise HTTPException(404, "Not found")

    idea = await db.ideas.find_one(
        {"idea_id": diag["idea_id"], "status": {"$ne": "archived"}},
        {"_id": 0},
    )
    if not idea:
        raise HTTPException(404, "Not found")

    user = await db.users.find_one(
        {"user_id": diag["user_id"]},
        {"_id": 0},
    )

    indexable = is_indexable(diag)

    return {
        "idea": {
            "title": idea.get("title"),
            "one_liner": idea.get("one_liner"),
        },
        "founder": {
            "name": (user or {}).get("name", "A founder"),
            "picture": (user or {}).get("picture"),
        },
        "diagnosis": {
            "verdict": diag["verdict"],
            "verdict_headline": diag["verdict_headline"],
            "diagnosis": diag["diagnosis"],
            "key_insight": diag["key_insight"],
            "kill_conditions": diag.get("kill_conditions", []),
            "momentum_signals": diag.get("momentum_signals", []),
            "fmf_score": diag["fmf_score"],
            "wtp_score": diag["wtp_score"],
            "momentum_score": diag["momentum_score"],
            "execution_risk": diag["execution_risk"],
            "competitor_signal": diag.get("competitor_signal", ""),
            "this_week_actions": [
                {
                    "title": a.get("title"),
                    "why": a.get("why"),
                    "effort": a.get("effort"),
                }
                for a in diag.get("this_week_actions", [])
            ],
            "created_at": diag["created_at"],
            "created_at_ist": _to_ist_iso(diag["created_at"]),
        },
        "is_indexable": indexable,
    }


@api.get("/share/{slug}")
async def get_shared_diagnosis_old(slug: str):
    return await build_shared_diagnosis_content(slug)


@api.get("/metrics/summary")
async def metrics_summary():
    now = datetime.now(timezone.utc)
    week_ago = (now - timedelta(days=7)).isoformat()

    # Total ideas
    total_ideas = await db.ideas.count_documents({})

    # Active founders (users with ideas)
    active_founders = len(await db.ideas.distinct("user_id"))

    # Actions completed this week
    diagnoses = await db.diagnoses.find(
        {"created_at": {"$gte": week_ago}}, {"_id": 0, "this_week_actions": 1}
    ).to_list(1000)

    actions_completed = 0
    for d in diagnoses:
        for a in d.get("this_week_actions", []):
            if a.get("done"):
                actions_completed += 1

    # Avg momentum score
    momentum_docs = await db.diagnoses.find(
        {}, {"_id": 0, "momentum_score": 1}
    ).to_list(1000)

    avg_momentum = int(
        sum(d.get("momentum_score", 0) for d in momentum_docs)
        / max(len(momentum_docs), 1)
    )

    # Verdict distribution
    pursue = await db.ideas.count_documents({"latest_verdict": "pursue"})
    pivot = await db.ideas.count_documents({"latest_verdict": "pivot"})
    kill = await db.ideas.count_documents({"latest_verdict": "kill"})

    return {
        "total_ideas": total_ideas,
        "active_founders": active_founders,
        "actions_completed_week": actions_completed,
        "avg_momentum": avg_momentum,
        "pursue": pursue,
        "pivot": pivot,
        "kill": kill,
        "updated_at": now.isoformat(),
    }


app.include_router(api)
app.add_middleware(
    CORSMiddleware,
    allow_credentials=True,
    allow_origins=os.environ.get("CORS_ORIGINS", "*").split(","),
    allow_methods=["*"],
    allow_headers=["*"],
)


@app.on_event("startup")
async def startup_indexes():
    try:
        await db.user_sessions.create_index("session_token", unique=True)
        await db.diagnoses.create_index("share_slug", unique=False, sparse=True)
        await db.diagnosis_jobs.create_index("job_id", unique=True)
    except Exception:
        logger.exception("index creation failed (non-fatal)")


@app.on_event("shutdown")
async def shutdown_db_client():
    client.close()