send_enhanced_gmail.py

#!/usr/bin/env python3
"""
Send enhanced Gmail-style personalized outbound emails via CCAI.
Handles both basic and enhanced Gmail outbound results.
"""

import asyncio
import json
import os
import aiohttp
from pathlib import Path
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

class CCAPIClient:
    """Client for CCAI API integration."""
    
    def __init__(self):
        self.api_key = os.getenv("CCAI_API_KEY")
        self.client_id = os.getenv("CCAI_CLIENT_ID")
        self.email_url = os.getenv("CCAI_EMAIL_URL")
        self.core_url = os.getenv("CCAI_CORE_URL")
        
        if not self.api_key or not self.client_id:
            raise ValueError("CCAI_API_KEY and CCAI_CLIENT_ID must be set in .env file")
        
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json",
            "Accept": "*/*",
            "clientId": self.client_id,
            "accountId": "1223"
        }
    
    async def send_personalized_email(self, first_name: str, last_name: str, to_email: str, subject: str, message: str):
        """Send personalized email via CCAI campaigns API."""
        try:
            from datetime import datetime, timedelta
            import pytz
            
            # Schedule for immediate sending
            pst = pytz.timezone('America/Los_Angeles')
            tomorrow = datetime.now(pst) + timedelta(days=1)
            scheduled_time = tomorrow.replace(hour=16, minute=30, second=0, microsecond=0)
            
            campaign = {
                "subject": subject,
                "title": f"Personalized Outbound - {first_name}",
                "message": message,
                "senderEmail": os.getenv("SENDER_EMAIL", "andreas@allcode.com"),
                "replyEmail": os.getenv("SENDER_EMAIL", "andreas@allcode.com"),
                "senderName": os.getenv("SENDER_NAME", "Andreas Garcia"),
                "scheduledTimestamp": scheduled_time.isoformat(),
                "scheduledTimezone": "America/Los_Angeles",
                "accounts": [{
                    "firstName": first_name,
                    "lastName": last_name,
                    "email": to_email,
                    "phone": ""
                }],
                "campaignType": "EMAIL",
                "addToList": "noList",
                "contactInput": "accounts",
                "fromType": "single",
                "senders": []
            }
            
            async with aiohttp.ClientSession() as session:
                async with session.post(
                    f"{self.email_url}/api/v1/campaigns",
                    headers=self.headers,
                    json=campaign
                ) as response:
                    result = await response.json()
                    return {
                        "success": response.status in [200, 201],
                        "status_code": response.status,
                        "response": result
                    }
        except Exception as e:
            return {"success": False, "error": str(e)}

async def send_enhanced_batch(results_file="enhanced_gmail_outbound_results.json"):
    """Send enhanced Gmail-style emails via CCAI."""
    
    # Check for results file
    if not Path(results_file).exists():
        print(f"❌ Results file not found: {results_file}")
        print("Run enhanced_gmail_outbound.py first to generate emails")
        return
    
    with open(results_file, 'r', encoding='utf-8') as f:
        contacts = json.load(f)
    
    if not contacts:
        print("❌ No contacts found in results file")
        return
    
    print(f"📧 Sending {len(contacts)} enhanced personalized emails via CCAI...")
    
    ccai_client = CCAPIClient()
    sent_emails = 0
    errors = []
    
    for i, contact in enumerate(contacts, 1):
        contact_info = contact["contact_info"]
        
        # Handle both enhanced and basic email formats
        email_content = contact.get("enhanced_gmail_email") or contact.get("gmail_email", "")
        
        print(f"\n📤 Sending to {contact_info['name']} ({i}/{len(contacts)})")
        
        # Show personalization analysis if available
        if "personalization_analysis" in contact:
            analysis = contact["personalization_analysis"]
            print(f"🧠 Personalization: {len([k for k, v in analysis.items() if v])} factors used")
        
        try:
            # Parse email content
            lines = email_content.split('\n')
            subject = lines[0].replace("Subject: ", "")
            
            # Find where the body starts
            body_start = 1
            while body_start < len(lines) and not lines[body_start].strip():
                body_start += 1
            
            body = '\n'.join(lines[body_start:])
            
            # Parse name
            name_parts = contact_info["name"].split()
            first_name = name_parts[0] if name_parts else "Friend"
            last_name = " ".join(name_parts[1:]) if len(name_parts) > 1 else ""
            
            # Send email
            email_result = await ccai_client.send_personalized_email(
                first_name=first_name,
                last_name=last_name,
                to_email=contact_info["email"],
                subject=subject,
                message=body
            )
            
            if email_result["success"]:
                print(f"✅ Email sent successfully")
                sent_emails += 1
            else:
                print(f"❌ Email failed: {email_result}")
                errors.append(f"Email to {contact_info['name']}: {email_result}")
                
        except Exception as e:
            print(f"❌ Email error: {e}")
            errors.append(f"Email to {contact_info['name']}: {e}")
        
        # Delay between emails
        await asyncio.sleep(3)
    
    print(f"\n🎉 Enhanced Gmail campaign completed!")
    print(f"📧 Emails sent: {sent_emails}")
    
    if errors:
        print(f"⚠️  Errors: {len(errors)}")
        for error in errors[:3]:
            print(f"   {error}")

