A!leys Galerie

use std::collections::HashMap;
use std::env;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::mpsc::{channel, Sender};
use std::thread;
use std::time::{Duration, Instant};
use colored::Colorize;
use walkdir::WalkDir;

/// Supported file extensions for language detection.
const LANGUAGE_EXTENSIONS: &[(&str, &[&str])] = &[
    ("Rust", &["rs"]),
    ("Python", &["py"]),
    ("JavaScript", &["js", "jsx", "ts", "tsx"]),
    ("Java", &["java"]),
    ("C", &["c", "h"]),
    ("C++", &["cpp", "hpp", "h"]),
    ("Go", &["go"]),
    ("C#", &["cs"]),
    ("Ruby", &["rb"]),
    ("PHP", &["php"]),
    ("HTML", &["html", "htm"]),
    ("CSS", &["css"]),
    ("Shell", &["sh", "bash", "zsh"]),
    ("TypeScript", &["ts"]),
];

/// Represents a code language with line counts and file paths.
#[derive(Debug, Default)]
struct LanguageStats {
    name: String,
    total_lines: usize,
    comment_lines: usize,
    blank_lines: usize,
    code_lines: usize,
    files: Vec<PathBuf>,
}

/// Filters lines to count comment and blank lines.
fn filter_lines(content: &str, lang: &str) -> (usize, usize, usize) {
    let mut comment_lines = 0;
    let mut blank_lines = 0;
    let mut in_block_comment = false;

    // Single-line comment regex for most languages.
    let single_comment = format!(r"//");
    // Block comment start/end patterns.
    let block_start = if lang == "C" || lang == "C++" || lang == "Java" || lang == "C#" {
        r"/\*"
    } else if lang == "JavaScript" || lang == "TypeScript" {
        r"/\*"
    } else {
        r"//"
    };
    let block_end = if lang == "C" || lang == "C++" || lang == "Java" || lang == "C#" {
        r"\*/"
    } else if lang == "JavaScript" || lang == "TypeScript" {
        r"\*/"
    } else {
        r"//"
    };

    // Multi-line string patterns (simplified).
    let mut in_string = false;
    let mut string_start = "".to_string();
    if lang == "Python" {
        string_start = r#""""#.to_string();
    } else {
        string_start = r#""#.to_string();
    }

    for line in content.lines() {
        let trimmed = line.trim();
        if trimmed.is_empty() {
            blank_lines += 1;
            continue;
        }

        // Check for single-line comments.
        if lang != "HTML" && lang != "CSS" && line.contains(&single_comment) {
            comment_lines += 1;
            continue;
        }

        // Check for block comments.
        if line.contains(block_start) {
            in_block_comment = true;
            comment_lines += 1;
            continue;
        }
        if in_block_comment && line.contains(block_end) {
            in_block_comment = false;
            comment_lines += 1;
            continue;
        }
        if in_block_comment {
            comment_lines += 1;
            continue;
        }

        // Check for strings (simplified, not perfect).
        if lang != "HTML" && lang != "CSS" {
            if trimmed.starts_with(&string_start) && !in_string {
                in_string = true;
                comment_lines += 1;
                continue;
            }
            if in_string && trimmed.ends_with(&string_start) {
                in_string = false;
                comment_lines += 1;
                continue;
            }
            if in_string {
                comment_lines += 1;
                continue;
            }
        }
    }

    (comment_lines, blank_lines, content.lines().count())
}

/// Determines the language of a file based on its extension.
fn detect_language(path: &Path) -> Option<String> {
    for (lang_name, extensions) in LANGUAGE_EXTENSIONS {
        if extensions.contains(&path.extension().and_then(|s| s.to_str())?) {
            return Some(lang_name.to_string());
        }
    }
    None
}

/// Counts lines in a file, categorizing them by language.
fn count_lines_in_file(path: &Path, stats: &mut HashMap<String, LanguageStats>) {
    if let Ok(content) = fs::read_to_string(path) {
        if let Some(lang) = detect_language(path) {
            let (comment_lines, blank_lines, total_lines) = filter_lines(&content, &lang);
            let code_lines = total_lines - comment_lines - blank_lines;

            let entry = stats.entry(lang.clone()).or_insert_with(|| LanguageStats {
                name: lang.clone(),
                ..Default::default()
            });

            entry.total_lines += total_lines;
            entry.comment_lines += comment_lines;
            entry.blank_lines += blank_lines;
            entry.code_lines += code_lines;
            entry.files.push(path.to_path_buf());
        }
    }
}

