app-service/backend/app/api/v1/settings.py

"""Settings endpoints."""

from typing import Any
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session

from app import crud, schemas
from app.dependencies import get_db, get_current_superuser, get_current_user
from app.models.user import User
from app.core.settings_registry import (
    THEME_KEYS,
    MODULE_KEYS,
    UI_KEYS,
    SETTINGS_REGISTRY,
    get_default_value,
)


router = APIRouter()


@router.get("/theme", response_model=dict[str, Any])
def get_theme_settings(
    *,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
) -> Any:
    """
    Get theme settings (accessible to all authenticated users).

    Returns theme-related settings that apply to all users.
    """
    result = {}
    for key in THEME_KEYS:
        setting = crud.settings.get_setting(db, key=key)
        if setting:
            result[key] = setting.get_value()
        else:
            # Use default from registry
            result[key] = get_default_value(key)
    return result


@router.put("/theme", response_model=dict[str, Any])
def update_theme_settings(
    *,
    db: Session = Depends(get_db),
    theme_data: dict[str, Any],
    current_user: User = Depends(get_current_superuser)
) -> Any:
    """
    Update theme settings (admin only).

    Updates multiple theme settings at once.
    """
    result = {}
    for key, value in theme_data.items():
        if key in THEME_KEYS or key.startswith("theme_"):
            setting = crud.settings.update_setting(db, key=key, value=value)
            result[key] = setting.get_value()
    return result


@router.get("/modules", response_model=dict[str, Any])
def get_module_settings(
    *,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
) -> Any:
    """
    Get module settings (accessible to all authenticated users).

    Returns module enabled/disabled states.
    """
    result = {}
    for key in MODULE_KEYS:
        setting = crud.settings.get_setting(db, key=key)
        if setting:
            result[key] = setting.get_value()
        else:
            # Use default from registry
            result[key] = get_default_value(key)
    return result


@router.get("/ui", response_model=dict[str, Any])
def get_ui_settings(
    *,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
) -> Any:
    """
    Get UI settings (accessible to all authenticated users).

    Returns UI/layout settings that apply to all users.
    """
    result = {}
    for key in UI_KEYS:
        setting = crud.settings.get_setting(db, key=key)
        if setting:
            result[key] = setting.get_value()
        else:
            result[key] = get_default_value(key)
    return result


@router.put("/ui", response_model=dict[str, Any])
def update_ui_settings(
    *,
    db: Session = Depends(get_db),
    ui_data: dict[str, Any],
    current_user: User = Depends(get_current_superuser)
) -> Any:
    """
    Update UI settings (admin only).

    Updates multiple UI/layout settings at once.
    """
    result = {}
    for key, value in ui_data.items():
        if key in UI_KEYS:
            setting = crud.settings.update_setting(db, key=key, value=value)
            result[key] = setting.get_value()
    return result


@router.put("/modules", response_model=dict[str, Any])
def update_module_settings(
    *,
    db: Session = Depends(get_db),
    module_data: dict[str, Any],
    current_user: User = Depends(get_current_superuser)
) -> Any:
    """
    Update module settings (admin only).

    Enable or disable modules for all users.
    """
    result = {}
    for key, value in module_data.items():
        if key in MODULE_KEYS or key.startswith("module_"):
            setting = crud.settings.update_setting(db, key=key, value=value)
            result[key] = setting.get_value()
    return result


@router.get("/user_mode_enabled", response_model=dict[str, Any])
def get_user_mode_enabled(
    *,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
) -> Any:
    """
    Get user mode enabled setting (accessible to all authenticated users).
    """
    setting = crud.settings.get_setting(db, key="user_mode_enabled")
    if setting:
        return {"key": "user_mode_enabled", "value": setting.get_value()}
    # Use default from registry
    return {"key": "user_mode_enabled", "value": get_default_value("user_mode_enabled")}


@router.put("/user_mode_enabled", response_model=dict[str, Any])
def update_user_mode_enabled(
    *,
    db: Session = Depends(get_db),
    data: dict[str, Any],
    current_user: User = Depends(get_current_superuser)
) -> Any:
    """
    Update user mode enabled setting (admin only).
    """
    value = data.get("value", True)
    setting = crud.settings.update_setting(db, key="user_mode_enabled", value=value)
    return {"key": "user_mode_enabled", "value": setting.get_value()}


@router.get("", response_model=dict[str, Any])
def get_all_settings(
    *,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_superuser)
) -> Any:
    """
    Get all settings (admin only).

    Returns all application settings as a dictionary.
    """
    settings_list = crud.settings.get_all_settings(db)
    return {s.key: s.get_value() for s in settings_list}


@router.get("/{key}", response_model=schemas.Setting)
def get_setting(
    *,
    db: Session = Depends(get_db),
    key: str,
    current_user: User = Depends(get_current_superuser)
) -> Any:
    """
    Get a specific setting by key (admin only).
    """
    setting = crud.settings.get_setting(db, key=key)
    if not setting:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"Setting '{key}' not found"
        )
    return schemas.Setting.from_orm(setting)


@router.put("/{key}", response_model=schemas.Setting)
def update_setting(
    *,
    db: Session = Depends(get_db),
    key: str,
    setting_in: schemas.SettingUpdate,
    current_user: User = Depends(get_current_superuser)
) -> Any:
    """
    Update a setting (admin only).
    
    Creates the setting if it doesn't exist.
    """
    setting = crud.settings.update_setting(db, key=key, value=setting_in.value)
    return schemas.Setting.from_orm(setting)