//! `{{variable}}` substitution for paths, params, headers and bodies.
//!
//! Two kinds of variable resolve here:
//!
//! - **Collection variables** — looked up by (trimmed) name in the Variables tab.
//! - **Dynamic variables** — computed at send time: `{{uuid}}`, `{{timestamp}}`,
//!   `{{randomInt(1,100)}}` … see [`DYNAMIC_VARS`].
//!
//! A collection variable shadows a dynamic one of the same name, so `uuid` can
//! be pinned to a fixed value for a debugging session. Prefixing with `$`
//! (`{{$uuid}}`, Postman's spelling) always takes the dynamic one.
//!
//! Unknown variables are left untouched so the user can see what failed to
//! resolve.

use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

use uuid::Uuid;

/// Dynamic variable names and their help text, in the order the help popup
/// lists them. Names are matched case-insensitively, ignoring `_`, so
/// `isoTimestamp`, `iso_timestamp` and `ISOTIMESTAMP` are the same variable.
pub const DYNAMIC_VARS: [(&str, &str); 8] = [
    ("uuid", "UUID v4, fresh per occurrence"),
    ("timestamp", "Unix time in seconds"),
    ("timestampMs", "Unix time in milliseconds"),
    ("isoTimestamp", "RFC 3339 UTC, e.g. 2026-08-06T12:34:56Z"),
    ("randomInt", "0–1000, or randomInt(min,max) inclusive"),
    ("randomHex", "16 hex chars, or randomHex(n)"),
    ("randomString", "16 alphanumerics, or randomString(n)"),
    ("randomBool", "true or false"),
];

pub fn substitute(input: &str, vars: &HashMap<String, String>) -> String {
    let mut out = String::with_capacity(input.len());
    let mut rest = input;
    while let Some(start) = rest.find("{{") {
        out.push_str(&rest[..start]);
        let after = &rest[start + 2..];
        match after.find("}}") {
            Some(end) => {
                let key = after[..end].trim();
                match resolve(key, vars) {
                    Some(v) => out.push_str(&v),
                    // Unknown variable: keep the placeholder as-is.
                    None => out.push_str(&rest[..start + 2 + end + 2]),
                }
                rest = &after[end + 2..];
            }
            None => {
                out.push_str(&rest[start..]);
                rest = "";
            }
        }
    }
    out.push_str(rest);
    out
}

/// A `$` prefix forces the dynamic variable; otherwise the collection wins.
fn resolve(key: &str, vars: &HashMap<String, String>) -> Option<String> {
    match key.strip_prefix('$') {
        Some(name) => dynamic(name.trim()),
        None => vars.get(key).cloned().or_else(|| dynamic(key)),
    }
}

/// Evaluate a dynamic variable, with optional `name(arg,arg)` arguments.
/// Returns `None` for an unknown name or unusable arguments — the caller then
/// leaves the placeholder visible rather than silently emitting junk.
fn dynamic(spec: &str) -> Option<String> {
    let (name, args) = split_call(spec)?;
    let name = normalize(&name);
    Some(match (name.as_str(), args.as_slice()) {
        ("uuid", []) => Uuid::new_v4().to_string(),
        ("timestamp", []) => unix_secs().to_string(),
        ("timestampms", []) => unix_millis().to_string(),
        ("isotimestamp", []) => iso_timestamp(unix_secs()),
        ("randomint", []) => random_int(0, 1000).to_string(),
        ("randomint", [min, max]) => {
            let (min, max) = (min.parse::<i64>().ok()?, max.parse::<i64>().ok()?);
            if min > max {
                return None;
            }
            random_int(min, max).to_string()
        }
        ("randomhex", []) => random_hex(16),
        ("randomhex", [n]) => random_hex(parse_len(n)?),
        ("randomstring", []) => random_string(16),
        ("randomstring", [n]) => random_string(parse_len(n)?),
        ("randombool", []) => (random_int(0, 1) == 1).to_string(),
        _ => return None,
    })
}

/// `name` or `name(a, b)` → `("name", ["a", "b"])`. Empty args are rejected so
/// `randomHex()` doesn't quietly mean `randomHex`.
fn split_call(spec: &str) -> Option<(String, Vec<String>)> {
    let Some(open) = spec.find('(') else {
        return Some((spec.to_string(), Vec::new()));
    };
    let inner = spec.strip_suffix(')')?.get(open + 1..)?;
    let args: Vec<String> = inner.split(',').map(|a| a.trim().to_string()).collect();
    if args.iter().any(|a| a.is_empty()) {
        return None;
    }
    Some((spec[..open].trim().to_string(), args))
}

