"""get_recent — cross-type recent-activity tool.

Returns the most-recently-touched notes, tasks, and projects for the user,
ordered by updated_at descending. Useful for Claude to bootstrap context at
the start of a conversation ("what was I working on?").

Aggregation is Python-side after two small per-table queries — simpler than
a UNION ALL with type-discriminating columns, and fine for personal-scale data.
"""
from __future__ import annotations

from datetime import datetime, timedelta, timezone

from sqlalchemy import select

from scribe.mcp._context import current_user_id
from scribe.models import async_session
from scribe.models.note import Note
from scribe.models.project import Project


async def get_recent(days: int = 7, limit: int = 25) -> dict:
    """Return recently-touched items across notes, tasks, and projects.

    Args:
        days: Look-back window in days (1-90).
        limit: Maximum number of items returned (1-100).

    Returns:
        {"items": [{"id", "type", "title", "updated_at"}], "total": int}
        Sorted by updated_at descending.

    Scope note: this spans ALL projects and takes no project filter. When a
    project is in scope, prefer list_tasks(project_id=...) /
    list_notes(project_id=...) so you don't surface other projects' activity.
    """
    uid = current_user_id()
    days = max(1, min(days, 90))
    limit = max(1, min(limit, 100))
    since = datetime.now(timezone.utc) - timedelta(days=days)
    items: list[dict] = []
    async with async_session() as session:
        notes = (await session.execute(
            select(Note).where(Note.user_id == uid, Note.updated_at >= since,
                               Note.deleted_at.is_(None))
            .order_by(Note.updated_at.desc()).limit(limit)
        )).scalars().all()
        for n in notes:
            items.append({
                "id": n.id,
                "type": "task" if n.is_task else "note",
                "title": n.title,
                "updated_at": n.updated_at.isoformat(),
            })
        projects = (await session.execute(
            select(Project).where(Project.user_id == uid,
                                  Project.updated_at >= since,
                                  Project.deleted_at.is_(None))
            .order_by(Project.updated_at.desc()).limit(limit)
        )).scalars().all()
        for p in projects:
            items.append({
                "id": p.id,
                "type": "project",
                "title": p.title,
                "updated_at": p.updated_at.isoformat(),
            })
    items.sort(key=lambda r: r["updated_at"], reverse=True)
    items = items[:limit]
    return {"items": items, "total": len(items)}


def register(mcp) -> None:
    mcp.tool(name="get_recent")(get_recent)
