def generate_cold_email(founder_name, company_name, pain_point, your_solution):
    prompt = f"""Write a cold outreach email to {founder_name}, founder of {company_name}.

Their company struggles with: {pain_point}
Your product solves: {your_solution}

Requirements:
- Under 150 words
- No buzzwords
- One specific observation about their company
- Clear call to action
- Subject line included"""

    return prompt

import openai

def generate_outreach_email(founder_data: dict, model: str = "gpt-4") -> dict:
    system_prompt = """You write concise, direct cold outreach emails.
    Lead with a specific observation. One call to action. Under 130 words."""

    user_prompt = f"""Write to {founder_data['name']} at {founder_data['company']}.
    Their problem: {founder_data['pain_point']}
    Your solution: {founder_data['your_solution']}"""

    response = openai.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt}
        ],
        temperature=0.3
    )

    return {"email": response.choices[0].message.content}

import anthropic

def generate_outreach_email_claude(founder_data: dict) -> dict:
    client = anthropic.Anthropic()

    prompt = f"""Write a cold outreach email. Lead with a specific observation about {founder_data['company']}. Their problem: {founder_data['pain_point']}. Your solution: {founder_data['your_solution']}. Under 130 words. Include subject line."""

    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=300,
        temperature=0.3,
        system="You write concise, direct cold outreach emails.",
        messages=[{"role": "user", "content": prompt}]
    )

    return {"email": message.content[0].text}

def build_cold_email_prompt(prospect_profile):
    """Generate optimized prompt based on prospect research."""

    prompt = f"""
You are a B2B sales expert specializing in high-value partnerships.

PROSPECT PROFILE:
- Name: {prospect_profile['name']}
- Company: {prospect_profile['company']}
- Company size: {prospect_profile['company_size']}
- Industry: {prospect_profile['industry']}
- Pain point: {prospect_profile['pain_point']}
- Company news: {prospect_profile.get('recent_news', 'None')}

YOUR OFFERING:
- Solution: {prospect_profile['solution']}
- Target user: {prospect_profile['target_user']}
- Cost impact: {prospect_profile.get('cost_impact', 'Varies')}

EMAIL REQUIREMENTS:
1. Subject line that creates curiosity (avoid clickbait)
2. Open with a specific observation about their company (not generic praise)
3. Single clear problem statement they face
4. One sentence about your solution
5. Social proof (company, metric, or testimonial)
6. Call to action (specific next step)
7. Total length: 120-150 words
8. Tone: Professional but conversational (not salesy)

Generate 3 email variants with different angles:
- Variant A: Lead with their recent growth/news
- Variant B: Lead with specific pain point
- Variant C: Lead with mutual connection potential

For each, explain why it works and which prospect profile responds best."""

    return prompt

import random
from collections import defaultdict
from datetime import datetime

class EmailABTestFramework:
    def __init__(self):
        self.variants = []
        self.results = defaultdict(lambda: {
            'sent': 0, 'opened': 0, 'replied': 0, 'booked': 0
        })

    def create_test(self, variant_id, email_template):
        """Register an email variant for testing."""
        self.variants.append({
            'id': variant_id,
            'template': email_template,
            'created_at': datetime.utcnow()
        })

    def select_variant(self, prospect_id):
        """Use stratified random selection for balanced testing."""
        # Assign variants by prospect ID for deterministic split
        variant_index = hash(prospect_id) % len(self.variants)
        return self.variants[variant_index]['id']

    def record_event(self, variant_id, event_type):
        """Track email performance."""
        self.results[variant_id][event_type] += 1

    def analyze_results(self):
        """Calculate statistical significance."""
        analysis = {}

        for variant_id, metrics in self.results.items():
            if metrics['sent'] < 30:  # Need minimum sample size
                continue

            analysis[variant_id] = {
                'open_rate': metrics['opened'] / metrics['sent'],
                'reply_rate': metrics['replied'] / metrics['sent'],
                'book_rate': metrics['booked'] / metrics['sent'],
                'sample_size': metrics['sent'],
                'status': 'incomplete' if metrics['sent'] < 50 else 'complete'
            }

        return analysis

    def declare_winner(self, threshold=0.95):
        """Identify statistically significant winner."""
        results = self.analyze_results()

        # Find best reply rate
        best_variant = max(
            results.items(),
            key=lambda x: x[1]['reply_rate']
        )

        confidence = self._calculate_confidence(best_variant[1])

        if confidence >= threshold:
            return {
                'winner': best_variant[0],
                'reply_rate': best_variant[1]['reply_rate'],
                'confidence': confidence,
                'recommendation': f"Deploy {best_variant[0]} to all remaining prospects"
            }

        return {
            'winner': None,
            'confidence': confidence,
            'recommendation': 'Continue testing, need more sample size'
        }

    def _calculate_confidence(self, metrics):
        """Estimate statistical confidence using binomial test."""
        # Simplified: ratio of success to failures
        successes = metrics.get('replied', 0)
        trials = metrics.get('sent', 1)
        if trials < 30:
            return 0.0
        return min(1.0, (successes / trials) / 0.08)  # 0.08 is baseline

