api.py

import time
from contextlib import asynccontextmanager

from fastapi import FastAPI, Depends, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from sqlalchemy.orm import Session

from config import settings
from db import get_db, create_tables, SessionLocal, Product, Category, CategoryReviewQueue
from ai_verifier import AgentCore
from logger import get_logger

log = get_logger("api")

agent: AgentCore | None = None


@asynccontextmanager
async def lifespan(application: FastAPI):
    global agent
    log.info("Starting Category Checker API (env=%s, log_level=%s)", settings.app_env, settings.log_level)
    create_tables()

    db = SessionLocal()
    try:
        all_categories = [c.name for c in db.query(Category).all()]
    finally:
        db.close()

    log.info("Initializing AI agent with %d categories...", len(all_categories))
    agent = AgentCore(all_category_names=all_categories)
    log.info("API ready")
    yield
    log.info("Shutting down API")


app = FastAPI(
    title="Category Checker API",
    description="AI-powered product category verification system",
    version="1.0.0",
    docs_url=None if settings.is_production else "/docs",
    redoc_url=None if settings.is_production else "/redoc",
    lifespan=lifespan,
)

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


class QueueItemResponse(BaseModel):
    id: int
    product_id: int
    product_name: str
    product_description: str
    current_category_id: int
    current_category_name: str
    ai_approach: str
    is_mismatch: bool
    confidence_score: float
    reason: str
    review_status: str
    suggested_category: str = ""

    model_config = {"from_attributes": True}


class ResolveRequest(BaseModel):
    review_status: str


class VerificationMetric(BaseModel):
    product_id: int
    product_name: str
    category_name: str
    ai_approach: str
    is_mismatch: bool
    confidence_score: float
    elapsed_seconds: float
    suggested_category: str = ""


class BatchResponse(BaseModel):
    processed: int
    results: list[VerificationMetric]
    total_elapsed_seconds: float


class HealthResponse(BaseModel):
    status: str
    env: str
    embedding_enabled: bool
    llm_enabled: bool


@app.get("/api/health", response_model=HealthResponse, tags=["System"])
def health_check():
    return HealthResponse(
        status="ok",
        env=settings.app_env,
        embedding_enabled=settings.enable_embedding_approach,
        llm_enabled=settings.enable_llm_approach,
    )


def _build_queue_response(item: CategoryReviewQueue, db: Session) -> QueueItemResponse:
    product = db.query(Product).filter(Product.id == item.product_id).first()
    category = db.query(Category).filter(Category.id == item.current_category_id).first()
    return QueueItemResponse(
        id=item.id,
        product_id=item.product_id,
        product_name=product.name if product else "Unknown",
        product_description=product.description if product else "",
        current_category_id=item.current_category_id,
        current_category_name=category.name if category else "Unknown",
        ai_approach=item.ai_approach,
        is_mismatch=item.is_mismatch,
        confidence_score=item.confidence_score,
        reason=item.reason,
        review_status=item.review_status,
        suggested_category=item.suggested_category,
    )


@app.get("/api/queue", response_model=list[QueueItemResponse], tags=["Review Queue"])
def get_queue(db: Session = Depends(get_db)):
    log.info("Fetching review queue (pending items)")

    items = (
        db.query(CategoryReviewQueue)
        .filter(CategoryReviewQueue.review_status == "pending")
        .order_by(CategoryReviewQueue.confidence_score.desc())
        .all()
    )

    results = [_build_queue_response(item, db) for item in items]
    log.info("Returning %d pending queue items", len(results))
    return results


@app.get("/api/queue/all", response_model=list[QueueItemResponse], tags=["Review Queue"])
def get_all_queue(db: Session = Depends(get_db)):
    log.info("Fetching all review queue items")

    items = (
        db.query(CategoryReviewQueue)
        .order_by(CategoryReviewQueue.confidence_score.desc())
        .all()
    )

    results = [_build_queue_response(item, db) for item in items]
    log.info("Returning %d total queue items", len(results))
    return results


