#!/usr/bin/env python3
"""
Fixed Gmail integration for Rivet's morning brief.
Simplified version that works reliably.
"""

import json
import requests
import sys
import re
from datetime import datetime, timezone
from pathlib import Path

# Configuration
TOKEN_PATH = Path("/root/.clawdbot/google-oauth.json")
OUTPUT_PATH = Path("/home/ccuser/rateright-growth/rivet/memory/gmail-summary.md")
GMAIL_API_BASE = "https://gmail.googleapis.com/gmail/v1/users/me"

def load_token():
    """Load access token from file."""
    try:
        with open(TOKEN_PATH, 'r') as f:
            token_data = json.load(f)
        return token_data.get('access_token', '')
    except Exception as e:
        print(f"Error loading token: {e}")
        return ""

def refresh_token():
    """Refresh access token using refresh_token."""
    try:
        # Read credentials
        with open(TOKEN_PATH, 'r') as f:
            credentials = json.load(f)
        
        client_id = credentials.get('client_id')
        client_secret = credentials.get('client_secret')
        refresh_token = credentials.get('refresh_token')
        
        if not all([client_id, client_secret, refresh_token]):
            print("Missing credentials for refresh")
            return ""
        
        # Refresh token
        data = {
            'client_id': client_id,
            'client_secret': client_secret,
            'refresh_token': refresh_token,
            'grant_type': 'refresh_token'
        }
        
        response = requests.post('https://oauth2.googleapis.com/token', data=data, timeout=10)
        if response.status_code == 200:
            new_token = response.json().get('access_token')
            # Update token file
            credentials['access_token'] = new_token
            with open(TOKEN_PATH, 'w') as f:
                json.dump(credentials, f, indent=2)
            print("Token refreshed successfully")
            return new_token
        else:
            print(f"Token refresh failed: {response.status_code} {response.text}")
            return ""
    except Exception as e:
        print(f"Error refreshing token: {e}")
        return ""

def make_gmail_request(endpoint, access_token, params=None):
    """Make a request to Gmail API with timeout and retry."""
    headers = {
        "Authorization": f"Bearer {access_token}",
        "Accept": "application/json"
    }
    
    url = f"{GMAIL_API_BASE}/{endpoint}"
    
    try:
        response = requests.get(url, headers=headers, params=params, timeout=30)
        
        # If token expired, refresh and retry once
        if response.status_code == 401:
            print("Token expired, refreshing...")
            new_token = refresh_token()
            if new_token:
                headers["Authorization"] = f"Bearer {new_token}"
                response = requests.get(url, headers=headers, params=params, timeout=30)
            else:
                print("Failed to refresh token")
                return None
        
        response.raise_for_status()
        return response.json()
        
    except requests.exceptions.RequestException as e:
        print(f"API request failed: {e}")
        return None

def get_unread_messages(access_token, max_results=20):
    """Fetch unread messages from Gmail."""
    params = {
        "labelIds": ["UNREAD"],
        "maxResults": max_results
    }
    
    data = make_gmail_request("messages", access_token, params)
    if not data or 'messages' not in data:
        return []
    
    messages = []
    for msg in data['messages'][:5]:  # Limit to 5 messages for speed
        msg_id = msg['id']
        msg_data = make_gmail_request(f"messages/{msg_id}", access_token, {
            "format": "metadata",
            "metadataHeaders": ["From", "Subject", "Date"]
        })
        
        if msg_data:
            messages.append(msg_data)
    
    return messages

def extract_email_info(message):
    """Extract relevant information from a message."""
    headers = message.get('payload', {}).get('headers', [])
    
    info = {
        'id': message.get('id', ''),
        'subject': '',
        'from': '',
        'date': '',
        'snippet': message.get('snippet', '')[:100],
        'internalDate': message.get('internalDate', '')
    }
    
    for header in headers:
        name = header.get('name', '').lower()
        value = header.get('value', '')
        
        if name == 'subject':
            info['subject'] = value
        elif name == 'from':
            # Extract email address from "Name <email@example.com>" format
            match = re.search(r'<([^>]+)>', value)
            if match:
                info['from'] = match.group(1).lower()
            else:
                info['from'] = value.lower()
        elif name == 'date':
            info['date'] = value
    
    return info

