#!/usr/bin/env python3
"""
EDEN META SERVICE - Self-Maintaining Business Engine
One service to rule them all. No philosophy. Just money.

Functions:
1. Keep all services alive
2. Monitor outreach pipeline
3. Fix broken things
4. Log what works, improve
"""
import subprocess
import sqlite3
import time
import json
import os
from datetime import datetime
from pathlib import Path

LOG = "/Eden/LOGS/meta_service.log"
DB = "/Eden/DATA/asi_memory.db"
SALES_DB = "/Eden/DATA/sales.db"
STATE_FILE = "/Eden/DATA/meta_state.json"

# Critical services that must run
CRITICAL_SERVICES = [
    "eden-omega-evolution",
    "eden-fibonacci-followup", 
    "eden-playground",
    "eden-dashboard",
    "eden-sage-prod",
]

def log(msg):
    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    line = f"[{ts}] {msg}"
    print(line)
    with open(LOG, 'a') as f:
        f.write(line + "\n")

def load_state():
    try:
        return json.loads(Path(STATE_FILE).read_text())
    except:
        return {"fixes": 0, "restarts": 0, "outreach_sent": 0, "last_improvement": None}

def save_state(state):
    Path(STATE_FILE).write_text(json.dumps(state, indent=2))

def get_service_status(name):
    """Check if service is running"""
    try:
        result = subprocess.run(
            ["systemctl", "is-active", name],
            capture_output=True, text=True
        )
        return result.stdout.strip() == "active"
    except:
        return False

def restart_service(name):
    """Restart a failed service"""
    try:
        subprocess.run(["sudo", "systemctl", "restart", name], check=True)
        return True
    except:
        return False

def check_and_fix_services(state):
    """Keep critical services alive"""
    for svc in CRITICAL_SERVICES:
        if not get_service_status(svc):
            log(f"⚠️ {svc} is DOWN - restarting...")
            if restart_service(svc):
                log(f"✅ {svc} restarted")
                state["restarts"] += 1
            else:
                log(f"❌ Failed to restart {svc}")
    return state

def check_outreach_pipeline():
    """Monitor outreach and report status"""
    try:
        conn = sqlite3.connect(SALES_DB)
        
        # Queue status
        queue = conn.execute("SELECT status, COUNT(*) FROM outreach_queue GROUP BY status").fetchall()
        
        # Leads status  
        leads = conn.execute("SELECT status, COUNT(*) FROM leads GROUP BY status").fetchall()
        
        # Followup sequence
        followups = conn.execute("SELECT COUNT(*) FROM followup_sequence").fetchone()[0]
        
        conn.close()
        
        return {
            "queue": dict(queue),
            "leads": dict(leads),
            "followups_pending": followups
        }
    except Exception as e:
        log(f"❌ Pipeline check error: {e}")
        return None

def fix_empty_followup_sequence():
    """If followup_sequence is empty, populate from hot leads"""
    try:
        conn = sqlite3.connect(SALES_DB)
        
        # Count current
        count = conn.execute("SELECT COUNT(*) FROM followup_sequence").fetchone()[0]
        
        if count == 0:
            log("📥 followup_sequence empty - importing hot leads...")
            
            # Get leads with issue_url that haven't been followed up
            hot_leads = conn.execute("""
                SELECT target, source, issue_url, score 
                FROM leads 
                WHERE issue_url IS NOT NULL AND issue_url != ''
                AND status IN ('in_followup', 'REVIEW_NEEDED', 'replied')
                LIMIT 20
            """).fetchall()
            
            imported = 0
            for target, source, issue_url, score in hot_leads:
                try:
                    conn.execute("""
                        INSERT OR IGNORE INTO followup_sequence 
                        (user, repo, issue_url, score, status, created_at, next_followup_date)
                        VALUES (?, ?, ?, ?, 'active', datetime('now'), datetime('now'))
                    """, (target, source, issue_url, max(score, 1.0)))
                    imported += 1
                except:
                    pass
            
            conn.commit()
            log(f"✅ Imported {imported} leads to followup_sequence")
        
        conn.close()
    except Exception as e:
        log(f"❌ Fix followup error: {e}")

