// HA功能测试

use remdb::*;
use remdb::config::{HARole, ReplicationMode, LogMode};
use remdb::ha::{HAError, Result as HAResult};
use remdb::ha::role::RoleManager;
use remdb::ha::heartbeat::HeartbeatMonitor;
use remdb::ha::replication::ReplicationManager;
use remdb::ha::manager::HAManager;

// 定义测试平台
struct TestPlatform;

impl crate::platform::Platform for TestPlatform {
    fn get_timestamp(&self) -> u64 {
        123456
    }
    
    fn get_timestamp_us(&self) -> u64 {
        123456789
    }
    
    fn spin_lock(&self, _lock: &mut u32) {
        // 简单实现，不做实际锁定
    }
    
    fn spin_unlock(&self, _lock: &mut u32) {
        // 简单实现，不做实际锁定
    }
    
    fn memcpy(&self, dst: *mut u8, src: *const u8, size: usize) {
        // 使用标准库的内存拷贝
        unsafe {
            std::ptr::copy(src, dst, size);
        }
    }
    
    fn memset(&self, ptr: *mut u8, value: u8, size: usize) {
        // 使用标准库的内存设置
        unsafe {
            std::ptr::write_bytes(ptr, value, size);
        }
    }
    
    fn compiler_barrier(&self) {
        // 不执行任何操作
    }
    
    fn full_memory_barrier(&self) {
        // 不执行任何操作
    }
    
    fn delay_ms(&self, _ms: u32) {
        // 不执行任何操作
    }
    
    fn delay_us(&self, _us: u32) {
        // 不执行任何操作
    }
    
    fn file_open(&self, _path: &str, _mode: crate::platform::FileMode) -> std::result::Result<*const u8, ()> {
        Ok(std::ptr::null())
    }
    
    fn file_close(&self, _handle: *const u8) -> std::result::Result<(), ()> {
        Ok(())
    }
    
    fn file_write(&self, _handle: *const u8, _data: *const u8, _size: usize) -> std::result::Result<usize, ()> {
        Ok(0)
    }
    
    fn file_read(&self, _handle: *const u8, _data: *mut u8, _size: usize) -> std::result::Result<usize, ()> {
        Ok(0)
    }
    
    fn file_seek(&self, _handle: *const u8, _offset: i64, _whence: crate::platform::SeekWhence) -> std::result::Result<u64, ()> {
        Ok(0)
    }
    
    fn file_remove(&self, _path: &str) -> std::result::Result<(), ()> {
        Ok(())
    }
    
    fn file_size(&self, _path: &str) -> std::result::Result<usize, ()> {
        Ok(0)
    }
    
    fn crc32(&self, _data: *const u8, _size: usize) -> u32 {
        0
    }
}

static TEST_PLATFORM: TestPlatform = TestPlatform;

// 定义全局空表切片
static EMPTY_TABLES: &[crate::types::TableDef] = &[];

// 初始化测试平台
fn init_test_platform() {
    unsafe {
        crate::platform::init_platform(&TEST_PLATFORM);
    }
}

// 测试角色管理器
#[test]
fn test_role_manager() {
    init_test_platform();
    
    // 创建角色管理器，初始角色为主节点
    let role_manager = RoleManager::new(HARole::Master).expect("Failed to create RoleManager");
    
    // 初始化角色管理器
    role_manager.init().expect("Failed to initialize RoleManager");
    
    // 检查初始角色
    assert_eq!(role_manager.get_role(), HARole::Master);
    
    // 设置角色为从节点
    role_manager.set_role(HARole::Slave).expect("Failed to set role to Slave");
    
    // 检查角色是否更新
    assert_eq!(role_manager.get_role(), HARole::Slave);
    
    // 设置角色为自动模式
    role_manager.set_role(HARole::Auto).expect("Failed to set role to Auto");
    
    // 检查角色是否更新
    assert_eq!(role_manager.get_role(), HARole::Auto);
    
    // 检查角色状态判断方法
    assert!(!role_manager.is_master());
    assert!(!role_manager.is_slave());
    assert!(role_manager.is_auto());
    
    // 关闭角色管理器
    role_manager.shutdown().expect("Failed to shutdown RoleManager");
}

