use rhai::Engine;
use sal_os::rhai::register_os_module;
use tempfile::TempDir;

fn create_test_engine() -> Engine {
    let mut engine = Engine::new();
    register_os_module(&mut engine).expect("Failed to register OS module");
    engine
}

#[test]
fn test_rhai_module_registration() {
    // Test that the OS module can be registered without errors
    let _engine = create_test_engine();

    // If we get here without panicking, the module was registered successfully
    // We can't easily test function registration without calling the functions
}

#[test]
fn test_rhai_file_operations() {
    let engine = create_test_engine();
    let temp_dir = TempDir::new().unwrap();
    let temp_path = temp_dir.path().to_str().unwrap();

    // Test file operations through Rhai
    let script = format!(
        r#"
        let test_dir = "{}/test_rhai";
        let test_file = test_dir + "/test.txt";
        let content = "Hello from Rhai!";
        
        // Create directory
        mkdir(test_dir);
        
        // Check if directory exists
        let dir_exists = exist(test_dir);
        
        // Write file
        file_write(test_file, content);
        
        // Check if file exists
        let file_exists = exist(test_file);
        
        // Read file
        let read_content = file_read(test_file);
        
        // Return results
        #{{"dir_exists": dir_exists, "file_exists": file_exists, "content_match": read_content == content}}
    "#,
        temp_path
    );

    let result: rhai::Map = engine.eval(&script).expect("Script execution failed");

    assert_eq!(result["dir_exists"].as_bool().unwrap(), true);
    assert_eq!(result["file_exists"].as_bool().unwrap(), true);
    assert_eq!(result["content_match"].as_bool().unwrap(), true);
}

#[test]
fn test_rhai_file_size() {
    let engine = create_test_engine();
    let temp_dir = TempDir::new().unwrap();
    let temp_path = temp_dir.path().to_str().unwrap();

    let script = format!(
        r#"
        let test_file = "{}/size_test.txt";
        let content = "12345"; // 5 bytes
        
        file_write(test_file, content);
        let size = file_size(test_file);
        
        size
    "#,
        temp_path
    );

    let result: i64 = engine.eval(&script).expect("Script execution failed");
    assert_eq!(result, 5);
}

#[test]
fn test_rhai_file_append() {
    let engine = create_test_engine();
    let temp_dir = TempDir::new().unwrap();
    let temp_path = temp_dir.path().to_str().unwrap();

    let script = format!(
        r#"
        let test_file = "{}/append_test.txt";
        
        file_write(test_file, "Line 1\n");
        file_write_append(test_file, "Line 2\n");
        
        let content = file_read(test_file);
        content
    "#,
        temp_path
    );

    let result: String = engine.eval(&script).expect("Script execution failed");
    assert_eq!(result, "Line 1\nLine 2\n");
}

#[test]
fn test_rhai_copy_and_move() {
    let engine = create_test_engine();
    let temp_dir = TempDir::new().unwrap();
    let temp_path = temp_dir.path().to_str().unwrap();

    let script = format!(
        r#"
        let source = "{}/source.txt";
        let copy_dest = "{}/copy.txt";
        let move_dest = "{}/moved.txt";
        let content = "Test content";

        // Create source file
        file_write(source, content);

        // Copy file
        copy(source, copy_dest);

        // Move the copy
        mv(copy_dest, move_dest);

        // Check results
        let source_exists = exist(source);
        let copy_exists = exist(copy_dest);
        let move_exists = exist(move_dest);
        let move_content = file_read(move_dest);

        #{{"source_exists": source_exists, "copy_exists": copy_exists, "move_exists": move_exists, "content_match": move_content == content}}
    "#,
        temp_path, temp_path, temp_path
    );

    let result: rhai::Map = engine.eval(&script).expect("Script execution failed");

    assert_eq!(result["source_exists"].as_bool().unwrap(), true);
    assert_eq!(result["copy_exists"].as_bool().unwrap(), false); // Should be moved
    assert_eq!(result["move_exists"].as_bool().unwrap(), true);
    assert_eq!(result["content_match"].as_bool().unwrap(), true);
}

#[test]
fn test_rhai_delete() {
    let engine = create_test_engine();
    let temp_dir = TempDir::new().unwrap();
    let temp_path = temp_dir.path().to_str().unwrap();

    let script = format!(
        r#"
        let test_file = "{}/delete_test.txt";
        
        // Create file
        file_write(test_file, "content");
        let exists_before = exist(test_file);
        
        // Delete file
        delete(test_file);
        let exists_after = exist(test_file);
        
        #{{"before": exists_before, "after": exists_after}}
    "#,
        temp_path
    );

    let result: rhai::Map = engine.eval(&script).expect("Script execution failed");

    assert_eq!(result["before"].as_bool().unwrap(), true);
    assert_eq!(result["after"].as_bool().unwrap(), false);
}

