#!/usr/bin/env python3
"""
Basic Usage Example for Muon g-2 Fractal Correction Engine

This example demonstrates the fundamental usage of the fractal correction
engine, from basic calculations to advanced optimization and visualization.

Run this script to see the fractal correction engine in action!
"""

import sys
import os

# Add src to Python path
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))

def basic_example():
    """Basic usage example."""
    print("🔬 BASIC FRACTAL CORRECTION ENGINE EXAMPLE")
    print("=" * 50)
    print()
    
    # Import the simulators
    from muon_g2_simulator import MuonG2Simulator
    from ultimate_simulator import UltimateMuonG2Simulator
    
    # 1. Basic simulator
    print("1️⃣  Basic Simulator:")
    print("-" * 20)
    
    basic_sim = MuonG2Simulator(fractal_intensity=1.0)
    basic_results = basic_sim.calculate_total_anomaly()
    
    print(f"   Sigma deviation: {basic_results['sigma_deviation']:.2f}σ")
    print(f"   Coverage: {abs(basic_results['discrepancy_coverage']):.1f}%")
    print(f"   Improvement: {basic_results['improvement_factor']:.1f}×")
    print()
    
    # 2. Ultimate simulator
    print("2️⃣  Ultimate Simulator:")
    print("-" * 22)
    
    ultimate_sim = UltimateMuonG2Simulator(fractal_intensity=2.8)
    ultimate_results = ultimate_sim.calculate_total_anomaly()
    
    print(f"   Sigma deviation: {ultimate_results['sigma_deviation']:.2f}σ")
    print(f"   Coverage: {abs(ultimate_results['discrepancy_coverage']):.1f}%")
    print(f"   Improvement: {ultimate_results['improvement_factor']:.1f}×")
    print()
    
    # 3. Parameter optimization
    print("3️⃣  Parameter Optimization:")
    print("-" * 27)
    
    print("   Optimizing fractal intensity...")
    optimal_intensity = basic_sim.optimize_fractal_intensity()
    optimized_results = basic_sim.calculate_total_anomaly()
    
    print(f"   Optimal intensity: {optimal_intensity:.3f}")
    print(f"   Optimized sigma: {optimized_results['sigma_deviation']:.2f}σ")
    print()
    
    return {
        'basic': basic_results,
        'ultimate': ultimate_results,
        'optimized': optimized_results,
        'optimal_intensity': optimal_intensity
    }

def advanced_example():
    """Advanced usage example with detailed analysis."""
    print("🚀 ADVANCED FRACTAL CORRECTION ENGINE EXAMPLE")
    print("=" * 55)
    print()
    
    from ultimate_simulator import UltimateMuonG2Simulator
    
    # Advanced configuration
    advanced_sim = UltimateMuonG2Simulator(
        fractal_intensity=2.5,
        enhancement_weights={
            'enhanced_coupling': 0.30,
            'multi_scale': 0.25,
            'nonlinear': 0.20,
            'resonance': 0.15,
            'alternative': 0.05,
            'quantum_coherence': 0.025,
            'rg_flow': 0.025
        },
        golden_ratio_params=[1.2, 0.8, 1.5],
        coherence_params=[0.9, 1.1, 0.7],
        rg_flow_params=[1.0, 0.8, 1.3]
    )
    
    print("🔧 Advanced Configuration:")
    print(f"   Fractal intensity: {advanced_sim.fractal_intensity}")
    print(f"   Enhancement weights: {len(advanced_sim.weights)} mechanisms")
    print(f"   Golden ratio params: {advanced_sim.golden_params}")
    print()
    
    # Calculate detailed results
    advanced_results = advanced_sim.calculate_total_anomaly()
    
    print("📊 Detailed Results:")
    print(f"   Total correction: {advanced_results['total_correction']:.1f} × 10⁻¹⁰")
    print(f"   Enhanced coupling: {advanced_results['enhanced_coupling']:.1f} × 10⁻¹⁰")
    print(f"   Multi-scale: {advanced_results['multi_scale']:.1f} × 10⁻¹⁰")
    print(f"   Non-linear: {advanced_results['nonlinear']:.1f} × 10⁻¹⁰")
    print(f"   Golden resonance: {advanced_results['resonance']:.1f} × 10⁻¹⁰")
    print(f"   Quantum coherence: {advanced_results['quantum_coherence']:.1f} × 10⁻¹⁰")
    print(f"   RG flow: {advanced_results['rg_flow']:.1f} × 10⁻¹⁰")
    print()
    
    print("🎯 Performance Metrics:")
    print(f"   Sigma deviation: {advanced_results['sigma_deviation']:.2f}σ")
    print(f"   Discrepancy coverage: {abs(advanced_results['discrepancy_coverage']):.1f}%")
    print(f"   Improvement factor: {advanced_results['improvement_factor']:.1f}×")
    print(f"   Scientific constraints: {'✅ Satisfied' if advanced_results['scientific_constraints_satisfied'] else '❌ Violated'}")
    print()
    
    return advanced_results

