A!leys Galerie

use std::{
    env, fs,
    path::{Path, PathBuf},
    process,
};
use colored::Colorize;
use walkdir::WalkDir;
use regex::Regex;

/// Supported file extensions with their respective languages
const SUPPORTED_EXTENSIONS: &[(&str, &str)] = &[
    (".rs", "Rust"),
    (".py", "Python"),
    (".js", ".jsx", "JavaScript"),
    (".ts", ".tsx", "TypeScript"),
    (".java", "Java"),
    (".go", "Go"),
    (".cpp", ".cc", ".cxx", ".h", ".hpp", ".hxx", "C++"),
    (".c", "C"),
    (".h", "C Header"),
    (".swift", "Swift"),
    (".kt", ".kts", "Kotlin"),
    (".scala", "Scala"),
    (".rb", "Ruby"),
    (".php", "PHP"),
    (".cs", "C#"),
    (".html", ".htm", ".xhtml", "HTML"),
    (".css", "CSS"),
    (".sql", "SQL"),
    (".md", "Markdown"),
    (".toml", "TOML"),
    (".yml", ".yaml", "YAML"),
    (".json", "JSON"),
    (".sh", ".bash", "Shell"),
    (".xml", "XML"),
    (".lua", "Lua"),
    (".rust", "Rust"), // For completeness, though .rs is standard
];

/// Count lines in a file, excluding comments and whitespace-only lines
fn count_lines_in_file(file_path: &Path) -> (usize, usize, usize) {
    let content = match fs::read_to_string(file_path) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("{}: {}", "Error reading file".red(), e);
            return (0, 0, 0);
        }
    };

    let mut code_lines = 0;
    let mut comment_lines = 0;
    let mut blank_lines = 0;

    // Language-specific comment and block comment patterns
    let language = match file_path.extension().and_then(|s| s.to_str()) {
        Some(ext) => match ext.to_lowercase().as_str() {
            "rs" => ("Rust", vec!["//", "/*", "*/"], true),
            "py" => ("Python", vec!["#"], true),
            "js" | "jsx" | "ts" | "tsx" => ("JavaScript/TypeScript", vec!["//", "/*", "*/"], true),
            "java" => ("Java", vec!["//", "/*", "*/"], true),
            "go" => ("Go", vec!["//", "//"], true),
            "cpp" | "cc" | "cxx" | "h" | "hpp" | "hxx" => ("C++", vec!["//", "//", "/*", "*/"], true),
            "c" => ("C", vec!["//", "//", "/*", "*/"], true),
            "swift" => ("Swift", vec!["//", "/*", "*/"], true),
            "kt" | "kts" => ("Kotlin", vec!["//", "/*", "*/"], true),
            "scala" => ("Scala", vec!["//", "/*", "*/"], true),
            "rb" => ("Ruby", vec!["#"], true),
            "php" => ("PHP", vec!["//", "#", "/*", "*/"], true),
            "cs" => ("C#", vec!["//", "/*", "*/"], true),
            "html" | "htm" | "xhtml" => ("HTML", vec!["<!--", "-->"], false),
            "css" => ("CSS", vec!["/*", "*/"], false),
            "sql" => ("SQL", vec![], false),
            "md" => ("Markdown", vec!["#"], false),
            "toml" => ("TOML", vec!["#"], false),
            "yml" | "yaml" => ("YAML", vec!["#", "-"], false),
            "json" => ("JSON", vec![], false),
            "sh" | "bash" => ("Shell", vec!["#"], false),
            "xml" => ("XML", vec!["<!--", "-->"], false),
            "lua" => ("Lua", vec!["--", "--[[", "]]"], true),
            _ => ("Unknown", vec![], false),
        },
        None => ("Unknown", vec![], false),
    };

    let comment_matches: Vec<_> = language.1.iter().map(|re| Regex::new(re)).collect();
    let is_block_comment_language = language.2;

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

        // Check for comments
        let mut is_comment = false;
        if is_block_comment_language {
            for (i, re) in comment_matches.iter().enumerate() {
                if re.is_match(line) {
                    if i < 2 && !line.contains("//") {
                        // Handle /* */ style comments
                        is_comment = true;
                        break;
                    } else {
                        // Single-line comments
                        is_comment = true;
                        break;
                    }
                }
            }
        } else {
            for re in comment_matches.iter() {
                if re.is_match(line) {
                    is_comment = true;
                    break;
                }
            }
        }

        if is_comment {
            comment_lines += 1;
        } else {
            code_lines += 1;
        }
    }

    (code_lines, comment_lines, blank_lines)
}

