// src/agent/runtime/hardline.rs
//
// Hardline 命令阻止层 — 不可绕过的危险命令检查。
// 参考 Hermes-Agent approval.py HARDLINE_PATTERNS 设计。
//
// 设计原则：
//   1. Hardline 规则在任何模式下都不可被绕过（包括 YOLO/Bypass 模式）
//   2. 优先级高于所有其他权限规则
//   3. 在命令执行前做反规避标准化后再匹配
//
// 阻止的命令类别：
//   - 系统关机/重启
//   - 磁盘擦除/格式化
//   - Fork 炸弹
//   - 递归删除根目录
//   - kill -1（信号广播）

use regex::RegexSet;
use std::sync::LazyLock;

// ── 反规避命令标准化 ──

/// 在安全检查前对命令字符串做标准化处理。
/// 参考 Hermes `_normalize_command_for_detection()` 实现。
///
/// 转换顺序：
///   1. 剥离 ANSI 转义序列（ECMA-48）
///   2. 剥离 null 字节
///   3. Unicode 全角字符 NFKC 标准化
///   4. 剥离 shell 反斜杠转义（`r\m` → `rm`）
///   5. 剥离空字符串字面量（`r''m` → `rm`）
///   6. 解析后的绝对路径还原为 `~/` 形式
pub fn normalize_command(raw: &str) -> String {
    // Step 1: 剥离 ANSI 转义序列
    let s = strip_ansi_escapes(raw);

    // Step 2: 剥离 null 字节
    let s = s.replace('\0', "");

    // Step 3: Unicode NFKC 标准化（全角 → 半角）
    let s = unicode_normalization::lookup(&s).unwrap_or_else(|| s.to_string());

    // Step 4: 剥离 shell 反斜杠转义（`r\m` → `rm`）
    let s = strip_backslash_escapes(&s);

    // Step 5: 剥离空字符串字面量（`r''m` → `rm`, `r""m` → `rm`）
    let s = strip_empty_string_literals(&s);

    // Step 6: 还原 Home 路径

    normalize_home_paths(&s)
}

/// 剥离 ANSI 转义序列（CSI 序列，ECMA-48 §5.4）
fn strip_ansi_escapes(s: &str) -> String {
    static ANSI_RE: LazyLock<regex::Regex> =
        LazyLock::new(|| regex::Regex::new(r"\x1b\[[0-9;]*[a-zA-Z]").expect("ANSI regex compile"));
    ANSI_RE.replace_all(s, "").to_string()
}

/// Unicode 全角字符 NFKC 标准化 + 常见全角 ASCII 映射
mod unicode_normalization {
    use std::collections::HashMap;
    use std::sync::LazyLock;

    static FULLWIDTH_MAP: LazyLock<HashMap<char, char>> = LazyLock::new(|| {
        // 全角 ASCII（U+FF01-U+FF5E）映射到半角（U+0021-U+007E）
        let mut map = HashMap::new();
        for code in 0xFF01u32..=0xFF5E {
            if let Some(c) = char::from_u32(code) {
                let half_width = char::from_u32(code - 0xFEE0).unwrap_or(c);
                if c != half_width {
                    map.insert(c, half_width);
                }
            }
        }
        // 全角空格 U+3000 → 半角空格 U+0020
        map.insert('\u{3000}', ' ');
        map
    });

    /// 如果字符串包含全角字符，返回标准化后的版本；否则返回 None（无需复制）。
    pub fn lookup(s: &str) -> Option<String> {
        let needs_normalize = s.chars().any(|c| FULLWIDTH_MAP.contains_key(&c));
        if !needs_normalize {
            return None;
        }
        let normalized: String = s
            .chars()
            .map(|c| FULLWIDTH_MAP.get(&c).copied().unwrap_or(c))
            .collect();
        Some(normalized)
    }
}

/// 剥离 shell 反斜杠转义。
/// 匹配 `\<任意字符>` 并还原为 `<字符>`。
/// 示例：`r\m\ \-\r\f\ \/` → `rm -rf /`
fn strip_backslash_escapes(s: &str) -> String {
    // 匹配 backslash 后跟任意非换行字符，捕获该字符
    static BACKSLASH_ESCAPE_RE: LazyLock<regex::Regex> =
        LazyLock::new(|| regex::Regex::new(r"\\(.)").expect("backslash escape regex compile"));
    // 仅当有反斜杠时才执行替换（快速路径）
    if s.contains('\\') {
        BACKSLASH_ESCAPE_RE.replace_all(s, "$1").to_string()
    } else {
        s.to_string()
    }
}