@app.post("/api/verify-batch", response_model=BatchResponse, tags=["Verification"])
def verify_batch(db: Session = Depends(get_db)):
    log.info("Starting batch verification (batch_size=%d)", settings.batch_size)
    batch_start = time.time()

    products = db.query(Product).limit(settings.batch_size).all()
    log.info("Loaded %d products for verification", len(products))

    metrics: list[VerificationMetric] = []

    for product in products:
        category = db.query(Category).filter(Category.id == product.category_id).first()
        if not category:
            log.warning("Product %d has invalid category_id %d, skipping", product.id, product.category_id)
            continue

        log.debug("Verifying product %d: '%s' (category: '%s')", product.id, product.name, category.name)

        verification_results = agent.verify_product(product.name, product.description, category.name)

        for result in verification_results:
            existing = (
                db.query(CategoryReviewQueue)
                .filter(
                    CategoryReviewQueue.product_id == product.id,
                    CategoryReviewQueue.ai_approach == result.ai_approach,
                )
                .first()
            )

            if existing:
                existing.is_mismatch = result.is_mismatch
                existing.confidence_score = result.confidence_score
                existing.reason = result.reason
                existing.suggested_category = result.suggested_category
                existing.review_status = "pending"
                log.debug("Updated existing queue entry for product %d (%s)", product.id, result.ai_approach)
            else:
                queue_item = CategoryReviewQueue(
                    product_id=product.id,
                    current_category_id=product.category_id,
                    ai_approach=result.ai_approach,
                    is_mismatch=result.is_mismatch,
                    confidence_score=result.confidence_score,
                    reason=result.reason,
                    suggested_category=result.suggested_category,
                    review_status="pending",
                )
                db.add(queue_item)
                log.debug("Created new queue entry for product %d (%s)", product.id, result.ai_approach)

            metrics.append(VerificationMetric(
                product_id=product.id,
                product_name=product.name,
                category_name=category.name,
                ai_approach=result.ai_approach,
                is_mismatch=result.is_mismatch,
                confidence_score=result.confidence_score,
                elapsed_seconds=result.elapsed_seconds,
                suggested_category=result.suggested_category,
            ))

    db.commit()
    total_elapsed = round(time.time() - batch_start, 4)

    log.info(
        "Batch verification complete: %d products, %d results, %.2fs total",
        len(products), len(metrics), total_elapsed,
    )

    return BatchResponse(
        processed=len(products),
        results=metrics,
        total_elapsed_seconds=total_elapsed,
    )


@app.post("/api/queue/{item_id}/resolve", response_model=QueueItemResponse, tags=["Review Queue"])
def resolve_item(item_id: int, body: ResolveRequest, db: Session = Depends(get_db)):
    log.info("Resolving queue item %d with status '%s'", item_id, body.review_status)

    if body.review_status not in ("approved", "rejected"):
        raise HTTPException(status_code=400, detail="review_status must be 'approved' or 'rejected'")

    item = db.query(CategoryReviewQueue).filter(CategoryReviewQueue.id == item_id).first()
    if not item:
        raise HTTPException(status_code=404, detail=f"Queue item {item_id} not found")

    item.review_status = body.review_status
    db.commit()
    db.refresh(item)

    log.info("Queue item %d resolved as '%s'", item_id, body.review_status)

    return _build_queue_response(item, db)


@app.get("/api/products", tags=["Products"])
def get_products(db: Session = Depends(get_db)):
    products = db.query(Product).all()
    results = []
    for p in products:
        cat = db.query(Category).filter(Category.id == p.category_id).first()
        results.append({
            "id": p.id,
            "name": p.name,
            "description": p.description,
            "category_id": p.category_id,
            "category_name": cat.name if cat else "Unknown",
        })
    return results


@app.get("/api/categories", tags=["Products"])
def get_categories(db: Session = Depends(get_db)):
    return [{"id": c.id, "name": c.name} for c in db.query(Category).all()]