from typing import Dict, Any, Optional, List
from enum import Enum
from agents.conversation_agent import ConversationAgent
from agents.tool_agent import ToolAgent


class WorkflowType(Enum):
    """Available workflow types"""
    CONVERSATION = "conversation"
    TOOL_USING = "tool_using"
    

class WorkflowManager:
    """Manages different workflow types and their execution"""
    
    def __init__(self):
        self.workflows = {
            WorkflowType.CONVERSATION: ConversationAgent(),
            WorkflowType.TOOL_USING: ToolAgent()
        }
        self.active_sessions: Dict[str, Any] = {}
    
    def get_workflow(self, workflow_type: WorkflowType):
        """Get a workflow instance"""
        return self.workflows.get(workflow_type)
    
    def execute_workflow(self, workflow_type: WorkflowType, user_input: str, 
                        session_id: Optional[str] = None, **kwargs) -> Dict[str, Any]:
        """Execute a specific workflow"""
        workflow = self.get_workflow(workflow_type)
        
        if not workflow:
            return {"error": f"Workflow {workflow_type.value} not found"}
        
        # Generate session ID if not provided
        if not session_id:
            session_id = f"session_{len(self.active_sessions) + 1}"
        
        # Execute the workflow
        result = workflow.run(user_input, **kwargs)
        
        # Store session data
        self.active_sessions[session_id] = {
            "workflow_type": workflow_type,
            "last_result": result,
            "timestamp": self._get_timestamp()
        }
        
        return {
            "session_id": session_id,
            "workflow_type": workflow_type.value,
            "result": result
        }
    
    def get_available_workflows(self) -> List[str]:
        """Get list of available workflow types"""
        return [workflow.value for workflow in WorkflowType]
    
    def _get_timestamp(self) -> str:
        """Get current timestamp"""
        from datetime import datetime
        return datetime.now().isoformat()
    
    def get_session_info(self, session_id: str) -> Optional[Dict[str, Any]]:
        """Get information about a session"""
        return self.active_sessions.get(session_id)
    
    def cleanup_sessions(self, older_than_hours: int = 24):
        """Clean up old sessions"""
        from datetime import datetime, timedelta
        
        cutoff_time = datetime.now() - timedelta(hours=older_than_hours)
        
        sessions_to_remove = []
        for session_id, session_data in self.active_sessions.items():
            session_time = datetime.fromisoformat(session_data["timestamp"])
            if session_time < cutoff_time:
                sessions_to_remove.append(session_id)
        
        for session_id in sessions_to_remove:
            del self.active_sessions[session_id]
        
        return len(sessions_to_remove)