/// 剥离空字符串字面量。
/// 匹配 `''` 或 `""`（shell 中用于分割命令名）。
/// 示例：`r''m` → `rm`, `r""m` → `rm`
fn strip_empty_string_literals(s: &str) -> String {
    // 匹配连续两个单引号（''）或连续两个双引号（""）
    static EMPTY_QUOTE_RE: LazyLock<regex::Regex> =
        LazyLock::new(|| regex::Regex::new(r"'{2}|\x22{2}").expect("empty quote regex compile"));
    let has_single_empty = s.contains("''");
    let has_double_empty = s.contains("\"\"");
    if has_single_empty || has_double_empty {
        EMPTY_QUOTE_RE.replace_all(s, "").to_string()
    } else {
        s.to_string()
    }
}

/// 将解析后的绝对 HOME 路径还原为 `~/` 形式。
fn normalize_home_paths(s: &str) -> String {
    let home = std::env::var("HOME").unwrap_or_else(|_| "/home/unknown".to_string());
    if home.is_empty() || home == "/" {
        return s.to_string();
    }
    s.replace(&home, "~")
}

// ── Hardline 模式定义 ──

/// 不可绕过的硬阻止模式。
///
/// 每个模式包含：
/// - `pattern`: 正则表达式
/// - `category`: 命令类别（用于日志和错误消息）
/// - `message`: 返回给 LLM 的阻止理由
struct HardlinePattern {
    pattern: &'static str,
    category: &'static str,
    message: &'static str,
}

/// Hardline 模式列表。
/// 参考 Hermes HARDLINE_PATTERNS + 科研场景特定扩展。
static HARDLINE_PATTERNS: LazyLock<Vec<HardlinePattern>> = LazyLock::new(|| {
    vec![
        // ══════ 系统关机/重启 ══════
        HardlinePattern {
            pattern: r"\b(?:shutdown|poweroff|halt|reboot)\b",
            category: "system_shutdown",
            message: "系统关机/重启命令被硬阻止",
        },
        HardlinePattern {
            pattern: r"\binit\s+[06]\b",
            category: "system_shutdown",
            message: "init 运行级别切换被硬阻止",
        },
        HardlinePattern {
            pattern: r"\bsystemctl\s+(?:poweroff|reboot|halt)\b",
            category: "system_shutdown",
            message: "systemctl 关机命令被硬阻止",
        },
        // ══════ 磁盘擦除/格式化 ══════
        HardlinePattern {
            pattern: r"\bmkfs\b",
            category: "disk_format",
            message: "磁盘格式化命令 mkfs 被硬阻止",
        },
        HardlinePattern {
            pattern: r"\bdd\s+.*\bof=/dev/[a-z]+",
            category: "dd_to_device",
            message: "dd 写入块设备被硬阻止",
        },
        HardlinePattern {
            pattern: r"\bdd\s+.*\bof=/dev/(?:sd[a-z]|nvme\d+n\d+|mmcblk\d+)",
            category: "dd_to_device",
            message: "dd 写入磁盘设备被硬阻止",
        },
        // ══════ 递归删除根目录 ══════
        HardlinePattern {
            pattern: r"\brm\s+-rf\s+(?:/|/\*)",
            category: "rm_root",
            message: "递归删除根目录被硬阻止",
        },
        HardlinePattern {
            pattern: r"\brm\s+.*\s+-rf\s+/",
            category: "rm_root",
            message: "递归删除根目录被硬阻止",
        },
        // ══════ Fork 炸弹 ══════
        HardlinePattern {
            pattern: r":\(\)\s*\{[^}]*:[^}]*\}",
            category: "fork_bomb",
            message: "Fork 炸弹模式被硬阻止",
        },
        HardlinePattern {
            pattern: r"\bperl\s+-e\s+.*fork.*while",
            category: "fork_bomb",
            message: "Perl fork 循环被硬阻止",
        },
        HardlinePattern {
            pattern: r"\bpython3?\s+-c\s+.*while.*os\.fork",
            category: "fork_bomb",
            message: "Python fork 炸弹被硬阻止",
        },
        // ══════ Kill 信号广播 ══════
        HardlinePattern {
            pattern: r"\bkill\s+-1\b",
            category: "kill_all",
            message: "kill -1（信号广播到所有进程）被硬阻止",
        },
        // ══════ 覆盖关键系统文件 ══════
        HardlinePattern {
            pattern: r">\s*/etc/(?:passwd|shadow|sudoers|hosts)\b",
            category: "system_file_overwrite",
            message: "重定向覆盖关键系统文件被硬阻止",
        },
        HardlinePattern {
            pattern: r"\bcp\s+.*\s+/etc/(?:passwd|shadow|sudoers)\b",
            category: "system_file_overwrite",
            message: "复制覆盖关键系统文件被硬阻止",
        },
        // ══════ chmod 危险操作 ══════
        HardlinePattern {
            pattern: r"\bchmod\s+.*777\s+/(?:etc|bin|usr|lib|sbin|boot)\b",
            category: "dangerous_chmod",
            message: "对系统目录执行 chmod 777 被硬阻止",
        },
        // ══════ chown 到 root ══════
        HardlinePattern {
            pattern: r"\bchown\s+-R\s+root:root\s+/",
            category: "chown_root",
            message: "递归 chown root 到根目录被硬阻止",
        },
    ]
});