async def preview_enhanced_emails(results_file="enhanced_gmail_outbound_results.json"):
    """Preview enhanced Gmail-style emails with personalization analysis."""
    
    if not Path(results_file).exists():
        print(f"❌ Results file not found: {results_file}")
        return
    
    with open(results_file, 'r', encoding='utf-8') as f:
        contacts = json.load(f)
    
    print(f"📧 Preview of {len(contacts)} enhanced personalized emails:")
    print("=" * 80)
    
    for i, contact in enumerate(contacts[:3], 1):
        contact_info = contact["contact_info"]
        email_content = contact.get("enhanced_gmail_email") or contact.get("gmail_email", "")
        
        print(f"\n📤 Email {i} - To: {contact_info['name']} ({contact_info['email']})")
        print(f"🏢 Company: {contact_info['company']} | Title: {contact_info['title']}")
        
        # Show personalization analysis
        if "personalization_analysis" in contact:
            analysis = contact["personalization_analysis"]
            print("🧠 Personalization factors used:")
            for key, value in analysis.items():
                if value:
                    if isinstance(value, list) and value:
                        print(f"   • {key}: {', '.join(value)}")
                    elif isinstance(value, str):
                        print(f"   • {key}: {value[:60]}...")
        
        print("-" * 60)
        print(email_content)
        print("-" * 60)
    
    if len(contacts) > 3:
        print(f"\n... and {len(contacts) - 3} more personalized emails")

async def analyze_personalization_stats(results_file="enhanced_gmail_outbound_results.json"):
    """Analyze personalization statistics from the results."""
    
    if not Path(results_file).exists():
        print(f"❌ Results file not found: {results_file}")
        return
    
    with open(results_file, 'r', encoding='utf-8') as f:
        contacts = json.load(f)
    
    print(f"📊 Personalization Analysis for {len(contacts)} contacts:")
    print("=" * 50)
    
    # Count personalization factors
    factor_counts = {}
    for contact in contacts:
        if "personalization_analysis" in contact:
            analysis = contact["personalization_analysis"]
            for key, value in analysis.items():
                if value:
                    factor_counts[key] = factor_counts.get(key, 0) + 1
    
    print("🧠 Personalization factors used:")
    for factor, count in sorted(factor_counts.items(), key=lambda x: x[1], reverse=True):
        percentage = (count / len(contacts)) * 100
        print(f"   • {factor}: {count}/{len(contacts)} ({percentage:.1f}%)")
    
    # Show sample personalizations
    print(f"\n📝 Sample personalizations:")
    for i, contact in enumerate(contacts[:2], 1):
        if "personalization_analysis" in contact:
            print(f"\n{i}. {contact['contact_info']['name']}:")
            analysis = contact["personalization_analysis"]
            for key, value in analysis.items():
                if value and isinstance(value, str) and len(value) > 10:
                    print(f"   • {key}: {value[:80]}...")

if __name__ == "__main__":
    import sys
    
    print("🚀 Enhanced Gmail-Style Email Sender")
    print("=" * 40)
    
    if len(sys.argv) > 1:
        if sys.argv[1] == "preview":
            asyncio.run(preview_enhanced_emails())
        elif sys.argv[1] == "stats":
            asyncio.run(analyze_personalization_stats())
        elif sys.argv[1] == "basic":
            # Send basic Gmail emails
            asyncio.run(send_enhanced_batch("gmail_outbound_results.json"))
        else:
            print("Usage: python send_enhanced_gmail.py [preview|stats|basic]")
    else:
        # Send enhanced emails by default
        asyncio.run(send_enhanced_batch())