# usage_signal_detector.py
from anthropic import Anthropic
import json
from datetime import datetime, timedelta

class UsageSignalDetector:
    def __init__(self):
        self.client = Anthropic()
        
    def analyze_usage_patterns(self, customer_id: str) -> dict:
        """Analyze customer usage data for expansion signals."""
        
        # Pull usage data from your analytics system
        usage_data = self.get_usage_data(customer_id)
        plan_limits = self.get_plan_limits(customer_id)
        
        analysis_prompt = f"""
        Analyze this customer's usage data for expansion/upsell signals.
        
        ## Current Plan
        {json.dumps(plan_limits, indent=2)}
        
        ## Usage Data (Last 90 Days)
        {json.dumps(usage_data, indent=2)}
        
        ## Identify
        1. Features approaching or exceeding limits
        2. Usage growth trends (week-over-week, month-over-month)
        3. Power users who might need advanced features
        4. New use cases emerging (based on feature adoption)
        5. Comparison to similar customers who upgraded
        
        ## Output
        Return JSON:
        {{
            "expansion_score": 0-100,
            "primary_signal": "most significant expansion indicator",
            "signals": [
                {{
                    "type": "limit_approaching|growth_trend|power_user|new_use_case",
                    "description": "what we observed",
                    "urgency": "high|medium|low",
                    "relevant_upsell": "which product/tier addresses this"
                }}
            ],
            "recommended_timing": "immediate|this_month|next_quarter",
            "talking_points": ["point 1", "point 2", "point 3"]
        }}
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1500,
            messages=[{"role": "user", "content": analysis_prompt}]
        )
        
        return json.loads(response.content[0].text)
    
    def get_usage_data(self, customer_id: str) -> dict:
        """Pull usage metrics from your analytics system."""
        # Implementation depends on your stack (Mixpanel, Amplitude, custom)
        pass
    
    def detect_limit_approach(self, customer_id: str, threshold: float = 0.8) -> list:
        """Find customers approaching plan limits."""
        
        usage = self.get_usage_data(customer_id)
        limits = self.get_plan_limits(customer_id)
        
        approaching_limits = []
        
        for metric, current_value in usage.items():
            if metric in limits:
                limit = limits[metric]
                utilization = current_value / limit if limit > 0 else 0
                
                if utilization >= threshold:
                    approaching_limits.append({
                        "metric": metric,
                        "current": current_value,
                        "limit": limit,
                        "utilization": f"{utilization:.1%}",
                        "days_to_limit": self.estimate_days_to_limit(
                            customer_id, metric, current_value, limit
                        )
                    })
        
        return approaching_limits

# support_signal_detector.py
class SupportSignalDetector:
    def __init__(self):
        self.client = Anthropic()
        
    def analyze_support_tickets(self, customer_id: str, days: int = 90) -> dict:
        """Analyze support tickets for expansion signals."""
        
        tickets = self.get_recent_tickets(customer_id, days)
        
        if not tickets:
            return {"expansion_score": 0, "signals": []}
        
        analysis_prompt = f"""
        Analyze these support tickets for upsell/expansion signals.
        
        ## Tickets
        {json.dumps(tickets, indent=2)}
        
        ## Signal Types to Look For
        1. Feature requests that exist in higher tiers
        2. Questions about integrations/APIs
        3. Workaround requests (working around limitations)
        4. Multi-department/team involvement
        5. Scaling concerns or performance issues
        6. Questions about enterprise features (SSO, audit logs, etc.)
        
        ## Output
        Return JSON:
        {{
            "expansion_score": 0-100,
            "signals": [
                {{
                    "ticket_id": "reference",
                    "signal_type": "feature_request|integration|workaround|scaling|enterprise",
                    "quote": "relevant excerpt from ticket",
                    "implied_need": "what this suggests they need",
                    "relevant_upsell": "product/tier that addresses this"
                }}
            ],
            "pattern_summary": "overall pattern observed",
            "recommended_action": "specific next step"
        }}
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1500,
            messages=[{"role": "user", "content": analysis_prompt}]
        )
        
        return json.loads(response.content[0].text)
    
    def get_recent_tickets(self, customer_id: str, days: int) -> list:
        """Pull tickets from Zendesk, Intercom, Freshdesk, etc."""
        # Implementation depends on your support platform
        pass

