"""
API Key Management Service
Handles API key operations for onboarding.
"""

import time
from typing import Dict, Any
from fastapi import HTTPException
from loguru import logger

from services.api_key_manager import APIKeyManager
from services.validation import check_all_api_keys

class APIKeyManagementService:
    """Service for handling API key management operations."""
    
    def __init__(self):
        self.api_key_manager = APIKeyManager()
        # Simple cache for API keys
        self._api_keys_cache = None
        self._cache_timestamp = 0
        self.CACHE_DURATION = 30  # Cache for 30 seconds
    
    async def get_api_keys(self) -> Dict[str, Any]:
        """Get all configured API keys (masked)."""
        current_time = time.time()
        
        # Return cached result if still valid
        if self._api_keys_cache and (current_time - self._cache_timestamp) < self.CACHE_DURATION:
            logger.debug("Returning cached API keys")
            return self._api_keys_cache
        
        try:
            self.api_key_manager.load_api_keys()  # Load keys from environment
            api_keys = self.api_key_manager.api_keys  # Get the loaded keys
            
            # Mask the API keys for security
            masked_keys = {}
            for provider, key in api_keys.items():
                if key:
                    masked_keys[provider] = "*" * (len(key) - 4) + key[-4:] if len(key) > 4 else "*" * len(key)
                else:
                    masked_keys[provider] = None
            
            result = {
                "api_keys": masked_keys,
                "total_providers": len(api_keys),
                "configured_providers": [k for k, v in api_keys.items() if v]
            }
            
            # Cache the result
            self._api_keys_cache = result
            self._cache_timestamp = current_time
            
            return result
        except Exception as e:
            logger.error(f"Error getting API keys: {str(e)}")
            raise HTTPException(status_code=500, detail="Internal server error")
    
    async def get_api_keys_for_onboarding(self) -> Dict[str, Any]:
        """Get all configured API keys for onboarding (unmasked)."""
        try:
            self.api_key_manager.load_api_keys()  # Load keys from environment
            api_keys = self.api_key_manager.api_keys  # Get the loaded keys
            
            # Return actual API keys for onboarding pre-filling
            result = {
                "api_keys": api_keys,
                "total_providers": len(api_keys),
                "configured_providers": [k for k, v in api_keys.items() if v]
            }
            
            return result
        except Exception as e:
            logger.error(f"Error getting API keys for onboarding: {str(e)}")
            raise HTTPException(status_code=500, detail="Internal server error")
    
    async def save_api_key(self, provider: str, api_key: str, description: str = None) -> Dict[str, Any]:
        """Save an API key for a provider."""
        try:
            success = self.api_key_manager.save_api_key(provider, api_key)
            
            if success:
                return {
                    "message": f"API key for {provider} saved successfully",
                    "provider": provider,
                    "status": "saved"
                }
            else:
                raise HTTPException(status_code=400, detail=f"Failed to save API key for {provider}")
        except HTTPException:
            raise
        except Exception as e:
            logger.error(f"Error saving API key: {str(e)}")
            raise HTTPException(status_code=500, detail="Internal server error")
    
    async def validate_api_keys(self) -> Dict[str, Any]:
        """Validate all configured API keys."""
        try:
            validation_results = check_all_api_keys(self.api_key_manager)
            
            return {
                "validation_results": validation_results.get('results', {}),
                "all_valid": validation_results.get('all_valid', False),
                "total_providers": len(validation_results.get('results', {}))
            }
        except Exception as e:
            logger.error(f"Error validating API keys: {str(e)}")
            raise HTTPException(status_code=500, detail="Internal server error")