def comparison_example():
    """Compare different approaches."""
    print("📈 APPROACH COMPARISON EXAMPLE")
    print("=" * 40)
    print()
    
    from muon_g2_simulator import MuonG2Simulator
    from definitive_simulator import DefinitiveMuonG2Simulator  
    from ultimate_simulator import UltimateMuonG2Simulator
    
    approaches = [
        ("Basic", MuonG2Simulator(fractal_intensity=1.0)),
        ("Definitive", DefinitiveMuonG2Simulator(fractal_intensity=1.5)),
        ("Ultimate", UltimateMuonG2Simulator(fractal_intensity=2.8))
    ]
    
    print("| Approach   | Sigma Dev | Coverage | Improvement |")
    print("|------------|-----------|----------|-------------|")
    
    results_comparison = {}
    
    for name, simulator in approaches:
        try:
            results = simulator.calculate_total_anomaly()
            sigma = results['sigma_deviation']
            coverage = abs(results['discrepancy_coverage'])
            improvement = results['improvement_factor']
            
            print(f"| {name:<10} | {sigma:>7.2f}σ | {coverage:>6.1f}% | {improvement:>9.1f}× |")
            
            results_comparison[name] = {
                'sigma': sigma,
                'coverage': coverage,
                'improvement': improvement
            }
            
        except Exception as e:
            print(f"| {name:<10} | Error: {str(e)[:20]:<20} |")
    
    print()
    
    # Find best approach
    if results_comparison:
        best_approach = min(results_comparison.keys(), 
                          key=lambda k: results_comparison[k]['sigma'])
        
        print(f"🏆 Best Approach: {best_approach}")
        print(f"   Achieves {results_comparison[best_approach]['sigma']:.2f}σ deviation")
        print(f"   with {results_comparison[best_approach]['coverage']:.1f}% coverage")
    
    return results_comparison

def visualization_example():
    """Visualization example (if available)."""
    print("🎨 VISUALIZATION EXAMPLE")
    print("=" * 30)
    print()
    
    try:
        from visualization import MuonG2Visualizer
        
        print("Creating visualizer...")
        viz = MuonG2Visualizer()
        
        print("Available visualization methods:")
        methods = [method for method in dir(viz) if method.startswith('plot_') and not method.startswith('_')]
        for i, method in enumerate(methods, 1):
            print(f"   {i}. {method}")
        
        print()
        print("💡 To generate plots, run:")
        print("   viz = MuonG2Visualizer()")
        print("   viz.create_full_analysis_dashboard()")
        print()
        
        return True
        
    except ImportError as e:
        print(f"⚠️  Visualization not available: {e}")
        print("   Install matplotlib and seaborn for visualization features")
        return False

def parameter_exploration_example():
    """Parameter space exploration example."""
    print("🔍 PARAMETER EXPLORATION EXAMPLE")
    print("=" * 40)
    print()
    
    from ultimate_simulator import UltimateMuonG2Simulator
    
    print("Testing different fractal intensities:")
    print()
    
    intensities = [0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
    
    print("| Intensity | Sigma Dev | Coverage | Status    |")
    print("|-----------|-----------|----------|-----------|")
    
    best_result = {'intensity': 0, 'sigma': float('inf')}
    
    for intensity in intensities:
        try:
            sim = UltimateMuonG2Simulator(fractal_intensity=intensity)
            results = sim.calculate_total_anomaly()
            
            sigma = results['sigma_deviation']
            coverage = abs(results['discrepancy_coverage'])
            
            if sigma < 2.0:
                status = "Excellent"
            elif sigma < 3.0:
                status = "Good"
            elif sigma < 5.0:
                status = "Fair"
            else:
                status = "Poor"
            
            print(f"| {intensity:>7.1f} | {sigma:>7.2f}σ | {coverage:>6.1f}% | {status:<9} |")
            
            if sigma < best_result['sigma']:
                best_result = {'intensity': intensity, 'sigma': sigma, 'coverage': coverage}
                
        except Exception as e:
            print(f"| {intensity:>7.1f} | Error: {str(e)[:15]:<15} |")
    
    print()
    print(f"🎯 Best Parameters Found:")
    print(f"   Intensity: {best_result['intensity']}")
    print(f"   Sigma: {best_result['sigma']:.2f}σ")
    print(f"   Coverage: {best_result.get('coverage', 0):.1f}%")
    
    return best_result

def main():
    """Run all examples."""
    print("🧪 MUON G-2 FRACTAL CORRECTION ENGINE - USAGE EXAMPLES")
    print("=" * 65)
    print("   Comprehensive examples of fractal correction engine usage")
    print("=" * 65)
    print()
    
    try:
        # Run examples
        basic_results = basic_example()
        print()
        
        advanced_results = advanced_example()
        print()
        
        comparison_results = comparison_example()
        print()
        
        viz_available = visualization_example()
        print()
        
        exploration_results = parameter_exploration_example()
        print()
        
        # Summary
        print("✅ ALL EXAMPLES COMPLETED SUCCESSFULLY!")
        print()
        print("🎯 Key Findings:")
        
        if 'ultimate' in basic_results:
            ultimate_sigma = basic_results['ultimate']['sigma_deviation']
            ultimate_coverage = abs(basic_results['ultimate']['discrepancy_coverage'])
            
            print(f"   • Ultimate simulator achieves {ultimate_sigma:.2f}σ agreement")
            print(f"   • Explains {ultimate_coverage:.1f}% of experimental discrepancy")
            
            if ultimate_sigma < 2.0:
                print("   • 🎉 BREAKTHROUGH: < 2σ agreement achieved!")
            elif ultimate_sigma < 3.0:
                print("   • 🌟 EXCELLENT: Near-complete resolution!")
            else:
                print("   • 📈 PROGRESS: Significant theoretical advance!")
        
        print()
        print("🔬 Next Steps:")
        print("   1. Try different parameter combinations")
        print("   2. Explore visualization features")
        print("   3. Run optimization algorithms")
        print("   4. Analyze scientific constraints")
        print()
        print("📚 For more information, see:")
        print("   • docs/theory.md - Theoretical background")
        print("   • docs/implementation.md - Technical details")
        print("   • examples/ - Additional examples")
        
        return True
        
    except Exception as e:
        print(f"❌ Example execution failed: {e}")
        import traceback
        traceback.print_exc()
        return False

if __name__ == "__main__":
    success = main()
    sys.exit(0 if success else 1)