wave-file 0.1.0

use clap::{Parser, Subcommand};
use colored::*;
use std::fs;
use std::f64::consts::PI;
use wave_file::{WaveFile, Wave, IlluminationMode, NestedRings};

#[derive(Parser)]
#[command(name = "wave-read")]
#[command(about = "🌊 Read files as wave interference patterns", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Read file at specific angle
    Read {
        /// File to read
        file: String,
        
        /// Reading angle in degrees (0-360)
        #[arg(short, long, default_value = "0")]
        angle: f64,
        
        /// Phase shift (0-1)
        #[arg(short, long, default_value = "1.0")]
        phase: f64,
    },
    
    /// Read file at golden ratio angle
    Golden {
        /// File to read
        file: String,
    },
    
    /// Quantum read - all angles simultaneously
    Quantum {
        /// File to read
        file: String,
    },
    
    /// Illuminate file structure
    Illuminate {
        /// File to read
        file: String,
        
        /// Mode: red-shift, blue-shift, quantum-phase
        #[arg(short, long, default_value = "red-shift")]
        mode: String,
    },
    
    /// Check nested rings resonance
    Rings {
        /// File to check
        file: String,
    },
    
    /// Scan multiple angles and find harmonics
    Scan {
        /// File to scan
        file: String,
        
        /// Step size in degrees
        #[arg(short, long, default_value = "15")]
        step: f64,
    },
}

fn main() {
    let cli = Cli::parse();
    
    match cli.command {
        Commands::Read { file, angle, phase } => {
            read_file(&file, angle, phase);
        }
        Commands::Golden { file } => {
            read_golden(&file);
        }
        Commands::Quantum { file } => {
            read_quantum(&file);
        }
        Commands::Illuminate { file, mode } => {
            illuminate_file(&file, &mode);
        }
        Commands::Rings { file } => {
            check_rings(&file);
        }
        Commands::Scan { file, step } => {
            scan_angles(&file, step);
        }
    }
}

fn read_file(path: &str, angle_deg: f64, phase: f64) {
    println!("{}",  "╔════════════════════════════════════════╗".cyan());
    println!("{}",  "║        🌊 WAVE FILE READER 🌊         ║".cyan());
    println!("{}",  "║     Files as Phase Matrices           ║".cyan());
    println!("{}",  "╚════════════════════════════════════════╝".cyan());
    println!();
    
    let content = match fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("{} {}", "Error reading file:".red(), e);
            return;
        }
    };
    
    let mut wave_file = WaveFile::from_text(&content);
    let angle_rad = angle_deg * PI / 180.0;
    let wave = Wave::new(angle_rad, phase);
    
    println!("{} {}", "📂 File:".bright_blue(), path);
    println!("{} {:.1}°", "📐 Angle:".bright_blue(), angle_deg);
    println!("{} {:.2}", "🌀 Phase:".bright_blue(), phase);
    println!();
    
    let chord = wave_file.read(wave);
    
    println!("{}", "📊 Chord Analysis:".green());
    println!("  {} {} frequencies", "•".cyan(), chord.frequencies.len());
    println!("  {} {:.2} Hz", "• Resonance:".cyan(), chord.resonance);
    println!("  {} {}", "• Meaning:".cyan(), chord.meaning.yellow());
    
    if !chord.frequencies.is_empty() {
        println!();
        println!("{}", "🎵 Frequency Spectrum:".green());
        
        // Show first 10 frequencies
        for (i, freq) in chord.frequencies.iter().take(10).enumerate() {
            let bar_len = (freq.abs() / 100.0).min(40.0) as usize;
            let bar = "█".repeat(bar_len);
            println!("  {}: {:>8.2} Hz {}", 
                     format!("F{}", i).cyan(),
                     freq,
                     bar.bright_cyan());
        }
        
        if chord.frequencies.len() > 10 {
            println!("  {} more frequencies...", 
                     (chord.frequencies.len() - 10).to_string().dimmed());
        }
    }
    
    // File evolved
    println!();
    println!("{} File evolved after reading (generation {})", 
             "✨".yellow(), 
             wave_file.evolution);
}

