import requests
import json
from openai import OpenAI
from datetime import datetime
from typing import Dict, List, Optional
import csv

# API Setup
B2D_API_KEY = "YOUR_B2D_API_KEY"
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY"

openai_client = OpenAI(api_key=OPENAI_API_KEY)

# Your product launch details
PRODUCT_INFO = {
    "name": "DevFlow AI",
    "description": "AI-powered code review and documentation generation tool",
    "key_features": [
        "Automated code review with GPT-4",
        "Generate documentation from code comments", 
        "Integrate with GitHub, GitLab, and Bitbucket",
        "Real-time collaboration features",
        "Custom coding standards enforcement"
    ],
    "target_audience": "Python, JavaScript, TypeScript, and Go developers",
    "launch_date": "December 2024",
    "pricing": "Free tier + $29/month pro",
    "website": "https://devflow.ai",
    "beta_signup": "https://devflow.ai/beta"
}

# Target developers list (GitHub usernames, emails, or LinkedIn profiles)
TARGET_DEVELOPERS = [
    {"type": "github_username", "value": "gvanrossum"},  # Python creator
    {"type": "github_username", "value": "tj"},  # Express.js creator
    {"type": "github_username", "value": "sindresorhus"},  # Popular OSS developer
    {"type": "email", "value": "developer@company.com"},
    {"type": "linkedin_username", "value": "johnsmith"},
    # Add your target list here - up to 1000 developers
]

print(f"🚀 Product Launch Outreach for {PRODUCT_INFO['name']}")
print(f"📋 Targeting {len(TARGET_DEVELOPERS)} developers")

def enrich_developer_profile(target: Dict) -> Optional[Dict]:
    """Enrich a single developer profile using B2D API"""
    
    # Build API parameters based on target type
    params = {"api_key": B2D_API_KEY, "size": 1, "summary_length": 2048}
    
    if target["type"] == "github_username":
        params["github_username"] = target["value"]
    elif target["type"] == "email":
        params["email"] = target["value"]
    elif target["type"] == "linkedin_username":
        params["linkedin_username"] = target["value"]
    else:
        print(f"❌ Unknown target type: {target['type']}")
        return None
    
    try:
        response = requests.get("https://api.b2d.ai/user", params=params)
        
        if response.status_code == 200:
            data = response.json()
            if data.get('results'):
                profile = data['results'][0]  # Get first match
                return profile
            else:
                print(f"❌ No profile found for {target['value']}")
                return None
        else:
            error_msg = response.json().get('error', 'Unknown error')
            print(f"❌ API error for {target['value']}: {error_msg}")
            return None
            
    except Exception as e:
        print(f"❌ Exception for {target['value']}: {e}")
        return None

# Enrich all target developers
print("\n🔍 Enriching developer profiles...")
enriched_profiles = []
credits_used = 0

for i, target in enumerate(TARGET_DEVELOPERS, 1):
    print(f"  {i}/{len(TARGET_DEVELOPERS)}: Looking up {target['value']}")
    
    profile = enrich_developer_profile(target)
    if profile:
        enriched_profiles.append(profile)
        credits_used += 1
        
        name = profile.get('full_name', profile.get('github_username', 'Unknown'))
        company = profile.get('company', 'N/A')
        followers = profile.get('followers', 0)
        
        print(f"    ✅ Found: {name} - {company} ({followers} followers)")
        
        # Show top skills
        skills = profile.get('skills', [])[:3]
        if skills:
            skill_names = [skill['skill'] for skill in skills]
            print(f"    🛠️  Top skills: {', '.join(skill_names)}")
    else:
        print(f"    ❌ Profile not found")
    
    print()

print(f"✅ Successfully enriched {len(enriched_profiles)} developer profiles")
print(f"💳 Credits used: {credits_used}")

🔍 Enriching developer profiles...
  1/5: Looking up gvanrossum
    ✅ Found: Guido van Rossum - Python Software Foundation (15234 followers)
    🛠️  Top skills: Python, Programming Languages, Software Architecture

  2/5: Looking up tj
    ✅ Found: TJ Holowaychuk - N/A (8901 followers)  
    🛠️  Top skills: JavaScript, Node.js, Go

  3/5: Looking up sindresorhus
    ✅ Found: Sindre Sorhus - N/A (12543 followers)
    🛠️  Top skills: JavaScript, TypeScript, Node.js

