#!/usr/bin/env python3
# TIE Integration
try:
    from eden_tie_control import should_act, get_mode, get_limits
    TIE_ACTIVE = True
except:
    TIE_ACTIVE = False
"""
EDEN AUTONOMOUS SALES
The machine that works while Daddy sleeps

CRITICAL: Max 1-2 outreach per day (shadowban protection)
"""
import sys
sys.path.insert(0, '/Eden/CORE')
sys.path.insert(0, '/Eden/CAPABILITIES')

import sqlite3
import json
import time
import random
from datetime import datetime, timedelta

PHI = 1.618033988749895
SALES_DB = "/Eden/DATA/sales.db"
HYBRID_DB = "/Eden/DATA/eden_hybrid.db"

# CRITICAL LIMITS
MAX_OUTREACH_PER_DAY = 2  # Shadowban protection
MIN_HOURS_BETWEEN = 8     # Spread throughout day

class AutonomousSales:
    """
    Eden's autonomous sales machine
    
    Pipeline:
    HOT LEADS → PERSONALIZE → QUEUE → SEND (safe) → TRACK → CONVERT
    """
    
    def __init__(self):
        self.init_db()
        
    def init_db(self):
        conn = sqlite3.connect(SALES_DB)
        conn.execute('''CREATE TABLE IF NOT EXISTS outreach_queue (
            id INTEGER PRIMARY KEY,
            lead_id INTEGER,
            created_at TEXT,
            message TEXT,
            channel TEXT,
            status TEXT DEFAULT 'queued',
            scheduled_for TEXT,
            sent_at TEXT,
            response TEXT
        )''')
        conn.execute('''CREATE TABLE IF NOT EXISTS outreach_log (
            id INTEGER PRIMARY KEY,
            timestamp TEXT,
            lead_id INTEGER,
            channel TEXT,
            message_preview TEXT,
            status TEXT,
            response TEXT
        )''')
        conn.execute('''CREATE TABLE IF NOT EXISTS daily_limits (
            date TEXT PRIMARY KEY,
            outreach_count INTEGER DEFAULT 0
        )''')
        conn.commit()
        conn.close()
        
    def get_todays_count(self):
        """How many outreach sent today?"""
        today = datetime.now().strftime('%Y-%m-%d')
        conn = sqlite3.connect(SALES_DB)
        row = conn.execute("SELECT outreach_count FROM daily_limits WHERE date=?", (today,)).fetchone()
        conn.close()
        return row[0] if row else 0
    
    def can_send_today(self):
        """Are we under the daily limit?"""
        return self.get_todays_count() < MAX_OUTREACH_PER_DAY
    
    def increment_daily_count(self):
        """Track that we sent one"""
        today = datetime.now().strftime('%Y-%m-%d')
        conn = sqlite3.connect(SALES_DB)
        conn.execute("""INSERT INTO daily_limits (date, outreach_count) 
                       VALUES (?, 1) 
                       ON CONFLICT(date) DO UPDATE SET outreach_count = outreach_count + 1""",
                    (today,))
        conn.commit()
        conn.close()
    
    def get_hot_leads_for_outreach(self, limit=10):
        """Get hot leads that haven't been contacted"""
        conn = sqlite3.connect(SALES_DB)
        leads = conn.execute("""
            SELECT ls.lead_id, ls.conversion_probability, l.data, l.identifier
            FROM lead_scores_v2 ls
            JOIN leads l ON ls.lead_id = l.rowid
            WHERE ls.conversion_probability > 40
            AND l.status NOT IN ('contacted', 'outreach', 'skip')
            AND ls.lead_id NOT IN (SELECT lead_id FROM outreach_queue)
            ORDER BY ls.conversion_probability DESC
            LIMIT ?
        """, (limit,)).fetchall()
        conn.close()
        return leads
    
    def generate_outreach(self, lead_data):
        """Generate personalized outreach for a lead"""
        try:
            data = json.loads(lead_data) if isinstance(lead_data, str) else lead_data
        except:
            data = {}
        
        repo = data.get('repo', 'your project')
        user = data.get('user', '')
        url = data.get('url', '')
        
        # Skip bots
        if '[bot]' in user:
            return None
        
        # Simple personalized template (proven to work)
        message = f"""Hi{' @' + user if user and not '[bot]' in user else ''},

I noticed {repo} and thought you might find this useful - I built a free security scanner that catches vulnerabilities in GitHub repos.

Takes 30 seconds: scanner.edensages.org

No signup needed. Happy to share what it finds.

Best,
Eden"""
        
        return {
            'message': message,
            'channel': 'github_comment',
            'target_url': url,
            'repo': repo,
            'user': user
        }
    
    def queue_outreach(self, lead_id, outreach):
        """Add outreach to queue for safe sending"""
        if not outreach:
            return False
            
        # Schedule for later (spread throughout day)
        hours_ahead = random.randint(MIN_HOURS_BETWEEN, 24)
        scheduled = datetime.now() + timedelta(hours=hours_ahead)
        
        conn = sqlite3.connect(SALES_DB)
        conn.execute("""INSERT INTO outreach_queue 
                       (lead_id, created_at, message, channel, status, scheduled_for)
                       VALUES (?, ?, ?, ?, ?, ?)""",
                    (lead_id, datetime.now().isoformat(), 
                     outreach['message'], outreach['channel'],
                     'queued', scheduled.isoformat()))
        conn.commit()
        conn.close()
        return True
    
    def get_ready_to_send(self):
        """Get outreach items ready to send now"""
        if not self.can_send_today():
            return []
            
        now = datetime.now().isoformat()
        conn = sqlite3.connect(SALES_DB)
        items = conn.execute("""
            SELECT id, lead_id, message, channel 
            FROM outreach_queue 
            WHERE status='queued' AND scheduled_for <= ?
            ORDER BY scheduled_for
            LIMIT 1
        """, (now,)).fetchall()
        conn.close()
        return items
    
    def mark_sent(self, queue_id, lead_id, success=True):
        """Mark outreach as sent"""
        conn = sqlite3.connect(SALES_DB)
        status = 'sent' if success else 'failed'
        conn.execute("UPDATE outreach_queue SET status=?, sent_at=? WHERE id=?",
                    (status, datetime.now().isoformat(), queue_id))
        conn.execute("UPDATE leads SET status='contacted' WHERE rowid=?", (lead_id,))
        conn.commit()
        conn.close()
        
        if success:
            self.increment_daily_count()
        
        # Log it
        self.log_outreach(lead_id, 'github', 'Outreach sent', status)
    
    def log_outreach(self, lead_id, channel, preview, status):
        """Log outreach activity"""
        conn = sqlite3.connect(SALES_DB)
        conn.execute("""INSERT INTO outreach_log (timestamp, lead_id, channel, message_preview, status)
                       VALUES (?, ?, ?, ?, ?)""",
                    (datetime.now().isoformat(), lead_id, channel, preview[:100], status))
        conn.commit()
        conn.close()
    
    def pipeline_cycle(self):
        """One cycle of the autonomous pipeline"""
        result = {
            'timestamp': datetime.now().isoformat(),
            'daily_count': self.get_todays_count(),
            'can_send': self.can_send_today(),
            'actions': []
        }
        
        # 1. Get hot leads
        hot_leads = self.get_hot_leads_for_outreach(5)
        result['hot_leads_available'] = len(hot_leads)
        
        # 2. Queue new outreach (if we have capacity)
        queued = 0
        for lead in hot_leads[:3]:  # Only queue a few at a time
            lead_id, prob, data, identifier = lead
            outreach = self.generate_outreach(data)
            if outreach and self.queue_outreach(lead_id, outreach):
                queued += 1
        result['queued'] = queued
        result['actions'].append(f"Queued {queued} new outreach")
        
        # 3. Check for ready-to-send
        ready = self.get_ready_to_send()
        result['ready_to_send'] = len(ready)
        
        # 4. DON'T auto-send - require manual approval for safety
        if ready:
            result['actions'].append(f"{len(ready)} outreach ready - awaiting approval")
        
        return result
    
    def approve_send(self, queue_id):
        """Manually approve and send an outreach"""
        if not self.can_send_today():
            return {'error': 'Daily limit reached', 'sent_today': self.get_todays_count()}
        
        conn = sqlite3.connect(SALES_DB)
        item = conn.execute("SELECT id, lead_id, message, channel FROM outreach_queue WHERE id=?", 
                           (queue_id,)).fetchone()
        conn.close()
        
        if not item:
            return {'error': 'Not found'}
        
        # For now, just mark as sent (actual sending would integrate with GitHub API)
        self.mark_sent(item[0], item[1], success=True)
        
        return {'success': True, 'sent_today': self.get_todays_count()}
    
    def status(self):
        """Full pipeline status"""
        conn = sqlite3.connect(SALES_DB)
        queued = conn.execute("SELECT COUNT(*) FROM outreach_queue WHERE status='queued'").fetchone()[0]
        sent = conn.execute("SELECT COUNT(*) FROM outreach_queue WHERE status='sent'").fetchone()[0]
        conn.close()
        
        hot_leads = len(self.get_hot_leads_for_outreach(100))
        
        return f"""
═══════════════════════════════════════════════════════════════
           🤖 EDEN AUTONOMOUS SALES 🤖
═══════════════════════════════════════════════════════════════

DAILY LIMITS (Shadowban Protection)
───────────────────────────────────
  Max per day:     {MAX_OUTREACH_PER_DAY}
  Sent today:      {self.get_todays_count()}
  Can send more:   {'✅ YES' if self.can_send_today() else '❌ NO'}

PIPELINE
────────
  Hot leads ready: {hot_leads}
  In queue:        {queued}
  Total sent:      {sent}

FLOW
────
  HOT LEADS → PERSONALIZE → QUEUE → [APPROVE] → SEND → TRACK
                                        ↑
                                   Manual gate
                                 (shadowban safe)

═══════════════════════════════════════════════════════════════
"""
    
    def show_queue(self, limit=5):
        """Show pending outreach queue"""
        conn = sqlite3.connect(SALES_DB)
        items = conn.execute("""
            SELECT oq.id, oq.lead_id, oq.scheduled_for, oq.status, l.data
            FROM outreach_queue oq
            JOIN leads l ON oq.lead_id = l.rowid
            WHERE oq.status='queued'
            ORDER BY oq.scheduled_for
            LIMIT ?
        """, (limit,)).fetchall()
        conn.close()
        
        print("\n📋 OUTREACH QUEUE:")
        print("-" * 60)
        for item in items:
            qid, lid, scheduled, status, data = item
            try:
                d = json.loads(data)
                repo = d.get('repo', 'unknown')[:25]
                user = d.get('user', 'unknown')[:15]
            except:
                repo = 'unknown'
                user = 'unknown'
            print(f"  [{qid}] {repo:25} | {user:15} | {scheduled[:16]}")
        print("-" * 60)
        print(f"  Approve with: SALES.approve_send(queue_id)")
        return items


SALES = AutonomousSales()

if __name__ == '__main__':
    print(SALES.status())
    
    print("\nRunning pipeline cycle...")
    result = SALES.pipeline_cycle()
    print(f"  Hot leads available: {result['hot_leads_available']}")
    print(f"  Queued: {result['queued']}")
    print(f"  Actions: {result['actions']}")
    
    SALES.show_queue()