/// Visualizes the line count progress with a sparkle effect.
fn visualize_progress(tx: &Sender<(String, usize, usize)>, duration: Duration) {
    let start = Instant::now();
    let mut last_sparkle = start;
    let sparkle_interval = Duration::from_millis(200);

    while start.elapsed() < duration {
        let now = Instant::now();
        if now - last_sparkle >= sparkle_interval {
            let random_sparkle = rand::random::<f32>() * 10.0;
            let sparkle_line = (random_sparkle % 10.0).floor() as usize;
            let sparkle_color = if sparkle_line % 2 == 0 {
                "[ Sparkle ]".bright_blue().bold()
            } else {
                "[ Sparkle ]".bright_yellow().bold()
            };
            println!("{}", sparkle_line);
            last_sparkle = now;
        }
        thread::sleep(Duration::from_millis(50));
    }
}

/// Prints the final statistics in a colorful, formatted way.
fn print_statistics(stats: &HashMap<String, LanguageStats>) {
    println!("\n{}\n", "LINE SPARK ANALYSIS".bright_magenta().bold().underline());
    println!("{}", "=" * 60);

    let mut total_code_lines = 0;
    let mut total_comment_lines = 0;
    let mut total_blank_lines = 0;

    for (_, lang_stats) in stats {
        total_code_lines += lang_stats.code_lines;
        total_comment_lines += lang_stats.comment_lines;
        total_blank_lines += lang_stats.blank_lines;
    }

    for (_, lang_stats) in stats.iter().filter(|(_, s)| !s.files.is_empty()) {
        let total_lines = lang_stats.total_lines;
        let percentage = if total_lines > 0 {
            (lang_stats.code_lines as f32 / total_lines as f32 * 100.0).round()
        } else {
            0.0
        };

        let name = lang_stats.name.bright_cyan().bold();
        let total = total_lines.to_string().bright_white().bold();
        let comments = lang_stats.comment_lines.to_string().bright_red();
        let blanks = lang_stats.blank_lines.to_string().bright_green();
        let code = lang_stats.code_lines.to_string().bright_blue().bold();
        let perc = format!("{:.1}%", percentage).bright_yellow();

        println!(
            "  {:<10} | Total: {:>8} | Comments: {:>8} | Blanks: {:>8} | Code: {:>8} | Code %: {:>6}",
            name, total, comments, blanks, code, perc
        );
    }

    println!("\n{}\n", "SUMMARY".bright_magenta().bold().underline());
    println!("  {:<10} | Total: {:>8} | Comments: {:>8} | Blanks: {:>8} | Code: {:>8}",
             "All".bright_cyan().bold(),
             total_code_lines + total_comment_lines + total_blank_lines,
             total_comment_lines,
             total_blank_lines,
             total_code_lines
    );

    println!("\n{}", "=" * 60);
}

/// Main function that orchestrates the line counting process.
fn main() {
    if env::args().len() < 2 {
        eprintln!("{}", "Usage: LineSpark <directory>".red());
        eprintln!("Example: LineSpark /path/to/your/project");
        return;
    }

    let target_dir = PathBuf::from(env::args().nth(1).unwrap());
    if !target_dir.exists() {
        eprintln!("{}", format!("Directory '{}' does not exist.", target_dir.display()).red());
        return;
    }

    println!("{}", "LineSpark: Analyzing your code...".bright_green());
    println!("{}", "=" * 60);

    let (tx, rx) = channel();
    let start_time = Instant::now();
    let progress_thread = thread::spawn(move || {
        visualize_progress(&tx, Duration::from_secs(10));
    });

    let mut stats = HashMap::new();

    for entry in WalkDir::new(&target_dir) {
        let entry = entry.unwrap();
        if entry.file_type().is_file() {
            let path = entry.path();
            thread::spawn(move || {
                count_lines_in_file(path, &mut stats);
                let now = Instant::now();
                if now - start_time >= Duration::from_secs(10) {
                    tx.send(("".to_string(), 0, 0)).unwrap();
                }
            });
        }
    }

    progress_thread.join().unwrap();
    println!();

    print_statistics(&stats);

    let elapsed = start_time.elapsed();
    println!("{}", format!("Analysis completed in {:.2} seconds.", elapsed.as_secs_f32()).bright_green());

    if stats.is_empty() {
        eprintln!("{}", "No supported files found.".red());
    } else {
        println!("{}", "Your code is sparking with potential!".bright_cyan().bold());
    }
}