✅ Successfully enriched 3 developer profiles
💳 Credits used: 3

def generate_launch_message(profile: Dict, product_info: Dict) -> Dict:
    """Generate personalized product launch message using GPT-4"""
    
    # Extract key profile information for personalization
    developer_data = {
        "name": profile.get('full_name', profile.get('github_username')),
        "github_username": profile.get('github_username'),
        "bio": profile.get('bio', ''),
        "company": profile.get('company', ''),
        "location": profile.get('location', ''),
        "followers": profile.get('followers', 0),
        "top_skills": [skill['skill'] for skill in profile.get('skills', [])[:5]],
        "recent_repos": [
            {
                "name": repo.get('full_name', ''),
                "description": repo.get('description', ''),
                "language": repo.get('language', ''),
                "stars": repo.get('stargazers_count', 0)
            }
            for repo in profile.get('repos', [])[:3]
        ],
        "summary_text": profile.get('summary_text', '')[:500]  # First 500 chars
    }
    
    system_prompt = f"""You are an expert developer relations professional writing personalized outreach messages.

Product Information:
- Name: {product_info['name']}
- Description: {product_info['description']}
- Key Features: {', '.join(product_info['key_features'])}
- Target Audience: {product_info['target_audience']}
- Pricing: {product_info['pricing']}
- Beta Signup: {product_info['beta_signup']}

Write a personalized message to introduce this product to the developer. The message should:

1. **Personal Connection**: Reference their specific projects, skills, or contributions
2. **Relevant Benefits**: Highlight features most relevant to their work
3. **Professional Tone**: Respectful, not salesy, focus on value
4. **Clear CTA**: Include the beta signup link naturally
5. **Concise**: 2-3 paragraphs maximum

Important:
- Reference specific repositories or technologies they use
- Explain WHY this product would be useful for their specific work
- Avoid generic praise - be specific about their contributions
- Don't oversell - present genuine value proposition

Return a JSON object with:
- "subject_line": Email subject (under 50 characters)
- "message": Full personalized message
- "reasoning": Brief explanation of personalization approach
- "relevance_score": 1-10 score of how relevant the product is to this developer"""

    try:
        response = openai_client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": json.dumps(developer_data, indent=2)}
            ],
            temperature=0.8,  # Slightly higher for creativity
            max_tokens=800
        )
        
        result = response.choices[0].message.content.strip()
        
        # Parse JSON response
        if result.startswith("```json"):
            result = result.replace("```json", "").replace("```", "").strip()
        
        message_data = json.loads(result)
        
        # Add token usage for cost tracking
        usage = response.usage
        message_data['tokens_used'] = usage.total_tokens
        message_data['estimated_cost'] = usage.total_tokens * 0.00015  # GPT-4o-mini pricing
        
        return message_data
        
    except Exception as e:
        print(f"❌ Message generation error: {e}")
        return {
            "subject_line": f"Introducing {product_info['name']}",
            "message": f"Hi! We'd love to introduce you to {product_info['name']}...",
            "reasoning": "Fallback message due to generation error",
            "relevance_score": 5,
            "tokens_used": 0,
            "estimated_cost": 0
        }

# Generate messages for all enriched profiles
print("\n✍️  Generating personalized messages...")

outreach_campaigns = []
total_tokens = 0
total_cost = 0

for i, profile in enumerate(enriched_profiles, 1):
    name = profile.get('full_name', profile.get('github_username', 'Developer'))
    username = profile.get('github_username')
    
    print(f"  {i}/{len(enriched_profiles)}: Generating message for {name} (@{username})")
    
    message_data = generate_launch_message(profile, PRODUCT_INFO)
    
    # Combine profile and message data
    campaign_entry = {
        **profile,  # Include full profile
        **message_data,  # Include generated message
        "generated_at": datetime.now().isoformat()
    }
    
    outreach_campaigns.append(campaign_entry)
    
    total_tokens += message_data.get('tokens_used', 0)
    total_cost += message_data.get('estimated_cost', 0)
    
    print(f"    ✅ Relevance: {message_data['relevance_score']}/10")
    print(f"    📧 Subject: \"{message_data['subject_line']}\"")
    print(f"    💰 Cost: ${message_data.get('estimated_cost', 0):.4f}")
    print()