#[test]
fn test_rhai_find_files() {
    let engine = create_test_engine();
    let temp_dir = TempDir::new().unwrap();
    let temp_path = temp_dir.path().to_str().unwrap();

    let script = format!(
        r#"
        let test_dir = "{}/find_test";
        mkdir(test_dir);
        
        // Create test files
        file_write(test_dir + "/file1.txt", "content1");
        file_write(test_dir + "/file2.txt", "content2");
        file_write(test_dir + "/other.log", "log content");
        
        // Find .txt files
        let txt_files = find_files(test_dir, "*.txt");
        let all_files = find_files(test_dir, "*");
        
        #{{"txt_count": txt_files.len(), "all_count": all_files.len()}}
    "#,
        temp_path
    );

    let result: rhai::Map = engine.eval(&script).expect("Script execution failed");

    assert_eq!(result["txt_count"].as_int().unwrap(), 2);
    assert!(result["all_count"].as_int().unwrap() >= 3);
}

#[test]
fn test_rhai_which_command() {
    let engine = create_test_engine();

    let script = r#"
        let ls_path = which("ls");
        let nonexistent = which("nonexistentcommand12345");
        
        #{"ls_found": ls_path.len() > 0, "nonexistent_found": nonexistent.len() > 0}
    "#;

    let result: rhai::Map = engine.eval(script).expect("Script execution failed");

    assert_eq!(result["ls_found"].as_bool().unwrap(), true);
    assert_eq!(result["nonexistent_found"].as_bool().unwrap(), false);
}

#[test]
fn test_rhai_error_handling() {
    let engine = create_test_engine();

    // Test that errors are properly propagated to Rhai
    // Instead of try-catch, just test that the function call fails
    let script = r#"file_read("/nonexistent/path/file.txt")"#;

    let result = engine.eval::<String>(script);
    assert!(
        result.is_err(),
        "Expected error when reading non-existent file"
    );
}

#[test]
fn test_rhai_package_functions() {
    let engine = create_test_engine();

    // Test that package functions are registered by calling them

    let script = r#"
        let platform = package_platform();
        let debug_result = package_set_debug(true);
        
        #{"platform": platform, "debug": debug_result}
    "#;

    let result: rhai::Map = engine.eval(script).expect("Script execution failed");

    // Platform should be a non-empty string
    let platform: String = result["platform"].clone().try_cast().unwrap();
    assert!(!platform.is_empty());

    // Debug setting should return true
    assert_eq!(result["debug"].as_bool().unwrap(), true);
}

#[test]
fn test_rhai_download_functions() {
    let engine = create_test_engine();

    // Test that download functions are registered by calling them

    let temp_dir = TempDir::new().unwrap();
    let temp_path = temp_dir.path().to_str().unwrap();

    let script = format!(
        r#"
        let test_file = "{}/test_script.sh";
        
        // Create a test script
        file_write(test_file, "echo 'test'");
        
        // Make it executable
        try {{
            let result = chmod_exec(test_file);
            result.len() >= 0 // chmod_exec returns a string, so check if it's valid
        }} catch {{
            false
        }}
    "#,
        temp_path
    );

    let result: bool = engine.eval(&script).expect("Script execution failed");
    assert!(result);
}

#[test]
fn test_rhai_array_returns() {
    let engine = create_test_engine();
    let temp_dir = TempDir::new().unwrap();
    let temp_path = temp_dir.path().to_str().unwrap();

    let script = format!(
        r#"
        let test_dir = "{}/array_test";
        mkdir(test_dir);
        
        // Create some files
        file_write(test_dir + "/file1.txt", "content");
        file_write(test_dir + "/file2.txt", "content");
        
        // Test that find_files returns an array
        let files = find_files(test_dir, "*.txt");
        
        // Test array operations
        let count = files.len();
        let first_file = if count > 0 {{ files[0] }} else {{ "" }};
        
        #{{"count": count, "has_files": count > 0, "first_file_exists": first_file.len() > 0}}
    "#,
        temp_path
    );

    let result: rhai::Map = engine.eval(&script).expect("Script execution failed");

    assert_eq!(result["count"].as_int().unwrap(), 2);
    assert_eq!(result["has_files"].as_bool().unwrap(), true);
    assert_eq!(result["first_file_exists"].as_bool().unwrap(), true);
}

#[test]
fn test_rhai_platform_functions() {
    let engine = create_test_engine();

    let script = r#"
        let is_osx = platform_is_osx();
        let is_linux = platform_is_linux();
        let is_arm = platform_is_arm();
        let is_x86 = platform_is_x86();

        // Test that platform detection is consistent
        let platform_consistent = !(is_osx && is_linux);
        let arch_consistent = !(is_arm && is_x86);

        #{"osx": is_osx, "linux": is_linux, "arm": is_arm, "x86": is_x86, "platform_consistent": platform_consistent, "arch_consistent": arch_consistent}
    "#;

    let result: rhai::Map = engine.eval(script).expect("Script execution failed");

    // Verify platform detection consistency
    assert_eq!(result["platform_consistent"].as_bool().unwrap(), true);
    assert_eq!(result["arch_consistent"].as_bool().unwrap(), true);

    // At least one platform should be detected
    let osx = result["osx"].as_bool().unwrap();
    let linux = result["linux"].as_bool().unwrap();

    // At least one architecture should be detected
    let arm = result["arm"].as_bool().unwrap();
    let x86 = result["x86"].as_bool().unwrap();

    // Print current platform for debugging
    println!(
        "Platform detection: OSX={}, Linux={}, ARM={}, x86={}",
        osx, linux, arm, x86
    );
}