# conversation_signal_detector.py
class ConversationSignalDetector:
    def __init__(self):
        self.client = Anthropic()
        
    def analyze_call_transcripts(self, customer_id: str) -> dict:
        """Analyze recent call transcripts for expansion signals."""
        
        transcripts = self.get_recent_calls(customer_id)
        
        analysis_prompt = f"""
        Analyze these customer call transcripts for expansion/upsell signals.
        
        ## Transcripts
        {json.dumps(transcripts, indent=2)}
        
        ## Signals to Identify
        1. Budget discussions or planning mentions
        2. Team growth or hiring plans
        3. New initiatives or product launches
        4. Pain points getting worse
        5. Competitive mentions or evaluations
        6. Questions about capabilities they don't have
        7. Success stories they're sharing (ready to expand)
        8. Executive involvement (strategic importance)
        
        ## Output
        Return JSON:
        {{
            "expansion_score": 0-100,
            "signals": [
                {{
                    "call_date": "date",
                    "signal_type": "budget|growth|initiative|pain|competitive|capability|success|executive",
                    "quote": "exact words that indicate the signal",
                    "context": "surrounding context",
                    "urgency": "high|medium|low",
                    "recommended_response": "how to follow up"
                }}
            ],
            "key_stakeholders": ["names and roles identified"],
            "best_timing": "when to approach based on what was said",
            "risk_factors": ["any concerns or objections mentioned"]
        }}
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2000,
            messages=[{"role": "user", "content": analysis_prompt}]
        )
        
        return json.loads(response.content[0].text)
    
    def analyze_email_threads(self, customer_id: str) -> dict:
        """Analyze email communications for expansion signals."""
        
        emails = self.get_customer_emails(customer_id)
        
        analysis_prompt = f"""
        Analyze these email threads with the customer for expansion signals.
        
        ## Emails
        {json.dumps(emails, indent=2)}
        
        ## Look For
        1. Requests that indicate growing needs
        2. Forward-looking statements about plans
        3. Questions about pricing or contracts
        4. Mentions of other teams or use cases
        5. Positive feedback (good time to expand)
        6. Frustrations that upgrades would solve
        
        ## Output
        Return JSON with signals found, quotes, and recommendations.
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1500,
            messages=[{"role": "user", "content": analysis_prompt}]
        )
        
        return json.loads(response.content[0].text)

# expansion_scorer.py
class ExpansionScorer:
    def __init__(self):
        self.client = Anthropic()
        self.usage_detector = UsageSignalDetector()
        self.support_detector = SupportSignalDetector()
        self.conversation_detector = ConversationSignalDetector()
        
    def calculate_expansion_score(self, customer_id: str) -> dict:
        """Aggregate all signals into a comprehensive expansion score."""
        
        # Gather signals from all sources
        usage_signals = self.usage_detector.analyze_usage_patterns(customer_id)
        support_signals = self.support_detector.analyze_support_tickets(customer_id)
        conversation_signals = self.conversation_detector.analyze_call_transcripts(customer_id)
        
        # Get customer context
        customer_data = self.get_customer_data(customer_id)
        
        aggregation_prompt = f"""
        Calculate a comprehensive expansion opportunity score for this customer.
        
        ## Customer Profile
        {json.dumps(customer_data, indent=2)}
        
        ## Usage Signals
        {json.dumps(usage_signals, indent=2)}
        
        ## Support Signals
        {json.dumps(support_signals, indent=2)}
        
        ## Conversation Signals
        {json.dumps(conversation_signals, indent=2)}
        
        ## Scoring Framework
        - Base score from usage patterns (0-30 points)
        - Support signal strength (0-25 points)
        - Conversation buying signals (0-25 points)
        - Account health/NPS bonus (0-10 points)
        - Timing factors (0-10 points)
        
        ## Output
        Return JSON:
        {{
            "total_score": 0-100,
            "score_breakdown": {{
                "usage": 0-30,
                "support": 0-25,
                "conversation": 0-25,
                "health": 0-10,
                "timing": 0-10
            }},
            "confidence": "high|medium|low",
            "primary_opportunity": {{
                "product": "specific upsell opportunity",
                "estimated_value": "ARR increase",
                "win_probability": "percentage",
                "key_signal": "strongest indicator"
            }},
            "secondary_opportunities": [...],
            "recommended_approach": "how to start the conversation",
            "ideal_timing": "when to reach out",
            "key_stakeholder": "who to engage",
            "talking_points": ["personalized points based on their signals"],
            "risk_factors": ["potential objections to prepare for"]
        }}
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2000,
            messages=[{"role": "user", "content": aggregation_prompt}]
        )
        
        return json.loads(response.content[0].text)
    
    def generate_expansion_playbook(self, customer_id: str) -> dict:
        """Generate a complete playbook for approaching this expansion opportunity."""
        
        score_data = self.calculate_expansion_score(customer_id)
        customer_data = self.get_customer_data(customer_id)
        
        playbook_prompt = f"""
        Create a detailed expansion playbook for this opportunity.
        
        ## Customer
        {json.dumps(customer_data, indent=2)}
        
        ## Expansion Analysis
        {json.dumps(score_data, indent=2)}
        
        ## Generate
        1. Email template to open the conversation
        2. Call script with discovery questions
        3. Objection handling for likely concerns
        4. ROI calculation framework
        5. Timeline and next steps
        
        Make it specific to this customer's signals, not generic.
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=3000,
            messages=[{"role": "user", "content": playbook_prompt}]
        )
        
        return {
            "score_data": score_data,
            "playbook": response.content[0].text
        }