print(f"✅ Generated {len(outreach_campaigns)} personalized messages")
print(f"💰 Total GPT cost: ${total_cost:.4f}")
print(f"🔢 Total tokens used: {total_tokens}")

# Sort by relevance score
high_relevance = sorted(outreach_campaigns, key=lambda x: x['relevance_score'], reverse=True)

print("\n🏆 Top 5 Most Relevant Messages:")
print("=" * 100)

for i, campaign in enumerate(high_relevance[:5], 1):
    name = campaign.get('full_name', campaign.get('github_username'))
    username = campaign.get('github_username')
    email = campaign.get('email', 'No email found')
    relevance = campaign['relevance_score']
    
    print(f"{i}. {name} (@{username}) - Relevance: {relevance}/10")
    print(f"   📧 {email}")
    print(f"   🏢 {campaign.get('company', 'N/A')} | 📍 {campaign.get('location', 'N/A')}")
    print()
    print(f"   Subject: {campaign['subject_line']}")
    print(f"   Message:")
    print(f"   {campaign['message']}")
    print()
    print(f"   Reasoning: {campaign['reasoning']}")
    print("-" * 100)

# Filter by relevance threshold
high_relevance_campaigns = [c for c in outreach_campaigns if c['relevance_score'] >= 7]
medium_relevance_campaigns = [c for c in outreach_campaigns if 5 <= c['relevance_score'] < 7]
low_relevance_campaigns = [c for c in outreach_campaigns if c['relevance_score'] < 5]

print(f"\n📊 Campaign Segmentation:")
print(f"   🎯 High relevance (7-10): {len(high_relevance_campaigns)} developers")
print(f"   📈 Medium relevance (5-6): {len(medium_relevance_campaigns)} developers")  
print(f"   📉 Low relevance (1-4): {len(low_relevance_campaigns)} developers")

# Show contact coverage
contactable = [c for c in outreach_campaigns if c.get('email')]
print(f"\n📬 Contact Information:")
print(f"   📧 Have email addresses: {len(contactable)}/{len(outreach_campaigns)} developers")

🏆 Top 5 Most Relevant Messages:

1. Guido van Rossum (@gvanrossum) - Relevance: 9/10
   📧 guido@python.org
   🏢 Python Software Foundation | 📍 California, USA

   Subject: DevFlow AI: Code Review for Python Ecosystem
   Message:
   Hi Guido,

   As the creator of Python, I thought you'd be interested in DevFlow AI - a new AI-powered code review tool that's particularly strong with Python codebases. Given your continued involvement in Python's development and your focus on code clarity and maintainability, this tool could be valuable for the Python community.

   DevFlow AI uses GPT-4 to automatically review code for Python best practices, generate documentation from docstrings, and enforce coding standards - all areas where Python has strong conventions. We'd love to have your feedback during our beta phase.

   Would you be interested in trying it out? You can sign up at https://devflow.ai/beta

   Best regards,
   The DevFlow AI Team

   Reasoning: High relevance due to Python expertise and focus on code quality. Referenced his role in Python development and specific benefits for Python community.

----------------------------------------

✅ Generated 5 personalized messages
💰 Total GPT cost: $0.0234
🔢 Total tokens used: 1560

def format_email_template(campaign: Dict) -> str:
    """Format campaign data as email template"""
    
    email_template = f"""To: {campaign.get('email', 'EMAIL_PLACEHOLDER')}
From: your-email@company.com
Subject: {campaign['subject_line']}

{campaign['message']}

---
Developer Profile:
- GitHub: https://github.com/{campaign.get('github_username', '')}
- Company: {campaign.get('company', 'N/A')}
- Location: {campaign.get('location', 'N/A')}
- Followers: {campaign.get('followers', 0):,}
- Top Skills: {', '.join([skill['skill'] for skill in campaign.get('skills', [])[:3]])}

Generated on {campaign.get('generated_at', '')}
Relevance Score: {campaign.get('relevance_score', 0)}/10
"""
    return email_template