def calculate_cold_email_roi(
    emails_sent: int,
    reply_rate: float,
    meeting_rate_from_replies: float,
    deal_close_rate: float,
    avg_deal_value: float,
    cost_per_email: float = 0.50,
    ai_tool_cost_monthly: float = 20
):
    """Calculate ROI of AI-assisted cold email."""

    # Conversions
    replies = emails_sent * reply_rate
    meetings = replies * meeting_rate_from_replies
    deals = meetings * deal_close_rate
    revenue = deals * avg_deal_value

    # Costs
    email_costs = emails_sent * cost_per_email
    ai_tool_annual_cost = ai_tool_cost_monthly * 12
    total_cost = email_costs + ai_tool_annual_cost

    # ROI
    gross_profit = revenue
    net_profit = gross_profit - total_cost
    roi_percentage = (net_profit / total_cost * 100) if total_cost > 0 else 0

    return {
        'emails_sent': emails_sent,
        'replies': int(replies),
        'meetings': int(meetings),
        'deals': int(deals),
        'revenue_generated': f'${revenue:,.0f}',
        'total_costs': f'${total_cost:,.0f}',
        'net_profit': f'${net_profit:,.0f}',
        'roi': f'{roi_percentage:.0f}%',
        'cost_per_deal': f'${total_cost / deals:,.0f}' if deals > 0 else 'N/A',
        'payback_emails': int(total_cost / (revenue / emails_sent)) if revenue > 0 else None
    }

# Example: 1,000 emails, 10% reply rate, 30% meeting rate, 20% close rate, $20k avg deal
result = calculate_cold_email_roi(
    emails_sent=1000,
    reply_rate=0.10,
    meeting_rate_from_replies=0.30,
    deal_close_rate=0.20,
    avg_deal_value=20000,
    cost_per_email=0.50,
    ai_tool_cost_monthly=20
)

print(f"ROI: {result['roi']}")
print(f"Net profit from campaign: {result['net_profit']}")

INDUSTRY_STRATEGIES = {
    'saas': {
        'angle': 'Efficiency gains / cost reduction',
        'social_proof': 'Number of companies using solution',
        'pain_point': 'Workflow inefficiency or high costs',
        'cta': 'Demo request'
    },
    'healthcare': {
        'angle': 'Compliance and patient outcomes',
        'social_proof': 'Hospital certifications achieved',
        'pain_point': 'Regulatory burden or patient safety',
        'cta': 'Compliance briefing call'
    },
    'finance': {
        'angle': 'Risk reduction and ROI',
        'social_proof': 'AUM managed or customers',
        'pain_point': 'Regulatory risk or capital efficiency',
        'cta': 'Risk assessment call'
    },
    'ecommerce': {
        'angle': 'Conversion rate improvement',
        'social_proof': 'Revenue uplift percentage',
        'pain_point': 'Cart abandonment or CAC',
        'cta': 'Conversion audit'
    }
}

def generate_industry_specific_email(
    prospect,
    industry,
    ai_client
):
    """Generate email tailored to industry vertical."""
    strategy = INDUSTRY_STRATEGIES.get(industry.lower())

    prompt = f"""Write a cold email for a {industry} prospect.

Prospect: {prospect['name']} at {prospect['company']}

Industry Strategy:
- Lead angle: {strategy['angle']}
- Use this social proof: {strategy['social_proof']}
- Address this pain: {strategy['pain_point']}
- CTA type: {strategy['cta']}

Generate the email (120-150 words, direct tone)."""

    # Call AI to generate
    return prompt