# expansion_alerts.py
class ExpansionAlertSystem:
    def __init__(self):
        self.scorer = ExpansionScorer()
        self.alert_threshold = 70  # Score threshold for alerts
        
    def run_daily_scan(self):
        """Scan all customers for expansion opportunities."""
        
        customers = self.get_all_active_customers()
        opportunities = []
        
        for customer in customers:
            try:
                score_data = self.scorer.calculate_expansion_score(customer['id'])
                
                if score_data['total_score'] >= self.alert_threshold:
                    opportunities.append({
                        "customer": customer,
                        "score_data": score_data,
                        "playbook": self.scorer.generate_expansion_playbook(customer['id'])
                    })
            except Exception as e:
                self.log_error(f"Failed to score {customer['id']}: {e}")
        
        # Sort by score and notify
        opportunities.sort(key=lambda x: x['score_data']['total_score'], reverse=True)
        
        self.send_alerts(opportunities)
        
        return opportunities
    
    def send_alerts(self, opportunities: list):
        """Send alerts to CSMs/AEs for each opportunity."""
        
        for opp in opportunities:
            customer = opp['customer']
            score = opp['score_data']
            
            # Format alert message
            alert = f"""
🎯 *EXPANSION OPPORTUNITY*

🏢 {customer['name']}
📊 Score: {score['total_score']}/100
💰 Potential: {score['primary_opportunity']['estimated_value']}
🎲 Win Probability: {score['primary_opportunity']['win_probability']}

*Top Signal:* {score['primary_opportunity']['key_signal']}

*Recommended Approach:*
{score['recommended_approach']}

*Talking Points:*
{chr(10).join('• ' + p for p in score['talking_points'][:3])}

*Best Timing:* {score['ideal_timing']}

[View Full Playbook]
"""
            
            # Route to appropriate owner
            owner = self.get_account_owner(customer['id'])
            self.send_notification(owner, alert, opp['playbook'])
    
    def send_notification(self, owner: dict, alert: str, playbook: dict):
        """Send via appropriate channel (Slack, email, WhatsApp)."""
        # Implementation depends on your notification setup
        pass

def calculate_expansion_metrics(period_days: int = 30) -> dict:
    return {
        # Detection metrics
        "opportunities_identified": 47,
        "avg_score_of_opportunities": 78,
        "false_positive_rate": 0.12,  # Flagged but no real opportunity
        
        # Conversion metrics
        "opportunities_acted_on": 38,
        "opportunities_converted": 24,
        "conversion_rate": 0.63,
        
        # Revenue metrics
        "expansion_arr_identified": 890000,
        "expansion_arr_closed": 540000,
        "avg_deal_size": 22500,
        
        # Efficiency metrics
        "time_from_signal_to_outreach_days": 1.8,
        "time_from_outreach_to_close_days": 18,
        
        # Comparison (AI vs manual)
        "ai_identified_conversion_rate": 0.63,
        "manually_identified_conversion_rate": 0.34
    }