# Generate email templates for high-relevance campaigns
print("\n📧 Creating email templates...")

email_templates = []
for campaign in high_relevance_campaigns:
    template = format_email_template(campaign)
    email_templates.append({
        'developer': campaign.get('full_name', campaign.get('github_username')),
        'email': campaign.get('email'),
        'template': template,
        'relevance': campaign['relevance_score']
    })

# Save individual email files
import os
os.makedirs('outreach_emails', exist_ok=True)

for i, template_data in enumerate(email_templates):
    developer = template_data['developer'].replace(' ', '_').replace('@', '_')
    filename = f"outreach_emails/email_{i+1:02d}_{developer}.txt"
    
    with open(filename, 'w') as f:
        f.write(template_data['template'])

print(f"✅ Created {len(email_templates)} email templates in outreach_emails/")

# Export CSV for email tools (Mailchimp, SendGrid, etc.)
csv_filename = f"product_launch_outreach_{datetime.now().strftime('%Y%m%d')}.csv"

with open(csv_filename, 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f)
    
    # CSV headers
    writer.writerow([
        'Name', 'Email', 'GitHub Username', 'Company', 'Location', 
        'Followers', 'Top Skills', 'Subject Line', 'Message', 
        'Relevance Score', 'Profile URL'
    ])
    
    # Write high-relevance campaigns
    for campaign in high_relevance_campaigns:
        if campaign.get('email'):  # Only include contactable developers
            writer.writerow([
                campaign.get('full_name', ''),
                campaign.get('email', ''),
                campaign.get('github_username', ''),
                campaign.get('company', ''),
                campaign.get('location', ''),
                campaign.get('followers', 0),
                ', '.join([skill['skill'] for skill in campaign.get('skills', [])[:3]]),
                campaign.get('subject_line', ''),
                campaign.get('message', '').replace('\n', ' '),  # Single line for CSV
                campaign.get('relevance_score', 0),
                f"https://github.com/{campaign.get('github_username', '')}"
            ])

print(f"📊 Exported CSV: {csv_filename}")

# Campaign Analytics
def generate_campaign_report(campaigns: List[Dict]) -> Dict:
    """Generate comprehensive campaign analytics"""
    
    total_campaigns = len(campaigns)
    contactable = len([c for c in campaigns if c.get('email')])
    
    # Relevance distribution
    relevance_scores = [c['relevance_score'] for c in campaigns]
    avg_relevance = sum(relevance_scores) / len(relevance_scores) if relevance_scores else 0
    
    # Skills analysis
    all_skills = []
    for campaign in campaigns:
        skills = campaign.get('skills', [])
        all_skills.extend([skill['skill'] for skill in skills[:5]])
    
    from collections import Counter
    top_skills = Counter(all_skills).most_common(10)
    
    # Company analysis
    companies = [c.get('company', 'Unknown') for c in campaigns if c.get('company')]
    top_companies = Counter(companies).most_common(5)
    
    # Location analysis
    locations = [c.get('location', 'Unknown') for c in campaigns if c.get('location')]
    top_locations = Counter(locations).most_common(5)
    
    # Cost analysis
    total_cost = sum(c.get('estimated_cost', 0) for c in campaigns)
    total_tokens = sum(c.get('tokens_used', 0) for c in campaigns)
    
    return {
        "campaign_overview": {
            "total_developers_targeted": total_campaigns,
            "successfully_enriched": len([c for c in campaigns if c.get('github_username')]),
            "contactable_developers": contactable,
            "average_relevance_score": round(avg_relevance, 1),
            "high_relevance_count": len([c for c in campaigns if c['relevance_score'] >= 7])
        },
        "audience_analysis": {
            "top_skills": top_skills,
            "top_companies": top_companies,
            "top_locations": top_locations
        },
        "cost_analysis": {
            "b2d_credits_used": total_campaigns,
            "b2d_cost": total_campaigns * 0.01,
            "openai_cost": total_cost,
            "total_cost": total_campaigns * 0.01 + total_cost,
            "cost_per_message": (total_campaigns * 0.01 + total_cost) / total_campaigns,
            "tokens_used": total_tokens
        },
        "recommendations": {
            "priority_outreach": f"Focus on {len([c for c in campaigns if c['relevance_score'] >= 8])} developers with 8+ relevance",
            "skill_targeting": f"Top skill match: {top_skills[0][0]} ({top_skills[0][1]} developers)" if top_skills else "N/A",
            "geographic_focus": f"Top location: {top_locations[0][0]} ({top_locations[0][1]} developers)" if top_locations else "N/A"
        }
    }

