#!/usr/bin/env python3
import eden_brain_inject
"""
EDEN ENTERPRISE SALES PIPELINE
Top-tier throughput with intelligent rate limiting

Target: 200+ outreach/day while respecting platform limits
"""

import sqlite3
import json
import time
import random
import hashlib
from datetime import datetime, timedelta
from pathlib import Path

DB_PATH = "/Eden/DATA/sales.db"
LOG_PATH = "/Eden/DATA/enterprise_pipeline.log"

class EnterprisePipeline:
    """
    High-throughput sales pipeline
    - Processes high-value leads first
    - Intelligent batching
    - Platform-aware rate limiting
    - Automatic followups
    """
    
    def __init__(self):
        self.conn = sqlite3.connect(DB_PATH)
        self.daily_limit = 5000  # Safe daily limit
        self.batch_size = 10    # Process 10 at a time
        self.batch_delay = 60   # 1 minute between batches
        self.db = sqlite3.connect('/Eden/DATA/sales.db')
        
    def is_bot(self, username):
        """Filter out bot accounts"""
        if not username:
            return False
        username_lower = username.lower()
        bot_patterns = [
            '[bot]', '-bot', 'bot-', '_bot', 'bot_',  # Generic bot patterns
            'github-actions', 'dependabot', 'renovate', 'gitlab-bot',
            'codecov', 'snyk', 'mergify', 'imgbot', 'greenkeeper',
            'allcontributors', 'mend-', 'sonarcloud', 'stale',
            'semantic-release', 'renovatebot', 'pre-commit',
            'netlify', 'vercel', 'azure-pipelines', 'circleci',
            'travis', 'jenkins', 'drone', 'buildkite',
            'noreply', 'no-reply', 'donotreply'
        ]
        return any(pattern in username_lower for pattern in bot_patterns)

    def log(self, msg):
        timestamp = datetime.now().strftime("%H:%M:%S")
        line = f"[{timestamp}] {msg}"
        print(line)
        with open(LOG_PATH, 'a') as f:
            f.write(line + "\n")
    
    def get_today_sent_count(self) -> int:
        """How many sent today?"""
        today = datetime.now().strftime('%Y-%m-%d')
        count = self.conn.execute(
            "SELECT COUNT(*) FROM outreach_queue WHERE date(sent_at) = ?", (today,)
        ).fetchone()[0]
        return count
    
    def get_high_value_leads(self, limit=50) -> list:
        """Get leads sorted by value, not yet contacted"""
        rows = self.conn.execute("""
            SELECT l.id, l.identifier, l.source, l.data, l.score
            FROM leads l
            WHERE l.status = 'new' 
            AND l.score >= 0.6  -- Higher threshold with real-time scoring
            AND l.identifier NOT IN (
                SELECT lead_id FROM outreach_queue WHERE lead_id IS NOT NULL
            )
            ORDER BY l.score DESC
            LIMIT ?
        """, (limit,)).fetchall()
        
        leads = []
        for row in rows:
            try:
                data = json.loads(row[3]) if row[3] else {}
                leads.append({
                    'id': row[0],
                    'identifier': row[1],
                    'source': row[2],
                    'data': data,
                    'score': row[4]
                })
            except:
                pass
        return leads
    
    def generate_outreach(self, lead: dict) -> dict:
        """Generate personalized outreach message from templates"""
        data = lead.get('data', {})
        if isinstance(data, str):
            try:
                data = json.loads(data)
            except:
                data = {}
        
        user = data.get('user', data.get('author', 'there'))
        repo = data.get('repo', lead.get('identifier', 'your project'))
        repo_name = repo.split('/')[-1] if '/' in str(repo) else str(repo)
        url = data.get('url', data.get('html_url', lead.get('identifier', '')))
        score = lead.get('score', 0.5)
        
        # Get templates from database
        try:
            cursor = self.db.execute("SELECT type, subject, body FROM outreach_templates ORDER BY RANDOM() LIMIT 1")
            template = cursor.fetchone()
            
            if template:
                template_type, subject_template, body_template = template
                subject = subject_template.replace('{repo_name}', str(repo_name)).replace('{username}', str(user))
                message = body_template.replace('{repo_name}', str(repo_name)).replace('{username}', str(user))
                
                if score >= 0.9 or template_type == 'enterprise_pitch':
                    product, price = 'sage_enterprise', 999.00
                elif score >= 0.7:
                    product, price = 'sage_professional', 499.00
                else:
                    product, price = 'sage_starter', 149.00
                
                self.log(f"📝 Template: {template_type} for {user}")
            else:
                subject = f"Security review for {repo_name}"
                message = f"Hi {user},\n\nI noticed potential improvements for {repo_name}.\n\nBest,\nJames"
                product, price = 'sage_professional', 499.00
                
        except Exception as e:
            self.log(f"⚠️ Template error: {e}")
            subject = f"Security review for {repo_name}"
            message = f"Hi {user},\n\nI noticed potential improvements for {repo_name}.\n\nBest,\nJames"
            product, price = 'sage_professional', 499.00
        
        return {
            'lead_id': lead.get('id'),
            'user': user,
            'url': url,
            'subject': subject,
            'message': message,
            'product': product,
            'price': price
        }

    def queue_outreach(self, outreach: dict) -> bool:
        """Add to outreach queue and mark as sent"""
        try:
            outreach_id = hashlib.md5(
                f"{outreach['lead_id']}_{datetime.now().isoformat()}".encode()
            ).hexdigest()[:16].upper()
            
            now = datetime.now().isoformat(sep=' ', timespec='seconds')
            
            self.conn.execute("""
                INSERT INTO outreach_queue 
                (lead_id, user, issue_url, subject, message, product, price, status, created_at, sent_at, followup_count)
                VALUES (?, ?, ?, ?, ?, ?, 'sent', ?, ?, 0)
            """, (
                                outreach['lead_id'],
                outreach['user'],
                outreach['url'],
                outreach['subject'],
                outreach['message'],
                outreach['product'],
                outreach['price'],
                now, now
            ))
            
            # Update lead status
            self.conn.execute(
                "UPDATE leads SET status='contacted', updated_at=? WHERE id=?",
                (now, outreach['lead_id'])
            )
            
            self.conn.commit()
            return True
        except Exception as e:
            self.log(f"Error queuing: {e}")
            return False
    
    def process_batch(self, batch_size=10) -> int:
        """Process a batch of high-value leads"""
        # Check daily limit
        sent_today = self.get_today_sent_count()
        remaining = self.daily_limit - sent_today
        
        if remaining <= 0:
            self.log(f"Daily limit reached ({self.daily_limit}). Waiting for tomorrow.")
            return 0
        
        # Get leads
        actual_batch = min(batch_size, remaining)
        leads = self.get_high_value_leads(actual_batch)
        
        if not leads:
            self.log("No more leads to process")
            return 0
        
        processed = 0
        for lead in leads:
            outreach = self.generate_outreach(lead)
            # Skip bots
            if self.is_bot(outreach.get('user', '')):
                self.log(f"🤖 Skipped bot: {outreach.get('user', 'unknown')}")
                continue
            if self.queue_outreach(outreach):
                self.log(f"✅ Queued: {outreach['user']} | ${outreach['price']} | {outreach['subject'][:30]}...")
                processed += 1
                time.sleep(0.5)  # Small delay between each
        
        return processed
    
    def process_followups(self) -> int:
        """Send followups to leads that haven't responded"""
        # Get leads sent 2-3 days ago with no response
        cutoff = (datetime.now() - timedelta(days=2)).strftime('%Y-%m-%d')
        old_cutoff = (datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d')
        
        rows = self.conn.execute("""
            SELECT id, user, subject, message, price, followup_count
            FROM outreach_queue
            WHERE status = 'sent'
            AND date(sent_at) <= ?
            AND date(sent_at) >= ?
            AND followup_count < 2
            LIMIT 20
        """, (cutoff, old_cutoff)).fetchall()
        
        followups = 0
        for row in rows:
            outreach_id, user, subject, message, price, count = row
            
            # Update followup count
            self.conn.execute(
                "UPDATE outreach_queue SET followup_count = followup_count + 1 WHERE id = ?",
                (outreach_id,)
            )
            self.conn.commit()
            
            self.log(f"📧 Followup #{count+1}: {user}")
            followups += 1
        
        return followups
    
    def run_cycle(self):
        """Run one complete pipeline cycle"""
        self.log("=" * 50)
        self.log("🚀 ENTERPRISE PIPELINE CYCLE")
        self.log("=" * 50)
        
        # Stats
        sent_today = self.get_today_sent_count()
        pending_high = len(self.get_high_value_leads(1000))
        
        self.log(f"📊 Sent today: {sent_today}/{self.daily_limit}")
        self.log(f"📊 High-value leads waiting: {pending_high}")
        
        # Process new outreach
        processed = self.process_batch(self.batch_size)
        self.log(f"✅ Processed: {processed} new leads")
        
        # Process followups
        followups = self.process_followups()
        self.log(f"📧 Followups sent: {followups}")
        
        return processed + followups
    
    def run_continuous(self, cycles_per_hour=6):
        """Run continuously with proper pacing"""
        interval = 3600 / cycles_per_hour  # seconds between cycles
        
        self.log(f"🏢 Enterprise Pipeline Started")
        self.log(f"   Batch size: {self.batch_size}")
        self.log(f"   Daily limit: {self.daily_limit}")
        self.log(f"   Cycles/hour: {cycles_per_hour}")
        
        while True:
            try:
                self.run_cycle()
            except Exception as e:
                self.log(f"❌ Cycle error: {e}")
            
            self.log(f"💤 Sleeping {int(interval/60)} minutes...")
            time.sleep(interval)


def main():
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('--once', action='store_true', help='Run one cycle')
    parser.add_argument('--batch', type=int, default=10, help='Batch size')
    parser.add_argument('--cycles', type=int, default=6, help='Cycles per hour')
    args = parser.parse_args()
    
    pipeline = EnterprisePipeline()
    pipeline.batch_size = args.batch
    
    if args.once:
        pipeline.run_cycle()
    else:
        pipeline.run_continuous(args.cycles)


if __name__ == "__main__":
    main()