fn read_golden(path: &str) {
    println!("{}", "🌟 Reading at Golden Ratio angle...".yellow());
    
    let content = match fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("{} {}", "Error reading file:".red(), e);
            return;
        }
    };
    
    let mut wave_file = WaveFile::from_text(&content);
    let chord = wave_file.read(Wave::golden());
    
    println!("{} {}", "📂 File:".bright_blue(), path);
    println!("{} φ (1.618...)", "📐 Angle:".bright_blue());
    println!("{} 1/φ (0.618...)", "🌀 Phase:".bright_blue());
    println!();
    println!("{} {}", "✨ Golden Meaning:".yellow(), chord.meaning);
    println!("{} {:.2} Hz", "🎵 Resonance:".yellow(), chord.resonance);
}

fn read_quantum(path: &str) {
    println!("{}", "🌌 Quantum reading - all states simultaneously...".magenta());
    
    let content = match fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("{} {}", "Error reading file:".red(), e);
            return;
        }
    };
    
    let mut wave_file = WaveFile::from_text(&content);
    let chord = wave_file.read(Wave::quantum());
    
    println!("{} {}", "📂 File:".bright_blue(), path);
    println!("{} ∞", "📐 Angle:".bright_blue());
    println!("{} ∞", "🌀 Phase:".bright_blue());
    println!();
    println!("{} {}", "🌌 Quantum State:".magenta(), chord.meaning);
    println!("{} {} frequencies in superposition", 
             "⚛️".magenta(), 
             chord.frequencies.len());
}

fn illuminate_file(path: &str, mode: &str) {
    let content = match fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("{} {}", "Error reading file:".red(), e);
            return;
        }
    };
    
    let wave_file = WaveFile::from_text(&content);
    
    let illumination_mode = match mode {
        "red-shift" => IlluminationMode::RedShift,
        "blue-shift" => IlluminationMode::BlueShift,
        "quantum-phase" => IlluminationMode::QuantumPhase,
        _ => {
            eprintln!("{} {}", "Unknown mode:".red(), mode);
            return;
        }
    };
    
    println!("{} Illuminating with {} mode...", "💡".yellow(), mode);
    println!();
    
    let visualization = wave_file.illuminate(illumination_mode);
    println!("{}", visualization);
}

fn check_rings(path: &str) {
    println!("{}", "🔮 Checking nested rings resonance...".cyan());
    
    let data = match fs::read(path) {
        Ok(d) => d,
        Err(e) => {
            eprintln!("{} {}", "Error reading file:".red(), e);
            return;
        }
    };
    
    let rings = NestedRings::new(&data);
    
    println!("{} {}", "📂 File:".bright_blue(), path);
    println!("{} {} bytes", "📏 Size:".bright_blue(), data.len());
    println!();
    
    println!("{}", "🌀 Nested Rings:".green());
    println!("  {} SHA256 (deterministic)", "1️⃣".cyan());
    println!("  {} CID (distributed)", "2️⃣".cyan());
    println!("  {} pHash (resonant)", "3️⃣".cyan());
    
    if rings.resonates() {
        println!("  {} Quantum (emerged!)", "4️⃣".magenta());
        println!();
        println!("{}", "✨ STANDING WAVE DETECTED! ✨".yellow().bold());
        println!("The rings create perfect resonance at 432Hz");
    } else {
        println!("  {} Quantum (not present)", "4️⃣".dimmed());
        println!();
        println!("{}", "No standing wave - rings not in resonance".dimmed());
    }
}

fn scan_angles(path: &str, step: f64) {
    println!("{}", "📡 Scanning all angles for harmonic patterns...".cyan());
    
    let content = match fs::read_to_string(path) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("{} {}", "Error reading file:".red(), e);
            return;
        }
    };
    
    let mut wave_file = WaveFile::from_text(&content);
    let mut harmonics = Vec::new();
    
    println!("{} {}", "📂 File:".bright_blue(), path);
    println!("{} {:.1}°", "📐 Step:".bright_blue(), step);
    println!();
    
    let mut angle = 0.0;
    while angle < 360.0 {
        let angle_rad = angle * PI / 180.0;
        let wave = Wave::new(angle_rad, 1.0);
        let chord = wave_file.read(wave);
        
        harmonics.push((angle, chord.resonance, chord.meaning));
        angle += step;
    }
    
    // Find peaks
    harmonics.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
    
    println!("{}", "🎵 Top Harmonic Angles:".green());
    for (i, (angle, resonance, meaning)) in harmonics.iter().take(5).enumerate() {
        println!("  {}. {:>6.1}° → {:.2} Hz ({})",
                 i + 1,
                 angle,
                 resonance,
                 meaning.yellow());
    }
    
    println!();
    println!("{} File evolved {} times during scan", 
             "✨".yellow(), 
             wave_file.evolution);
}