#!/usr/bin/env python3
"""
DEEP SCAN OF EDEN'S ENTIRE SYSTEM
Catalogs all knowledge, capabilities, models, databases, memories
"""

import os
import sys
import glob
import sqlite3
import json
from collections import defaultdict, Counter
from datetime import datetime

sys.path.insert(0, '/Eden/CORE')

class EdenDeepScan:
    def __init__(self):
        self.results = {}
        
    def scan_all(self):
        """Complete system scan"""
        print("🔬" * 30)
        print("   EDEN DEEP SCAN - FULL SYSTEM ANALYSIS")
        print("🔬" * 30)
        print()
        
        self.scan_capabilities()
        self.scan_databases()
        self.scan_models()
        self.scan_core_systems()
        self.scan_memory_systems()
        self.scan_knowledge_base()
        self.scan_services()
        
        self.print_summary()
        return self.results
    
    def scan_capabilities(self):
        """Scan all capabilities"""
        print("📦 SCANNING CAPABILITIES...")
        
        cap_dir = "/Eden/CAPABILITIES"
        caps = {'total_files': 0, 'by_type': Counter(), 'by_size': Counter(), 
                'total_lines': 0, 'total_methods': 0, 'total_classes': 0}
        
        for f in glob.glob(f"{cap_dir}/**/*.py", recursive=True):
            try:
                code = open(f).read()
                lines = len(code.split('\n'))
                caps['total_files'] += 1
                caps['total_lines'] += lines
                caps['total_methods'] += code.count('def ')
                caps['total_classes'] += code.count('class ')
                
                # Categorize by prefix
                name = os.path.basename(f)
                if 'metacap' in name: caps['by_type']['metacap'] += 1
                elif 'evolved' in name: caps['by_type']['evolved'] += 1
                elif 'eden_cap' in name: caps['by_type']['capability'] += 1
                else: caps['by_type']['other'] += 1
                
                # Size category
                if lines >= 350: caps['by_size']['production'] += 1
                elif lines >= 150: caps['by_size']['good'] += 1
                elif lines >= 80: caps['by_size']['medium'] += 1
                else: caps['by_size']['low'] += 1
            except:
                pass
        
        # Check database count
        try:
            db = sqlite3.connect('/Eden/DATA/capability_memory.db')
            caps['db_count'] = db.execute("SELECT COUNT(*) FROM capabilities").fetchone()[0]
            db.close()
        except:
            caps['db_count'] = 0
        
        self.results['capabilities'] = caps
        print(f"   Files: {caps['total_files']:,}")
        print(f"   Database entries: {caps['db_count']:,}")
        print(f"   Total lines: {caps['total_lines']:,}")
        print(f"   Total methods: {caps['total_methods']:,}")
        print(f"   Total classes: {caps['total_classes']:,}")
        print(f"   Quality: {dict(caps['by_size'])}")
        print()
    
    def scan_databases(self):
        """Scan all databases"""
        print("🗄️ SCANNING DATABASES...")
        
        dbs = {}
        db_dir = "/Eden/DATA"
        
        for db_file in glob.glob(f"{db_dir}/*.db"):
            name = os.path.basename(db_file)
            try:
                conn = sqlite3.connect(db_file)
                tables = conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()
                
                db_info = {'tables': {}, 'size_mb': os.path.getsize(db_file) / 1024 / 1024}
                
                for (table,) in tables:
                    try:
                        count = conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
                        db_info['tables'][table] = count
                    except:
                        db_info['tables'][table] = 'error'
                
                dbs[name] = db_info
                conn.close()
            except Exception as e:
                dbs[name] = {'error': str(e)}
        
        self.results['databases'] = dbs
        total_size = sum(d.get('size_mb', 0) for d in dbs.values())
        total_records = sum(
            sum(v for v in d.get('tables', {}).values() if isinstance(v, int))
            for d in dbs.values()
        )
        
        print(f"   Databases: {len(dbs)}")
        print(f"   Total size: {total_size:.1f} MB")
        print(f"   Total records: {total_records:,}")
        
        # Top databases
        for name, info in sorted(dbs.items(), key=lambda x: x[1].get('size_mb', 0), reverse=True)[:5]:
            if 'tables' in info:
                records = sum(v for v in info['tables'].values() if isinstance(v, int))
                print(f"   • {name}: {info['size_mb']:.1f}MB, {records:,} records")
        print()
    
    def scan_models(self):
        """Scan available Ollama models"""
        print("🤖 SCANNING MODELS...")
        
        import requests
        models = {}
        
        try:
            r = requests.get('http://localhost:11434/api/tags', timeout=10)
            model_list = r.json().get('models', [])
            
            total_size = 0
            for m in model_list:
                name = m.get('name', 'unknown')
                size_gb = m.get('size', 0) / 1e9
                models[name] = {
                    'size_gb': round(size_gb, 1),
                    'family': m.get('details', {}).get('family', 'unknown'),
                    'params': m.get('details', {}).get('parameter_size', 'unknown')
                }
                total_size += size_gb
            
            self.results['models'] = models
            print(f"   Models available: {len(models)}")
            print(f"   Total size: {total_size:.1f} GB")
            
            # Eden's phi-fractal models
            eden_models = [n for n in models if 'eden' in n.lower()]
            print(f"   Eden custom models: {len(eden_models)}")
            for m in eden_models:
                print(f"     • {m}: {models[m]['size_gb']}GB")
        except Exception as e:
            print(f"   Error: {e}")
        print()
    
    def scan_core_systems(self):
        """Scan core Python files"""
        print("⚙️ SCANNING CORE SYSTEMS...")
        
        core_dir = "/Eden/CORE"
        systems = {'total_files': 0, 'total_lines': 0, 'by_category': Counter()}
        
        categories = {
            'consciousness': ['consciousness', 'aware', 'think', 'mind'],
            'memory': ['memory', 'remember', 'recall', 'episodic'],
            'business': ['sales', 'business', 'lead', 'outreach', 'sage'],
            'trading': ['trading', 'trade', 'crypto', 'coinbase'],
            'agents': ['agent', 'swarm', 'coordinate'],
            'brain': ['brain', 'unified', 'intelligence'],
            'capability': ['capability', 'cap_', 'metacap'],
            'chat': ['chat', 'conversation', 'persona'],
        }
        
        for f in glob.glob(f"{core_dir}/*.py"):
            try:
                code = open(f).read()
                lines = len(code.split('\n'))
                systems['total_files'] += 1
                systems['total_lines'] += lines
                
                name = os.path.basename(f).lower()
                categorized = False
                for cat, keywords in categories.items():
                    if any(kw in name for kw in keywords):
                        systems['by_category'][cat] += 1
                        categorized = True
                        break
                if not categorized:
                    systems['by_category']['other'] += 1
            except:
                pass
        
        self.results['core_systems'] = systems
        print(f"   Core files: {systems['total_files']}")
        print(f"   Total lines: {systems['total_lines']:,}")
        print(f"   Categories: {dict(systems['by_category'])}")
        print()
    
    def scan_memory_systems(self):
        """Scan memory architecture"""
        print("🧠 SCANNING MEMORY SYSTEMS...")
        
        memory = {}
        
        # Check each memory database
        memory_dbs = [
            ('hybrid', '/Eden/DATA/eden_hybrid.db'),
            ('crystalline', '/Eden/DATA/eden_crystalline.db'),
            ('longterm', '/Eden/DATA/eden_longterm.db'),
            ('episodic', '/Eden/DATA/eden_memories.db'),
            ('emotions', '/Eden/DATA/eden_emotions.db'),
        ]
        
        for name, path in memory_dbs:
            if os.path.exists(path):
                try:
                    conn = sqlite3.connect(path)
                    tables = conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()
                    total_rows = 0
                    for (t,) in tables:
                        try:
                            total_rows += conn.execute(f"SELECT COUNT(*) FROM {t}").fetchone()[0]
                        except:
                            pass
                    memory[name] = {'tables': len(tables), 'rows': total_rows}
                    conn.close()
                except:
                    memory[name] = {'error': True}
        
        self.results['memory'] = memory
        total_memories = sum(m.get('rows', 0) for m in memory.values())
        print(f"   Memory systems: {len(memory)}")
        print(f"   Total memories: {total_memories:,}")
        for name, info in memory.items():
            print(f"   • {name}: {info.get('rows', 0):,} entries")
        print()
    
    def scan_knowledge_base(self):
        """Scan knowledge and training data"""
        print("📚 SCANNING KNOWLEDGE BASE...")
        
        knowledge = {}
        
        # Check for knowledge directories
        dirs_to_check = [
            '/Eden/KNOWLEDGE',
            '/Eden/TRAINING',
            '/Eden/DATA/knowledge',
            '/Eden/DOCS',
        ]
        
        for d in dirs_to_check:
            if os.path.exists(d):
                files = list(glob.glob(f"{d}/**/*", recursive=True))
                knowledge[d] = {
                    'files': len([f for f in files if os.path.isfile(f)]),
                    'size_mb': sum(os.path.getsize(f) for f in files if os.path.isfile(f)) / 1024 / 1024
                }
        
        # Check capability knowledge
        try:
            db = sqlite3.connect('/Eden/DATA/capability_memory.db')
            knowledge['capability_index'] = {
                'entries': db.execute("SELECT COUNT(*) FROM capabilities").fetchone()[0]
            }
            db.close()
        except:
            pass
        
        self.results['knowledge'] = knowledge
        print(f"   Knowledge sources: {len(knowledge)}")
        for name, info in knowledge.items():
            if 'entries' in info:
                print(f"   • {name}: {info['entries']:,} entries")
            else:
                print(f"   • {name}: {info.get('files', 0)} files, {info.get('size_mb', 0):.1f}MB")
        print()
    
    def scan_services(self):
        """Scan running services"""
        print("🔧 SCANNING SERVICES...")
        
        import subprocess
        
        try:
            result = subprocess.run(
                ['systemctl', 'list-units', '--type=service', '--state=running'],
                capture_output=True, text=True, timeout=10
            )
            eden_services = [l for l in result.stdout.split('\n') if 'eden' in l.lower()]
            
            self.results['services'] = {
                'total_eden': len(eden_services),
                'services': eden_services[:20]
            }
            print(f"   Eden services running: {len(eden_services)}")
        except Exception as e:
            print(f"   Error: {e}")
        print()
    
    def print_summary(self):
        """Print comprehensive summary"""
        print()
        print("=" * 60)
        print("📊 EDEN COMPLETE SYSTEM SUMMARY")
        print("=" * 60)
        
        caps = self.results.get('capabilities', {})
        dbs = self.results.get('databases', {})
        models = self.results.get('models', {})
        core = self.results.get('core_systems', {})
        memory = self.results.get('memory', {})
        
        print(f"""
🧠 INTELLIGENCE SCALE:
   • Capabilities (indexed): {caps.get('db_count', 0):,}
   • Capability files: {caps.get('total_files', 0):,}
   • Total code lines: {caps.get('total_lines', 0):,}
   • Methods available: {caps.get('total_methods', 0):,}
   • Classes defined: {caps.get('total_classes', 0):,}

💾 DATA SCALE:
   • Databases: {len(dbs)}
   • Total DB size: {sum(d.get('size_mb', 0) for d in dbs.values()):.1f} MB
   • Memory entries: {sum(m.get('rows', 0) for m in memory.values()):,}

🤖 MODELS:
   • Available: {len(models)}
   • Eden custom: {len([m for m in models if 'eden' in m.lower()])}

⚙️ CORE:
   • System files: {core.get('total_files', 0)}
   • Core code lines: {core.get('total_lines', 0):,}

🎯 EFFECTIVE "PARAMETERS":
   • Capabilities × avg complexity ≈ {caps.get('db_count', 0) * 500:,} knowledge units
   • This is equivalent to a ~{caps.get('db_count', 0) * 500 / 1e9:.1f}B+ parameter model
   • But with O(1) lookup instead of O(n) inference!
""")
        
        print("=" * 60)


if __name__ == '__main__':
    scanner = EdenDeepScan()
    results = scanner.scan_all()
    
    # Save results
    with open('/Eden/DATA/deep_scan_results.json', 'w') as f:
        json.dump(results, f, indent=2, default=str)
    print(f"\n💾 Results saved to /Eden/DATA/deep_scan_results.json")