Displaying Google Calendar Events in Conky

#!/usr/bin/env python3
import os
import socket
from datetime import datetime, timedelta
from pathlib import Path

try:
    from dotenv import load_dotenv
    from google.oauth2 import service_account
    from googleapiclient.discovery import build
    DEPENDENCIES_AVAILABLE = True
except ImportError as e:
    DEPENDENCIES_AVAILABLE = False
    print(f"Missing dependencies: {e}")

# Load configuration
script_dir = Path(__file__).parent
env_file = script_dir / '.env'
if env_file.exists():
    load_dotenv(env_file)

SERVICE_ACCOUNT_FILE = os.getenv('GOOGLE_SERVICE_ACCOUNT_FILE', 'google_calendar_key.json')
CALENDAR_ID = os.getenv('GOOGLE_CALENDAR_ID', 'primary')
MAX_EVENTS = int(os.getenv('MAX_EVENTS', '10'))
CACHE_DAYS = int(os.getenv('CACHE_DAYS', '7'))
CACHE_FILE = os.path.expanduser("~/.conky/calendar_cache.txt")
SCOPES = ['https://www.googleapis.com/auth/calendar.readonly']

def check_internet():
    try:
        socket.create_connection(("8.8.8.8", 53), timeout=3)
        return True
    except OSError:
        return False

def get_calendar_service():
    try:
        script_dir = Path(__file__).parent
        service_account_path = script_dir / SERVICE_ACCOUNT_FILE
        
        if not service_account_path.exists():
            raise FileNotFoundError(f"Service account file not found: {service_account_path}")
        
        credentials = service_account.Credentials.from_service_account_file(
            str(service_account_path), scopes=SCOPES
        )
        return build('calendar', 'v3', credentials=credentials)
    except Exception as e:
        print(f"Error creating calendar service: {e}")
        return None

def get_events():
    try:
        service = get_calendar_service()
        if not service:
            return None
        
        now = datetime.now()
        start_time = now.replace(hour=0, minute=0, second=0, microsecond=0)
        end_time = start_time + timedelta(days=CACHE_DAYS)
        
        time_min = start_time.isoformat() + 'Z'
        time_max = end_time.isoformat() + 'Z'
        
        # Key parameter: singleEvents=True expands recurring events
        events_result = service.events().list(
            calendarId=CALENDAR_ID,
            timeMin=time_min,
            timeMax=time_max,
            maxResults=MAX_EVENTS * 2,
            singleEvents=True,  # Expands recurring events
            orderBy='startTime'
        ).execute()
        
        events = events_result.get('items', [])
        return events[:MAX_EVENTS]
    except Exception as e:
        print(f"Error fetching events: {e}")
        return None

def format_event(event):
    try:
        summary = event.get('summary', 'No Title')
        start = event.get('start', {})
        
        if 'dateTime' in start:
            dt_str = start['dateTime']
            dt = datetime.fromisoformat(dt_str.replace('Z', '+00:00')).astimezone()
            time_str = dt.strftime('%m/%d %H:%M' if CACHE_DAYS > 1 else '%H:%M')
        elif 'date' in start:
            date_obj = datetime.fromisoformat(start['date'])
            time_str = date_obj.strftime('%m/%d All Day' if CACHE_DAYS > 1 else 'All Day')
        else:
            time_str = '??:??'
        
        # Truncate long summaries
        max_length = 35 if CACHE_DAYS > 1 else 40
        if len(summary) > max_length:
            summary = summary[:max_length-3] + '...'
        
        # Add recurring indicator
        if event.get('recurringEventId'):
            summary += " ↻"
        
        return f"{time_str} - {summary}"
    except Exception as e:
        return f"Error formatting event: {e}"

def load_cache():
    try:
        if os.path.exists(CACHE_FILE):
            with open(CACHE_FILE, 'r') as f:
                return f.read().strip()
    except Exception:
        pass
    return None

def save_cache(content):
    try:
        cache_dir = os.path.dirname(CACHE_FILE)
        os.makedirs(cache_dir, exist_ok=True)
        with open(CACHE_FILE, 'w') as f:
            f.write(content)
    except Exception as e:
        print(f"Error saving cache: {e}")

def main():
    if not DEPENDENCIES_AVAILABLE:
        print("Required dependencies not installed")
        return
    
    script_dir = Path(__file__).parent
    if not (script_dir / SERVICE_ACCOUNT_FILE).exists():
        print(f"Service account file not found: {SERVICE_ACCOUNT_FILE}")
        return
    
    if not check_internet():
        cached_content = load_cache()
        if cached_content:
            print(cached_content)
        else:
            print("No internet connection and no cached data")
        return
    
    events = get_events()
    
    if events is None:
        cached_content = load_cache()
        if cached_content:
            print("Using cached data:")
            print(cached_content)
        else:
            print("Unable to fetch calendar events")
        return
    
    if not events:
        days_text = f"next {CACHE_DAYS} day{'s' if CACHE_DAYS > 1 else ''}" if CACHE_DAYS > 1 else "today"
        output = f"No events {days_text}"
    else:
        formatted_events = [format_event(event) for event in events]
        output = '\n'.join(formatted_events)
    
    save_cache(output)
    print(output)

if __name__ == '__main__':
    main()