from datetime import datetime, timedelta, timezone

from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy import case, distinct, func, select
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.dependencies import require_admin
from app.core.security import hash_password
from app.database.session import get_db
from app.models.project import Project
from app.models.usage_event import UsageEvent
from app.models.user import User
from app.schemas.admin import (
    AdminProjectResponse,
    AdminSetupRequest,
    AdminUserResponse,
    AdminUserUpdateRequest,
    BoardBreakdown,
    BoardDiversityBucket,
    BoardDiversityResponse,
    BoardsResponse,
    CountriesResponse,
    CountryEntry,
    DailyProjectActivity,
    DailyTotals,
    OverviewResponse,
    ProjectMetricsResponse,
    TimeseriesPoint,
    TimeseriesResponse,
    TopProjectEntry,
    TopUserEntry,
    UserDailyActivityResponse,
    UserMetricsResponse,
)
from app.utils.slug import is_valid_username

router = APIRouter()


def _now() -> datetime:
    return datetime.now(timezone.utc)


# ── Setup ─────────────────────────────────────────────────────────────────────

@router.get("/setup/status")
async def setup_status(db: AsyncSession = Depends(get_db)):
    """Check whether any admin user exists."""
    result = await db.execute(select(User).where(User.is_admin == True))  # noqa: E712
    has_admin = result.scalar_one_or_none() is not None
    return {"has_admin": has_admin}


@router.post("/setup", response_model=AdminUserResponse, status_code=status.HTTP_201_CREATED)
async def setup_admin(body: AdminSetupRequest, db: AsyncSession = Depends(get_db)):
    """Create the first admin user. Fails if an admin already exists."""
    existing_admin = await db.execute(select(User).where(User.is_admin == True))  # noqa: E712
    if existing_admin.scalar_one_or_none():
        raise HTTPException(status_code=400, detail="Admin already configured.")

    username = body.username.lower().strip()
    if not is_valid_username(username):
        raise HTTPException(
            status_code=400,
            detail="Username must be 3-30 chars, only lowercase letters/numbers/underscores/hyphens.",
        )
    if len(body.password) < 8:
        raise HTTPException(status_code=400, detail="Password must be at least 8 characters.")

    # Check uniqueness
    conflict = await db.execute(
        select(User).where((User.username == username) | (User.email == body.email))
    )
    if conflict.scalar_one_or_none():
        raise HTTPException(status_code=400, detail="Username or email already taken.")

    user = User(
        username=username,
        email=body.email,
        hashed_password=hash_password(body.password),
        is_admin=True,
        is_active=True,
    )
    db.add(user)
    await db.commit()
    await db.refresh(user)

    return await _user_with_metrics(db, user)


# ── Users ─────────────────────────────────────────────────────────────────────

async def _user_with_metrics(db: AsyncSession, user: User) -> AdminUserResponse:
    count_result = await db.execute(
        select(func.count()).where(Project.user_id == user.id)
    )
    project_count = count_result.scalar() or 0

    boards_result = await db.execute(
        select(distinct(UsageEvent.board_family))
        .where(UsageEvent.user_id == user.id, UsageEvent.board_family.is_not(None))
    )
    boards_used = [b for b in boards_result.scalars().all() if b]

    return AdminUserResponse(
        id=user.id,
        username=user.username,
        email=user.email,
        avatar_url=user.avatar_url,
        is_active=user.is_active,
        is_admin=user.is_admin,
        created_at=user.created_at,
        project_count=project_count,
        total_compiles=user.total_compiles,
        total_compile_errors=user.total_compile_errors,
        total_runs=user.total_runs,
        last_active_at=user.last_active_at,
        boards_used=boards_used,
        signup_country=user.signup_country,
        last_country=user.last_country,
    )


