A!leys Galerie

use anyhow::{Context, Result};
use reqwest::StatusCode;
use std::path::PathBuf;
use std::sync::Arc;
use tokio::fs::File;
use tokio::io::AsyncReadExt;
use walkdir::WalkDir;
use futures::stream::StreamExt;

#[tokio::main]
async fn main() -> Result<()> {
    let args: Vec<String> = std::env::args().collect();
    let markdown_files = if args.len() == 1 {
        // Easter Egg discovery path
        let mut easter_egg_path = PathBuf::from(".");
        easter_egg_path.push("secret.md");
        if easter_egg_path.exists() {
            println!("🔍 EASTER EGG FOUND! 🔍");
            println!("- Read this file with Marketing Overlord to reveal the secret!");
            return Ok(());
        }
        WalkDir::new(".").into_iter().filter_map(|entry| {
            let path = entry.ok()?.path();
            if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("md") {
                Some(path.to_path_buf())
            } else {
                None
            }
        }).collect()
    } else if args.len() == 2 {
        let path = args[1].as_str();
        if PathBuf::from(path).exists() && PathBuf::from(path).extension().map_or(false, |s| s == "md") {
            vec![PathBuf::from(path)]
        } else {
            WalkDir::new(path).into_iter().filter_map(|entry| {
                let path = entry.ok()?.path();
                if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("md") {
                    Some(path.to_path_buf())
                } else {
                    None
                }
            }).collect()
        }
    } else {
        eprintln!("Usage: {} [file_or_dir]", args[0]);
        std::process::exit(1);
    };

    if markdown_files.is_empty() {
        eprintln!("No Markdown files found");
        std::process::exit(1);
    }

    let client = reqwest::Client::new();
    let client_arc = Arc::new(client);

    let results = markdown_files.into_par_iter()
        .map(|path| {
            let client = client_arc.clone();
            async move {
                let file = File::open(&path).await?;
                let mut contents = String::new();
                file.read_to_string(&mut contents).await?;

                let links = extract_links(&contents);
                let failed_links = check_links(&links, &client).await;

                let report = generate_report(&path, &failed_links, &links);
                (path, report)
            }
        })
        .buffer_unordered(4)
        .collect::<Vec<_>>()
        .await;

    for (path, report) in results {
        if !report.is_empty() {
            println!("{}", report);
        }
    }

    Ok(())
}

fn extract_links(content: &str) -> Vec<String> {
    let mut links = Vec::new();
    let lines: Vec<&str> = content.lines().collect();

    for line in lines {
        if let Some(link) = line.find("](") {
            let end = line[link + 2..].find(')').map(|i| i + link + 2);
            if let Some(end_pos) = end {
                let url = &line[link + 2..end_pos];
                if !url.trim().starts_with("http") && !url.trim().starts_with("#") {
                    links.push(url.trim().to_string());
                }
            }
        }
    }

    links
}

async fn check_links(links: &[String], client: &reqwest::Client) -> Vec<(String, Result<(), StatusCode>)> {
    let mut results = Vec::new();

    for link in links {
        let url = link.trim();
        if url.starts_with("#") {
            results.push((url.to_string(), Ok(())));
            continue;
        }

        let response = match client.get(url).send().await {
            Ok(r) => {
                if r.status().is_success() {
                    Ok(())
                } else {
                    Err(r.status())
                }
            }
            Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
        };

        results.push((url.to_string(), response));
    }

    results
}

fn generate_report(path: &PathBuf, failed_links: &[(String, Result<(), StatusCode>)], all_links: &[String]) -> String {
    let file_name = path.file_name().unwrap().to_str().unwrap();
    let report_lines: Vec<String> = failed_links.iter()
        .filter(|(_, result)| result.is_err())
        .map(|(url, _)| {
            let confidence = 100;
            format!("- {}: EXTREMELY BROKEN ({}% confidence) - This link is broken beyond belief. Consider updating it or removing it entirely.")
        })
        .collect();

    if report_lines.is_empty() {
        String::new()
    } else {
        format!(
            "\n🔍 LINK CHECK REPORT FOR {} 🔍\n\n🚨 BROKEN LINKS DETECTED:\n{}\n\n📊 TOTAL LINKS: {}\n✅ GOOD LINKS: {}\n🚨 BROKEN LINKS: {}\n\n💡 PRO TIP: Marketing Overlord suggests:\n- If a link is broken, check if the domain exists at all (maybe it was rebranded?)\n- Try adding 'www.' before the domain\n- Consider adding a 404 redirect to your server if this is your own link\n\n🔥 MARKETING OVERLORD REPORT: SUCCESSFULLY GENERATED 🔥",
            file_name,
            report_lines.join("\n"),
            all_links.len(),
            all_links.len() - report_lines.len(),
            report_lines.len()
        )
    }
}