admin / Synapse-Cortex

import uuid
from typing import Optional

from fastapi import APIRouter, Depends, Request
from fastapi.responses import HTMLResponse, RedirectResponse
from fastapi.templating import Jinja2Templates
from sqlalchemy.orm import Session

from .. import models
from ..database import get_db
from ..deps import get_session_user
from ..paths import TEMPLATES_DIR
from ..queries import (
    QUEUE_FILTERS,
    TICKET_SORTS,
    apply_queue_filter,
    apply_ticket_search,
    apply_ticket_sort,
    queue_counts,
    tenant_tickets,
)

router = APIRouter()
templates = Jinja2Templates(directory=str(TEMPLATES_DIR))


def _agents_for_tenant(db: Session, tenant_id: uuid.UUID):
    return (
        db.query(models.User)
        .filter(
            models.User.tenant_id == tenant_id,
            models.User.role.in_(
                [models.UserRole.AGENT, models.UserRole.TENANT_ADMIN, models.UserRole.GLOBAL_ADMIN]
            ),
        )
        .order_by(models.User.full_name)
        .all()
    )


def _asset_types_for_tenant(db: Session, tenant_id: uuid.UUID):
    return (
        db.query(models.AssetTypeOption)
        .filter(models.AssetTypeOption.tenant_id == tenant_id)
        .order_by(models.AssetTypeOption.name)
        .all()
    )


@router.get("/", response_class=HTMLResponse)
def dashboard(request: Request, db: Session = Depends(get_db), user=Depends(get_session_user)):
    if not user:
        return RedirectResponse("/login", status_code=303)

    tenant_id = user.tenant_id
    tickets = tenant_tickets(db, tenant_id).order_by(models.Ticket.created_at.desc()).limit(25).all()

    return templates.TemplateResponse(
        "dashboard.html",
        {
            "request": request,
            "user": user,
            "active": "dashboard",
            "queue": queue_counts(db, tenant_id),
            "tickets": tickets,
        },
    )


@router.get("/tickets", response_class=HTMLResponse)
def tickets_page(
    request: Request,
    filter: Optional[str] = None,
    q: Optional[str] = None,
    sort: Optional[str] = None,
    db: Session = Depends(get_db),
    user=Depends(get_session_user),
):
    if not user:
        return RedirectResponse("/login", status_code=303)

    query = tenant_tickets(db, user.tenant_id)
    active_filter = filter if filter in QUEUE_FILTERS else None
    if active_filter:
        query = apply_queue_filter(query, active_filter)

    search_text = (q or "").strip()
    if search_text:
        query = apply_ticket_search(query, search_text)

    active_sort = sort if sort in TICKET_SORTS else "newest"
    query, python_sort_key = apply_ticket_sort(query, active_sort)

    tickets = query.all()
    if python_sort_key:
        tickets = sorted(tickets, key=python_sort_key)

    assets = (
        db.query(models.Asset)
        .filter(models.Asset.tenant_id == user.tenant_id)
        .order_by(models.Asset.name)
        .all()
    )
    agents = _agents_for_tenant(db, user.tenant_id)
    return templates.TemplateResponse(
        "tickets.html",
        {
            "request": request,
            "user": user,
            "active": "tickets",
            "tickets": tickets,
            "assets": assets,
            "agents": agents,
            "active_filter": active_filter,
            "search_text": search_text,
            "active_sort": active_sort,
        },
    )


@router.get("/tickets/{ticket_id}", response_class=HTMLResponse)
def ticket_detail_page(
    ticket_id: uuid.UUID,
    request: Request,
    db: Session = Depends(get_db),
    user=Depends(get_session_user),
):
    if not user:
        return RedirectResponse("/login", status_code=303)

    ticket = (
        db.query(models.Ticket)
        .filter(models.Ticket.id == ticket_id, models.Ticket.tenant_id == user.tenant_id)
        .first()
    )
    if not ticket:
        return RedirectResponse("/tickets", status_code=303)

    assets = (
        db.query(models.Asset)
        .filter(models.Asset.tenant_id == user.tenant_id)
        .order_by(models.Asset.name)
        .all()
    )
    agents = _agents_for_tenant(db, user.tenant_id)
    return templates.TemplateResponse(
        "ticket_detail.html",
        {
            "request": request,
            "user": user,
            "active": "tickets",
            "ticket": ticket,
            "assets": assets,
            "agents": agents,
        },
    )


@router.get("/assets", response_class=HTMLResponse)
def assets_page(request: Request, db: Session = Depends(get_db), user=Depends(get_session_user)):
    if not user:
        return RedirectResponse("/login", status_code=303)

    assets = (
        db.query(models.Asset)
        .filter(models.Asset.tenant_id == user.tenant_id)
        .order_by(models.Asset.created_at.desc())
        .all()
    )
    asset_types = _asset_types_for_tenant(db, user.tenant_id)
    return templates.TemplateResponse(
        "assets.html",
        {"request": request, "user": user, "active": "assets", "assets": assets, "asset_types": asset_types},
    )


@router.get("/assets/{asset_id}", response_class=HTMLResponse)
def asset_detail_page(
    asset_id: uuid.UUID,
    request: Request,
    db: Session = Depends(get_db),
    user=Depends(get_session_user),
):
    if not user:
        return RedirectResponse("/login", status_code=303)

    asset = (
        db.query(models.Asset)
        .filter(models.Asset.id == asset_id, models.Asset.tenant_id == user.tenant_id)
        .first()
    )
    if not asset:
        return RedirectResponse("/assets", status_code=303)

    agents = _agents_for_tenant(db, user.tenant_id)
    tickets = (
        db.query(models.Ticket)
        .filter(models.Ticket.asset_id == asset.id, models.Ticket.tenant_id == user.tenant_id)
        .order_by(models.Ticket.created_at.desc())
        .all()
    )
    asset_types = _asset_types_for_tenant(db, user.tenant_id)
    return templates.TemplateResponse(
        "asset_detail.html",
        {
            "request": request,
            "user": user,
            "active": "assets",
            "asset": asset,
            "agents": agents,
            "tickets": tickets,
            "asset_types": asset_types,
        },
    )


# SLA Policies page lives under /admin/sla-policies (see routers/admin.py).