admin / Apex

"""Answer Library — searchable catalogue of tender questions & responses (MVP).

Search is DB-agnostic (ILIKE + Python filtering/ranking) so it runs identically on
Postgres (production) and SQLite (tests). Postgres full-text + trigram / semantic
search are documented Phase-2 enhancements.
"""
from __future__ import annotations

from datetime import datetime, timezone

from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy import or_, select
from sqlalchemy.orm import Session

from app.core.database import get_db
from app.core.deps import audit, get_current_user, require_roles
from app.models import (
    ROLE_ADMIN,
    ROLE_BID_MANAGER,
    ROLE_CONTRIBUTOR,
    AnswerEntry,
    AnswerReuseLog,
    User,
)
from app.schemas import (
    AnswerEntryIn,
    AnswerEntryOut,
    AnswerEntryUpdate,
    AnswerSearchOut,
    ReuseIn,
)
from app.services import library as lib

router = APIRouter(prefix="/api/library", tags=["library"])
curator = require_roles(ROLE_ADMIN, ROLE_BID_MANAGER, ROLE_CONTRIBUTOR)

_OUTCOME_WEIGHT = {"won": 3, "in_progress": 1, "n/a": 1, "lost": 0}


@router.get("", response_model=AnswerSearchOut)
def search(
    q: str | None = None,
    category: str | None = None,
    client: str | None = None,
    outcome: str | None = None,
    framework: int | None = None,
    tag: str | None = None,
    include_archived: bool = False,
    limit: int = 25,
    offset: int = 0,
    db: Session = Depends(get_db),
    _: User = Depends(get_current_user),
):
    stmt = select(AnswerEntry)
    if not include_archived:
        stmt = stmt.where(AnswerEntry.status != "archived")
    if q:
        like = f"%{q.strip()}%"
        stmt = stmt.where(or_(
            AnswerEntry.question.ilike(like),
            AnswerEntry.answer.ilike(like),
            AnswerEntry.summary.ilike(like),
        ))
    if category:
        stmt = stmt.where(AnswerEntry.category == category)
    if client:
        stmt = stmt.where(AnswerEntry.client == client)
    if outcome:
        stmt = stmt.where(AnswerEntry.outcome == outcome)

    rows = list(db.execute(stmt).scalars().all())
    # JSON membership + tag filters applied in Python (portable across SQLite/Postgres)
    if framework is not None:
        rows = [r for r in rows if framework in (r.frameworks or [])]
    if tag:
        tl = tag.lower()
        rows = [r for r in rows if any(tl == str(t).lower() for t in (r.tags or []))]

    # relevance-ish ranking: master first, then won>neutral>lost, then reuse, then recency
    rows.sort(key=lambda r: (
        r.is_master,
        _OUTCOME_WEIGHT.get(r.outcome, 1),
        r.reuse_count,
        r.updated_at or datetime.min.replace(tzinfo=timezone.utc),
    ), reverse=True)

    total = len(rows)
    page = rows[offset: offset + limit]
    return {"total": total, "items": [AnswerEntryOut.model_validate(r) for r in page]}


@router.get("/facets")
def facets(db: Session = Depends(get_db), _: User = Depends(get_current_user)):
    rows = db.execute(select(AnswerEntry).where(AnswerEntry.status != "archived")).scalars().all()
    cats, clients, tags = set(), set(), set()
    for r in rows:
        if r.category:
            cats.add(r.category)
        if r.client:
            clients.add(r.client)
        for t in (r.tags or []):
            tags.add(str(t))
    return {
        "categories": sorted(cats),
        "clients": sorted(clients),
        "tags": sorted(tags),
        "outcomes": ["won", "lost", "in_progress", "n/a"],
    }


@router.get("/{entry_id}", response_model=AnswerEntryOut)
def get_entry(entry_id: int, db: Session = Depends(get_db), _: User = Depends(get_current_user)):
    entry = db.get(AnswerEntry, entry_id)
    if not entry:
        raise HTTPException(404, "Not found")
    return entry


@router.post("", response_model=AnswerEntryOut, status_code=201)
def create_entry(body: AnswerEntryIn, db: Session = Depends(get_db), actor: User = Depends(curator)):
    entry = AnswerEntry(
        question=body.question, answer=body.answer, summary=body.summary,
        category=body.category, tags=body.tags, frameworks=body.frameworks,
        source_type="manual", outcome="n/a", status="curated",
        word_count=len(body.answer.split()), created_by=actor.id,
    )
    db.add(entry)
    db.commit()
    db.refresh(entry)
    audit(db, actor, "library_entry_created", "answer_entry", entry.id)
    return entry


@router.patch("/{entry_id}", response_model=AnswerEntryOut)
def update_entry(entry_id: int, body: AnswerEntryUpdate, db: Session = Depends(get_db), actor: User = Depends(curator)):
    entry = db.get(AnswerEntry, entry_id)
    if not entry:
        raise HTTPException(404, "Not found")
    data = body.model_dump(exclude_none=True)
    for k, v in data.items():
        setattr(entry, k, v)
    if "answer" in data:
        entry.word_count = len(entry.answer.split())
    entry.updated_at = datetime.now(timezone.utc)
    db.commit()
    db.refresh(entry)
    audit(db, actor, "library_entry_updated", "answer_entry", entry.id)
    return entry


@router.post("/{entry_id}/master", response_model=AnswerEntryOut)
def toggle_master(entry_id: int, db: Session = Depends(get_db), actor: User = Depends(curator)):
    entry = db.get(AnswerEntry, entry_id)
    if not entry:
        raise HTTPException(404, "Not found")
    entry.is_master = not entry.is_master
    db.commit()
    db.refresh(entry)
    audit(db, actor, "library_master_set", "answer_entry", entry.id, {"is_master": entry.is_master})
    return entry


@router.delete("/{entry_id}")
def archive_entry(entry_id: int, db: Session = Depends(get_db), actor: User = Depends(curator)):
    entry = db.get(AnswerEntry, entry_id)
    if entry:
        entry.status = "archived"
        db.commit()
        audit(db, actor, "library_entry_archived", "answer_entry", entry_id)
    return {"ok": True}


@router.post("/harvest")
def harvest(db: Session = Depends(get_db), actor: User = Depends(require_roles(ROLE_ADMIN, ROLE_BID_MANAGER))):
    count = lib.backfill(db, actor.id)
    audit(db, actor, "library_backfill", "answer_entry", None, {"harvested": count})
    return {"harvested": count}


@router.post("/{entry_id}/reuse", response_model=AnswerEntryOut)
def log_reuse(entry_id: int, body: ReuseIn, db: Session = Depends(get_db), actor: User = Depends(curator)):
    entry = db.get(AnswerEntry, entry_id)
    if not entry:
        raise HTTPException(404, "Not found")
    entry.reuse_count = (entry.reuse_count or 0) + 1
    db.add(AnswerReuseLog(
        answer_id=entry.id, bid_id=body.bid_id, response_id=body.response_id,
        user_id=actor.id, action=body.action,
    ))
    db.commit()
    db.refresh(entry)
    audit(db, actor, "library_answer_reused", "answer_entry", entry.id,
          {"action": body.action, "response_id": body.response_id}, bid_id=body.bid_id)
    return entry