//! 宪法版本管理模块

use crate::{ConstitutionVersion, Result, Error};

/// 版本管理器
pub struct VersionManager {
    versions: Vec<ConstitutionVersion>,
}

impl VersionManager {
    /// 创建新的版本管理器
    pub fn new() -> Self {
        Self {
            versions: Vec::new(),
        }
    }

    /// 添加版本
    pub fn add_version(&mut self, version: ConstitutionVersion) -> Result<()> {
        version.validate()?;
        
        // 检查版本号是否已存在
        if self.versions.iter().any(|v| v.version == version.version) {
            return Err(Error::VersionExists(version.version));
        }

        self.versions.push(version);
        self.versions.sort_by(|a, b| a.version.cmp(&b.version));
        
        Ok(())
    }

    /// 获取版本
    pub fn get_version(&self, version: u64) -> Option<&ConstitutionVersion> {
        self.versions.iter().find(|v| v.version == version)
    }

    /// 获取最新版本
    pub fn get_latest_version(&self) -> Option<&ConstitutionVersion> {
        self.versions.last()
    }

    /// 获取所有版本
    pub fn get_all_versions(&self) -> &[ConstitutionVersion] {
        &self.versions
    }

    /// 获取版本范围
    pub fn get_version_range(&self, from: u64, to: u64) -> Vec<&ConstitutionVersion> {
        self.versions
            .iter()
            .filter(|v| v.version >= from && v.version <= to)
            .collect()
    }

    /// 检查版本是否存在
    pub fn version_exists(&self, version: u64) -> bool {
        self.versions.iter().any(|v| v.version == version)
    }

    /// 获取版本数量
    pub fn version_count(&self) -> usize {
        self.versions.len()
    }
}

impl Default for VersionManager {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use nac_udm::primitives::{Hash, Address};

    fn create_test_version(version: u64) -> ConstitutionVersion {
        ConstitutionVersion::new(
            version,
            Hash::zero(),
            version * 1000,
            10,
            version * 100,
            Address::zero(),
            format!("Version {}", version),
        )
    }

    #[test]
    fn test_add_version() {
        let mut manager = VersionManager::new();
        let version = create_test_version(1);
        assert!(manager.add_version(version).is_ok());
        assert_eq!(manager.version_count(), 1);
    }

    #[test]
    fn test_duplicate_version() {
        let mut manager = VersionManager::new();
        let version = create_test_version(1);
        assert!(manager.add_version(version.clone()).is_ok());
        assert!(manager.add_version(version).is_err());
    }

    #[test]
    fn test_get_version() {
        let mut manager = VersionManager::new();
        let version = create_test_version(1);
        manager.add_version(version.clone()).unwrap();
        
        let retrieved = manager.get_version(1);
        assert!(retrieved.is_some());
        assert_eq!(retrieved.unwrap().version, 1);
    }

    #[test]
    fn test_get_latest_version() {
        let mut manager = VersionManager::new();
        manager.add_version(create_test_version(1)).unwrap();
        manager.add_version(create_test_version(3)).unwrap();
        manager.add_version(create_test_version(2)).unwrap();
        
        let latest = manager.get_latest_version();
        assert!(latest.is_some());
        assert_eq!(latest.unwrap().version, 3);
    }

    #[test]
    fn test_version_range() {
        let mut manager = VersionManager::new();
        manager.add_version(create_test_version(1)).unwrap();
        manager.add_version(create_test_version(2)).unwrap();
        manager.add_version(create_test_version(3)).unwrap();
        manager.add_version(create_test_version(4)).unwrap();
        
        let range = manager.get_version_range(2, 3);
        assert_eq!(range.len(), 2);
        assert_eq!(range[0].version, 2);
        assert_eq!(range[1].version, 3);
    }
}