"""
Configuration management API.
"""
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from typing import Optional, List, Dict, Any
import logging

logger = logging.getLogger(__name__)
router = APIRouter()


class IntegrationConfig(BaseModel):
    jira_url: Optional[str] = None
    jira_token: Optional[str] = None
    jira_projects: List[str] = []
    bitbucket_url: Optional[str] = None
    bitbucket_token: Optional[str] = None
    llm_provider: str = "openrouter"  # openrouter | azure
    azure_endpoint: Optional[str] = None
    azure_key: Optional[str] = None
    azure_model: str = "gpt-4o"
    openrouter_key: Optional[str] = None
    openrouter_model: str = "meta-llama/llama-3.3-70b-instruct:free"
    embedding_provider: str = "local"  # local | azure


class RepositoryConfig(BaseModel):
    url: str
    name: str
    ai_fork_name: Optional[str] = None
    indexed: bool = False
    last_sync: Optional[str] = None
    file_count: int = 0


class ModuleConfig(BaseModel):
    name: str
    description: Optional[str] = None
    program_patterns: List[str] = []
    keywords: List[str] = []
    rules: List[str] = []
    restrictions: List[str] = []


class SystemConfig(BaseModel):
    integrations: IntegrationConfig
    repositories: List[RepositoryConfig] = []
    modules: List[ModuleConfig] = []


@router.get("/integrations", response_model=IntegrationConfig)
async def get_integrations():
    """Get integration configuration (tokens masked)."""
    # TODO: Load from database
    return IntegrationConfig()


@router.put("/integrations")
async def update_integrations(config: IntegrationConfig):
    """Update integration configuration."""
    logger.info("💾 Updating integration config")
    # TODO: Save to database
    return {"status": "updated"}


@router.post("/integrations/test/{service}")
async def test_integration(service: str):
    """Test connection to a service (jira, bitbucket, llm, embeddings)."""
    logger.info(f"🔌 Testing connection: {service}")
    # TODO: Implement connection tests
    return {"status": "ok", "service": service, "connected": True}


@router.get("/repositories", response_model=List[RepositoryConfig])
async def list_repositories():
    """List configured repositories."""
    # TODO: Load from database
    return []


@router.post("/repositories")
async def add_repository(repo: RepositoryConfig):
    """Add a new repository for indexing."""
    logger.info(f"📦 Adding repository: {repo.url}")
    # TODO: Save and trigger indexing
    return {"status": "added", "repository": repo.name}


@router.delete("/repositories/{repo_name}")
async def remove_repository(repo_name: str):
    """Remove a repository."""
    logger.info(f"🗑️ Removing repository: {repo_name}")
    # TODO: Remove from database and vector store
    return {"status": "removed"}


@router.post("/repositories/{repo_name}/reindex")
async def reindex_repository(repo_name: str):
    """Trigger re-indexing of a repository."""
    logger.info(f"🔄 Re-indexing repository: {repo_name}")
    # TODO: Queue re-indexing job
    return {"status": "queued"}


@router.get("/modules", response_model=List[ModuleConfig])
async def list_modules():
    """List business rule modules."""
    # TODO: Load from database
    return []


@router.post("/modules")
async def add_module(module: ModuleConfig):
    """Add a new business rule module."""
    logger.info(f"🧠 Adding module: {module.name}")
    # TODO: Save to database
    return {"status": "added", "module": module.name}


@router.put("/modules/{module_name}")
async def update_module(module_name: str, module: ModuleConfig):
    """Update a business rule module."""
    logger.info(f"💾 Updating module: {module_name}")
    # TODO: Update in database
    return {"status": "updated"}


@router.delete("/modules/{module_name}")
async def delete_module(module_name: str):
    """Delete a business rule module."""
    logger.info(f"🗑️ Deleting module: {module_name}")
    # TODO: Remove from database
    return {"status": "deleted"}