// 测试心跳监视器
#[test]
fn test_heartbeat_monitor() {
    init_test_platform();
    
    // 创建心跳监视器
    let heartbeat_monitor = HeartbeatMonitor::new(1000, 3000).expect("Failed to create HeartbeatMonitor");
    
    // 初始化心跳监视器
    heartbeat_monitor.init().expect("Failed to initialize HeartbeatMonitor");
    
    // 检查主节点是否存活（默认值）
    assert!(heartbeat_monitor.is_master_alive());
    
    // 检查最后心跳时间（默认值）
    assert_eq!(heartbeat_monitor.get_last_heartbeat_time(), 0);
    
    // 关闭心跳监视器
    heartbeat_monitor.shutdown().expect("Failed to shutdown HeartbeatMonitor");
}

// 测试复制管理器
#[test]
fn test_replication_manager() {
    init_test_platform();
    
    // 创建复制管理器，同步模式
    let replication_manager = ReplicationManager::new(ReplicationMode::Sync).expect("Failed to create ReplicationManager");
    
    // 初始化复制管理器
    replication_manager.init().expect("Failed to initialize ReplicationManager");
    
    // 检查复制模式
    assert_eq!(replication_manager.get_replication_mode(), ReplicationMode::Sync);
    
    // 初始化主节点
    replication_manager.init_master().expect("Failed to initialize master");
    
    // 初始化从节点
    replication_manager.init_slave().expect("Failed to initialize slave");
    
    // 检查复制状态
    replication_manager.check_status().expect("Failed to check status");
    
    // 关闭复制管理器
    replication_manager.shutdown().expect("Failed to shutdown ReplicationManager");
}

// 测试HA管理器
#[test]
fn test_ha_manager() {
    init_test_platform();
    
    // 定义测试表结构
    // 注意：TableDef是私有类型，这里使用空切片代替实际表定义
    static EMPTY_TABLES: &[crate::types::TableDef] = &[];
    
    // 创建测试配置
    static CONFIG: config::DbConfig = config::DbConfig {
        tables: EMPTY_TABLES,
        total_memory: 8 * 1024 * 1024, // 8MB
        low_power_mode_supported: false,
        low_power_max_records: None,
        default_max_records: 1000,
        memory_allocator: &config::DefaultMemoryAllocator,
        log_mode: LogMode::Async,
        checkpoint_interval_ms: 60000,
        log_file_size_limit: 1 * 1024 * 1024,
        log_prealloc_size: 0,
        log_segment_size: 1 * 1024 * 1024,
        retained_checkpoints: 1,
        // HA配置
        ha_role: HARole::Master,
        replication_mode: ReplicationMode::Sync,
        heartbeat_interval_ms: 1000,
        failure_detection_ms: 3000,
        sync_timeout_ms: 2000,
        master_address: None,
        master_port: None,
    };
    
    // 创建HA管理器
    let ha_manager = HAManager::new(&CONFIG).expect("Failed to create HAManager");
    
    // 初始化HA管理器
    ha_manager.init().expect("Failed to initialize HAManager");
    
    // 检查角色
    assert_eq!(ha_manager.get_role(), HARole::Master);
    
    // 检查复制模式
    assert_eq!(ha_manager.get_replication_mode(), ReplicationMode::Sync);
    
    // 检查状态
    ha_manager.check_status().expect("Failed to check HA status");
    
    // 关闭HA管理器
    ha_manager.shutdown().expect("Failed to shutdown HAManager");
}