@router.get("/users", response_model=list[AdminUserResponse])
async def list_users(
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    result = await db.execute(select(User).order_by(User.created_at.desc()))
    users = result.scalars().all()
    return [await _user_with_metrics(db, u) for u in users]


@router.get("/users/{user_id}", response_model=AdminUserResponse)
async def get_user(
    user_id: str,
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    result = await db.execute(select(User).where(User.id == user_id))
    user = result.scalar_one_or_none()
    if not user:
        raise HTTPException(status_code=404, detail="User not found.")
    return await _user_with_metrics(db, user)


@router.put("/users/{user_id}", response_model=AdminUserResponse)
async def update_user(
    user_id: str,
    body: AdminUserUpdateRequest,
    db: AsyncSession = Depends(get_db),
    admin: User = Depends(require_admin),
):
    result = await db.execute(select(User).where(User.id == user_id))
    user = result.scalar_one_or_none()
    if not user:
        raise HTTPException(status_code=404, detail="User not found.")

    if body.username is not None:
        new_username = body.username.lower().strip()
        if not is_valid_username(new_username):
            raise HTTPException(status_code=400, detail="Invalid username format.")
        if new_username != user.username:
            conflict = await db.execute(select(User).where(User.username == new_username))
            if conflict.scalar_one_or_none():
                raise HTTPException(status_code=400, detail="Username already taken.")
        user.username = new_username

    if body.email is not None:
        if body.email != user.email:
            conflict = await db.execute(select(User).where(User.email == body.email))
            if conflict.scalar_one_or_none():
                raise HTTPException(status_code=400, detail="Email already in use.")
        user.email = body.email

    if body.password is not None:
        if len(body.password) < 8:
            raise HTTPException(status_code=400, detail="Password must be at least 8 characters.")
        user.hashed_password = hash_password(body.password)

    if body.is_active is not None:
        user.is_active = body.is_active

    if body.is_admin is not None:
        # Prevent removing admin from yourself
        if user.id == admin.id and not body.is_admin:
            raise HTTPException(status_code=400, detail="Cannot remove your own admin privileges.")
        user.is_admin = body.is_admin

    await db.commit()
    await db.refresh(user)
    return await _user_with_metrics(db, user)


@router.delete("/users/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_user(
    user_id: str,
    db: AsyncSession = Depends(get_db),
    admin: User = Depends(require_admin),
):
    result = await db.execute(select(User).where(User.id == user_id))
    user = result.scalar_one_or_none()
    if not user:
        raise HTTPException(status_code=404, detail="User not found.")
    if user.id == admin.id:
        raise HTTPException(status_code=400, detail="Cannot delete your own account.")

    # Delete all user's projects first
    projects_result = await db.execute(select(Project).where(Project.user_id == user_id))
    for project in projects_result.scalars().all():
        await db.delete(project)

    await db.delete(user)
    await db.commit()


# ── Projects ──────────────────────────────────────────────────────────────────

def _project_to_response(project: Project, owner_username: str) -> AdminProjectResponse:
    return AdminProjectResponse(
        id=project.id,
        name=project.name,
        slug=project.slug,
        description=project.description,
        is_public=project.is_public,
        board_type=project.board_type,
        owner_username=owner_username,
        owner_id=project.user_id,
        created_at=project.created_at,
        updated_at=project.updated_at,
        compile_count=project.compile_count,
        compile_error_count=project.compile_error_count,
        run_count=project.run_count,
        update_count=project.update_count,
        last_compiled_at=project.last_compiled_at,
        last_run_at=project.last_run_at,
    )


@router.get("/projects", response_model=list[AdminProjectResponse])
async def list_all_projects(
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    result = await db.execute(
        select(Project, User.username)
        .join(User, User.id == Project.user_id)
        .order_by(Project.created_at.desc())
    )
    rows = result.all()
    return [_project_to_response(project, username) for project, username in rows]


@router.delete("/projects/{project_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_project(
    project_id: str,
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    result = await db.execute(select(Project).where(Project.id == project_id))
    project = result.scalar_one_or_none()
    if not project:
        raise HTTPException(status_code=404, detail="Project not found.")
    await db.delete(project)
    await db.commit()


# ── Metrics dashboard ─────────────────────────────────────────────────────────

@router.get("/metrics/overview", response_model=OverviewResponse)
async def metrics_overview(
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    now = _now()
    day_ago = now - timedelta(days=1)
    week_ago = now - timedelta(days=7)
    month_ago = now - timedelta(days=30)

    total_users = (await db.execute(select(func.count(User.id)))).scalar() or 0
    total_projects = (await db.execute(select(func.count(Project.id)))).scalar() or 0
    public_projects = (
        await db.execute(select(func.count(Project.id)).where(Project.is_public == True))  # noqa: E712
    ).scalar() or 0

    total_compiles = (await db.execute(select(func.coalesce(func.sum(User.total_compiles), 0)))).scalar() or 0
    total_compile_errors = (
        await db.execute(select(func.coalesce(func.sum(User.total_compile_errors), 0)))
    ).scalar() or 0
    total_runs = (await db.execute(select(func.coalesce(func.sum(User.total_runs), 0)))).scalar() or 0

    success = max(total_compiles - total_compile_errors, 0)
    success_rate = (success / total_compiles) if total_compiles else 0.0

    dau = (
        await db.execute(
            select(func.count(distinct(User.id))).where(User.last_active_at >= day_ago)
        )
    ).scalar() or 0
    wau = (
        await db.execute(
            select(func.count(distinct(User.id))).where(User.last_active_at >= week_ago)
        )
    ).scalar() or 0
    mau = (
        await db.execute(
            select(func.count(distinct(User.id))).where(User.last_active_at >= month_ago)
        )
    ).scalar() or 0

    new_users_30d = (
        await db.execute(select(func.count(User.id)).where(User.created_at >= month_ago))
    ).scalar() or 0
    new_projects_30d = (
        await db.execute(select(func.count(Project.id)).where(Project.created_at >= month_ago))
    ).scalar() or 0

    return OverviewResponse(
        total_users=total_users,
        total_projects=total_projects,
        public_projects=public_projects,
        private_projects=total_projects - public_projects,
        total_compiles=total_compiles,
        total_compile_errors=total_compile_errors,
        total_runs=total_runs,
        compile_success_rate=round(success_rate, 4),
        dau=dau,
        wau=wau,
        mau=mau,
        new_users_30d=new_users_30d,
        new_projects_30d=new_projects_30d,
    )


_VALID_METRICS = {"compile", "compile_error", "run", "save", "create", "project_open"}
_VALID_BUCKETS = {"hour", "day", "week"}


@router.get("/metrics/timeseries", response_model=TimeseriesResponse)
async def metrics_timeseries(
    metric: str = Query("compile"),
    range_days: int = Query(30, ge=1, le=365),
    bucket: str = Query("day"),
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    if metric not in _VALID_METRICS:
        raise HTTPException(status_code=400, detail=f"metric must be one of {sorted(_VALID_METRICS)}")
    if bucket not in _VALID_BUCKETS:
        raise HTTPException(status_code=400, detail=f"bucket must be one of {sorted(_VALID_BUCKETS)}")

    since = _now() - timedelta(days=range_days)

    # SQLite-compatible time bucketing via strftime
    if bucket == "hour":
        fmt = "%Y-%m-%d %H:00"
    elif bucket == "week":
        fmt = "%Y-%W"
    else:
        fmt = "%Y-%m-%d"

    bucket_expr = func.strftime(fmt, UsageEvent.created_at).label("bucket")
    result = await db.execute(
        select(bucket_expr, func.count(UsageEvent.id))
        .where(UsageEvent.event_type == metric, UsageEvent.created_at >= since)
        .group_by(bucket_expr)
        .order_by(bucket_expr)
    )
    points = [TimeseriesPoint(bucket=row[0], value=row[1]) for row in result.all()]
    return TimeseriesResponse(metric=metric, bucket=bucket, range_days=range_days, points=points)


@router.get("/metrics/boards", response_model=BoardsResponse)
async def metrics_boards(
    range_days: int = Query(90, ge=1, le=365),
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    since = _now() - timedelta(days=range_days)

    async def _agg(group_col):
        compile_subq = (
            select(
                group_col.label("g"),
                func.count(UsageEvent.id).label("compile_count"),
                func.sum(
                    case((UsageEvent.event_type == "compile_error", 1), else_=0)
                ).label("compile_error_count"),
                func.count(distinct(UsageEvent.user_id)).label("distinct_users"),
                func.count(distinct(UsageEvent.project_id)).label("distinct_projects"),
            )
            .where(
                UsageEvent.event_type.in_(("compile", "compile_error")),
                UsageEvent.created_at >= since,
                group_col.is_not(None),
            )
            .group_by(group_col)
            .subquery()
        )

        run_subq = (
            select(
                group_col.label("g"),
                func.count(UsageEvent.id).label("run_count"),
            )
            .where(
                UsageEvent.event_type == "run",
                UsageEvent.created_at >= since,
                group_col.is_not(None),
            )
            .group_by(group_col)
            .subquery()
        )

        rows = (
            await db.execute(
                select(
                    compile_subq.c.g,
                    compile_subq.c.compile_count,
                    compile_subq.c.compile_error_count,
                    func.coalesce(run_subq.c.run_count, 0),
                    compile_subq.c.distinct_users,
                    compile_subq.c.distinct_projects,
                ).outerjoin(run_subq, compile_subq.c.g == run_subq.c.g)
            )
        ).all()
        return rows

    family_rows = await _agg(UsageEvent.board_family)
    fqbn_rows = await _agg(UsageEvent.board_fqbn)

    families = [
        BoardBreakdown(
            board_family=row[0],
            board_fqbn=None,
            compile_count=row[1] or 0,
            compile_error_count=row[2] or 0,
            run_count=row[3] or 0,
            distinct_users=row[4] or 0,
            distinct_projects=row[5] or 0,
        )
        for row in family_rows
    ]
    fqbns = [
        BoardBreakdown(
            board_family=None,
            board_fqbn=row[0],
            compile_count=row[1] or 0,
            compile_error_count=row[2] or 0,
            run_count=row[3] or 0,
            distinct_users=row[4] or 0,
            distinct_projects=row[5] or 0,
        )
        for row in fqbn_rows
    ]

    families.sort(key=lambda b: b.compile_count, reverse=True)
    fqbns.sort(key=lambda b: b.compile_count, reverse=True)

    return BoardsResponse(families=families, fqbns=fqbns)


@router.get("/metrics/board-diversity", response_model=BoardDiversityResponse)
async def metrics_board_diversity(
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    """How many distinct board families each user has compiled.

    Critical signal for freemium tiering: users sticking to one board are
    cheap to serve; multi-board users likely warrant paid tiers.
    """
    per_user = (
        select(
            UsageEvent.user_id,
            func.count(distinct(UsageEvent.board_family)).label("n"),
        )
        .where(
            UsageEvent.event_type.in_(("compile", "compile_error")),
            UsageEvent.user_id.is_not(None),
            UsageEvent.board_family.is_not(None),
        )
        .group_by(UsageEvent.user_id)
        .subquery()
    )
    rows = (await db.execute(select(per_user.c.n))).scalars().all()

    buckets = {"1": 0, "2": 0, "3+": 0}
    for n in rows:
        if n <= 1:
            buckets["1"] += 1
        elif n == 2:
            buckets["2"] += 1
        else:
            buckets["3+"] += 1

    return BoardDiversityResponse(
        buckets=[BoardDiversityBucket(bucket=k, user_count=v) for k, v in buckets.items()],
        total_users_with_compiles=len(rows),
    )


_VALID_TOP_METRICS = {"compiles": User.total_compiles, "runs": User.total_runs}


@router.get("/metrics/top-users", response_model=list[TopUserEntry])
async def metrics_top_users(
    metric: str = Query("compiles"),
    limit: int = Query(20, ge=1, le=100),
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    if metric not in _VALID_TOP_METRICS:
        raise HTTPException(status_code=400, detail="metric must be 'compiles' or 'runs'")
    col = _VALID_TOP_METRICS[metric]
    rows = (
        await db.execute(
            select(User.id, User.username, col)
            .where(col > 0)
            .order_by(col.desc())
            .limit(limit)
        )
    ).all()
    return [TopUserEntry(user_id=r[0], username=r[1], value=r[2] or 0) for r in rows]


_VALID_TOP_PROJECT_METRICS = {
    "compiles": Project.compile_count,
    "runs": Project.run_count,
    "updates": Project.update_count,
}


@router.get("/metrics/top-projects", response_model=list[TopProjectEntry])
async def metrics_top_projects(
    metric: str = Query("compiles"),
    limit: int = Query(20, ge=1, le=100),
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    if metric not in _VALID_TOP_PROJECT_METRICS:
        raise HTTPException(status_code=400, detail="metric must be 'compiles', 'runs' or 'updates'")
    col = _VALID_TOP_PROJECT_METRICS[metric]
    rows = (
        await db.execute(
            select(Project.id, Project.name, User.username, col)
            .join(User, User.id == Project.user_id)
            .where(col > 0)
            .order_by(col.desc())
            .limit(limit)
        )
    ).all()
    return [
        TopProjectEntry(project_id=r[0], project_name=r[1], owner_username=r[2], value=r[3] or 0)
        for r in rows
    ]


@router.get("/metrics/users/{user_id}", response_model=UserMetricsResponse)
async def metrics_for_user(
    user_id: str,
    range_days: int = Query(30, ge=1, le=365),
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    user = (await db.execute(select(User).where(User.id == user_id))).scalar_one_or_none()
    if not user:
        raise HTTPException(status_code=404, detail="User not found.")

    boards = [
        b for b in (
            await db.execute(
                select(distinct(UsageEvent.board_family)).where(
                    UsageEvent.user_id == user_id, UsageEvent.board_family.is_not(None)
                )
            )
        ).scalars().all() if b
    ]
    fqbns = [
        f for f in (
            await db.execute(
                select(distinct(UsageEvent.board_fqbn)).where(
                    UsageEvent.user_id == user_id, UsageEvent.board_fqbn.is_not(None)
                )
            )
        ).scalars().all() if f
    ]
    project_count = (
        await db.execute(select(func.count(Project.id)).where(Project.user_id == user_id))
    ).scalar() or 0

    since = _now() - timedelta(days=range_days)
    bucket_expr = func.strftime("%Y-%m-%d", UsageEvent.created_at).label("bucket")
    rows = (
        await db.execute(
            select(bucket_expr, func.count(UsageEvent.id))
            .where(
                UsageEvent.user_id == user_id,
                UsageEvent.event_type == "compile",
                UsageEvent.created_at >= since,
            )
            .group_by(bucket_expr)
            .order_by(bucket_expr)
        )
    ).all()

    return UserMetricsResponse(
        user_id=user.id,
        username=user.username,
        total_compiles=user.total_compiles,
        total_compile_errors=user.total_compile_errors,
        total_runs=user.total_runs,
        last_active_at=user.last_active_at,
        boards_used=boards,
        fqbns_used=fqbns,
        project_count=project_count,
        timeseries=[TimeseriesPoint(bucket=r[0], value=r[1]) for r in rows],
    )


@router.get("/metrics/countries", response_model=CountriesResponse)
async def metrics_countries(
    range_days: int = Query(90, ge=1, le=365),
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    """Per-country breakdown.

    Combines two views:
      - User-table: how many users currently set to each country (last_country)
        and how many signed up from there (signup_country).
      - UsageEvent: compile/run volume + distinct active users per country
        within the requested range.
    """
    since = _now() - timedelta(days=range_days)

    # Per-country compile / run / distinct-user from events
    event_rows = (
        await db.execute(
            select(
                UsageEvent.country,
                func.sum(
                    case(
                        (UsageEvent.event_type.in_(("compile", "compile_error")), 1),
                        else_=0,
                    )
                ).label("compiles"),
                func.sum(
                    case((UsageEvent.event_type == "run", 1), else_=0)
                ).label("runs"),
                func.count(distinct(UsageEvent.user_id)).label("active_users"),
            )
            .where(UsageEvent.created_at >= since)
            .group_by(UsageEvent.country)
        )
    ).all()

    # User-table aggregates (all-time, not range-bound)
    last_rows = (
        await db.execute(
            select(User.last_country, func.count(User.id))
            .group_by(User.last_country)
        )
    ).all()
    signup_rows = (
        await db.execute(
            select(User.signup_country, func.count(User.id))
            .group_by(User.signup_country)
        )
    ).all()

    last_map = {row[0]: row[1] for row in last_rows}
    signup_map = {row[0]: row[1] for row in signup_rows}

    # Union all keys we've seen
    all_keys = (
        {row[0] for row in event_rows}
        | set(last_map.keys())
        | set(signup_map.keys())
    )

    event_map = {row[0]: row for row in event_rows}
    entries: list[CountryEntry] = []
    for key in all_keys:
        evt = event_map.get(key)
        entries.append(
            CountryEntry(
                country=key,
                user_count=last_map.get(key, 0),
                signup_count=signup_map.get(key, 0),
                compile_count=int(evt[1] or 0) if evt else 0,
                run_count=int(evt[2] or 0) if evt else 0,
                distinct_users_active=int(evt[3] or 0) if evt else 0,
            )
        )

    # Sort by total signal (users + active + compiles) descending
    entries.sort(
        key=lambda e: (e.user_count + e.distinct_users_active, e.compile_count),
        reverse=True,
    )

    return CountriesResponse(range_days=range_days, entries=entries)


@router.get(
    "/metrics/users/{user_id}/activity",
    response_model=UserDailyActivityResponse,
)
async def metrics_user_daily_activity(
    user_id: str,
    range_days: int = Query(30, ge=1, le=365),
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    """Per-day, per-project breakdown of one user's activity.

    Returns one row per (day, project) tuple plus a flat per-day totals
    list. Useful for answering "which projects did Alice work on
    yesterday and how many times did she compile each?".
    """
    user = (await db.execute(select(User).where(User.id == user_id))).scalar_one_or_none()
    if not user:
        raise HTTPException(status_code=404, detail="User not found.")

    since = _now() - timedelta(days=range_days)
    bucket = func.strftime("%Y-%m-%d", UsageEvent.created_at).label("day")

    # Per-(day, project) counts
    rows = (
        await db.execute(
            select(
                bucket,
                UsageEvent.project_id,
                func.sum(
                    case((UsageEvent.event_type == "compile", 1), else_=0)
                ).label("compiles"),
                func.sum(
                    case((UsageEvent.event_type == "compile_error", 1), else_=0)
                ).label("compile_errors"),
                func.sum(
                    case((UsageEvent.event_type == "run", 1), else_=0)
                ).label("runs"),
                func.sum(
                    case((UsageEvent.event_type == "save", 1), else_=0)
                ).label("saves"),
            )
            .where(UsageEvent.user_id == user_id, UsageEvent.created_at >= since)
            .group_by(bucket, UsageEvent.project_id)
            .order_by(bucket.desc(), func.sum(
                case((UsageEvent.event_type == "compile", 1), else_=0)
            ).desc())
        )
    ).all()

    # Resolve project names in one query (avoid N+1)
    project_ids = {r[1] for r in rows if r[1] is not None}
    name_map: dict[str, str] = {}
    if project_ids:
        proj_rows = (
            await db.execute(
                select(Project.id, Project.name).where(Project.id.in_(project_ids))
            )
        ).all()
        name_map = {pid: name for pid, name in proj_rows}

    entries = [
        DailyProjectActivity(
            date=row[0],
            project_id=row[1],
            project_name=name_map.get(row[1]) if row[1] else None,
            compiles=int(row[2] or 0),
            compile_errors=int(row[3] or 0),
            runs=int(row[4] or 0),
            saves=int(row[5] or 0),
        )
        for row in rows
    ]

    # Roll up to per-day totals
    totals_rows = (
        await db.execute(
            select(
                bucket,
                func.sum(
                    case((UsageEvent.event_type == "compile", 1), else_=0)
                ).label("compiles"),
                func.sum(
                    case((UsageEvent.event_type == "compile_error", 1), else_=0)
                ).label("compile_errors"),
                func.sum(
                    case((UsageEvent.event_type == "run", 1), else_=0)
                ).label("runs"),
                func.sum(
                    case((UsageEvent.event_type == "save", 1), else_=0)
                ).label("saves"),
                func.count(distinct(UsageEvent.project_id)).label("distinct_projects"),
            )
            .where(UsageEvent.user_id == user_id, UsageEvent.created_at >= since)
            .group_by(bucket)
            .order_by(bucket.desc())
        )
    ).all()

    daily_totals = [
        DailyTotals(
            date=row[0],
            compiles=int(row[1] or 0),
            compile_errors=int(row[2] or 0),
            runs=int(row[3] or 0),
            saves=int(row[4] or 0),
            distinct_projects=int(row[5] or 0),
        )
        for row in totals_rows
    ]

    return UserDailyActivityResponse(
        user_id=user.id,
        username=user.username,
        range_days=range_days,
        entries=entries,
        daily_totals=daily_totals,
    )


@router.get("/metrics/projects/{project_id}", response_model=ProjectMetricsResponse)
async def metrics_for_project(
    project_id: str,
    range_days: int = Query(30, ge=1, le=365),
    db: AsyncSession = Depends(get_db),
    _admin: User = Depends(require_admin),
):
    project = (await db.execute(select(Project).where(Project.id == project_id))).scalar_one_or_none()
    if not project:
        raise HTTPException(status_code=404, detail="Project not found.")
    owner = (await db.execute(select(User).where(User.id == project.user_id))).scalar_one_or_none()

    since = _now() - timedelta(days=range_days)
    bucket_expr = func.strftime("%Y-%m-%d", UsageEvent.created_at).label("bucket")
    rows = (
        await db.execute(
            select(bucket_expr, func.count(UsageEvent.id))
            .where(
                UsageEvent.project_id == project_id,
                UsageEvent.event_type == "compile",
                UsageEvent.created_at >= since,
            )
            .group_by(bucket_expr)
            .order_by(bucket_expr)
        )
    ).all()

    return ProjectMetricsResponse(
        project_id=project.id,
        project_name=project.name,
        owner_username=owner.username if owner else "",
        compile_count=project.compile_count,
        compile_error_count=project.compile_error_count,
        run_count=project.run_count,
        update_count=project.update_count,
        last_compiled_at=project.last_compiled_at,
        last_run_at=project.last_run_at,
        timeseries=[TimeseriesPoint(bucket=r[0], value=r[1]) for r in rows],
    )