"""
Excel method module.
Handles Excel operations using the Excel service.
"""

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

from modules.interfaces.interfaceExcel import ExcelService
from modules.methods.methodBase import MethodBase, MethodResult, action

logger = logging.getLogger(__name__)

class MethodExcel(MethodBase):
    """Excel method implementation"""
    
    def __init__(self, serviceContainer):
        """Initialize the Excel method"""
        super().__init__(serviceContainer)
        self.excelService = ExcelService(serviceContainer)

    @action
    async def read(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Read data from Excel file
        
        Args:
            parameters:
                fileId: ID of the Excel file
                sheetName: Name of the sheet to read
                range: Cell range to read (e.g. "A1:B10")
        """
        try:
            fileId = parameters["fileId"]
            sheetName = parameters.get("sheetName", "Sheet1")
            range = parameters.get("range")
            
            # Get file from service
            file = await self.service.interfaceComponent.getFile(fileId)
            if not file:
                return self._createResult(
                    success=False,
                    data={"error": f"File not found: {fileId}"}
                )
            
            # Read data from Excel
            data = await self.excelService.readData(file, sheetName, range)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": fileId,
                    "sheetName": sheetName,
                    "range": range,
                    "data": data
                }
            )
            
        except Exception as e:
            logger.error(f"Error reading Excel file: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def write(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Write data to Excel file
        
        Args:
            parameters:
                fileId: ID of the Excel file
                sheetName: Name of the sheet to write to
                range: Cell range to write to (e.g. "A1:B10")
                data: Data to write
        """
        try:
            fileId = parameters["fileId"]
            sheetName = parameters.get("sheetName", "Sheet1")
            range = parameters.get("range")
            data = parameters["data"]
            
            # Get file from service
            file = await self.service.interfaceComponent.getFile(fileId)
            if not file:
                return self._createResult(
                    success=False,
                    data={"error": f"File not found: {fileId}"}
                )
            
            # Write data to Excel
            await self.excelService.writeData(file, sheetName, range, data)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": fileId,
                    "sheetName": sheetName,
                    "range": range
                }
            )
            
        except Exception as e:
            logger.error(f"Error writing to Excel file: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def create(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Create new Excel file
        
        Args:
            parameters:
                fileName: Name of the new file
                sheets: List of sheet configurations
        """
        try:
            fileName = parameters["fileName"]
            sheets = parameters.get("sheets", [{"name": "Sheet1"}])
            
            # Create new Excel file
            file = await self.excelService.createFile(fileName, sheets)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": file.id,
                    "fileName": fileName,
                    "sheets": sheets
                }
            )
            
        except Exception as e:
            logger.error(f"Error creating Excel file: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def format(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Format Excel cells
        
        Args:
            parameters:
                fileId: ID of the Excel file
                sheetName: Name of the sheet to format
                range: Cell range to format (e.g. "A1:B10")
                format: Format configuration
        """
        try:
            fileId = parameters["fileId"]
            sheetName = parameters.get("sheetName", "Sheet1")
            range = parameters.get("range")
            format = parameters["format"]
            
            # Get file from service
            file = await self.service.interfaceComponent.getFile(fileId)
            if not file:
                return self._createResult(
                    success=False,
                    data={"error": f"File not found: {fileId}"}
                )
            
            # Apply formatting
            await self.excelService.formatCells(file, sheetName, range, format)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": fileId,
                    "sheetName": sheetName,
                    "range": range
                }
            )
            
        except Exception as e:
            logger.error(f"Error formatting Excel cells: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )