A!leys Galerie

```rust
// RustyBookcase — Ein minimalistischer HTTP-Server mit intelligentem Directory-Listing
// Mein Twist: Er analysiert die Verzeichnis-Struktur, um schnelle Navigation zu ermöglichen

use std::{
    fs::{self, File},
    io::{self, Read, Write},
    net::{TcpListener, TcpStream},
    path::{Path, PathBuf},
    sync::{Arc, Mutex},
    thread,
    time::Duration,
};
use std::collections::HashMap;
use std::str::FromStr;
use std::io::ErrorKind;
use mime_guess::from_path;

const DEFAULT_PORT: u16 = 8080;
const BUFFER_SIZE: usize = 8192;

// MIME-Typen und Datei-Endungen
lazy_static::lazy_static! {
    static ref MIME_TYPES: HashMap<&'static str, &'static str> = {
        let mut m = HashMap::new();
        m.insert("html", "text/html");
        m.insert("htm", "text/html");
        m.insert("txt", "text/plain");
        m.insert("js", "application/javascript");
        m.insert("css", "text/css");
        m.insert("png", "image/png");
        m.insert("jpg", "image/jpeg");
        m.insert("jpeg", "image/jpeg");
        m.insert("gif", "image/gif");
        m.insert("json", "application/json");
        m.insert("mp3", "audio/mpeg");
        m.insert("wav", "audio/wav");
        m.insert("mp4", "video/mp4");
        m.insert("pdf", "application/pdf");
        m.insert("md", "text/markdown");
        m.insert("xml", "application/xml");
        m.insert("zip", "application/zip");
        m.insert("exe", "application/x-msdownload");
        m.insert("bin", "application/octet-stream");
        m.insert("", "application/octet-stream"); // Standard für unbekannte Typen
        m
    };
}

// Struktur für die Verzeichnis-Analyse
#[derive(Debug, Clone)]
struct DirectoryInfo {
    path: PathBuf,
    files: Vec<PathBuf>,
    dirs: Vec<PathBuf>,
    has_index: bool, // Gibt es eine index.html?
    file_count: usize,
    dir_count: usize,
    modified: std::time::SystemTime,
}

// HTTP-Request-Struktur
#[derive(Debug)]
struct HttpRequest {
    method: String,
    path: String,
    headers: HashMap<String, String>,
}

impl HttpRequest {
    fn parse(stream: &mut TcpStream) -> io::Result<Self> {
        let mut buffer = [0; 1024];
        let bytes_read = stream.read(&mut buffer)?;
        let request_str = String::from_utf8_lossy(&buffer[..bytes_read]);

        let mut lines = request_str.lines().take_while(|line| !line.trim().is_empty());
        let first_line = lines.next().ok_or(io::Error::new(
            ErrorKind::InvalidData,
            "No request line found",
        ))?;
        let mut parts = first_line.split_whitespace();

        let method = parts.next().ok_or(io::Error::new(
            ErrorKind::InvalidData,
            "No method found",
        ))?.to_string();
        let path = parts.next().ok_or(io::Error::new(
            ErrorKind::InvalidData,
            "No path found",
        ))?.to_string();

        let mut headers = HashMap::new();
        for line in lines {
            if line.trim().is_empty() {
                break;
            }
            let colon_pos = line.find(':').ok_or(io::Error::new(
                ErrorKind::InvalidData,
                format!("Invalid header line: {}", line),
            ))?;
            let key = line[..colon_pos].trim().to_lowercase();
            let value = line[colon_pos + 1..].trim().to_string();
            headers.insert(key, value);
        }

        Ok(HttpRequest { method, path, headers })
    }
}

// HTTP-Response-Struktur
#[derive(Debug)]
struct HttpResponse {
    status: u16,
    headers: HashMap<String, String>,
    body: Vec<u8>,
}

impl HttpResponse {
    fn new(status: u16) -> Self {
        HttpResponse {
            status,
            headers: HashMap::new(),
            body: Vec::new(),
        }
    }

    fn set_header(&mut self, key: &str, value: &str) {
        self.headers.insert(key.to_string(), value.to_string());
    }

    fn set_body(&mut self, body: Vec<u8>) {
        self.body = body;
    }

    fn to_bytes(&self) -> Vec<u8> {
        let status_line = format!("HTTP/1.1 {} {}", self.status, get_status_text(self.status));
        let header_lines: Vec<String> = self.headers.iter().map(|(k, v)| format!("{}: {}", k, v)).collect();
        let headers_str = header_lines.join("\r\n");
        let response = format!("{}\r\n{}\r\n\r\n{}", status_line, headers_str, String::from_utf8_lossy(&self.body));
        response.into_bytes()
    }
}

fn get_status_text(status: u16) -> &'static str {
    match status {
        200 => "OK",
        301 => "Moved Permanently",
        400 => "Bad Request",
        404 => "Not Found",
        405 => "Method Not Allowed",
        500 => "Internal Server Error",
        _ => "Unknown Status",
    }
}

// Analysiert ein Verzeichnis und erstellt eine Struktur mit Dateien und Unterverzeichnissen
fn analyze_directory(path: &Path) -> io::Result<DirectoryInfo> {
    if !path.exists() || !path.is_dir() {
        return Err(io::Error::new(
            ErrorKind::NotFound,
            format!("Path {} does not exist or is not a directory", path.display()),
        ));
    }

    let entries = fs::read_dir(path)?;
    let mut files = Vec::new();
    let mut dirs = Vec::new();
    let mut has_index = false;

    for entry in entries {
        let entry = entry?;
        let path = entry.path();
        let metadata = entry.metadata()?;

        if path.ends_with("index.html") {
            has_index = true;
        }

        if path.is_dir() {
            dirs.push(path);
        } else if path.is_file() {
            files.push(path);
        }
    }

    // Sort files and directories
    files.sort();
    dirs.sort();

    let modified = fs::metadata(path)?.modified()?;
    Ok(DirectoryInfo {
        path: path.to_path_buf(),
        files,
        dirs,
        has_index,
        file_count: files.len(),
        dir_count: dirs.len(),
        modified,
    })
}

// Erstellt eine HTML-Directory-Listing-Seite
fn generate_directory_listing(dir_info: &DirectoryInfo, base_path: &Path) -> io::Result<Vec<u8>> {
    let base_path_str = base_path.display().to_string();
    let dir_path_str = dir_info.path.display().to_string();

    let template = format!(
        r#"<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>RustyBookcase: {}</title>
    <style>
        body {{
            font-family: 'Courier New', monospace;
            background-color: #1a1a1a;
            color: #e0e0e0;
            margin: 0;
            padding: 20px;
        }}
        .container {{
            max-width: 1200px;
            margin: 0 auto;
        }}
        h1 {{
            color: #61dafb;
            margin-bottom: 20px;
        }}
        .nav {{
            background-color: #2a2a2a;
            padding: 10px;
            margin-bottom: 20px;
            border-radius: 5px;
        }}
        .nav a {{
            color: #61dafb;
            text-decoration: none;
            margin-right: 15px;
        }}
        .nav a:hover {{
            text-decoration: underline;
        }}
        .file-table {{
            width: 100%;
            border-collapse: collapse;
        }}
        .file-table th, .file-table td {{
            padding: 8px;
            text-align: left;
            border-bottom: 1px solid #3a3a3a;
        }}
        .file-table th {{
            background-color: #2a2a2a;
            color: #61dafb;
        }}
        .file-table tr:hover {{
            background-color: #2a2a2a;
        }}
        .directory {{
            color: #61dafb;
            font-weight: bold;
        }}
        .file {{
            color: #a0a0a0;
        }}
        .size {{
            color: #808080;
        }}
        .modified {{
            color: #60a060;
            font-size: 0.9em;
        }}
        .error {{
            color: #ff5555;
            font-weight: bold;
        }}
    </style>
</head>
<body>
    <div class="container">
        <div class="nav">
            <a href="/">[Home]</a>
            {nav_links}
        </div>
        <h1>Directory Listing: {}</h1>
        {listing}
    </div>
</body>
</html>
        ",

        dir_path_str,
        dir_path_str
    );

    // Generate navigation links
    let mut nav_links = String::new();
    if dir_info.path.parent().and_then(|p| p.to_str()) != Some(base_path_str) {
        nav_links.push_str("<a href=\"..\">[Parent Directory]</a>");
    }

    if dir_info.dir_count > 0 {
        let subdirs: Vec<String> = dir_info.dirs.iter()
            .map(|d| {
                let d_str = d.display().to_string();
                if d_str == ".." {
                    return String::new();
                }
                let path_rel = d.strip_prefix(base_path).unwrap().to_str().unwrap().to_string();
                if path_rel == "." {
                    return String::new();
                }
                format!("<a href=\"{}\" class=\"directory\">{}</a>", path_rel, d.file_name().unwrap().to_str().unwrap())
            })
            .filter(|s| !s.is_empty())
            .collect();

        if !subdirs.is_empty() {
            nav_links.push_str("<br>Subdirectories: ");
            nav_links.push_str(&subdirs.join(" "));
        }
    }

    // Generate file listing
    let mut rows = Vec::new();

    if dir_info.files.is_empty() && dir_info.dir_count == 0 {
        rows.push("<tr><td colspan=\"4\" class=\"error\">No files or directories found</td></tr>".to_string());
    } else {
        // Sort files alphabetically (case-insensitive)
        let mut sorted_files: Vec<_> = dir_info.files.iter()
            .map(|f| {
                let f_str = f.display().to_string();
                let f_name = f.file_name().unwrap().to_str().unwrap();
                (f_str.to_lowercase(), f)
            })
            .collect();

        sorted_files.sort_by_key(|(s, _)| *s);

        for file in sorted_files.into_iter().map(|(_, f)| f) {
            let file_name = file.file_name().unwrap().to_str().unwrap();
            let file_size = fs::metadata(file)?.len();
            let modified = fs::metadata(file)?.modified()?;

            let relative_path = file.strip_prefix(base_path).unwrap();
            let path_rel = relative_path.to_str().unwrap().to_string();

            let mime_type = from_path(file_name).first_or_octet_stream().as_ref();
            let is_directory = false;

            let type_icon = if is_directory {
                "[DIR]"
            } else {
                match mime_type {
                    "text/html" | "text/plain" | "text/markdown" | "application/json" | "application/xml" => "[TXT]",
                    "application/javascript" | "text/css" => "[JS/CSS]",
                    "image/png" | "image/jpeg" | "image/gif" => "[IMG]",
                    "audio/mpeg" | "audio/wav" => "[AUDIO]",
                    "video/mp4" => "[VIDEO]",
                    "application/pdf" => "[PDF]",
                    "application/zip" => "[ZIP]",
                    _ => "[BIN]",
                }
            };

            let size_str = if file_size < 1024 {
                format!("{} B", file_size)
            } else if file_size < 1024 * 1024 {
                format!("{:.1} KB", file_size as f32 / 1024.0)
            } else {
                format!("{:.1} MB", file_size as f32 / (1024.0 * 1024.0))
            };

            let modified_str = modified.format("%Y-%m-%d %H:%M").unwrap();

            let row = format!(
                r#"<tr>
                    <td class="file">{}</td>
                    <td class="size">{}</td>
                    <td class="modified">{}</td>
                    <td><a href="{}">{}</a></td>
                </tr>"#,
                type_icon, size_str, modified_str, path_rel, file_name
            );
            rows.push(row);
        }
    }

    let listing = if rows.is_empty() {
        String::new()
    } else {
        let table = rows.join("\n");
        format!(
            r#"<table class="file-table">
                <thead>
                    <tr>
                        <th>Type</th>
                        <th>Size</th>
                        <th>Modified</th>
                        <th>Name</th>
                    </tr>
                </thead>
                <tbody>
                    {}
                </tbody>
            </table>"#,
            table
        )
    };

    Ok(template.replace("{nav_links}", &nav_links).replace("{listing}", &listing).into_bytes())
}

// Verarbeitet eine HTTP-Anfrage
fn handle_request(dir_info: Arc<Mutex<DirectoryInfo>>, req: HttpRequest) -> io::Result<HttpResponse> {
    let path = Path::new(&req.path[1..]); // Remove leading '/'
    let base_path = dir_info.lock().unwrap().path.clone();

    // Normalize path to prevent directory traversal
    let mut path = path.to_path_buf();
    path = path.strip_prefix("..").unwrap_or(&path);

    // Handle directory listing
    if path == Path::new("") || path == Path::new(".") {
        let listing = generate_directory_listing(&dir_info.lock().unwrap(), &base_path)?;
        let mut response = HttpResponse::new(200);
        response.set_header("Content-Type", "text/html; charset=utf-8");
        response.set_header("Content-Length", &listing.len().to_string());
        response.set_body(listing);
        return Ok(response);
    }

    // Check if path is a directory
    if path.is_dir() {
        let dir_path = base_path.join(&path);
        if !dir_path.exists() {
            return Ok(HttpResponse::new(404));
        }

        // Re-analyze directory if modified
        if let Ok(metadata) = fs::metadata(&dir_path) {
            if metadata.modified()? > dir_info.lock().unwrap().modified {
                let new_dir_info = analyze_directory(&dir_path)?;
                *dir_info.lock().unwrap() = new_dir_info;
            }
        }

        // Generate directory listing
        let listing = generate_directory_listing(&dir_info.lock().unwrap(), &base_path)?;
        let mut response = HttpResponse::new(200);
        response.set_header("Content-Type", "text/html; charset=utf-8");
        response.set_header("Content-Length", &listing.len().to_string());
        response.set_body(listing);
        return Ok(response);
    }

    // Handle file requests
    let file_path = base_path.join(&path);
    if !file_path.exists() || !file_path.is_file() {
        return Ok(HttpResponse::new(404));
    }

    // Read file
    let mut file = File::open(&file_path)?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)?;

    // Determine content type
    if let Some(ext) = file_path.extension().and_then(|e| e.to_str()) {
        if let Some(content_type) = MIME_TYPES.get(ext.to_lowercase().as_str()) {
            let mut response = HttpResponse::new(200);
            response.set_header("Content-Type", content_type);
            response.set_header("Content-Length", &buffer.len().to_string());
            response.set_body(buffer);
            return Ok(response);
        }
    }

    // Fallback to mime_guess for more robust MIME detection
    let content_type = from_path(&file_path).first_or_octet_stream().as_ref();
    let mut response = HttpResponse::new(200);
    response.set_header("Content-Type", content_type);
    response.set_header("Content-Length", &buffer.len().to_string());
    response.set_body(buffer);
    Ok(response)
}

// Startet den HTTP-Server
fn run_server(root_path: PathBuf, port: u16)

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);
}