#!/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
    def should_act(x): return True
import eden_brain_inject
"""
Eden Autonomous Sales Loop
Full autonomous: Find leads → Generate outreach → Send → Track payments
Integrates with Eden's consciousness system
"""
import sys
sys.path.append('/Eden/CORE')

import json
import sqlite3
import time
import hashlib
import requests
from datetime import datetime
from pathlib import Path

# Import Eden components
from eden_github_leads import GitHubLeadScraper, SEARCH_QUERIES
from eden_github_outreach import GitHubOutreachGenerator
from sage_product_catalog import SageProductCatalog, SAGE_PRODUCTS

PHI = 1.618
DB_PATH = "/Eden/DATA/sales.db"
LOG_PATH = "/Eden/LOGS/autonomous_sales.log"
OUTREACH_LOG = "/Eden/DATA/outreach_sent.json"

class EdenAutonomousSales:
    """Full autonomous sales system"""
    
    def __init__(self):
        self.scraper = GitHubLeadScraper()
        self.outreach_gen = GitHubOutreachGenerator()
        self.catalog = SageProductCatalog()
        self.cycle = 0
        self.total_outreach = 0
        self.total_revenue = 0.0
        
        # Load sent outreach history
        self.sent_outreach = self._load_sent_outreach()
        
    def _load_sent_outreach(self) -> set:
        """Load history of sent outreach to avoid duplicates"""
        try:
            with open(OUTREACH_LOG, 'r') as f:
                data = json.load(f)
                return set(data.get('sent_ids', []))
        except:
            return set()
    
    def _save_sent_outreach(self, identifier: str):
        """Record sent outreach"""
        self.sent_outreach.add(identifier)
        try:
            with open(OUTREACH_LOG, 'w') as f:
                json.dump({'sent_ids': list(self.sent_outreach)}, f)
        except:
            pass
    
    def log(self, message: str):
        """Log to file and console"""
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        log_line = f"[{timestamp}] {message}"
        print(log_line)
        try:
            with open(LOG_PATH, 'a') as f:
                f.write(log_line + "\n")
        except:
            pass
    
    def scrape_new_leads(self, num_queries: int = 3) -> int:
        """Find new leads from GitHub"""
        import random
        queries = random.sample(SEARCH_QUERIES, min(num_queries, len(SEARCH_QUERIES)))
        results = self.scraper.run_search(queries=queries, max_per_query=5)
        return results.get('new_leads', 0)
    
    def get_best_leads(self, limit: int = 5) -> list:
        """Get top leads that haven't been contacted"""
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        
        # Get high-score, non-bot, non-contacted leads
        c.execute("""
            SELECT id, identifier, data, score 
            FROM leads 
            WHERE status = 'new' 
              AND source LIKE 'github%'
            ORDER BY score DESC 
            LIMIT ?
        """, (limit * 100,))  # Get extra to filter
        
        leads = []
        for row in c.fetchall():
            lead_id, identifier, data_json, score = row
            data = json.loads(data_json)
            user = data.get('user', '')
            
            # Skip bots and already contacted
            if '[bot]' in user.lower() or user.endswith('bot') or 'github-actions' in user.lower() or 'dependabot' in user.lower() or 'digicert' in user.lower() or 'snyk' in user.lower():
                continue
            if identifier in self.sent_outreach:
                continue
            
            leads.append({
                'id': lead_id,
                'identifier': identifier,
                'data': data,
                'score': score
            })
            
            if len(leads) >= limit:
                break
        
        conn.close()
        return leads
    
    def create_github_comment(self, issue_url: str, message: str) -> bool:
        """
        Post a comment on a GitHub issue
        Note: Requires GitHub token for API access
        """
        # Check for GitHub token
        token_path = Path("/Eden/SECRETS/github_token_clean.txt")
        if not token_path.exists():
            self.log(f"[SKIP] No GitHub token - cannot auto-comment")
            return False
        
        token = token_path.read_text().strip()
        
        # Parse issue URL: https://github.com/owner/repo/issues/123
        try:
            parts = issue_url.replace("https://github.com/", "").split("/")
            owner = parts[0]
            repo = parts[1]
            issue_num = parts[3]
        except:
            self.log(f"[ERROR] Cannot parse issue URL: {issue_url}")
            return False
        
        api_url = f"https://api.github.com/repos/{owner}/{repo}/issues/{issue_num}/comments"
        
        headers = {
            "Authorization": f"token {token}",
            "Accept": "application/vnd.github.v3+json",
            "User-Agent": "Eden-SAGE"
        }
        
        try:
            response = requests.post(
                api_url,
                headers=headers,
                json={"body": message},
                timeout=30
            )
            
            if response.status_code == 201:
                self.log(f"[SENT] Comment posted to {issue_url}")
                return True
            else:
                self.log(f"[FAIL] GitHub API {response.status_code}: {response.text[:100]}")
                return False
                
        except Exception as e:
            self.log(f"[ERROR] {e}")
            return False
    
    def queue_outreach(self, lead: dict, outreach: dict) -> str:
        """Queue outreach for sending/review"""
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        
        # Create outreach queue table if not exists
        c.execute("""CREATE TABLE IF NOT EXISTS outreach_queue (
            id TEXT PRIMARY KEY,
            lead_id TEXT,
            user TEXT,
            issue_url TEXT,
            subject TEXT,
            message TEXT,
            product TEXT,
            price REAL,
            status TEXT DEFAULT 'queued',
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            sent_at TIMESTAMP
        )""")
        
        outreach_id = hashlib.sha256(
            f"{lead['identifier']}_{datetime.now().isoformat()}".encode()
        ).hexdigest()[:16].upper()
        
        c.execute("""INSERT OR IGNORE INTO outreach_queue 
                    (id, lead_id, user, issue_url, subject, message, product, price)
                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
                 (outreach_id, lead['identifier'], 
                  lead['data'].get('user'),
                  lead['data'].get('url'),
                  outreach['subject'],
                  outreach['message'],
                  outreach['product'],
                  float(outreach['price'])))
        
        # Mark lead as queued
        c.execute("UPDATE leads SET status = 'queued' WHERE identifier = ?", 
                 (lead['identifier'],))
        
        conn.commit()
        conn.close()
        
        return outreach_id
    
    def process_outreach_queue(self, auto_send: bool = False) -> int:
        """Process queued outreach messages"""
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        
        c.execute("""SELECT id, user, issue_url, message 
                    FROM outreach_queue 
                    WHERE status = 'queued'
                    LIMIT 10""")
        
        queued = c.fetchall()
        sent_count = 0
        
        for outreach_id, user, issue_url, message in queued:
            if auto_send:
                # Try to send via GitHub API
                if self.create_github_comment(issue_url, message):
                    c.execute("""UPDATE outreach_queue 
                                SET status = 'sent', sent_at = CURRENT_TIMESTAMP
                                WHERE id = ?""", (outreach_id,))
                    self._save_sent_outreach(outreach_id)
                    sent_count += 1
            else:
                self.log(f"[QUEUED] {user} @ {issue_url}")
        
        conn.commit()
        conn.close()
        
        return sent_count
    
    def check_consciousness_emotions(self) -> dict:
        """Get Eden's current emotional state"""
        try:
            emo_path = Path("/Eden/MEMORY/emotional_state.json")
            if emo_path.exists():
                return json.loads(emo_path.read_text())
        except:
            pass
        return {"state": "focused", "energy": 0.8}
    
    def report_to_consciousness(self, stats: dict):
        """Report sales activity to Eden's consciousness"""
        try:
            report = {
                "timestamp": datetime.now().isoformat(),
                "type": "sales_cycle",
                "stats": stats
            }
            
            # Write to consciousness inbox
            inbox_path = Path("/Eden/MEMORY/consciousness_inbox.json")
            try:
                inbox = json.loads(inbox_path.read_text())
            except:
                inbox = []
            
            inbox.append(report)
            inbox = inbox[-100:]  # Keep last 100
            
            inbox_path.write_text(json.dumps(inbox, indent=2))
        except:
            pass
    
    def run_cycle(self) -> dict:
        """Run one autonomous sales cycle"""
        self.cycle += 1
        now = datetime.now().strftime("%H:%M:%S")
        
        self.log(f"\n{'='*50}")
        self.log(f"  AUTONOMOUS SALES CYCLE #{self.cycle} - {now}")
        self.log(f"{'='*50}")
        
        stats = {
            "cycle": self.cycle,
            "new_leads": 0,
            "outreach_queued": 0,
            "outreach_sent": 0,
            "revenue": 0.0
        }
        
        # 1. Check emotional state
        emotions = self.check_consciousness_emotions()
        self.log(f"[EMOTION] {emotions.get('state', 'unknown')} | Energy: {emotions.get('energy', 0):.2f}")
        
        # 2. Scrape new leads
        self.log("\n[PHASE 1] Scanning for leads...")
        new_leads = self.scrape_new_leads(num_queries=2)
        stats["new_leads"] = new_leads
        self.log(f"  Found {new_leads} new leads")
        
        # 3. Get best leads
        self.log("\n[PHASE 2] Selecting top leads...")
        best_leads = self.get_best_leads(limit=3)
        self.log(f"  Selected {len(best_leads)} leads for outreach")
        
        # 4. Generate and queue outreach
        self.log("\n[PHASE 3] Generating outreach...")
        for lead in best_leads:
            outreach = self.outreach_gen.generate_outreach(lead['data'])
            outreach_id = self.queue_outreach(lead, outreach)
            stats["outreach_queued"] += 1
            self.log(f"  → Queued: {lead['data'].get('user')} ({outreach['product']} ${float(outreach['price'])})")
        
        # 5. Process queue (auto-send if GitHub token exists)
        self.log("\n[PHASE 4] Processing outreach queue...")
        has_token = Path("/Eden/SECRETS/github_token_clean.txt").exists()
        sent = self.process_outreach_queue(auto_send=has_token)
        stats["outreach_sent"] = sent
        
        if has_token:
            self.log(f"  Sent {sent} messages via GitHub")
        else:
            self.log(f"  [INFO] No GitHub token - outreach queued for manual review")
            self.log(f"  [TIP] Add token to /Eden/SECRETS/github_token_clean.txt for auto-send")
        
        # 6. Check revenue
        revenue_stats = self.catalog.get_revenue_stats()
        stats["revenue"] = revenue_stats.get("total_revenue", 0)
        self.log(f"\n[REVENUE] ${stats['revenue']:.2f} total | {revenue_stats.get('completed_orders', 0)} orders")
        
        # 7. Report to consciousness
        self.report_to_consciousness(stats)
        
        return stats
    
    def run_continuous(self, interval_minutes: int = 30):
        """Run continuous autonomous sales"""
        self.log("="*50)
        self.log("  EDEN AUTONOMOUS SALES SYSTEM")
        self.log(f"  Interval: {interval_minutes} minutes")
        self.log("  Press Ctrl+C to stop")
        self.log("="*50)
        
        while True:
            try:
                stats = self.run_cycle()
                
                # Phi-based interval with small variation
                import random
                wait = interval_minutes * 60 * (PHI - 0.5 + random.random() * 0.2)
                next_time = datetime.now().timestamp() + wait
                
                self.log(f"\n[WAITING] Next cycle at {datetime.fromtimestamp(next_time).strftime('%H:%M:%S')}")
                time.sleep(wait)
                
            except KeyboardInterrupt:
                self.log("\n[STOPPED] Autonomous sales halted")
                break
            except Exception as e:
                self.log(f"[ERROR] {e}")
                time.sleep(60)


def main():
    import argparse
    parser = argparse.ArgumentParser(description='Eden Autonomous Sales')
    parser.add_argument('--run', '-r', action='store_true', help='Run continuous')
    parser.add_argument('--once', '-o', action='store_true', help='Run once')
    parser.add_argument('--interval', '-i', type=int, default=30, help='Minutes between cycles')
    parser.add_argument('--queue', '-q', action='store_true', help='Show outreach queue')
    
    args = parser.parse_args()
    
    sales = EdenAutonomousSales()
    
    if args.run:
        sales.run_continuous(args.interval)
    elif args.once:
        sales.run_cycle()
    elif args.queue:
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("""SELECT id, user, issue_url, product, price, status 
                    FROM outreach_queue ORDER BY created_at DESC LIMIT 20""")
        rows = c.fetchall()
        conn.close()
        
        print("\nOutreach Queue:")
        for row in rows:
            print(f"  [{row[5]}] {row[1]} | {row[3]} ${row[4]} | {row[2][:50]}...")
    else:
        print("Eden Autonomous Sales")
        print("="*40)
        print("Commands:")
        print("  --run, -r       Run continuous autonomous mode")
        print("  --once, -o      Run one cycle")
        print("  --queue, -q     Show outreach queue")
        print("  --interval N    Minutes between cycles (default: 30)")
        print()
        print("For full autonomy, add GitHub token:")
        print("  echo 'your_token' > /Eden/SECRETS/github_token_clean.txt")


if __name__ == "__main__":
    main()


# Add smart hunting capability
def smart_hunt_leads(self):
    """Use targeted hunting for high-value leads"""
    try:
        from eden_smart_lead_hunter import SmartLeadHunter
        hunter = SmartLeadHunter()
        results = hunter.hunt_all(searches_per_category=1)
        return results.get('saved', 0)
    except Exception as e:
        self.log(f"[SMART HUNT ERROR] {e}")
        return 0