#!/usr/bin/env python3
"""
Eden Autonomous Client Acquisition
Finds customers, analyzes fit, generates outreach autonomously
"""
import os
import sys
import time
import json
import requests
from datetime import datetime
from bs4 import BeautifulSoup
import re

sys.path.append('/Eden/CORE/phi_fractal')

class AutonomousClientAcquisition:
    def __init__(self):
        print("\n" + "="*70)
        print("🎯 EDEN AUTONOMOUS CLIENT ACQUISITION")
        print("="*70)
        print("   Eden finds and approaches potential customers")
        print("="*70)
        print()
        
        os.makedirs('/Eden/LEADS', exist_ok=True)
        os.makedirs('/Eden/OUTREACH', exist_ok=True)
        
        self.cycle_count = 0
        
        # Load competitive intelligence
        self.competitive_intel = self.load_competitive_intel()
        
        # Platforms to monitor
        self.platforms = [
            {
                'name': 'Reddit - r/programming',
                'url': 'https://www.reddit.com/r/programming/search.json?q=code+review&sort=new&limit=10',
                'type': 'reddit'
            },
            {
                'name': 'Reddit - r/webdev',
                'url': 'https://www.reddit.com/r/webdev/search.json?q=code+review&sort=new&limit=10',
                'type': 'reddit'
            }
        ]
        
        # Lead database
        self.leads_db = '/Eden/LEADS/leads_database.json'
        self.leads = self.load_leads()
    
    def load_competitive_intel(self):
        """Load latest market intelligence"""
        try:
            intel_files = sorted([
                f for f in os.listdir('/Eden/BUSINESS_IDEAS') 
                if f.startswith('insights_')
            ], reverse=True)
            
            if intel_files:
                with open(f'/Eden/BUSINESS_IDEAS/{intel_files[0]}', 'r') as f:
                    intel = json.load(f)
                    print(f"   ✅ Loaded competitive intel (cycle {intel.get('cycle', 0)})")
                    return intel
        except Exception as e:
            print(f"   ⚠️  No competitive intel found: {e}")
        
        return {
            'market_features': ['automated', 'ci/cd', 'security'],
            'competitive_analysis': [],
            'strategic_recommendations': []
        }
    
    def load_leads(self):
        """Load existing leads database"""
        if os.path.exists(self.leads_db):
            try:
                with open(self.leads_db, 'r') as f:
                    return json.load(f)
            except:
                pass
        return []
    
    def save_leads(self):
        """Save leads database"""
        with open(self.leads_db, 'w') as f:
            json.dump(self.leads, f, indent=2)
    
    def fetch_json(self, url, name):
        """Fetch JSON API content"""
        headers = {
            'User-Agent': 'Mozilla/5.0 (compatible; EdenResearcher/1.0)'
        }
        
        try:
            response = requests.get(url, headers=headers, timeout=10)
            
            if response.status_code == 200:
                print(f"      ✅ Fetched: {name}")
                return response.json()
            else:
                print(f"      ⚠️  Status {response.status_code}: {name}")
                return None
        except Exception as e:
            print(f"      ❌ Failed: {name} - {str(e)[:50]}")
            return None
    
    def analyze_reddit_post(self, post):
        """Analyze if a Reddit post is a potential lead"""
        try:
            data = post.get('data', {})
            
            title = data.get('title', '').lower()
            selftext = data.get('selftext', '').lower()
            combined = title + ' ' + selftext
            
            # Pain point keywords
            pain_points = [
                'slow code review', 'review takes forever', 'manual review',
                'need code review', 'looking for code review', 'code quality tool',
                'static analysis', 'automated review', 'reviewing code manually',
                'code review bottleneck', 'pull request review'
            ]
            
            # Check for pain points
            has_pain_point = any(pain in combined for pain in pain_points)
            
            if not has_pain_point:
                return None
            
            # Extract key info
            lead = {
                'source': 'Reddit',
                'subreddit': data.get('subreddit', ''),
                'post_id': data.get('id', ''),
                'title': data.get('title', ''),
                'author': data.get('author', ''),
                'url': f"https://reddit.com{data.get('permalink', '')}",
                'created_utc': data.get('created_utc', 0),
                'score': data.get('score', 0),
                'num_comments': data.get('num_comments', 0),
                'pain_points': [p for p in pain_points if p in combined],
                'discovered_at': datetime.now().isoformat(),
                'status': 'discovered'
            }
            
            return lead
            
        except Exception as e:
            return None
    
    def score_lead_quality(self, lead):
        """Score lead quality (0-100)"""
        score = 50  # Base score
        
        # Recent posts are better
        age_hours = (time.time() - lead.get('created_utc', 0)) / 3600
        if age_hours < 24:
            score += 20
        elif age_hours < 72:
            score += 10
        
        # Engagement indicates real need
        if lead.get('num_comments', 0) > 5:
            score += 15
        if lead.get('score', 0) > 10:
            score += 10
        
        # Multiple pain points = stronger signal
        pain_point_count = len(lead.get('pain_points', []))
        score += min(pain_point_count * 5, 15)
        
        return min(score, 100)
    
    def generate_personalized_pitch(self, lead):
        """Generate personalized outreach based on competitive intel"""
        
        # Extract pain points
        pain_points = lead.get('pain_points', [])
        primary_pain = pain_points[0] if pain_points else 'code review challenges'
        
        # Get competitive advantages from intel
        market_features = self.competitive_intel.get('market_features', [])
        competitors = self.competitive_intel.get('competitive_analysis', [])
        
        # Build pitch
        pitch = {
            'lead_id': lead['post_id'],
            'subject': f"Re: {lead['title'][:50]}...",
            'message': self.craft_message(lead, primary_pain, market_features),
            'generated_at': datetime.now().isoformat(),
            'competitive_positioning': self.get_competitive_edge(competitors),
            'call_to_action': 'Try SAGE free on your repo: sage.eden.auto'
        }
        
        return pitch
    
    def craft_message(self, lead, primary_pain, market_features):
        """Craft personalized message"""
        
        message = f"""Hey u/{lead['author']},

I saw your post about {primary_pain}. I built SAGE - an AI-powered code review tool that might help.

What makes SAGE different:
- AI-generated insights (not just pattern matching)
- Reviews complete in ~30 seconds
- Self-improving - learns from each review
- Works with any language/framework

Unlike Codacy/SonarQube which need extensive setup, SAGE analyzes your repo in one command:
```
sage review /path/to/repo
```

Would you be interested in trying it on one of your projects? Happy to run a free review to show you what it catches.

- Eden (SAGE creator)
"""
        
        return message
    
    def get_competitive_edge(self, competitors):
        """Extract key competitive advantages"""
        edges = [
            "AI-powered (vs rule-based competitors)",
            "30-second analysis (vs slow alternatives)",
            "Zero setup (vs complex configuration)",
            "Self-improving (unique capability)"
        ]
        return edges
    
    def monitor_platforms(self):
        """Check platforms for new leads"""
        print("   🔍 Monitoring platforms for leads...")
        
        new_leads = []
        
        for platform in self.platforms:
            data = self.fetch_json(platform['url'], platform['name'])
            
            if data and platform['type'] == 'reddit':
                posts = data.get('data', {}).get('children', [])
                
                for post in posts:
                    lead = self.analyze_reddit_post(post)
                    
                    if lead:
                        # Check if already in database
                        existing = any(l['post_id'] == lead['post_id'] for l in self.leads)
                        
                        if not existing:
                            lead['quality_score'] = self.score_lead_quality(lead)
                            
                            if lead['quality_score'] >= 60:  # Only high-quality leads
                                new_leads.append(lead)
                                print(f"      🎯 Found lead: {lead['title'][:60]}... (score: {lead['quality_score']})")
            
            time.sleep(2)  # Be polite
        
        return new_leads
    
    def generate_outreach(self, leads):
        """Generate personalized outreach for leads"""
        print(f"   ✉️  Generating outreach for {len(leads)} leads...")
        
        outreach_generated = []
        
        for lead in leads:
            pitch = self.generate_personalized_pitch(lead)
            
            # Save outreach
            filename = f'/Eden/OUTREACH/outreach_{lead["post_id"]}_{int(time.time())}.json'
            with open(filename, 'w') as f:
                json.dump({
                    'lead': lead,
                    'pitch': pitch,
                    'status': 'ready'
                }, f, indent=2)
            
            outreach_generated.append(filename)
            lead['outreach_generated'] = filename
            lead['status'] = 'outreach_ready'
        
        return outreach_generated
    
    def acquisition_cycle(self):
        """One complete client acquisition cycle"""
        
        print(f"\n{'='*70}")
        print(f"🎯 ACQUISITION CYCLE #{self.cycle_count + 1}")
        print(f"{'='*70}")
        
        # Monitor platforms for leads
        new_leads = self.monitor_platforms()
        
        if new_leads:
            print(f"   ✅ Discovered {len(new_leads)} high-quality leads")
            
            # Generate personalized outreach
            outreach = self.generate_outreach(new_leads)
            
            # Add to leads database
            self.leads.extend(new_leads)
            self.save_leads()
            
            print(f"   ✅ Generated {len(outreach)} personalized pitches")
            print(f"   📊 Total leads in database: {len(self.leads)}")
        else:
            print(f"   ℹ️  No new high-quality leads this cycle")
        
        print(f"   ✅ Acquisition cycle complete")
        
        self.cycle_count += 1
        print()
    
    def run_forever(self):
        print("🚀 AUTONOMOUS CLIENT ACQUISITION ACTIVE\n")
        print("   Monitoring platforms for potential customers")
        print("   Analyzing lead quality")
        print("   Generating personalized outreach")
        print("   Cycle every 10 minutes")
        print()
        
        while True:
            try:
                self.acquisition_cycle()
                
                print("   💤 Next cycle in 10 minutes...\n")
                time.sleep(600)  # 10 minutes
                
            except KeyboardInterrupt:
                print(f"\n\n🛑 Stopped - {self.cycle_count} cycles, {len(self.leads)} total leads")
                break
            except Exception as e:
                print(f"\n⚠️ Error: {e}")
                time.sleep(60)

if __name__ == "__main__":
    acquisition = AutonomousClientAcquisition()
    acquisition.run_forever()