# [DEF:SettingsRouter:Module]
#
# @SEMANTICS: settings, api, router, fastapi
# @PURPOSE:   Provides API endpoints for managing application settings and Superset environments.
# @LAYER:     UI (API)
# @RELATION:  DEPENDS_ON -> ConfigManager
# @RELATION:  DEPENDS_ON -> ConfigModels
#
# @INVARIANT: All settings changes must be persisted via ConfigManager.
# @PUBLIC_API: router

# [SECTION: IMPORTS]
from fastapi import APIRouter, Depends, HTTPException
from typing import List
from ...core.config_models import AppConfig, Environment, GlobalSettings
from ...models.storage import StorageConfig
from ...dependencies import get_config_manager
from ...core.config_manager import ConfigManager
from ...core.logger import logger, belief_scope
from ...core.superset_client import SupersetClient
import os
# [/SECTION]

router = APIRouter()

# [DEF:get_settings:Function]
# @PURPOSE: Retrieves all application settings.
# @PRE:     Config manager is available.
# @POST:    Returns masked AppConfig.
# @RETURN: AppConfig - The current configuration.
@router.get("", response_model=AppConfig)
async def get_settings(config_manager: ConfigManager = Depends(get_config_manager)):
    with belief_scope("get_settings"):
        logger.info("[get_settings][Entry] Fetching all settings")
    config = config_manager.get_config().copy(deep=True)
    # Mask passwords
    for env in config.environments:
        if env.password:
            env.password = "********"
    return config
# [/DEF:get_settings:Function]

# [DEF:update_global_settings:Function]
# @PURPOSE: Updates global application settings.
# @PRE:     New settings are provided.
# @POST:    Global settings are updated.
# @PARAM: settings (GlobalSettings) - The new global settings.
# @RETURN: GlobalSettings - The updated settings.
@router.patch("/global", response_model=GlobalSettings)
async def update_global_settings(
    settings: GlobalSettings,
    config_manager: ConfigManager = Depends(get_config_manager)
):
    with belief_scope("update_global_settings"):
        logger.info("[update_global_settings][Entry] Updating global settings")
    
    config_manager.update_global_settings(settings)
    return settings
# [/DEF:update_global_settings:Function]

# [DEF:get_storage_settings:Function]
# @PURPOSE: Retrieves storage-specific settings.
# @RETURN: StorageConfig - The storage configuration.
@router.get("/storage", response_model=StorageConfig)
async def get_storage_settings(config_manager: ConfigManager = Depends(get_config_manager)):
    with belief_scope("get_storage_settings"):
        return config_manager.get_config().settings.storage
# [/DEF:get_storage_settings:Function]

# [DEF:update_storage_settings:Function]
# @PURPOSE: Updates storage-specific settings.
# @PARAM: storage (StorageConfig) - The new storage settings.
# @POST: Storage settings are updated and saved.
# @RETURN: StorageConfig - The updated storage settings.
@router.put("/storage", response_model=StorageConfig)
async def update_storage_settings(storage: StorageConfig, config_manager: ConfigManager = Depends(get_config_manager)):
    with belief_scope("update_storage_settings"):
        is_valid, message = config_manager.validate_path(storage.root_path)
        if not is_valid:
            raise HTTPException(status_code=400, detail=message)
        
        settings = config_manager.get_config().settings
        settings.storage = storage
        config_manager.update_global_settings(settings)
        return config_manager.get_config().settings.storage
# [/DEF:update_storage_settings:Function]

# [DEF:get_environments:Function]
# @PURPOSE: Lists all configured Superset environments.
# @PRE:     Config manager is available.
# @POST:    Returns list of environments.
# @RETURN: List[Environment] - List of environments.
@router.get("/environments", response_model=List[Environment])
async def get_environments(config_manager: ConfigManager = Depends(get_config_manager)):
    with belief_scope("get_environments"):
        logger.info("[get_environments][Entry] Fetching environments")
    return config_manager.get_environments()
# [/DEF:get_environments:Function]

