use rand::Rng;

pub const RUST_MODULE_HEADER_LINES: usize = 10;
pub const RUST_FUNCTION_LINES: usize = 12;
pub const RUST_FUNCTION_BODY_LINES: usize = 11;
pub const RUST_MODULE_FOOTER_LINES: usize = 5;

pub fn rust_file_line_count(function_count: usize) -> usize {
    RUST_MODULE_HEADER_LINES + function_count * RUST_FUNCTION_LINES + RUST_MODULE_FOOTER_LINES
}

pub fn random_rust_file(rng: &mut impl Rng, line_count: usize) -> Vec<String> {
    if line_count < RUST_MODULE_HEADER_LINES + RUST_MODULE_FOOTER_LINES {
        return (0..line_count)
            .map(|line_index| format!("// generated benchmark line {line_index}"))
            .collect();
    }

    let mut lines = vec![
        "use anyhow::{Context as _, Result};".to_string(),
        "use collections::HashMap;".to_string(),
        "".to_string(),
        "#[derive(Clone, Debug)]".to_string(),
        "pub struct WorkspaceSnapshot {".to_string(),
        "    buffers: HashMap<String, usize>,".to_string(),
        "    version: usize,".to_string(),
        "}".to_string(),
        "".to_string(),
        "impl WorkspaceSnapshot {".to_string(),
    ];

    let body_line_count = line_count - RUST_MODULE_HEADER_LINES - RUST_MODULE_FOOTER_LINES;
    let function_count = body_line_count / RUST_FUNCTION_LINES;
    let filler_line_count = body_line_count % RUST_FUNCTION_LINES;

    for function_index in 0..function_count {
        let function_name = rust_identifier(rng, function_index);
        let argument_name = rust_identifier(rng, function_index + 1_000);
        let local_name = rust_identifier(rng, function_index + 2_000);
        let branch_name = rust_identifier(rng, function_index + 3_000);
        let multiplier = rng.random_range(2..17);
        let offset = rng.random_range(1..128);

        lines.extend([
            format!(
                "    pub fn {function_name}(&mut self, {argument_name}: usize) -> Result<usize> {{"
            ),
            format!("        let mut {local_name} = {argument_name}.saturating_mul({multiplier});"),
            format!("        if {local_name} % 2 == 0 {{"),
            format!(
                "            {local_name} = {local_name}.saturating_add(self.version + {offset});"
            ),
            "        } else {".to_string(),
            format!("            {local_name} = {local_name}.saturating_sub({offset});"),
            "        }".to_string(),
            format!("        let {branch_name} = self.buffers.len().saturating_add({local_name});"),
            format!("        self.version = self.version.saturating_add({branch_name});"),
            format!("        Ok({branch_name})"),
            "    }".to_string(),
            "".to_string(),
        ]);
    }

    for filler_index in 0..filler_line_count {
        let filler_name = rust_identifier(rng, function_count + 4_000 + filler_index);
        lines.push(format!("    // benchmark filler {filler_name}"));
    }

    lines.push("}".to_string());
    lines.push("".to_string());
    lines.push("pub fn normalize_path(path: &str) -> String {".to_string());
    lines.push("    path.replace('\\\\', \"/\")".to_string());
    lines.push("}".to_string());

    debug_assert_eq!(lines.len(), line_count);
    lines
}

pub fn rust_identifier(rng: &mut impl Rng, salt: usize) -> String {
    const PARTS: &[&str] = &[
        "alpha", "beta", "gamma", "delta", "epsilon", "zeta", "theta", "lambda", "sigma", "omega",
    ];
    format!(
        "{}_{}_{}",
        PARTS[rng.random_range(0..PARTS.len())],
        salt,
        rng.random_range(0..10_000)
    )
}