fn normalize(name: &str) -> String {
    name.chars()
        .filter(|c| *c != '_')
        .flat_map(char::to_lowercase)
        .collect()
}

/// Length arguments are capped: a stray `randomString(999999999)` shouldn't
/// build a gigabyte of request body.
fn parse_len(s: &str) -> Option<usize> {
    let n = s.parse::<usize>().ok()?;
    (1..=4096).contains(&n).then_some(n)
}

// ----- clock -----

fn unix_millis() -> u128 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|d| d.as_millis())
        .unwrap_or(0)
}

fn unix_secs() -> i64 {
    (unix_millis() / 1000) as i64
}

/// RFC 3339 in UTC. Hand-rolled rather than pulling in a date crate: the only
/// calendar work cielago does is stamping a request.
fn iso_timestamp(secs: i64) -> String {
    let days = secs.div_euclid(86_400);
    let time = secs.rem_euclid(86_400);
    let (y, m, d) = civil_from_days(days);
    let (h, min, s) = (time / 3600, (time % 3600) / 60, time % 60);
    format!("{y:04}-{m:02}-{d:02}T{h:02}:{min:02}:{s:02}Z")
}

/// Days since 1970-01-01 → (year, month, day). Hinnant's civil-from-days.
fn civil_from_days(z: i64) -> (i64, u32, u32) {
    let z = z + 719_468;
    let era = z.div_euclid(146_097);
    let doe = z.rem_euclid(146_097); // [0, 146096]
    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146_096) / 365; // [0, 399]
    let y = yoe + era * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
    let mp = (5 * doy + 2) / 153; // [0, 11], March-based
    let d = (doy - (153 * mp + 2) / 5 + 1) as u32; // [1, 31]
    let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32; // [1, 12]
    (if m <= 2 { y + 1 } else { y }, m, d)
}

// ----- randomness -----

/// Random bytes borrowed from UUID v4 generation, so no extra RNG dependency.
/// Bytes 6 and 8 carry the version/variant bits and are dropped.
fn random_bytes(n: usize) -> Vec<u8> {
    let mut out = Vec::with_capacity(n + 14);
    while out.len() < n {
        let id = *Uuid::new_v4().as_bytes();
        out.extend(
            id.iter()
                .enumerate()
                .filter(|(i, _)| *i != 6 && *i != 8)
                .map(|(_, b)| *b),
        );
    }
    out.truncate(n);
    out
}

fn random_u64() -> u64 {
    let b = random_bytes(8);
    u64::from_le_bytes(b.try_into().expect("8 bytes requested"))
}

/// Uniform-ish over `[min, max]`; the modulo bias is irrelevant for test data.
/// Widened to i128 so a full-range `randomInt(i64::MIN, i64::MAX)` can't wrap.
fn random_int(min: i64, max: i64) -> i64 {
    let span = (max as i128 - min as i128 + 1) as u128;
    (min as i128 + (random_u64() as u128 % span) as i128) as i64
}

fn random_hex(n: usize) -> String {
    random_bytes(n.div_ceil(2))
        .iter()
        .map(|b| format!("{b:02x}"))
        .collect::<String>()
        .chars()
        .take(n)
        .collect()
}