def get_system_health():
    """Overall health check"""
    try:
        # Services running
        result = subprocess.run(
            "systemctl list-units --type=service --state=running | grep eden | wc -l",
            shell=True, capture_output=True, text=True
        )
        services_running = int(result.stdout.strip())
        
        # Capabilities count
        conn = sqlite3.connect(DB)
        caps = conn.execute("SELECT COUNT(*) FROM capabilities").fetchone()[0]
        elites = conn.execute("SELECT COUNT(*) FROM capabilities WHERE score >= 1500").fetchone()[0]
        conn.close()
        
        return {
            "services": services_running,
            "capabilities": caps,
            "elites": elites,
            "timestamp": datetime.now().isoformat()
        }
    except Exception as e:
        return {"error": str(e)}

def self_improve(state):
    """Learn from what works - simple feedback loop"""
    # Track success patterns
    pipeline = check_outreach_pipeline()
    if pipeline:
        # If outreach sent increased, log what worked
        sent = pipeline.get("queue", {}).get("sent", 0)
        if sent > state.get("outreach_sent", 0):
            log(f"📈 Outreach improved: {state.get('outreach_sent', 0)} -> {sent}")
            state["outreach_sent"] = sent
            state["last_improvement"] = datetime.now().isoformat()
    
    return state

def main_loop():
    """Main maintenance loop"""
    log("🚀 EDEN META SERVICE STARTING")
    log("=" * 50)
    
    state = load_state()
    cycle = 0
    
    while True:
        cycle += 1
        
        try:
            # 1. Keep services alive
            state = check_and_fix_services(state)
            
            # 2. Check pipeline every 5 cycles
            if cycle % 5 == 0:
                pipeline = check_outreach_pipeline()
                if pipeline:
                    log(f"📊 Pipeline: queue={pipeline['queue']}, followups={pipeline['followups_pending']}")
            
            # 3. Fix empty followup_sequence every 10 cycles
            if cycle % 10 == 0:
                fix_empty_followup_sequence()
            
            # 3b. Process hot leads every 10 cycles
            if cycle % 10 == 0:
                process_hot_leads()
            
            # 4. Health report every 20 cycles
            if cycle % 20 == 0:
                health = get_system_health()
                log(f"💚 Health: {health['services']} services, {health['elites']} elites, {health['capabilities']} caps")
            
            # 5. Self-improve every 30 cycles
            if cycle % 30 == 0:
                state = self_improve(state)
                save_state(state)
            
            # Sleep 30 seconds between cycles
            time.sleep(30)
            
        except KeyboardInterrupt:
            log("🛑 Meta service stopped by user")
            break
        except Exception as e:
            log(f"❌ Cycle error: {e}")
            time.sleep(60)

if __name__ == "__main__":
    main_loop()

def process_hot_leads():
    """Move hot leads with URLs into followup_sequence"""
    try:
        conn = sqlite3.connect(SALES_DB)
        
        # Get hot leads with issue_url
        hot = conn.execute("""
            SELECT id, source, target, issue_url, score 
            FROM leads 
            WHERE status='hot' AND issue_url IS NOT NULL AND issue_url != ''
        """).fetchall()
        
        added = 0
        for lead_id, source, target, issue_url, score in hot:
            # Add to followup_sequence if not already there
            exists = conn.execute(
                "SELECT 1 FROM followup_sequence WHERE issue_url=?", 
                (issue_url,)
            ).fetchone()
            
            if not exists:
                conn.execute("""
                    INSERT INTO followup_sequence 
                    (user, repo, issue_url, score, status, created_at, next_followup_date)
                    VALUES (?, ?, ?, ?, 'active', datetime('now'), datetime('now'))
                """, (target, source, issue_url, score))
                added += 1
                log(f"📥 Added hot lead: {source}/{target}")
        
        conn.commit()
        conn.close()
        
        if added:
            log(f"✅ Processed {added} hot leads into followup queue")
    except Exception as e:
        log(f"❌ Hot lead processing error: {e}")