/// 编译后的 Hardline 正则集合（模块加载时编译一次）
static HARDLINE_REGEX_SET: LazyLock<RegexSet> = LazyLock::new(|| {
    let patterns: Vec<&str> = HARDLINE_PATTERNS.iter().map(|p| p.pattern).collect();
    RegexSet::new(&patterns).expect("Hardline regex patterns must compile")
});

// ── 检查 API ──

/// Hardline 检查结果
#[derive(Debug, Clone)]
pub struct HardlineResult {
    /// 是否被阻止
    pub blocked: bool,
    /// 阻止原因（供 LLM 查看）
    pub reason: String,
    /// 命令类别（供日志分类）
    pub category: Option<String>,
}

impl HardlineResult {
    /// 通过检查
    pub fn allowed() -> Self {
        HardlineResult {
            blocked: false,
            reason: String::new(),
            category: None,
        }
    }

    /// 被拒绝
    pub fn denied(reason: String, category: &str) -> Self {
        HardlineResult {
            blocked: true,
            reason,
            category: Some(category.to_string()),
        }
    }
}

/// 检查命令是否命中 hardline 模式。
///
/// 执行反规避标准化后再匹配，返回第一个命中的模式。
///
/// 注意：此函数在模块导入时冻结 `HERMES_YOLO_MODE`，
/// 确保运行时无法通过设置环境变量绕过 hardline 检查。
pub fn check_command(raw_command: &str) -> HardlineResult {
    let normalized = normalize_command(raw_command);

    // ── YOLO 模式冻结 ──
    // YOLO 模式在首次调用时从环境变量读取并缓存，
    // 后续设置环境变量不会生效（防止注入攻击）。
    static YOLO_MODE_FROZEN: LazyLock<bool> = LazyLock::new(|| {
        let val = std::env::var("HERMES_YOLO_MODE")
            .unwrap_or_default()
            .to_lowercase();
        val == "1" || val == "true" || val == "yes" || val == "on"
    });

    // Hardline 即使在 YOLO 模式下也不可绕过
    let _yolo = *YOLO_MODE_FROZEN;

    let matches: Vec<usize> = HARDLINE_REGEX_SET
        .matches(&normalized)
        .into_iter()
        .collect();

    if let Some(&idx) = matches.first() {
        let pattern = &HARDLINE_PATTERNS[idx];
        let reason = format!(
            "⚠️ 命令被硬阻止（安全策略，不可绕过）。\n\
             类别: {}\n\
             原因: {}\n\
             请换用更安全的替代方案实现相同目标。",
            pattern.category, pattern.message
        );
        HardlineResult::denied(reason, pattern.category)
    } else {
        HardlineResult::allowed()
    }
}

/// 仅做标准化（不检查 hardline），用于在其他安全检查前预处理命令。
pub fn normalize_only(raw: &str) -> String {
    normalize_command(raw)
}

