"""FlowDeck — Notifications API (v4.9.0 collaboration)."""
from __future__ import annotations

import logging

from fastapi import APIRouter, Body, HTTPException, Request

from app.auth.session import SessionManager
from app.db import get_conn

logger = logging.getLogger(__name__)
router = APIRouter(tags=["notifications"], prefix="/api/notifications")


def _current_user(request: Request) -> dict:
    user = SessionManager.decode_session(request.cookies.get("flowdeck_session", ""))
    if not user or not user.get("id"):
        raise HTTPException(status_code=401, detail="Authentication required")
    return user


@router.get("")
def list_notifications(request: Request, limit: int = 50):
    """List the current user's notifications, newest first."""
    user = _current_user(request)
    with get_conn() as conn:
        rows = conn.execute(
            """SELECT n.*, a.login AS actor_login, a.full_name AS actor_name,
                      a.avatar_url AS actor_avatar, a.avatar_color AS actor_color
               FROM notifications n
               LEFT JOIN users a ON n.actor_id = a.id
               WHERE n.user_id=?
               ORDER BY n.created_at DESC, n.id DESC LIMIT ?""",
            (user["id"], limit),
        ).fetchall()
        unread = conn.execute(
            "SELECT COUNT(*) AS c FROM notifications WHERE user_id=? AND is_read=0",
            (user["id"],),
        ).fetchone()["c"]
    return {
        "notifications": [dict(r) for r in rows],
        "unread": unread,
    }


@router.get("/unread-count")
def unread_count(request: Request):
    """Unread count for the topbar badge."""
    user = _current_user(request)
    with get_conn() as conn:
        c = conn.execute(
            "SELECT COUNT(*) AS c FROM notifications WHERE user_id=? AND is_read=0",
            (user["id"],),
        ).fetchone()["c"]
    return {"unread": c}


@router.post("/read")
def mark_read(request: Request, body: dict = Body(default={})):
    """Mark one notification as read (id) or all (id omitted)."""
    user = _current_user(request)
    nid = body.get("id")
    with get_conn() as conn:
        if nid:
            conn.execute(
                "UPDATE notifications SET is_read=1 WHERE id=? AND user_id=?",
                (nid, user["id"]),
            )
        else:
            conn.execute(
                "UPDATE notifications SET is_read=1 WHERE user_id=?",
                (user["id"],),
            )
        conn.commit()
    return {"status": "ok"}


@router.post("/read-all")
async def mark_all_read(request: Request):
    """Mark all notifications as read."""
    return await mark_read(request)


@router.get("/prefs")
def get_prefs(request: Request):
    """Return the current user's notification email preferences."""
    user = _current_user(request)
    from app.services import notifications as notif
    return {"prefs": notif.get_user_prefs(user["id"])}


@router.post("/prefs")
def set_prefs(request: Request, body: dict = Body(default={})):
    """Update the current user's notification email preferences."""
    user = _current_user(request)
    from app.services import notifications as notif
    prefs = notif.get_user_prefs(user["id"])
    for key in ("comments", "mentions", "reminders", "assignments"):
        if key in body:
            prefs[key] = bool(body[key])
    notif.set_user_prefs(user["id"], prefs)
    return {"status": "ok", "prefs": prefs}


@router.get("/timezone")
def get_timezone(request: Request):
    """Return the current user's IANA timezone ('' = UTC)."""
    user = _current_user(request)
    with get_conn() as conn:
        row = conn.execute("SELECT timezone FROM users WHERE id=?", (user["id"],)).fetchone()
    tz = (row["timezone"] if row and "timezone" in row.keys() else "") or ""
    from app.services.recurrence import common_timezones
    return {"timezone": tz, "zones": common_timezones()}


@router.post("/timezone")
def set_timezone(request: Request, body: dict = Body(default={})):
    """Update the current user's IANA timezone (empty string = UTC)."""
    user = _current_user(request)
    tz = (body.get("timezone") or "").strip()
    from app.services.recurrence import is_valid_timezone
    if tz and not is_valid_timezone(tz):
        raise HTTPException(status_code=400, detail=f"Unknown timezone '{tz}'")
    with get_conn() as conn:
        conn.execute("UPDATE users SET timezone=? WHERE id=?", (tz, user["id"]))
        conn.commit()
    return {"status": "ok", "timezone": tz}


@router.get("/users/search")
def search_users(request: Request, q: str = ""):
    """User autocomplete for @mentions."""
    _current_user(request)
    q = (q or "").strip()
    with get_conn() as conn:
        if q:
            like = f"%{q}%"
            rows = conn.execute(
                """SELECT id, login, full_name, avatar_url, avatar_color
                   FROM users WHERE login LIKE ? OR full_name LIKE ?
                   ORDER BY (login=? OR full_name=?) DESC, login LIMIT 20""",
                (like, like, q, q),
            ).fetchall()
        else:
            rows = conn.execute(
                """SELECT id, login, full_name, avatar_url, avatar_color
                   FROM users ORDER BY login LIMIT 20"""
            ).fetchall()
    return {"users": [dict(r) for r in rows]}