"""
Email Agent Module.
Handles email-related tasks using Microsoft Graph API.
"""

import logging
import json
from typing import Dict, Any, List, Optional, Tuple
import uuid
import os

from modules.workflow.agentBase import AgentBase
from modules.interfaces.serviceChatModel import Task, ChatDocument, ChatContent

logger = logging.getLogger(__name__)

class AgentEmail(AgentBase):
    """Agent for handling email-related tasks."""
    
    def __init__(self):
        """Initialize the email agent."""
        super().__init__()
        self.name = "email"
        self.label = "Email Agent"
        self.description = "Handles email composition and sending using Microsoft Graph API"
        self.capabilities = [
            "email_composition",
            "email_draft_creation",
            "email_template_generation"
        ]
        self.serviceBase = None
    
    def setDependencies(self, serviceBase=None):
        """Set external dependencies for the agent."""
        self.serviceBase = serviceBase
    
    async def processTask(self, task: Task) -> Dict[str, Any]:
        """
        Process an email-related task.
        
        Args:
            task: Task object containing:
                - prompt: Instructions for the agent
                - inputDocuments: List of documents to process
                - outputSpecifications: List of required output documents
                - context: Additional context including workflow info
        
        Returns:
            Dictionary containing:
                - feedback: Text response explaining what was done
                - documents: List of created documents
        """
        try:
            # Extract task information
            prompt = task.prompt
            inputDocuments = task.filesInput
            outputSpecs = task.filesOutput
            
            # Check AI service
            if not self.service.base:
                return {
                    "feedback": "The Email agent requires an AI service to function.",
                    "documents": []
                }
            
            # Check if Microsoft connector is available
            if not hasattr(self.service, 'msft'):
                return {
                    "feedback": "Microsoft connector not available. Please ensure Microsoft integration is properly configured.",
                    "documents": []
                }
            
            # Get Microsoft token
            token_data = self.service.msft.getMsftToken()
            if not token_data:
                # Create authentication trigger document
                auth_doc = self._createFrontendAuthTriggerDocument()
                return {
                    "feedback": "Microsoft authentication required. Please authenticate to continue.",
                    "documents": [auth_doc]
                }
            
            # Extract document data from input
            documentContents, attachments = self._processInputDocuments(inputDocuments)
            
            # Generate email subject and body using AI
            emailTemplate = await self._generateEmailTemplate(prompt, documentContents)
            
            # Create HTML preview of the email
            htmlPreview = self._createHtmlPreview(emailTemplate)
            
            # Attempt to create a draft email using Microsoft Graph API
            draft_result = self.service.msft.createDraftEmail(
                emailTemplate["recipient"],
                emailTemplate["subject"],
                emailTemplate["htmlBody"],
                attachments
            )
            
            # Prepare output documents
            documents = []
            
            # Process output specifications
            for spec in outputSpecs:
                label = spec.get("label", "")
                description = spec.get("description", "")
                
                if label.endswith(".html"):
                    # Create the HTML template file
                    templateDoc = self.formatAgentDocumentOutput(
                        label,
                        emailTemplate["htmlBody"],  # Use the actual HTML body, not the preview
                        "text/html"
                    )
                    documents.append(templateDoc)
                elif label.endswith(".json"):
                    # Create JSON template if requested
                    templateJson = json.dumps(emailTemplate, indent=2)
                    templateDoc = self.formatAgentDocumentOutput(
                        label,
                        templateJson,
                        "application/json"
                    )
                    documents.append(templateDoc)
                else:
                    # Default to preview for other cases
                    previewDoc = self.formatAgentDocumentOutput(
                        label,
                        htmlPreview,
                        "text/html"
                    )
                    documents.append(previewDoc)
            
            # Prepare feedback message
            if draft_result:
                feedback = f"Email draft created successfully for {emailTemplate.get('recipient')}. The subject is: '{emailTemplate['subject']}'"
                if attachments:
                    feedback += f" with {len(attachments)} attachment(s)"
                feedback += ". You can open and edit it in your Outlook draft folder."
            else:
                feedback = "Email template created but could not save as draft. HTML preview and template are available as documents."
            
            return {
                "feedback": feedback,
                "documents": documents
            }
            
        except Exception as e:
            logger.error(f"Error in email agent: {str(e)}")
            return {
                "feedback": f"Error processing email task: {str(e)}",
                "documents": []
            }
    
    def _createFrontendAuthTriggerDocument(self) -> ChatDocument:
        """Create a document that triggers Microsoft authentication in the frontend."""
        return ChatDocument(
            id=str(uuid.uuid4()),
            name="microsoft_auth",
            ext="html",
            data="""
            <div>
                <h2>Microsoft Authentication Required</h2>
                <p>Please click the button below to authenticate with Microsoft:</p>
                <button onclick="window.location.href='/api/auth/microsoft'">Authenticate with Microsoft</button>
            </div>
            """,
            contents=[
                ChatContent(
                    name="main",
                    data="""
                    <div>
                        <h2>Microsoft Authentication Required</h2>
                        <p>Please click the button below to authenticate with Microsoft:</p>
                        <button onclick="window.location.href='/api/auth/microsoft'">Authenticate with Microsoft</button>
                    </div>
                    """,
                    summary="Microsoft authentication trigger page",
                    metadata={
                        "contentType": "text/html",
                        "isText": True
                    }
                )
            ]
        )
    
    def _processInputDocuments(self, input_docs: List[ChatDocument]) -> Tuple[str, List[Dict[str, Any]]]:
        """
        Process input documents to extract content and prepare attachments.
        
        Args:
            input_docs: List of input documents
            
        Returns:
            Tuple of (document content text, list of attachments)
        """
        documentContents = []
        attachments = []
        
        for doc in input_docs:
            docName = doc.name
            if doc.ext:
                docName = f"{docName}.{doc.ext}"
            
            # Add document name to contents
            documentContents.append(f"\n\n--- {docName} ---\n")
            
            # Process document data directly
            if doc.data:
                # Add to attachments with proper metadata
                attachments.append({
                    "name": docName,
                    "document": {
                        "data": doc.data,
                        "mimeType": doc.contents[0].metadata.get("contentType", "application/octet-stream") if doc.contents else "application/octet-stream",
                        "base64Encoded": doc.contents[0].metadata.get("base64Encoded", False) if doc.contents else False
                    }
                })
                documentContents.append(f"Document attached: {docName}")
            else:
                documentContents.append(f"Document referenced: {docName}")
        
        return "\n".join(documentContents), attachments
    
    def formatAgentDocumentOutput(self, filename: str, content: str, contentType: str) -> ChatDocument:
        """
        Format a document for agent output.
        
        Args:
            filename: Output filename
            content: Document content
            contentType: MIME type of the content
            
        Returns:
            ChatDocument object
        """
        # Split filename into name and extension
        name, ext = os.path.splitext(filename)
        if ext.startswith('.'):
            ext = ext[1:]
            
        # Create document object
        return ChatDocument(
            id=str(uuid.uuid4()),
            name=name,
            ext=ext,
            data=content,
            contents=[
                ChatContent(
                    name="main",
                    data=content,
                    summary=f"Generated {filename}",
                    metadata={"contentType": contentType}
                )
            ]
        )
    
    async def _generateEmailTemplate(self, prompt: str, documentContents: str) -> Dict[str, Any]:
        """
        Generate email template using AI.
        
        Args:
            prompt: The task prompt
            documentContents: Extracted document content
            
        Returns:
            Email template dictionary with recipient, subject, body
        """
        emailPrompt = f"""
        Create an email based on the following request:
        
        REQUEST: {prompt}
        
        DOCUMENT CONTENTS:
        {documentContents[:2000]}... (truncated if longer)
        
        Generate an email template with:
        1. A relevant recipient (use placeholder or derive from content if possible)
        2. A concise but descriptive subject line
        3. A professional HTML-formatted email body
        4. Appropriate greeting and closing
        
        Format your response as JSON with these fields:
        - recipient: email address
        - subject: subject line
        - plainBody: plain text version
        - htmlBody: HTML formatted version
        
        Only return valid JSON. No preamble or explanations.
        """
        
        try:
            response = await self.service.base.callAi([
                {"role": "system", "content": "You are an email template specialist. Create professional emails. Respond with valid JSON only."},
                {"role": "user", "content": emailPrompt}
            ])
            
            # Extract JSON from response
            jsonStart = response.find('{')
            jsonEnd = response.rfind('}') + 1
            
            if jsonStart >= 0 and jsonEnd > jsonStart:
                template = json.loads(response[jsonStart:jsonEnd])
                return template
            else:
                # Fallback plan
                logger.warning(f"Not able creating email template, generating fallback plan")
                return {
                    "recipient": "recipient@example.com",
                    "subject": "Information Regarding Your Request",
                    "plainBody": f"This email is regarding your request: {prompt}",
                    "htmlBody": f"<html><body><p>This email is regarding your request: {prompt}</p></body></html>"
                }
            
        except Exception as e:
            logger.warning(f"Error generating email template: {str(e)}")
            return {
                "recipient": "recipient@example.com",
                "subject": "Information Regarding Your Request",
                "plainBody": f"This email is regarding your request: {prompt}",
                "htmlBody": f"<html><body><p>This email is regarding your request: {prompt}</p></body></html>"
            }
    
    def _createHtmlPreview(self, emailTemplate: Dict[str, Any]) -> str:
        """
        Create an HTML preview of the email template.
        
        Args:
            emailTemplate: Email template dictionary
            
        Returns:
            HTML string for preview
        """
        html = f"""
        <!DOCTYPE html>
        <html>
        <head>
            <meta charset="UTF-8">
            <title>Email Preview: {emailTemplate.get('subject', 'Email Template')}</title>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 0; padding: 0; background-color: #f5f5f5; }}
                .email-container {{ max-width: 600px; margin: 20px auto; background-color: white; border: 1px solid #ddd; border-radius: 5px; overflow: hidden; }}
                .email-header {{ background-color: #f0f0f0; padding: 15px; border-bottom: 1px solid #ddd; }}
                .email-content {{ padding: 20px; }}
                .email-footer {{ background-color: #f0f0f0; padding: 15px; border-top: 1px solid #ddd; font-size: 12px; color: #666; }}
                .field {{ margin-bottom: 10px; }}
                .field-label {{ font-weight: bold; color: #555; }}
                .email-body {{ margin-top: 20px; padding-top: 20px; border-top: 1px solid #eee; }}
            </style>
        </head>
        <body>
            <div class="email-container">
                <div class="email-header">
                    <h2>Email Template Preview</h2>
                </div>
                <div class="email-content">
                    <div class="field">
                        <div class="field-label">To:</div>
                        <div>{emailTemplate.get('recipient', 'recipient@example.com')}</div>
                    </div>
                    <div class="field">
                        <div class="field-label">Subject:</div>
                        <div>{emailTemplate.get('subject', 'No Subject')}</div>
                    </div>
                    <div class="email-body">
                        {emailTemplate.get('htmlBody', '<p>No content</p>')}
                    </div>
                </div>
                <div class="email-footer">
                    <p>This is a preview of the email template. The actual email may appear differently in various email clients.</p>
                </div>
            </div>
        </body>
        </html>
        """
        return html

def getAgentEmail() -> AgentEmail:
    """Factory function to create and return an EmailAgent instance."""
    return AgentEmail()