/// 检查命令是否包含危险的重定向操作。
/// 用于 file_write/file_edit 等非 bash 工具的路径安全检查。
pub fn check_dangerous_path(path: &str) -> HardlineResult {
    let normalized = normalize_command(path);

    // 检查是否尝试覆盖关键系统文件
    let dangerous_prefixes = [
        "/etc/passwd",
        "/etc/shadow",
        "/etc/sudoers",
        "/etc/sudoers.d/",
        "/etc/ssh/",
        "/root/",
        "/boot/",
        "~/.ssh/authorized_keys",
        "~/.ssh/id_rsa",
        "~/.ssh/id_ed25519",
        "~/.netrc",
        "~/.pgpass",
        "~/.npmrc",
        "~/.pypirc",
        "~/.git-credentials",
    ];

    for prefix in &dangerous_prefixes {
        if normalized.starts_with(prefix) || normalized.contains(prefix) {
            return HardlineResult::denied(
                format!(
                    "路径 '{}' 指向受保护的系统/凭据文件，写入操作被硬阻止。",
                    path
                ),
                "sensitive_path",
            );
        }
    }

    HardlineResult::allowed()
}

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

    // ── 标准化测试 ──

    #[test]
    fn test_normalize_backslash_escapes() {
        assert_eq!(normalize_command(r"r\m"), "rm");
        assert_eq!(normalize_command(r"r\m\ \-\r\f"), "rm -rf");
    }

    #[test]
    fn test_normalize_empty_string_literals() {
        assert_eq!(normalize_command("r''m"), "rm");
        assert_eq!(normalize_command("r\"\"m"), "rm");
    }

    #[test]
    fn test_normalize_fullwidth() {
        // 全角 'ｒ' (U+FF52) → 半角 'r'
        let fullwidth_rm = "\u{FF52}\u{FF4D}"; // ｒｍ
        let normalized = normalize_command(fullwidth_rm);
        assert_eq!(normalized, "rm");
    }

    #[test]
    fn test_normalize_ansi_strip() {
        let cmd = "\x1b[31mrm -rf /\x1b[0m";
        let normalized = normalize_command(cmd);
        assert_eq!(normalized, "rm -rf /");
    }

    #[test]
    fn test_normalize_null_bytes() {
        let cmd = "rm\0 -rf\0 /";
        let normalized = normalize_command(cmd);
        assert!(!normalized.contains('\0'));
    }

    // ── Hardline 检查测试 ──

    #[test]
    fn test_block_shutdown() {
        let result = check_command("shutdown -h now");
        assert!(result.blocked);
        assert_eq!(result.category.as_deref(), Some("system_shutdown"));
    }

    #[test]
    fn test_block_reboot() {
        let result = check_command("reboot");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_systemctl_poweroff() {
        let result = check_command("systemctl poweroff");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_mkfs() {
        let result = check_command("mkfs.ext4 /dev/sda1");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_dd_to_device() {
        let result = check_command("dd if=/dev/zero of=/dev/sda bs=1M");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_dd_to_nvme() {
        let result = check_command("dd if=image.iso of=/dev/nvme0n1");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_rm_rf_root() {
        let result = check_command("rm -rf /");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_rm_rf_root_wildcard() {
        let result = check_command("rm -rf /*");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_fork_bomb() {
        let result = check_command(":(){ :|:& };:");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_kill_minus_one() {
        let result = check_command("kill -1 1");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_redirect_overwrite_passwd() {
        let result = check_command("echo 'x' > /etc/passwd");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_chmod_777_etc() {
        let result = check_command("chmod -R 777 /etc");
        assert!(result.blocked);
    }

    #[test]
    fn test_block_chown_root() {
        let result = check_command("chown -R root:root /");
        assert!(result.blocked);
    }

    #[test]
    fn test_allow_normal_commands() {
        assert!(!check_command("ls -la").blocked);
        assert!(!check_command("cargo build").blocked);
        assert!(!check_command("git status").blocked);
        assert!(!check_command("python3 -c 'print(1+1)'").blocked);
    }

    #[test]
    fn test_allow_safe_rm() {
        // rm 单个文件不阻止
        assert!(!check_command("rm file.txt").blocked);
        assert!(!check_command("rm -rf ./node_modules").blocked);
    }

    #[test]
    fn test_allow_dd_to_file() {
        // dd 写入普通文件不阻止
        assert!(!check_command("dd if=/dev/zero of=test.bin bs=1M count=10").blocked);
    }

    #[test]
    fn test_evasion_backslash_escapes() {
        // r\e\b\o\o\t 应该匹配 reboot
        let result = check_command(r"r\e\b\o\o\t");
        assert!(result.blocked);
    }

    #[test]
    fn test_evasion_empty_quotes() {
        // r''m 应该匹配
        let result = check_command("r''m -rf /");
        assert!(result.blocked);
    }

    #[test]
    fn test_dangerous_path_check() {
        let result = check_dangerous_path("/etc/passwd");
        assert!(result.blocked);

        let result = check_dangerous_path("/home/user/data.txt");
        assert!(!result.blocked);
    }
}