# variant_generator.py
from anthropic import Anthropic
import json

class EmailVariantGenerator:
    def __init__(self):
        self.client = Anthropic()
        
    def generate_variant_cluster(
        self, 
        base_context: dict,
        hypothesis: str,
        num_variants: int = 10
    ) -> list:
        """Generate a cluster of variants testing a specific hypothesis."""
        
        prompt = f"""
        You are an expert B2B sales copywriter. Generate {num_variants} email variants
        that test this hypothesis: {hypothesis}
        
        ## Context
        - Target persona: {base_context['persona']}
        - Company: {base_context['company']}
        - Pain points: {base_context['pain_points']}
        - Value prop: {base_context['value_prop']}
        - Goal: {base_context['goal']}
        
        ## Requirements
        - Each variant should be meaningfully different (not just word swaps)
        - Keep emails under 150 words (nobody reads long cold emails)
        - Include a clear, single CTA
        - Sound human, not AI-generated
        
        ## Output Format
        Return a JSON array with each variant:
        [
            {{
                "variant_id": "v1",
                "hypothesis_element": "what this variant tests",
                "subject": "subject line",
                "body": "email body",
                "cta": "call to action",
                "key_differentiator": "what makes this unique"
            }}
        ]
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4000,
            messages=[{"role": "user", "content": prompt}]
        )
        
        return json.loads(response.content[0].text)

# Example usage
generator = EmailVariantGenerator()

context = {
    "persona": "VP of Sales at B2B SaaS company, 50-200 employees",
    "company": "MarketBetter",
    "pain_points": ["SDR productivity", "lead response time", "data quality"],
    "value_prop": "AI-powered SDR workflow automation",
    "goal": "Book a demo call"
}

# Generate variants testing different opening hooks
hook_variants = generator.generate_variant_cluster(
    context,
    hypothesis="Question-based openings outperform statement openings",
    num_variants=10
)

# Generate variants testing pain point emphasis
pain_variants = generator.generate_variant_cluster(
    context,
    hypothesis="Emphasizing time savings beats emphasizing revenue gains",
    num_variants=10
)

# Generate variants testing social proof types
proof_variants = generator.generate_variant_cluster(
    context,
    hypothesis="Specific metrics outperform named customer logos",
    num_variants=10
)

# segment_matcher.py
class SegmentMatcher:
    def __init__(self, anthropic_client):
        self.client = anthropic_client
        
    def match_variants_to_segments(
        self,
        variants: list,
        segments: list
    ) -> dict:
        """Use Claude to match variants to segments they're most likely to resonate with."""
        
        prompt = f"""
        Match email variants to prospect segments based on likely resonance.
        
        ## Variants
        {json.dumps(variants, indent=2)}
        
        ## Segments
        {json.dumps(segments, indent=2)}
        
        For each variant, identify:
        1. Primary segment (best fit)
        2. Secondary segment (good fit)
        3. Avoid segment (poor fit)
        
        Return JSON mapping variant_id to segment recommendations.
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2000,
            messages=[{"role": "user", "content": prompt}]
        )
        
        return json.loads(response.content[0].text)

# Define your segments
segments = [
    {
        "id": "growth_stage",
        "description": "Series A-B companies, scaling fast, care about speed",
        "typical_pain": "Can't hire SDRs fast enough"
    },
    {
        "id": "enterprise_efficiency",
        "description": "Large companies, cost-conscious, care about ROI",
        "typical_pain": "SDR team is expensive and underperforming"
    },
    {
        "id": "founder_led",
        "description": "Founder still doing sales, limited time",
        "typical_pain": "No time for manual prospecting"
    },
    {
        "id": "revops_driven",
        "description": "Data-focused teams, care about metrics",
        "typical_pain": "Can't measure what's working"
    }
]

# Match variants to segments
matcher = SegmentMatcher(Anthropic())
variant_segment_map = matcher.match_variants_to_segments(hook_variants, segments)

# learning_loop.py
class EmailLearningLoop:
    def __init__(self):
        self.client = Anthropic()
        self.results_db = ResultsDatabase()
        
    def analyze_results(self, test_id: str) -> dict:
        """Analyze test results and generate insights."""
        
        results = self.results_db.get_test_results(test_id)
        
        analysis_prompt = f"""
        Analyze these email A/B test results and provide actionable insights.
        
        ## Test Results
        {json.dumps(results, indent=2)}
        
        ## Analysis Required
        1. Which variants performed best and why?
        2. What patterns emerge across winning variants?
        3. What should we test next based on these learnings?
        4. Any surprising results that warrant investigation?
        5. Recommended changes to our email playbook
        
        Be specific. Reference actual data from the results.
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2000,
            messages=[{"role": "user", "content": analysis_prompt}]
        )
        
        return {
            "analysis": response.content[0].text,
            "raw_results": results
        }
    
    def generate_next_iteration(
        self,
        winning_variants: list,
        insights: str
    ) -> list:
        """Generate next round of variants based on learnings."""
        
        prompt = f"""
        Based on our A/B test learnings, generate the next iteration of email variants.
        
        ## Winning Variants from Last Round
        {json.dumps(winning_variants, indent=2)}
        
        ## Key Insights
        {insights}
        
        ## Your Task
        Generate 10 new variants that:
        1. Build on what worked in the winning variants
        2. Test new hypotheses suggested by the insights
        3. Push the boundaries of what we've learned
        
        Don't just remix winners—evolve them.
        
        Return JSON array of new variants.
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4000,
            messages=[{"role": "user", "content": prompt}]
        )
        
        return json.loads(response.content[0].text)
    
    def run_learning_cycle(self, test_id: str):
        """Complete one learning cycle."""
        
        # 1. Analyze completed test
        analysis = self.analyze_results(test_id)
        
        # 2. Identify winners
        winners = [r for r in analysis['raw_results'] 
                   if r['reply_rate'] > analysis['avg_reply_rate'] * 1.2]
        
        # 3. Generate evolved variants
        next_variants = self.generate_next_iteration(
            winners,
            analysis['analysis']
        )
        
        # 4. Queue next test
        new_test_id = self.queue_test(next_variants)
        
        return {
            "completed_test": test_id,
            "insights": analysis['analysis'],
            "winners": winners,
            "next_test": new_test_id
        }

# reply_tracker.py
class ReplyTracker:
    def __init__(self):
        self.client = Anthropic()
        
    def classify_reply(self, reply_text: str) -> dict:
        """Classify reply sentiment and intent."""
        
        prompt = f"""
        Classify this email reply from a sales prospect:
        
        "{reply_text}"
        
        Return JSON:
        {{
            "sentiment": "positive|neutral|negative",
            "intent": "interested|not_interested|asking_questions|objection|out_of_office|unsubscribe",
            "buying_signal_strength": 0-10,
            "next_action": "book_call|send_info|nurture|disqualify",
            "key_insight": "what we learned from this reply"
        }}
        """
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=500,
            messages=[{"role": "user", "content": prompt}]
        )
        
        return json.loads(response.content[0].text)
    
    def calculate_variant_score(self, variant_id: str) -> dict:
        """Calculate comprehensive score for a variant."""
        
        replies = self.get_replies_for_variant(variant_id)
        sends = self.get_sends_for_variant(variant_id)
        
        classified_replies = [self.classify_reply(r['text']) for r in replies]
        
        return {
            "variant_id": variant_id,
            "total_sends": len(sends),
            "total_replies": len(replies),
            "reply_rate": len(replies) / len(sends) if sends else 0,
            "positive_reply_rate": len([r for r in classified_replies 
                                        if r['sentiment'] == 'positive']) / len(sends) if sends else 0,
            "avg_buying_signal": sum(r['buying_signal_strength'] 
                                     for r in classified_replies) / len(classified_replies) if classified_replies else 0,
            "meetings_booked": len([r for r in classified_replies 
                                    if r['next_action'] == 'book_call']),
            "conversion_to_meeting": len([r for r in classified_replies 
                                          if r['next_action'] == 'book_call']) / len(sends) if sends else 0
        }