# Generate report
campaign_report = generate_campaign_report(outreach_campaigns)

# Display report
print("\n📊 Campaign Analytics Report")
print("=" * 60)

print(f"\n📈 Campaign Overview:")
overview = campaign_report["campaign_overview"]
for key, value in overview.items():
    print(f"   {key.replace('_', ' ').title()}: {value}")

print(f"\n👥 Audience Analysis:")
audience = campaign_report["audience_analysis"]

print(f"   Top Skills:")
for skill, count in audience["top_skills"][:5]:
    print(f"     • {skill}: {count} developers")

print(f"   Top Companies:")
for company, count in audience["top_companies"][:3]:
    print(f"     • {company}: {count} developers")

print(f"\n💰 Cost Analysis:")
costs = campaign_report["cost_analysis"]
print(f"   B2D API Credits: {costs['b2d_credits_used']} credits (${costs['b2d_cost']:.2f})")
print(f"   OpenAI API Cost: ${costs['openai_cost']:.4f}")
print(f"   Total Campaign Cost: ${costs['total_cost']:.4f}")
print(f"   Cost per Message: ${costs['cost_per_message']:.4f}")

print(f"\n🎯 Recommendations:")
recs = campaign_report["recommendations"]
for key, value in recs.items():
    print(f"   • {value}")

# Save comprehensive report
report_filename = f"product_launch_report_{datetime.now().strftime('%Y%m%d_%H%M')}.json"
full_report = {
    "product_info": PRODUCT_INFO,
    "campaign_analytics": campaign_report,
    "campaigns": outreach_campaigns,
    "generated_at": datetime.now().isoformat()
}

with open(report_filename, 'w') as f:
    json.dump(full_report, f, indent=2)

print(f"\n📄 Comprehensive report saved: {report_filename}")

📊 Campaign Analytics Report
============================================================

📈 Campaign Overview:
   Total Developers Targeted: 5
   Successfully Enriched: 5
   Contactable Developers: 4
   Average Relevance Score: 7.8
   High Relevance Count: 4

👥 Audience Analysis:
   Top Skills:
     • Python: 3 developers
     • JavaScript: 2 developers
     • TypeScript: 2 developers
     • Node.js: 2 developers
     • Go: 1 developers

   Top Companies:
     • Python Software Foundation: 1 developers
     • Independent: 2 developers

💰 Cost Analysis:
   B2D API Credits: 5 credits ($0.05)
   OpenAI API Cost: $0.0234
   Total Campaign Cost: $0.0734
   Cost per Message: $0.0147

🎯 Recommendations:
   • Focus on 4 developers with 8+ relevance
   • Top skill match: Python (3 developers)
   • Top location: California (2 developers)

#!/usr/bin/env python3
"""
Product Launch Outreach Campaign
Enrich developer profiles and generate personalized launch messages
"""

import requests
import json
from openai import OpenAI
from datetime import datetime
import csv
import os
from collections import Counter
from typing import Dict, List, Optional

