"""
Google Calendar API Module
Provides comprehensive Google Calendar management functionality
"""

import logging
from datetime import datetime, timedelta
from typing import List, Dict, Optional, Any
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from .auth import calendar_auth

logger = logging.getLogger(__name__)

class GoogleCalendarAPI:
    """Google Calendar API wrapper class"""
    
    def __init__(self):
        self.service = None
        self._build_service()
    
    def _build_service(self):
        """Build the Google Calendar service"""
        try:
            credentials = calendar_auth.get_credentials()
            if credentials:
                self.service = build('calendar', 'v3', credentials=credentials)
                logger.info("Successfully built Google Calendar service")
            else:
                logger.error("Failed to build Google Calendar service: no credentials")
        except Exception as e:
            logger.error(f"Failed to build Google Calendar service: {e}")
            self.service = None
    
    def list_calendars(self) -> List[Dict[str, Any]]:
        """List all calendars accessible to the user"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            calendars = self.service.calendarList().list().execute()
            return calendars.get('items', [])
        except HttpError as e:
            logger.error(f"Error listing calendars: {e}")
            return {"error": str(e)}
    
    def get_calendar(self, calendar_id: str = 'primary') -> Dict[str, Any]:
        """Get details of a specific calendar"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            calendar = self.service.calendars().get(calendarId=calendar_id).execute()
            return calendar
        except HttpError as e:
            logger.error(f"Error getting calendar {calendar_id}: {e}")
            return {"error": str(e)}
    
    def create_calendar(self, summary: str, description: str = "", timezone: str = "UTC") -> Dict[str, Any]:
        """Create a new calendar"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            calendar = {
                'summary': summary,
                'description': description,
                'timeZone': timezone
            }
            
            created_calendar = self.service.calendars().insert(body=calendar).execute()
            return created_calendar
        except HttpError as e:
            logger.error(f"Error creating calendar: {e}")
            return {"error": str(e)}
    
    def delete_calendar(self, calendar_id: str) -> Dict[str, Any]:
        """Delete a calendar"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            self.service.calendars().delete(calendarId=calendar_id).execute()
            return {"success": f"Calendar {calendar_id} deleted successfully"}
        except HttpError as e:
            logger.error(f"Error deleting calendar {calendar_id}: {e}")
            return {"error": str(e)}
    
    def list_events(self, calendar_id: str = 'primary', max_results: int = 10, 
                   time_min: str = None, time_max: str = None) -> List[Dict[str, Any]]:
        """List events from a calendar"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            # Set default time range if not provided
            if not time_min:
                time_min = datetime.utcnow().isoformat() + 'Z'
            if not time_max:
                time_max = (datetime.utcnow() + timedelta(days=7)).isoformat() + 'Z'
            
            events_result = self.service.events().list(
                calendarId=calendar_id,
                timeMin=time_min,
                timeMax=time_max,
                maxResults=max_results,
                singleEvents=True,
                orderBy='startTime'
            ).execute()
            
            return events_result.get('items', [])
        except HttpError as e:
            logger.error(f"Error listing events: {e}")
            return {"error": str(e)}
    
    def get_event(self, calendar_id: str, event_id: str) -> Dict[str, Any]:
        """Get details of a specific event"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            event = self.service.events().get(
                calendarId=calendar_id,
                eventId=event_id
            ).execute()
            
            return event
        except HttpError as e:
            logger.error(f"Error getting event {event_id}: {e}")
            return {"error": str(e)}
    
    def create_event(self, calendar_id: str = 'primary', summary: str = "", 
                    description: str = "", start_time: str = None, end_time: str = None,
                    attendees: List[str] = None, location: str = "") -> Dict[str, Any]:
        """Create a new event"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            event = {
                'summary': summary,
                'description': description,
                'location': location,
                'start': {
                    'dateTime': start_time,
                    'timeZone': 'UTC',
                },
                'end': {
                    'dateTime': end_time,
                    'timeZone': 'UTC',
                }
            }
            
            if attendees:
                event['attendees'] = [{'email': email} for email in attendees]
            
            created_event = self.service.events().insert(
                calendarId=calendar_id,
                body=event
            ).execute()
            
            return created_event
        except HttpError as e:
            logger.error(f"Error creating event: {e}")
            return {"error": str(e)}
    
    def update_event(self, calendar_id: str, event_id: str, 
                    summary: str = None, description: str = None,
                    start_time: str = None, end_time: str = None,
                    attendees: List[str] = None, location: str = None) -> Dict[str, Any]:
        """Update an existing event"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            # Get current event
            event = self.service.events().get(
                calendarId=calendar_id,
                eventId=event_id
            ).execute()
            
            # Update fields if provided
            if summary:
                event['summary'] = summary
            if description:
                event['description'] = description
            if location:
                event['location'] = location
            if start_time:
                event['start']['dateTime'] = start_time
            if end_time:
                event['end']['dateTime'] = end_time
            if attendees:
                event['attendees'] = [{'email': email} for email in attendees]
            
            updated_event = self.service.events().update(
                calendarId=calendar_id,
                eventId=event_id,
                body=event
            ).execute()
            
            return updated_event
        except HttpError as e:
            logger.error(f"Error updating event {event_id}: {e}")
            return {"error": str(e)}
    
    def delete_event(self, calendar_id: str, event_id: str) -> Dict[str, Any]:
        """Delete an event"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            self.service.events().delete(
                calendarId=calendar_id,
                eventId=event_id
            ).execute()
            
            return {"success": f"Event {event_id} deleted successfully"}
        except HttpError as e:
            logger.error(f"Error deleting event {event_id}: {e}")
            return {"error": str(e)}
    
    def search_events(self, calendar_id: str = 'primary', query: str = "", 
                     max_results: int = 10) -> List[Dict[str, Any]]:
        """Search for events in a calendar"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            events_result = self.service.events().list(
                calendarId=calendar_id,
                q=query,
                maxResults=max_results,
                singleEvents=True,
                orderBy='startTime'
            ).execute()
            
            return events_result.get('items', [])
        except HttpError as e:
            logger.error(f"Error searching events: {e}")
            return {"error": str(e)}
    
    def get_free_busy(self, calendar_ids: List[str], time_min: str, time_max: str) -> Dict[str, Any]:
        """Get free/busy information for calendars"""
        try:
            if not self.service:
                return {"error": "Calendar service not available"}
            
            body = {
                'timeMin': time_min,
                'timeMax': time_max,
                'items': [{'id': cal_id} for cal_id in calendar_ids]
            }
            
            free_busy = self.service.freebusy().query(body=body).execute()
            return free_busy
        except HttpError as e:
            logger.error(f"Error getting free/busy info: {e}")
            return {"error": str(e)}