using System;
using System.Collections.Generic;
using System.Text;
using NOVA.DevFx.Security.Model;
using NOVA.DevFx.Cache;
using System.Collections;
using NOVA.DevFx.OnlineManagement;

namespace NOVA.DevFx.Security.Handler
{
    /// <summary>
    /// 系统用户数据处理类
    /// </summary>
    public class UserHandler
    {
        private static string m_CachePrefix = "cache";
        private static string m_UserCacheName = "user";
        private static string m_PermissionCacheName = "permission";

        private static string m_userCacher = "userCacher";

        /// <summary>
        /// 获取用户缓存器名称
        /// </summary>
        public static string UserCacherName
        {
            get { return m_userCacher; }
        }

        /// <summary>
        /// 系统用户信息缓存器
        /// </summary>
        public static ICache UserCacher
        {
            get
            {
                ICache cacher = CacheHelper.GetCache(m_userCacher);
                if (cacher == null)
                    return CacheHelper.CreateCache(m_userCacher);
                else
                    return cacher;
            }
            
        }

        #region 用户资料
        /// <summary>
        /// 根据用户ID获取用户资料(从缓存中获取)
        /// </summary>
        /// <param name="UserID">用户ID</param>
        /// <returns></returns>
        public static User GetUser(int UserID)
        {
            string CacheKey = string.Format("{0}-{1}-{2}", m_CachePrefix,m_UserCacheName, UserID);

            if (UserCacher[CacheKey] != null)
            {
                return (User)UserCacher[CacheKey];
            }
            else
            {
                //根据用户编码获取实体信息
                User sUT = DataHandler.UserHandler.GetItem(UserID);
                //添加用户信息到缓存中
                UserCacher.Add(CacheKey, sUT);
                return sUT;
            }
        }

        /// <summary>
        /// 根据用户登陆名,获取用户资料
        /// </summary>
        /// <param name="u_Name">用户名</param>
        /// <returns>用户实体类</returns>
        public static User GetUser(string u_Name)
        {
            return DataHandler.UserHandler.GetItemByName(u_Name);
        }

        /// <summary>
        /// 根据用户ID移除用户资料Cache
        /// </summary>
        /// <param name="UserID"></param>
        public static void RemoveUserCache(int UserID)
        {
            UserCacher.Remove(string.Format("{0}-{1}-{2}", m_CachePrefix, m_UserCacheName, UserID));
        }

        #endregion

        #region 用户权限
        /// <summary>
        /// 根据用户ID,模块ID判断用户是否拥有指定模块权限
        /// </summary>
        /// <param name="UserID">用户ID</param>
        /// <param name="ModuleId">应用ID</param>
        /// <returns></returns>
        public static bool CheckPermission(int UserID, int ModuleId)
        {
            bool bBool = false;
            //获取用户权限
            Hashtable UserPermission = GetUserPermission(UserID);
            if (UserPermission.Count > 0)
            {
                //判断当前用户是否有当前模块权限
                if (UserPermission.ContainsKey(ModuleId))
                {
                    bBool = true;
                }
            }
            return bBool;
        }

        /// <summary>
        /// 根据用户ID,模块ID,要检测权限数值
        /// </summary>
        /// <param name="UserID">用户ID</param>
        /// <param name="P_ApplicationID">应用ID</param>
        /// <param name="P_PageCode">PageCode</param>
        /// <param name="CheckPermissionValue">权限值</param>
        /// <returns></returns>
        public static bool CheckPermission(int UserID, int ModuleId, int PermissionId)
        { 
            bool bBool = false;
            //获取用户权限列表
            Hashtable UserPermission = GetUserPermission(UserID);
            if (UserPermission.Count > 0)
            {
                string Key = string.Format("{0}-{1}", ModuleId, PermissionId);
                if (UserPermission.ContainsKey(Key))
                {
                    bBool = true;
                }
            }
            return bBool;
        }

        /// <summary>
        /// 获取用户权限Hashtable
        /// </summary>
        /// <param name="UserID">用户ID</param>
        /// <returns></returns>
        private static Hashtable GetUserPermission(int UserID)
        {
            string Key = string.Format("{1}-{2}-{0}", UserID, m_CachePrefix, m_PermissionCacheName);
            if (UserCacher[Key] != null)
            {
                return (Hashtable)UserCacher[Key];
            }
            else
            {
                //从数据库中加载用户的所有权限信息
                Hashtable _Temp = GetUserPermissionFromDataBase(UserID);
                //添加权限信息到缓存中
                UserCacher.Add(Key, _Temp);
                return _Temp;
            }
        }

        /// <summary>
        /// 移除用户权限Cache
        /// </summary>
        /// <param name="UserID">用户ID</param>
        public static void RemoveUserPermissionCache(int UserID)
        {
            UserCacher.Remove(string.Format("{1}-{2}-{0}", UserID, m_CachePrefix, m_PermissionCacheName));
        }

        /// <summary>
        /// 移除某个角色的用户权限Cache
        /// </summary>
        /// <param name="RoleID"></param>
        public static void RemoveRolePermissionCache(int RoleID)
        {
            //获取属于该角色的所有用户列表
            List<User> lst = DataHandler.UserHandler.GetUserListByRoleID(RoleID);

            //循环移除所有用户的权限缓存
            foreach (User var in lst)
            {
                RemoveUserPermissionCache(var.id);
            }
        }

        /// <summary>
        /// 根据用户ID,获取用户模块权限列表
        /// </summary>
        /// <param name="UserID">用户ID</param>
        /// <returns></returns>
        private static Hashtable GetUserPermissionFromDataBase(int UserID)
        {
            Hashtable hsPermissionListCache = new Hashtable();
            List<Role_In_Permission> lsRolePermission = new List<Role_In_Permission>();

            //获取指定用户所拥有的所有角色
            List<User_In_Role> lst = DataHandler.UserRoleHandler.GetRoleListByUserID(UserID);
            foreach (User_In_Role var in lst)
            {
                //获取每个角色的权限
                lsRolePermission = GetRolesPermission(var.role_id);

                //循环添加所有用户权限
                for (int i = 0; i < lsRolePermission.Count; i++)
                {
                    string Key = string.Format("{0}-{1}", lsRolePermission[i].module_id, lsRolePermission[i].permission_id);
                    if (!hsPermissionListCache.ContainsKey(Key))
                    {
                        hsPermissionListCache.Add(Key, lsRolePermission[i]);
                    }
                }
            }

            return hsPermissionListCache;
        }

        /// <summary>
        /// 根据用户角色ID,获取权限列表
        /// </summary>
        /// <param name="RoleID">角色ID</param>
        /// <param name="List">权限列表</param>
        private static List<Role_In_Permission> GetRolesPermission(int RoleID)
        {
            List<Role_In_Permission> lst = DataHandler.RolePermissionHandler.GetPermissionListByRoleID(RoleID);
            return lst;
        }
        #endregion

        ///// <summary>
        ///// 获取当前登陆用户信息
        ///// </summary>
        //public static User CurrentUser
        //{
        //    get
        //    {
        //        return GetUser(Authenticator.UserID);
        //    }
        //}

    }
}