from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session

from app.core.database import get_db
from app.core.security import ApiPrincipal, require_api_key
from app.modules.ai_memory.constants import AIMemoryResponseKey, AIMemoryStatus
from app.modules.ai_memory.schemas import (
    AIMemoryRecallRequest,
    AIUserRuleCreate,
    AIUserRuleUpdate,
)
from app.modules.ai_memory.service import AIMemoryService

router = APIRouter(dependencies=[Depends(require_api_key)])


@router.get("/memory")
def list_memory(
    scope: str | None = None,
    subject: str | None = None,
    status: str = AIMemoryStatus.ACTIVE,
    limit: int = Query(default=100, ge=1, le=500),
    db: Session = Depends(get_db),
) -> dict:
    items = AIMemoryService(db).list_entries(
        scope=scope,
        subject=subject,
        status_filter=status,
        limit=limit,
        owner_id=None,
    )
    db.commit()
    return {AIMemoryResponseKey.ITEMS: items}


@router.post("/memory/recall")
def recall_memory(
    payload: AIMemoryRecallRequest,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    items = AIMemoryService(db).recall(
        query=payload.query,
        scope=payload.scope,
        subject=payload.subject,
        limit=payload.limit,
        actor=principal.actor,
        owner_id=None,
    )
    return {AIMemoryResponseKey.ITEMS: items}


@router.get("/rules")
def list_rules(
    scope: str | None = None,
    subject: str | None = None,
    status: str | None = None,
    limit: int = Query(default=100, ge=1, le=500),
    db: Session = Depends(get_db),
) -> dict:
    return {
        AIMemoryResponseKey.ITEMS: AIMemoryService(db).list_rules(
            scope=scope,
            subject=subject,
            status_filter=status,
            limit=limit,
            owner_id=None,
        )
    }


@router.post("/rules")
def create_rule(
    payload: AIUserRuleCreate,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    return {
        AIMemoryResponseKey.DATA: AIMemoryService(db).create_rule(
            content=payload.content,
            scope=payload.scope,
            subject=payload.subject,
            priority=payload.priority,
            tags=payload.tags,
            actor=principal.actor,
            owner_id=None,
        )
    }


@router.patch("/rules/{code}")
def update_rule(
    code: str,
    payload: AIUserRuleUpdate,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    return {
        AIMemoryResponseKey.DATA: AIMemoryService(db).update_rule(
            code=code,
            content=payload.content,
            priority=payload.priority,
            tags=payload.tags,
            enabled=payload.enabled,
            actor=principal.actor,
            owner_id=None,
        )
    }


@router.delete("/rules/{code}")
def delete_rule(
    code: str,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    AIMemoryService(db).delete_rule(
        code=code,
        actor=principal.actor,
        owner_id=None,
    )
    return {AIMemoryResponseKey.DATA: {"code": code, "deleted": True}}