from typing import Dict, Any, Optional
import logging
from datetime import datetime, UTC

from modules.workflow.methodBase import MethodBase, ActionResult, action

logger = logging.getLogger(__name__)

class CoderService:
    """Service for code analysis, generation, and refactoring operations"""
    
    def __init__(self, serviceContainer: Any):
        self.serviceContainer = serviceContainer
    
    async def analyzeCode(self, code: str, language: str = "python", checks: list = None) -> Dict[str, Any]:
        """Analyze code quality and structure"""
        if checks is None:
            checks = ["complexity", "style", "security"]
        
        try:
            # Create analysis prompt
            analysis_prompt = f"""
            Analyze this {language} code for quality, structure, and potential issues.
            
            Code to analyze:
            {code}
            
            Please check for:
            {', '.join(checks)}
            
            Provide a detailed analysis including:
            1. Code quality assessment
            2. Potential issues and improvements
            3. Security considerations
            4. Performance optimizations
            5. Best practices compliance
            """
            
            # Use AI service for analysis
            analysis_result = await self.serviceContainer.interfaceAiCalls.callAiTextAdvanced(analysis_prompt)
            
            return {
                "language": language,
                "checks": checks,
                "analysis": analysis_result,
                "timestamp": datetime.now(UTC).isoformat()
            }
            
        except Exception as e:
            logger.error(f"Error analyzing code: {str(e)}")
            return {
                "error": str(e),
                "language": language,
                "checks": checks
            }
    
    async def generateCode(self, requirements: str, language: str = "python", template: str = None) -> Dict[str, Any]:
        """Generate code based on requirements"""
        try:
            # Create generation prompt
            generation_prompt = f"""
            Generate {language} code based on the following requirements:
            
            Requirements:
            {requirements}
            
            {f'Template to follow: {template}' if template else ''}
            
            Please provide:
            1. Complete, working code
            2. Clear comments and documentation
            3. Error handling where appropriate
            4. Best practices implementation
            """
            
            # Use AI service for code generation
            generated_code = await self.serviceContainer.interfaceAiCalls.callAiTextAdvanced(generation_prompt)
            
            return {
                "language": language,
                "requirements": requirements,
                "code": generated_code,
                "timestamp": datetime.now(UTC).isoformat()
            }
            
        except Exception as e:
            logger.error(f"Error generating code: {str(e)}")
            return {
                "error": str(e),
                "language": language,
                "requirements": requirements
            }
    
    async def refactorCode(self, code: str, language: str = "python", improvements: list = None) -> Dict[str, Any]:
        """Refactor code for better quality"""
        if improvements is None:
            improvements = ["style", "complexity"]
        
        try:
            # Create refactoring prompt
            refactor_prompt = f"""
            Refactor this {language} code to improve:
            {', '.join(improvements)}
            
            Original code:
            {code}
            
            Please provide:
            1. Refactored code with improvements
            2. Explanation of changes made
            3. Benefits of the refactoring
            4. Any potential trade-offs
            """
            
            # Use AI service for refactoring
            refactored_code = await self.serviceContainer.interfaceAiCalls.callAiTextAdvanced(refactor_prompt)
            
            return {
                "language": language,
                "improvements": improvements,
                "original_code": code,
                "refactored_code": refactored_code,
                "timestamp": datetime.now(UTC).isoformat()
            }
            
        except Exception as e:
            logger.error(f"Error refactoring code: {str(e)}")
            return {
                "error": str(e),
                "language": language,
                "improvements": improvements
            }

class MethodCoder(MethodBase):
    """Coder method implementation for code operations"""
    
    def __init__(self, serviceContainer: Any):
        super().__init__(serviceContainer)
        self.name = "coder"
        self.description = "Handle code operations like analysis and generation"
        self.coderService = CoderService(serviceContainer)
    
    @action
    async def analyze(self, parameters: Dict[str, Any]) -> ActionResult:
        """
        Analyze code quality and structure
        
        Parameters:
            code (str): The code to analyze
            language (str, optional): Programming language (default: "python")
            checks (List[str], optional): Types of checks to perform (default: ["complexity", "style", "security"])
        """
        try:
            code = parameters.get("code")
            language = parameters.get("language", "python")
            checks = parameters.get("checks", ["complexity", "style", "security"])
            
            if not code:
                return self._createResult(
                    success=False,
                    data={},
                    error="Code is required"
                )
            
            # Analyze code
            results = await self.coderService.analyzeCode(
                code=code,
                language=language,
                checks=checks
            )
            
            return self._createResult(
                success=True,
                data=results
            )
            
        except Exception as e:
            logger.error(f"Error analyzing code: {str(e)}")
            return self._createResult(
                success=False,
                data={},
                error=str(e)
            )
    
    @action
    async def generate(self, parameters: Dict[str, Any]) -> ActionResult:
        """
        Generate code based on requirements
        
        Parameters:
            requirements (str): Requirements for the code to generate
            language (str, optional): Programming language (default: "python")
            template (str, optional): Template or pattern to follow
        """
        try:
            requirements = parameters.get("requirements")
            language = parameters.get("language", "python")
            template = parameters.get("template")
            
            if not requirements:
                return self._createResult(
                    success=False,
                    data={},
                    error="Requirements are required"
                )
            
            # Generate code
            code = await self.coderService.generateCode(
                requirements=requirements,
                language=language,
                template=template
            )
            
            return self._createResult(
                success=True,
                data=code
            )
            
        except Exception as e:
            logger.error(f"Error generating code: {str(e)}")
            return self._createResult(
                success=False,
                data={},
                error=str(e)
            )
    
    @action
    async def refactor(self, parameters: Dict[str, Any]) -> ActionResult:
        """
        Refactor code for better quality
        
        Parameters:
            code (str): The code to refactor
            language (str, optional): Programming language (default: "python")
            improvements (List[str], optional): Types of improvements to make (default: ["style", "complexity"])
        """
        try:
            code = parameters.get("code")
            language = parameters.get("language", "python")
            improvements = parameters.get("improvements", ["style", "complexity"])
            
            if not code:
                return self._createResult(
                    success=False,
                    data={},
                    error="Code is required"
                )
            
            # Refactor code
            results = await self.coderService.refactorCode(
                code=code,
                language=language,
                improvements=improvements
            )
            
            return self._createResult(
                success=True,
                data=results
            )
            
        except Exception as e:
            logger.error(f"Error refactoring code: {str(e)}")
            return self._createResult(
                success=False,
                data={},
                error=str(e)
            )