# [DEF:add_environment:Function]
# @PURPOSE: Adds a new Superset environment.
# @PRE:     Environment data is valid and reachable.
# @POST:    Environment is added to config.
# @PARAM: env (Environment) - The environment to add.
# @RETURN: Environment - The added environment.
@router.post("/environments", response_model=Environment)
async def add_environment(
    env: Environment,
    config_manager: ConfigManager = Depends(get_config_manager)
):
    with belief_scope("add_environment"):
        logger.info(f"[add_environment][Entry] Adding environment {env.id}")
    
    # Validate connection before adding
    try:
        client = SupersetClient(env)
        client.get_dashboards(query={"page_size": 1})
    except Exception as e:
        logger.error(f"[add_environment][Coherence:Failed] Connection validation failed: {e}")
        raise HTTPException(status_code=400, detail=f"Connection validation failed: {e}")

    config_manager.add_environment(env)
    return env
# [/DEF:add_environment:Function]

# [DEF:update_environment:Function]
# @PURPOSE: Updates an existing Superset environment.
# @PRE:     ID and valid environment data are provided.
# @POST:    Environment is updated in config.
# @PARAM: id (str) - The ID of the environment to update.
# @PARAM: env (Environment) - The updated environment data.
# @RETURN: Environment - The updated environment.
@router.put("/environments/{id}", response_model=Environment)
async def update_environment(
    id: str,
    env: Environment,
    config_manager: ConfigManager = Depends(get_config_manager)
):
    with belief_scope("update_environment"):
        logger.info(f"[update_environment][Entry] Updating environment {id}")
    
    # If password is masked, we need the real one for validation
    env_to_validate = env.copy(deep=True)
    if env_to_validate.password == "********":
        old_env = next((e for e in config_manager.get_environments() if e.id == id), None)
        if old_env:
            env_to_validate.password = old_env.password

    # Validate connection before updating
    try:
        client = SupersetClient(env_to_validate)
        client.get_dashboards(query={"page_size": 1})
    except Exception as e:
        logger.error(f"[update_environment][Coherence:Failed] Connection validation failed: {e}")
        raise HTTPException(status_code=400, detail=f"Connection validation failed: {e}")

    if config_manager.update_environment(id, env):
        return env
    raise HTTPException(status_code=404, detail=f"Environment {id} not found")
# [/DEF:update_environment:Function]

# [DEF:delete_environment:Function]
# @PURPOSE: Deletes a Superset environment.
# @PRE:     ID is provided.
# @POST:    Environment is removed from config.
# @PARAM: id (str) - The ID of the environment to delete.
@router.delete("/environments/{id}")
async def delete_environment(
    id: str,
    config_manager: ConfigManager = Depends(get_config_manager)
):
    with belief_scope("delete_environment"):
        logger.info(f"[delete_environment][Entry] Deleting environment {id}")
    config_manager.delete_environment(id)
    return {"message": f"Environment {id} deleted"}
# [/DEF:delete_environment:Function]

# [DEF:test_environment_connection:Function]
# @PURPOSE: Tests the connection to a Superset environment.
# @PRE:     ID is provided.
# @POST:    Returns success or error status.
# @PARAM: id (str) - The ID of the environment to test.
# @RETURN: dict - Success message or error.
@router.post("/environments/{id}/test")
async def test_environment_connection(
    id: str,
    config_manager: ConfigManager = Depends(get_config_manager)
):
    with belief_scope("test_environment_connection"):
        logger.info(f"[test_environment_connection][Entry] Testing environment {id}")
    
    # Find environment
    env = next((e for e in config_manager.get_environments() if e.id == id), None)
    if not env:
        raise HTTPException(status_code=404, detail=f"Environment {id} not found")
    
    try:
        # Initialize client (this will trigger authentication)
        client = SupersetClient(env)
        
        # Try a simple request to verify
        client.get_dashboards(query={"page_size": 1})
        
        logger.info(f"[test_environment_connection][Coherence:OK] Connection successful for {id}")
        return {"status": "success", "message": "Connection successful"}
    except Exception as e:
        logger.error(f"[test_environment_connection][Coherence:Failed] Connection failed for {id}: {e}")
        return {"status": "error", "message": str(e)}
# [/DEF:test_environment_connection:Function]


# [/DEF:SettingsRouter:Module]