//! 会话存储模块
//!
//! 提供高性能的会话数据存储实现,使用零拷贝操作来提升性能

use crate::utils::zero_copy::ZeroCopyBytes;
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
use serde_json;
use std::collections::HashMap;
use std::fmt;
use std::sync::Arc;

/// 会话存储错误类型
#[derive(Debug)]
pub enum SessionStorageError {
    /// 序列化时出错
    SerializationError(serde_json::Error),
    /// 反序列化时出错
    DeserializationError(serde_json::Error),
}

impl fmt::Display for SessionStorageError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SessionStorageError::SerializationError(e) => write!(f, "序列化时出错: {}", e),
            SessionStorageError::DeserializationError(e) => write!(f, "反序列化时出错: {}", e),
        }
    }
}

impl std::error::Error for SessionStorageError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            SessionStorageError::SerializationError(e) => Some(e),
            SessionStorageError::DeserializationError(e) => Some(e),
        }
    }
}

impl From<serde_json::Error> for SessionStorageError {
    fn from(err: serde_json::Error) -> Self {
        SessionStorageError::SerializationError(err)
    }
}

/// 会话存储数据结构
///
/// 使用 ZeroCopyBytes 存储序列化后的数据,避免不必要的内存拷贝
#[derive(Debug, Clone)]
pub struct SessionStorage {
    /// 使用 ZeroCopyBytes 代替 String,减少内存分配
    data: Arc<RwLock<HashMap<String, ZeroCopyBytes>>>,
}

impl SessionStorage {
    /// 创建一个新的会话存储实例
    pub fn new() -> Self {
        Self {
            data: Arc::new(RwLock::new(HashMap::new())),
        }
    }

    /// 存储任意类型的值
    ///
    /// 值会被序列化成 JSON 格式存储
    ///
    /// 性能优化: 使用 serde_json::to_vec 而不是 to_string,可以减少一次 UTF-8 验证
    pub fn set<T: Serialize>(&self, key: &str, value: &T) -> Result<(), SessionStorageError> {
        // 序列化为 JSON 字节,比 to_string 稍快一点
        let json_bytes = serde_json::to_vec(value)?;
        // 使用 ZeroCopyBytes 包装,避免额外的字符串分配
        let zero_copy_bytes = ZeroCopyBytes::new(json_bytes);
        // 写入数据
        self.data.write().insert(key.to_owned(), zero_copy_bytes);

        Ok(())
    }

    /// 获取存储的值并反序列化成指定类型
    pub fn get<T: for<'de> Deserialize<'de>>(&self, key: &str) -> Option<Result<T, SessionStorageError>> {
        // 优化：在锁内只进行克隆操作（ZeroCopyBytes 是 cheap clone），将耗时的反序列化移出锁外
        let zero_copy_bytes = {
            let data_guard = self.data.read();
            data_guard.get(key).cloned()
        };

        if let Some(zero_copy_bytes) = zero_copy_bytes {
            // 在锁外进行反序列化
            match serde_json::from_slice(zero_copy_bytes.as_slice()) {
                Ok(value) => Some(Ok(value)),
                Err(err) => Some(Err(SessionStorageError::DeserializationError(err))),
            }
        } else {
            None
        }
    }

    /// 移除指定键的值
    pub fn remove(&self, key: &str) -> bool {
        self.data.write().remove(key).is_some()
    }

    /// 清空所有存储的数据
    pub fn clear(&self) {
        self.data.write().clear();
    }

    /// 获取所有存储的键
    pub fn keys(&self) -> Vec<String> {
        self.data.read().keys().cloned().collect()
    }

    /// 检查键是否存在
    pub fn has(&self, key: &str) -> bool {
        self.data.read().contains_key(key)
    }
}

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