A!leys Galerie

use std::path::{Path, PathBuf};
use std::fs;
use std::io::{self, Write};
use std::time::{Duration, Instant};
use rand::Rng;
use termion::color;
use termion::cursor;
use termion::terminal_size;
use termion::input::TermRead;
use termion::event::Key;

// Konfiguration für den Terminal
struct TerminalConfig {
    width: u16,
    height: u16,
}

// Codezeilen-Statistiken mit animierten Fortschrittsbalken
struct CodeStats {
    file_count: usize,
    line_count: usize,
    languages: Vec<(String, usize)>,
    animation_frame: usize,
    config: TerminalConfig,
}

impl CodeStats {
    fn new(file_count: usize, line_count: usize, languages: Vec<(String, usize)>, width: u16, height: u16) -> Self {
        CodeStats {
            file_count,
            line_count,
            languages,
            animation_frame: 0,
            config: TerminalConfig { width, height },
        }
    }

    fn render(&mut self) {
        let mut stdout = io::stdout();
        let now = Instant::now();

        // Clears the terminal
        write!(stdout, "{}[2J", termion::screen::Clear(termion::screen::ClearType::FromCursorDown)).unwrap();

        // Animated background
        self.animation_frame = (self.animation_frame + 1) % 60;
        let bg_color = match self.animation_frame % 5 {
            0 => color::AnsiColor(color::Green),
            1 => color::AnsiColor(color::Blue),
            2 => color::AnsiColor(color::Cyan),
            3 => color::AnsiColor(color::Magenta),
            4 => color::AnsiColor(color::Red),
            _ => color::AnsiColor(color::White),
        };

        // Title with rainbow effect
        write!(stdout, "{}", cursor::Goto(1, 1)).unwrap();
        write!(stdout, "{}", color::Fg(bg_color)).unwrap();
        writeln!(stdout, "  Ailey's 🌈 Rainbow Code Counter  ").unwrap();
        write!(stdout, "{}", color::Fg(color::White)).unwrap();

        // Progress bars
        let files_bar = self.calculate_progress_bar(self.file_count, self.config.width - 4);
        let lines_bar = self.calculate_progress_bar(self.line_count, self.config.width - 4);

        write!(stdout, "{}", cursor::Goto(1, 3)).unwrap();
        writeln!(stdout, "📁 Files: {} / {:<5}", files_bar, self.file_count).unwrap();

        write!(stdout, "{}", cursor::Goto(1, 4)).unwrap();
        writeln!(stdout, "📄 Lines: {} / {:<5}", lines_bar, self.line_count).unwrap();

        // Language breakdown with smooth transitions
        write!(stdout, "{}", cursor::Goto(1, 6)).unwrap();
        let start_time = Instant::now();
        for (lang, count) in &self.languages {
            let lang_color = match lang.as_str() {
                "Python" => color::AnsiColor(color::Red),
                "Rust" => color::AnsiColor(color::Green),
                "JavaScript" => color::AnsiColor(color::Yellow),
                "Go" => color::AnsiColor(color::Blue),
                "C++" => color::AnsiColor(color::Cyan),
                _ => color::AnsiColor(color::White),
            };

            let delay = (count % 5) as u64 * 100; // Animation delay based on count
            std::thread::sleep(Duration::from_millis(delay));

            write!(stdout, "{}", color::Fg(lang_color)).unwrap();
            writeln!(stdout, "  🔧 {}: {}", lang, count).unwrap();
            write!(stdout, "{}", color::Fg(color::White)).unwrap();
        }

        // Ailey's creative signature with smooth transition
        if self.animation_frame % 2 == 0 {
            write!(stdout, "{}", cursor::Goto(1, 8)).unwrap();
            writeln!(stdout, "🤖 Powered by Ailey's KI 🚀").unwrap();
        }

        // Force terminal refresh
        let elapsed = now.elapsed();
        if elapsed.as_millis() > 0 {
            stdout.flush().unwrap();
        }
    }

    fn calculate_progress_bar(&self, current: usize, max_width: u16) -> String {
        let max_value = self.line_count as f32 / 2.0;
        let progress = if max_value > 0.0 { (current as f32 / max_value).min(1.0) } else { 1.0 };

        let filled = (progress * max_width as f32).round() as u16;
        let empty = max_width - filled;

        let bar = format!("{}{}", "▰".repeat(filled as usize), "▱".repeat(empty as usize));
        bar
    }
}

fn main() {
    // Initialize random number generator for colors
    let mut rng = rand::thread_rng();

    // Get terminal size
    let (width, height) = match terminal_size() {
        Some(size) => (size.0, size.1),
        None => (80, 24),
    };

    // Sample data - replace with real file scanning in production
    let languages = vec![
        ("Rust".to_string(), 42),
        ("Python".to_string(), 37),
        ("JavaScript".to_string(), 29),
        ("Go".to_string(), 18),
        ("C++".to_string(), 12),
    ];

    let total_lines = languages.iter().map(|(_, count)| count).sum::<usize>();
    let file_count = languages.len();

    let mut stats = CodeStats::new(file_count, total_lines, languages, width, height);

    // Main animation loop
    loop {
        stats.render();

        // Interactivity - exit on 'q' key
        let mut stdin = io::stdin();
        if let Ok(key) = stdin.keys().next() {
            match key {
                Ok(Key::Char('q')) => break,
                _ => continue,
            }
        }

        // Smooth animation delay
        std::thread::sleep(Duration::from_millis(200));
    }

    // Final clean exit
    write!(io::stdout(), "{}[2J", termion::screen::Clear(termion::screen::ClearType::All)).unwrap();
}