class ProductLaunchCampaign:
    def __init__(self, b2d_api_key: str, openai_api_key: str, product_info: Dict):
        self.b2d_api_key = b2d_api_key
        self.openai_client = OpenAI(api_key=openai_api_key)
        self.product_info = product_info
        
    def enrich_profiles(self, targets: List[Dict]) -> List[Dict]:
        """Enrich developer profiles using B2D API"""
        profiles = []
        
        print(f"🔍 Enriching {len(targets)} developer profiles...")
        
        for i, target in enumerate(targets, 1):
            print(f"  {i}/{len(targets)}: {target['value']}")
            
            params = {"api_key": self.b2d_api_key, "size": 1, "summary_length": 2048}
            params[target["type"]] = target["value"]
            
            try:
                response = requests.get("https://api.b2d.ai/user", params=params)
                if response.status_code == 200 and response.json().get('results'):
                    profile = response.json()['results'][0]
                    profiles.append(profile)
                    
                    name = profile.get('full_name', profile.get('github_username'))
                    print(f"    ✅ {name}")
                else:
                    print(f"    ❌ Not found")
                    
            except Exception as e:
                print(f"    ❌ Error: {e}")
                
        return profiles
    
    def generate_message(self, profile: Dict) -> Dict:
        """Generate personalized launch message"""
        
        system_prompt = f"""Generate a personalized product launch message.

Product: {self.product_info['name']} - {self.product_info['description']}
Features: {', '.join(self.product_info['key_features'])}
CTA: {self.product_info['beta_signup']}

Create a professional, personalized message that:
1. References their specific work/projects
2. Explains relevant product benefits
3. Includes natural call-to-action
4. Stays under 200 words

Return JSON with:
- subject_line: Under 50 characters
- message: Full personalized message
- relevance_score: 1-10 how relevant product is to them"""

        developer_data = {
            "name": profile.get('full_name', profile.get('github_username')),
            "github_username": profile.get('github_username'),
            "bio": profile.get('bio', ''),
            "company": profile.get('company', ''),
            "top_skills": [s['skill'] for s in profile.get('skills', [])[:5]],
            "recent_repos": [r.get('full_name', '') for r in profile.get('repos', [])[:3]],
            "summary": profile.get('summary_text', '')[:300]
        }
        
        try:
            response = self.openai_client.chat.completions.create(
                model="gpt-4o-mini",
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": json.dumps(developer_data)}
                ],
                temperature=0.8,
                max_tokens=600
            )
            
            result = response.choices[0].message.content.strip()
            if result.startswith("```json"):
                result = result.replace("```json", "").replace("```", "").strip()
            
            message_data = json.loads(result)
            message_data['tokens_used'] = response.usage.total_tokens
            
            return message_data
            
        except Exception as e:
            print(f"Message generation error: {e}")
            return {
                "subject_line": f"Introducing {self.product_info['name']}",
                "message": "Error generating message",
                "relevance_score": 0,
                "tokens_used": 0
            }
    
    def run_campaign(self, targets: List[Dict]) -> List[Dict]:
        """Run complete outreach campaign"""
        
        print(f"🚀 Starting {self.product_info['name']} Launch Campaign")
        
        # Step 1: Enrich profiles
        profiles = self.enrich_profiles(targets)
        print(f"✅ Enriched {len(profiles)} profiles")
        
        # Step 2: Generate messages
        print(f"\n✍️ Generating personalized messages...")
        campaigns = []
        
        for i, profile in enumerate(profiles, 1):
            name = profile.get('full_name', profile.get('github_username'))
            print(f"  {i}/{len(profiles)}: {name}")
            
            message_data = self.generate_message(profile)
            
            campaign = {**profile, **message_data}
            campaigns.append(campaign)
            
            print(f"    📧 Relevance: {message_data['relevance_score']}/10")
        
        return campaigns

# Usage Example
if __name__ == "__main__":
    # Product configuration
    PRODUCT_INFO = {
        "name": "DevFlow AI",
        "description": "AI-powered code review and documentation tool",
        "key_features": [
            "GPT-4 code review",
            "Auto documentation generation", 
            "GitHub/GitLab integration",
            "Custom coding standards"
        ],
        "beta_signup": "https://devflow.ai/beta"
    }
    
    # Target developers
    TARGETS = [
        {"type": "github_username", "value": "gvanrossum"},
        {"type": "github_username", "value": "tj"},
        {"type": "github_username", "value": "sindresorhus"},
        # Add more targets...
    ]
    
    # Initialize campaign
    campaign = ProductLaunchCampaign(
        b2d_api_key="YOUR_B2D_API_KEY",
        openai_api_key="YOUR_OPENAI_API_KEY",
        product_info=PRODUCT_INFO
    )
    
    # Run campaign
    results = campaign.run_campaign(TARGETS)
    
    # Save results
    with open(f"launch_campaign_{datetime.now().strftime('%Y%m%d')}.json", "w") as f:
        json.dump(results, f, indent=2)
    
    print(f"\n✅ Campaign complete! Generated {len(results)} personalized messages")