def categorize_email(info):
    """Categorize email based on content."""
    subject = info['subject'].lower()
    from_email = info['from']
    snippet = info['snippet'].lower()
    
    # Urgent keywords
    urgent_keywords = ["urgent", "asap", "immediate", "important", "invoice", "payment", "due", "deadline"]
    for keyword in urgent_keywords:
        if keyword in subject or keyword in snippet:
            return "urgent"
    
    # Business keywords
    business_keywords = ["meeting", "call", "project", "proposal", "contract", "agreement", "business", "work"]
    for keyword in business_keywords:
        if keyword in subject or keyword in snippet:
            return "business"
    
    # Known contacts
    known_contacts = [
        "admin@rateright.com.au",
        "chris@rateright.com.au",
        "team@rateright.com.au",
        "support@rateright.com.au",
        "info@rateright.com.au"
    ]
    
    if any(contact in from_email for contact in known_contacts):
        return "business"
    
    # Newsletter/promotion indicators
    low_indicators = ["newsletter", "promotion", "offer", "sale", "discount", "unsubscribe", "marketing"]
    for indicator in low_indicators:
        if indicator in subject or indicator in snippet:
            return "low"
    
    return "other"

def generate_summary(messages):
    """Generate summary markdown from messages."""
    if not messages:
        return "# 📧 Email Summary\n\nNo unread emails.\n"
    
    categorized = {"urgent": [], "business": [], "other": [], "low": []}
    
    for msg in messages:
        info = extract_email_info(msg)
        category = categorize_email(info)
        categorized[category].append(info)
    
    output = ["# 📧 Email Summary"]
    output.append(f"\n**Total unread:** {len(messages)}")
    
    # Add urgent emails first
    if categorized["urgent"]:
        output.append("\n## 🔴 Urgent")
        for email in categorized["urgent"]:
            output.append(f"- **{email['subject']}** — from {email['from']}")
            if email['snippet']:
                output.append(f"  *{email['snippet']}...*")
    
    # Add business emails
    if categorized["business"]:
        output.append("\n## 🟡 Business")
        for email in categorized["business"]:
            output.append(f"- {email['subject']} — from {email['from']}")
    
    # Add other emails (truncated)
    if categorized["other"]:
        output.append(f"\n## ⚪ Other ({len(categorized['other'])} more)")
        for email in categorized["other"][:3]:  # Show only first 3
            output.append(f"- {email['subject'][:50]}{'...' if len(email['subject']) > 50 else ''}")
        if len(categorized["other"]) > 3:
            output.append(f"  ... and {len(categorized['other']) - 3} more")
    
    # Note about low priority emails
    if categorized["low"]:
        output.append(f"\n*({len(categorized['low'])} promotional/newsletter emails filtered out)*")
    
    output.append(f"\n\n*Last checked: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M UTC')}*")
    
    return "\n".join(output)

def main():
    print("Starting Gmail check...")
    
    # Load token
    token = load_token()
    if not token:
        print("No token available")
        sys.exit(1)
    
    # Get unread messages
    messages = get_unread_messages(token, max_results=10)
    print(f"Retrieved {len(messages)} messages")
    
    # Generate summary
    summary = generate_summary(messages)
    
    # Write to file
    try:
        with open(OUTPUT_PATH, 'w') as f:
            f.write(summary)
        print(f"Summary written to {OUTPUT_PATH}")
    except Exception as e:
        print(f"Error writing summary: {e}")
        sys.exit(1)
    
    print("Gmail check completed successfully")

if __name__ == "__main__":
    main()