fn random_string(n: usize) -> String {
    const ALPHABET: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    random_bytes(n)
        .iter()
        .map(|b| ALPHABET[*b as usize % ALPHABET.len()] as char)
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    fn vars() -> HashMap<String, String> {
        HashMap::from([
            ("tenant".to_string(), "acme".to_string()),
            ("version".to_string(), "v2".to_string()),
        ])
    }

    #[test]
    fn substitutes_named_vars() {
        assert_eq!(
            substitute("/{{tenant}}/{{ version }}/x", &vars()),
            "/acme/v2/x"
        );
    }

    #[test]
    fn uuid_is_fresh_per_occurrence() {
        let out = substitute("{{uuid}}-{{uuid}}", &vars());
        assert_eq!(out.len(), 36 + 1 + 36);
        let (first, rest) = out.split_at(36);
        let second = &rest[1..];
        assert_eq!(&rest[..1], "-");
        assert!(uuid::Uuid::parse_str(first).is_ok());
        assert!(uuid::Uuid::parse_str(second).is_ok());
        assert_ne!(first, second);
    }

    #[test]
    fn unknown_vars_left_intact() {
        assert_eq!(substitute("{{nope}}", &vars()), "{{nope}}");
        assert_eq!(substitute("{{$nope}}", &vars()), "{{$nope}}");
    }

    #[test]
    fn unclosed_brace_left_intact() {
        assert_eq!(substitute("a {{oops", &vars()), "a {{oops");
    }

    #[test]
    fn collection_var_shadows_dynamic_unless_dollar_prefixed() {
        let vars = HashMap::from([("uuid".to_string(), "pinned".to_string())]);
        assert_eq!(substitute("{{uuid}}", &vars), "pinned");
        assert_eq!(substitute("{{$uuid}}", &vars).len(), 36);
    }

    #[test]
    fn timestamps_are_plausible() {
        let secs: i64 = substitute("{{timestamp}}", &vars()).parse().unwrap();
        // Somewhere after 2020 and before 2100.
        assert!((1_577_836_800..4_102_444_800).contains(&secs));
        let ms: i64 = substitute("{{timestampMs}}", &vars()).parse().unwrap();
        assert_eq!(ms / 1000, secs);

        let iso = substitute("{{isoTimestamp}}", &vars());
        assert_eq!(iso.len(), 20, "{iso}");
        assert!(iso.ends_with('Z'));
        assert_eq!(&iso[4..5], "-");
        assert_eq!(&iso[10..11], "T");
    }

    #[test]
    fn iso_timestamp_matches_known_instants() {
        assert_eq!(iso_timestamp(0), "1970-01-01T00:00:00Z");
        assert_eq!(iso_timestamp(1_000_000_000), "2001-09-09T01:46:40Z");
        // Leap day.
        assert_eq!(iso_timestamp(1_709_164_800), "2024-02-29T00:00:00Z");
        assert_eq!(iso_timestamp(1_754_484_896), "2025-08-06T12:54:56Z");
    }

    #[test]
    fn name_matching_ignores_case_and_underscores() {
        for name in ["isoTimestamp", "iso_timestamp", "ISO_TIMESTAMP"] {
            assert!(
                substitute(&format!("{{{{{name}}}}}"), &vars()).ends_with('Z'),
                "{name}"
            );
        }
    }

    #[test]
    fn random_int_respects_bounds() {
        for _ in 0..200 {
            let n: i64 = substitute("{{randomInt(5, 7)}}", &vars()).parse().unwrap();
            assert!((5..=7).contains(&n), "{n}");
        }
        assert_eq!(substitute("{{randomInt(-1,-1)}}", &vars()), "-1");
        let d: i64 = substitute("{{randomInt}}", &vars()).parse().unwrap();
        assert!((0..=1000).contains(&d));
    }

    #[test]
    fn random_strings_have_requested_length() {
        assert_eq!(substitute("{{randomHex}}", &vars()).len(), 16);
        assert_eq!(substitute("{{randomHex(7)}}", &vars()).len(), 7);
        assert_eq!(substitute("{{randomString}}", &vars()).len(), 16);
        assert_eq!(substitute("{{randomString(40)}}", &vars()).len(), 40);
        assert!(
            substitute("{{randomHex(9)}}", &vars())
                .chars()
                .all(|c| c.is_ascii_hexdigit())
        );
        assert!(
            substitute("{{randomString(64)}}", &vars())
                .chars()
                .all(|c| c.is_ascii_alphanumeric())
        );
    }

    #[test]
    fn random_bool_is_a_bool_and_varies() {
        let mut seen = std::collections::HashSet::new();
        for _ in 0..100 {
            let v = substitute("{{randomBool}}", &vars());
            assert!(v == "true" || v == "false", "{v}");
            seen.insert(v);
        }
        assert_eq!(seen.len(), 2, "randomBool never flipped");
    }

    #[test]
    fn bad_arguments_leave_the_placeholder() {
        for bad in [
            "{{randomInt(9,1)}}",
            "{{randomInt(a,b)}}",
            "{{randomInt(1)}}",
            "{{randomHex(0)}}",
            "{{randomHex(99999)}}",
            "{{randomString()}}",
            "{{uuid(2)}}",
        ] {
            assert_eq!(substitute(bad, &vars()), bad);
        }
    }

    #[test]
    fn every_documented_dynamic_var_resolves() {
        for (name, _) in DYNAMIC_VARS {
            let out = substitute(&format!("{{{{${name}}}}}"), &vars());
            assert!(!out.contains("{{"), "{name} did not resolve: {out}");
        }
    }
}