//! 账户管理模块
//!
//! 负责账户的创建、导入、导出和管理

use crate::error::{VisionError, Result};
use crate::types::{AccountInfo, AccountType, Address};
use tracing::{debug, info};
use std::collections::HashMap;

/// 账户管理器
pub struct AccountManager {
    /// 账户列表
    accounts: HashMap<Address, AccountInfo>,
    /// 当前活跃账户
    active_account: Option<Address>,
}

impl AccountManager {
    /// 创建新的账户管理器
    pub fn new() -> Result<Self> {
        info!("Creating new AccountManager");
        Ok(Self {
            accounts: HashMap::new(),
            active_account: None,
        })
    }

    /// 创建新账户
    pub fn create_account(&mut self, nickname: Option<String>) -> Result<Address> {
        // 简化实现: 生成模拟地址
        let address = format!("NAC{:016x}", rand::random::<u64>());
        info!("Creating new account: {}", address);

        let account = AccountInfo {
            address: address.clone(),
            balance: 0,
            nickname,
            account_type: AccountType::Normal,
        };

        self.accounts.insert(address.clone(), account);
        
        // 如果没有活跃账户，设置为活跃账户
        if self.active_account.is_none() {
            self.active_account = Some(address.clone());
        }

        Ok(address)
    }

    /// 导入账户
    pub fn import_account(&mut self, private_key: &str, nickname: Option<String>) -> Result<Address> {
        debug!("Importing account from private key");
        
        // 简化实现: 从私钥生成地址
        let address = format!("NAC{:016x}", private_key.len() as u64);
        
        let account = AccountInfo {
            address: address.clone(),
            balance: 0,
            nickname,
            account_type: AccountType::Normal,
        };

        self.accounts.insert(address.clone(), account);
        Ok(address)
    }

    /// 获取账户信息
    pub fn get_account(&self, address: &Address) -> Result<&AccountInfo> {
        self.accounts.get(address)
            .ok_or_else(|| VisionError::AccountError(format!("Account not found: {}", address)))
    }

    /// 获取所有账户
    pub fn list_accounts(&self) -> Vec<&AccountInfo> {
        self.accounts.values().collect()
    }

    /// 设置活跃账户
    pub fn set_active_account(&mut self, address: Address) -> Result<()> {
        if !self.accounts.contains_key(&address) {
            return Err(VisionError::AccountError(format!("Account not found: {}", address)));
        }
        self.active_account = Some(address);
        Ok(())
    }

    /// 获取活跃账户
    pub fn get_active_account(&self) -> Result<&AccountInfo> {
        let address = self.active_account.as_ref()
            .ok_or_else(|| VisionError::AccountError("No active account".to_string()))?;
        self.get_account(address)
    }

    /// 更新账户余额
    pub fn update_balance(&mut self, address: &Address, balance: u128) -> Result<()> {
        let account = self.accounts.get_mut(address)
            .ok_or_else(|| VisionError::AccountError(format!("Account not found: {}", address)))?;
        account.balance = balance;
        Ok(())
    }
}

// 简化实现: 使用固定随机数生成器
mod rand {
    pub fn random<T>() -> T 
    where
        T: From<u64>
    {
        // 简化实现: 返回固定值
        T::from(12345678u64)
    }
}

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

    #[test]
    fn test_create_account() {
        let mut manager = AccountManager::new().unwrap();
        let address = manager.create_account(Some("Test Account".to_string())).unwrap();
        assert!(!address.is_empty());
        assert!(address.starts_with("NAC"));
    }

    #[test]
    fn test_get_account() {
        let mut manager = AccountManager::new().unwrap();
        let address = manager.create_account(None).unwrap();
        let account = manager.get_account(&address).unwrap();
        assert_eq!(account.address, address);
    }

    #[test]
    fn test_active_account() {
        let mut manager = AccountManager::new().unwrap();
        let address = manager.create_account(None).unwrap();
        let active = manager.get_active_account().unwrap();
        assert_eq!(active.address, address);
    }

    #[test]
    fn test_update_balance() {
        let mut manager = AccountManager::new().unwrap();
        let address = manager.create_account(None).unwrap();
        manager.update_balance(&address, 1000000).unwrap();
        let account = manager.get_account(&address).unwrap();
        assert_eq!(account.balance, 1000000);
    }
}