/// Recursively walk through directories and count lines
fn count_lines_in_directory(root: &Path) -> (usize, usize, usize, usize, usize, usize) {
    let mut total_code = 0;
    let mut total_comments = 0;
    let mut total_blanks = 0;
    let mut file_count = 0;
    let mut language_counts: std::collections::HashMap<String, usize> = std::collections::HashMap::new();

    for entry in WalkDir::new(root) {
        let entry = match entry {
            Ok(e) => e,
            Err(e) => {
                eprintln!("{}: {}", "Error accessing directory".red(), e);
                continue;
            }
        };

        if entry.file_type().is_file() {
            let path = entry.path();
            if let Some(ext) = path.extension().and_then(|s| s.to_str()) {
                let ext_lower = ext.to_lowercase();
                for (exts, lang) in SUPPORTED_EXTENSIONS {
                    for e in exts.split_terminator(',') {
                        if ext_lower == e.trim() {
                            file_count += 1;
                            let (code, comments, blanks) = count_lines_in_file(path);
                            total_code += code;
                            total_comments += comments;
                            total_blanks += blanks;
                            *language_counts.entry(lang.to_string()).or_insert(0) += code;
                            break;
                        }
                    }
                }
            }
        }
    }

    (total_code, total_comments, total_blanks, file_count, language_counts)
}

/// Display the results in a visually appealing format
fn display_results(
    total_code: usize,
    total_comments: usize,
    total_blanks: usize,
    file_count: usize,
    language_counts: std::collections::HashMap<String, usize>,
) {
    let total_lines = total_code + total_comments + total_blanks;
    let comment_percentage = if total_lines > 0 {
        ((total_comments as f64 / total_lines as f64) * 100.0).round()
    } else {
        0.0
    };
    let blank_percentage = if total_lines > 0 {
        ((total_blanks as f64 / total_lines as f64) * 100.0).round()
    } else {
        0.0
    };
    let code_percentage = if total_lines > 0 {
        100.0 - comment_percentage - blank_percentage
    } else {
        0.0
    };

    println!();
    println!("{}", "RUSTY CODE COUNTER".green().bold());
    println!("{}", "=".repeat(30).green());
    println!();
    println!("{} {}", "Total files:".cyan(), file_count);
    println!("{} {}", "Total code lines:".cyan(), total_code.to_string().green());
    println!("{} {} ({}%)".cyan(), "Total comments:".cyan(), total_comments.to_string().yellow(), comment_percentage);
    println!("{} {} ({}%)".cyan(), "Total blank lines:".cyan(), total_blanks.to_string().blue(), blank_percentage);
    println!("{} {} ({}%)".cyan(), "Actual code:".cyan(), total_code.to_string().green(), code_percentage.round());
    println!();
    println!("{}", "LANGUAGE BREAKDOWN:".cyan().bold());
    println!("{}", "-".repeat(20).cyan());
    for (lang, lines) in language_counts {
        let percentage = if total_code > 0 {
            ((lines as f64 / total_code as f64) * 100.0).round()
        } else {
            0.0
        };
        println!("{} {:>5} ({}%)", lang.cyan(), lines.to_string().green(), percentage);
    }
    println!();
    println!("{}", "CODE QUALITY METRICS:".cyan().bold());
    println!("{}", "-".repeat(20).cyan());
    println!("{}", format!("Comment-to-Code Ratio: {:.2}%", comment_percentage).cyan());
    println!("{}", format!("Blank-to-Code Ratio: {:.2}%", blank_percentage).cyan());
    println!("{}", format!("Code Density: {:.2}%", code_percentage.round()).cyan());
    println!();
    println!("{}", "Generated by RustyCodeCounter 🦀".cyan().italic());
}

/// Main function
fn main() {
    let args: Vec<String> = env::args().collect();
    let root = if args.len() > 1 {
        PathBuf::from(&args[1])
    } else {
        env::current_dir().unwrap_or_else(|_| {
            eprintln!("{}", "Could not determine current directory".red());
            process::exit(1);
        })
    };

    if !root.exists() {
        eprintln!("{}: {}", "Path does not exist".red(), root.display());
        process::exit(1);
    }

    let (total_code, total_comments, total_blanks, file_count, language_counts) = count_lines_in_directory(&root);
    display_results(total_code, total_comments, total_blanks, file_count, language_counts);
}