ppt-tool/backend/api/v1/admin/analytics_router.py

"""Analytics endpoints for admin dashboard."""
import uuid
from datetime import datetime, timedelta, timezone
from typing import Optional

from fastapi import APIRouter, Depends, Query
from sqlalchemy import func, select, and_, case
from sqlalchemy.ext.asyncio import AsyncSession

from models.sql.presentation import PresentationModel
from models.sql.user import UserModel
from models.sql.audit_log import AuditLogModel
from models.sql.job import JobModel
from services.database import get_async_session
from utils.auth_dependencies import require_client_admin

ANALYTICS_ROUTER = APIRouter(tags=["Analytics"])


@ANALYTICS_ROUTER.get("/analytics/overview")
async def analytics_overview(
    client_id: Optional[uuid.UUID] = Query(None),
    current_user: UserModel = Depends(require_client_admin),
    session: AsyncSession = Depends(get_async_session),
):
    """Aggregated stats: total presentations, active users, etc."""
    now = datetime.now(timezone.utc)
    month_ago = now - timedelta(days=30)
    week_ago = now - timedelta(days=7)

    # Base query filter
    base = select(PresentationModel).where(PresentationModel.deleted_at.is_(None))
    if client_id:
        base = base.where(PresentationModel.client_id == client_id)

    # Total presentations
    total_q = select(func.count()).select_from(base.subquery())
    total = (await session.execute(total_q)).scalar() or 0

    # This month
    month_q = select(func.count()).select_from(
        base.where(PresentationModel.created_at >= month_ago).subquery()
    )
    this_month = (await session.execute(month_q)).scalar() or 0

    # This week
    week_q = select(func.count()).select_from(
        base.where(PresentationModel.created_at >= week_ago).subquery()
    )
    this_week = (await session.execute(week_q)).scalar() or 0

    # Active users (users who created presentations in last 30 days)
    active_q = select(func.count(func.distinct(PresentationModel.owner_id))).where(
        and_(
            PresentationModel.deleted_at.is_(None),
            PresentationModel.created_at >= month_ago,
            PresentationModel.owner_id.isnot(None),
        )
    )
    if client_id:
        active_q = active_q.where(PresentationModel.client_id == client_id)
    active_users = (await session.execute(active_q)).scalar() or 0

    # Approval rate
    reviewed_q = select(func.count()).where(
        and_(
            PresentationModel.deleted_at.is_(None),
            PresentationModel.status.in_(["approved", "in_review"]),
        )
    )
    approved_q = select(func.count()).where(
        and_(
            PresentationModel.deleted_at.is_(None),
            PresentationModel.status == "approved",
        )
    )
    if client_id:
        reviewed_q = reviewed_q.where(PresentationModel.client_id == client_id)
        approved_q = approved_q.where(PresentationModel.client_id == client_id)
    reviewed = (await session.execute(reviewed_q)).scalar() or 0
    approved = (await session.execute(approved_q)).scalar() or 0
    approval_rate = round((approved / reviewed * 100) if reviewed > 0 else 0, 1)

    return {
        "total_presentations": total,
        "this_month": this_month,
        "this_week": this_week,
        "active_users": active_users,
        "approval_rate": approval_rate,
    }


@ANALYTICS_ROUTER.get("/analytics/usage")
async def analytics_usage(
    client_id: Optional[uuid.UUID] = Query(None),
    days: int = Query(30, ge=7, le=90),
    current_user: UserModel = Depends(require_client_admin),
    session: AsyncSession = Depends(get_async_session),
):
    """Usage metrics: decks per day time series, top users."""
    now = datetime.now(timezone.utc)
    since = now - timedelta(days=days)

    # Decks per day
    daily_q = (
        select(
            func.date(PresentationModel.created_at).label("day"),
            func.count().label("count"),
        )
        .where(
            and_(
                PresentationModel.deleted_at.is_(None),
                PresentationModel.created_at >= since,
            )
        )
        .group_by(func.date(PresentationModel.created_at))
        .order_by(func.date(PresentationModel.created_at))
    )
    if client_id:
        daily_q = daily_q.where(PresentationModel.client_id == client_id)
    daily_result = await session.execute(daily_q)
    daily = [{"date": str(row.day), "count": row.count} for row in daily_result]

    # Top users
    top_users_q = (
        select(
            PresentationModel.owner_id,
            func.count().label("count"),
        )
        .where(
            and_(
                PresentationModel.deleted_at.is_(None),
                PresentationModel.owner_id.isnot(None),
                PresentationModel.created_at >= since,
            )
        )
        .group_by(PresentationModel.owner_id)
        .order_by(func.count().desc())
        .limit(10)
    )
    if client_id:
        top_users_q = top_users_q.where(PresentationModel.client_id == client_id)
    top_result = await session.execute(top_users_q)
    top_users = [
        {"user_id": str(row.owner_id), "count": row.count} for row in top_result
    ]

    return {
        "daily": daily,
        "top_users": top_users,
    }


@ANALYTICS_ROUTER.get("/analytics/quality")
async def analytics_quality(
    client_id: Optional[uuid.UUID] = Query(None),
    current_user: UserModel = Depends(require_client_admin),
    session: AsyncSession = Depends(get_async_session),
):
    """Quality metrics: status distribution, average comments."""
    base_filter = [PresentationModel.deleted_at.is_(None)]
    if client_id:
        base_filter.append(PresentationModel.client_id == client_id)

    # Status distribution
    status_q = (
        select(
            PresentationModel.status,
            func.count().label("count"),
        )
        .where(and_(*base_filter))
        .group_by(PresentationModel.status)
    )
    status_result = await session.execute(status_q)
    status_dist = {row.status or "draft": row.count for row in status_result}

    # Presentations with comments
    with_comments_q = select(func.count()).where(
        and_(
            *base_filter,
            PresentationModel.review_comment.isnot(None),
        )
    )
    with_comments = (await session.execute(with_comments_q)).scalar() or 0

    return {
        "status_distribution": status_dist,
        "presentations_with_comments": with_comments,
    }


@ANALYTICS_ROUTER.get("/analytics/performance")
async def analytics_performance(
    client_id: Optional[uuid.UUID] = Query(None),
    current_user: UserModel = Depends(require_client_admin),
    session: AsyncSession = Depends(get_async_session),
):
    """Performance metrics: job durations and error rates."""
    base_filter = []
    if client_id:
        # Jobs don't have client_id directly, so we join through presentations
        # For simplicity, return unfiltered job stats
        pass

    # Job status distribution
    job_status_q = (
        select(
            JobModel.status,
            func.count().label("count"),
        )
        .group_by(JobModel.status)
    )
    job_result = await session.execute(job_status_q)
    job_status = {row.status: row.count for row in job_result}

    # Average generation time (completed jobs only)
    avg_time_q = select(
        func.avg(
            func.extract("epoch", JobModel.completed_at)
            - func.extract("epoch", JobModel.started_at)
        )
    ).where(
        and_(
            JobModel.status == "completed",
            JobModel.started_at.isnot(None),
            JobModel.completed_at.isnot(None),
        )
    )
    avg_seconds = (await session.execute(avg_time_q)).scalar()
    avg_generation_time = round(avg_seconds, 1) if avg_seconds else None

    # Error rate
    total_jobs = sum(job_status.values()) if job_status else 0
    failed_jobs = job_status.get("failed", 0)
    error_rate = round((failed_jobs / total_jobs * 100) if total_jobs > 0 else 0, 1)

    return {
        "job_status_distribution": job_status,
        "avg_generation_time_seconds": avg_generation_time,
        "error_rate": error_rate,
        "total_jobs": total_jobs,
    }