import logging
import httpx
from typing import Dict, Any, List, Optional, Union
from fastapi import HTTPException
from modules.configuration import APP_CONFIG

# Configure logger
logger = logging.getLogger(__name__)

# Load configuration data
def load_config_data():
    return {
        "api_key": APP_CONFIG.get('Connector_AiOpenai_API_SECRET'),
        "api_url": APP_CONFIG.get('Connector_AiOpenai_API_URL'),
        "model_name": APP_CONFIG.get('Connector_AiOpenai_MODEL_NAME'),
        "temperature": float(APP_CONFIG.get('Connector_AiOpenai_TEMPERATURE')),
        "max_tokens": int(APP_CONFIG.get('Connector_AiOpenai_MAX_TOKENS'))
    }

class ChatService:
    """
    Connector for communication with the OpenAI API.
    """
    
    def __init__(self):
        # Load configuration
        self.config = load_config_data()
        self.api_key = self.config["api_key"]
        self.api_url = self.config["api_url"]
        self.model_name = self.config["model_name"]
        
        # HttpClient for API calls
        self.http_client = httpx.AsyncClient(
            timeout=120.0,  # Longer timeout for complex requests
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            }
        )
        logger.info(f"OpenAI Connector initialized with model: {self.model_name}")
    
    async def call_api(self, messages: List[Dict[str, Any]], temperature: float = None, max_tokens: int = None) -> str:
        """
        Calls the OpenAI API with the given messages.
        
        Args:
            messages: List of messages in OpenAI format (role, content)
            temperature: Temperature for response generation (0.0-1.0)
            max_tokens: Maximum number of tokens in the response
            
        Returns:
            The response from the OpenAI API
            
        Raises:
            HTTPException: For errors in API communication
        """
        try:
            # Use parameters from configuration if none were overridden
            if temperature is None:
                temperature = self.config.get("temperature", 0.2)
                
            if max_tokens is None:
                max_tokens = self.config.get("max_tokens", 2000)
            
            payload = {
                "model": self.model_name,
                "messages": messages,
                "temperature": temperature,
                "max_tokens": max_tokens
            }
            
            response = await self.http_client.post(
                self.api_url,
                json=payload
            )
            
            if response.status_code != 200:
                logger.error(f"OpenAI API error: {response.status_code} - {response.text}")
                raise HTTPException(status_code=500, detail="Error communicating with OpenAI API")
            
            response_json = response.json()
            content = response_json["choices"][0]["message"]["content"]
            return content
            
        except Exception as e:
            logger.error(f"Error calling OpenAI API: {str(e)}")
            raise HTTPException(status_code=500, detail=f"Error calling OpenAI API: {str(e)}")
    
    async def close(self):
        """Closes the HTTP client when the application exits"""
        await self.http_client.aclose()
    
    async def analyze_image(self, image_data: Union[str, bytes], mime_type: str = None, prompt: str = "Describe this image") -> str:
        """
        Analyzes an image with the OpenAI Vision API.
        
        Args:
            image_data: Either a file path (str) or image data (bytes)
            mime_type: The MIME type of the image (optional, only for binary data)
            prompt: The prompt for analysis
            
        Returns:
            The response from the OpenAI Vision API as text
        """
        try:
            logger.debug("Starting image analysis...")
            # Distinguish between file path and binary data
            if isinstance(image_data, str):
                # It's a file path - import filehandling only when needed
                from modules import agentservice_filemanager as file_handler
                base64_data, auto_mime_type = file_handler.encode_file_to_base64(image_data)
                mime_type = mime_type or auto_mime_type
            else:
                # It's binary data
                import base64
                base64_data = base64.b64encode(image_data).decode('utf-8')
                # MIME type must be specified for binary data
                if not mime_type:
                    # Fallback to generic image type
                    mime_type = "image/png"
            
            # Prepare the payload for the Vision API
            messages = [
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": prompt},
                        {
                            "type": "image_url",
                            "image_url": {
                                "url": f"data:{mime_type};base64,{base64_data}"
                            }
                        }
                    ]
                }
            ]
            
            # Use the existing call_api function with the Vision model
            response = await self.call_api(messages)
            
            # Extract and return content
            return response
        
        except Exception as e:
            logger.error(f"Error during image analysis: {str(e)}", exc_info=True)
            return f"[Error during image analysis: {str(e)}]"