// 测试HA管理器角色切换
#[test]
fn test_ha_manager_role_switch() {
    init_test_platform();
    
    // 使用全局定义的EMPTY_TABLES
    // 创建测试配置
    static CONFIG: config::DbConfig = config::DbConfig {
        tables: EMPTY_TABLES,
        total_memory: 8 * 1024 * 1024, // 8MB
        low_power_mode_supported: false,
        low_power_max_records: None,
        default_max_records: 1000,
        memory_allocator: &config::DefaultMemoryAllocator,
        log_mode: LogMode::Async,
        checkpoint_interval_ms: 60000,
        log_file_size_limit: 1 * 1024 * 1024,
        log_prealloc_size: 0,
        log_segment_size: 1 * 1024 * 1024,
        retained_checkpoints: 1,
        // HA配置
        ha_role: HARole::Master,
        replication_mode: ReplicationMode::Sync,
        heartbeat_interval_ms: 1000,
        failure_detection_ms: 3000,
        sync_timeout_ms: 2000,
        master_address: None,
        master_port: None,
    };
    
    // 创建HA管理器
    let mut ha_manager = HAManager::new(&CONFIG).expect("Failed to create HAManager");
    
    // 初始化HA管理器
    ha_manager.init().expect("Failed to initialize HAManager");
    
    // 检查初始角色
    assert_eq!(ha_manager.get_role(), HARole::Master);
    
    // 从主节点降级为从节点
    ha_manager.demote_to_slave().expect("Failed to demote to slave");
    
    // 检查角色是否更新
    assert_eq!(ha_manager.get_role(), HARole::Slave);
    
    // 从从节点提升为主节点
    ha_manager.promote_to_master().expect("Failed to promote to master");
    
    // 检查角色是否更新
    assert_eq!(ha_manager.get_role(), HARole::Master);
    
    // 关闭HA管理器
    ha_manager.shutdown().expect("Failed to shutdown HAManager");
}

// 测试HA错误类型
#[test]
fn test_ha_errors() {
    // 测试错误显示
    assert_eq!(format!("{}", HAError::InitFailed), "HA initialization failed");
    assert_eq!(format!("{}", HAError::NetworkError), "Network error");
    assert_eq!(format!("{}", HAError::InvalidParameter), "Invalid parameter");
    assert_eq!(format!("{}", HAError::RoleConflict), "Role conflict");
    assert_eq!(format!("{}", HAError::SyncFailed), "Sync failed");
    assert_eq!(format!("{}", HAError::HeartbeatTimeout), "Heartbeat timeout");
    assert_eq!(format!("{}", HAError::ReplicationError), "Replication error");
    assert_eq!(format!("{}", HAError::UnsupportedOperation), "Unsupported operation");
}

// 测试HA配置验证
#[test]
fn test_ha_config_validation() {
    init_test_platform();
    

    
    // 创建无效配置（心跳间隔太小）
    let invalid_config = config::DbConfig {
        tables: EMPTY_TABLES,
        total_memory: 8 * 1024 * 1024, // 8MB
        low_power_mode_supported: false,
        low_power_max_records: None,
        default_max_records: 1000,
        memory_allocator: &config::DefaultMemoryAllocator,
        log_mode: LogMode::Async,
        checkpoint_interval_ms: 60000,
        log_file_size_limit: 1 * 1024 * 1024,
        log_prealloc_size: 0,
        log_segment_size: 1 * 1024 * 1024,
        retained_checkpoints: 1,
        // 无效HA配置
        ha_role: HARole::Master,
        replication_mode: ReplicationMode::Sync,
        heartbeat_interval_ms: 50, // 心跳间隔太小，小于最小值100ms
        failure_detection_ms: 3000,
        sync_timeout_ms: 2000,
        master_address: None,
        master_port: None,
    };
    
    // 验证配置应该失败
    assert!(!config::validate_config(&invalid_config));
    
    // 创建有效配置
    let valid_config = config::DbConfig {
        tables: EMPTY_TABLES,
        total_memory: 8 * 1024 * 1024, // 8MB
        low_power_mode_supported: false,
        low_power_max_records: None,
        default_max_records: 1000,
        memory_allocator: &config::DefaultMemoryAllocator,
        log_mode: LogMode::Async,
        checkpoint_interval_ms: 60000,
        log_file_size_limit: 1 * 1024 * 1024,
        log_prealloc_size: 0,
        log_segment_size: 1 * 1024 * 1024,
        retained_checkpoints: 1,
        // 有效HA配置
        ha_role: HARole::Master,
        replication_mode: ReplicationMode::Sync,
        heartbeat_interval_ms: 1000, // 1秒
        failure_detection_ms: 3000, // 3秒
        sync_timeout_ms: 2000, // 2秒
        master_address: None,
        master_port: None,
    };
    
    // 验证配置应该成功
    assert!(config::validate_config(&valid_config));
}
