using YLErp.DBModels.Consts;
using YLErp.Model.Enum;
using YLErp.Modules.ClientModule;
using YLErp.Modules.ClientModule.Models;
using YLErp.Modules.DataProviderModule;
using YLErp.Providers;

namespace YLErp.Web
{
    public partial class UserInfo : OptUserInfo
    {
        public string LoginName { get; private set; }

        public IEnumerable<Role> Roles { get; private set; }

        public IEnumerable<Department> Departments { get; private set; }

        private IEnumerable<int> Rights { get; set; }

        public string UserToken { get; private set; }

        public UserInfo()
        {
            Roles = Enumerable.Empty<Role>();
            Departments = Enumerable.Empty<Department>();
            Rights = Enumerable.Empty<int>();

            系统参数 = new 系统参数_(this);
            基础参数管理 = new 基础参数管理_(this);
            客户管理 = new 客户管理_(this);
            系统管理 = new 系统管理_(this);
        }

        /// <summary>
        /// 获取当前角色交易品种
        /// </summary>
        public IEnumerable<int> GetUserVarietyIds()
        {
            return TradeRightProvider.GetUserVarietyIds(UserId);
        }

        /// <summary>
        /// todo:需要抓紧时间重构
        /// </summary>
        public List<int> GetTradeIdsByCurUser()
        {
            var trades = DbContextFactory.GetYLDbContext().trade.Where(a => a.ValidState != ConsGlobal.InValid).AsQueryable();
            var AsstunitIds = new List<int>();
            var ClientIds = new List<int>();
            var tradeIds = new List<int>();
            if (交易管理_查看所有交易)
            {
                if (ConsUserGroup.HasGroup)
                {
                    var group = UserBLL.GetById(UserId).UserGroup;
                    if (!string.IsNullOrEmpty(group))
                    {
                        AsstunitIds = assetunitBLL.GetAllAssetUnitModel().Where(n => n.UserGroup == group).Select(a => a.id).ToList();
                        if (AsstunitIds.Any())
                        {
                            return trades.Where(a => AsstunitIds.Contains(a.AssetId)).Select(a => a.id).ToList();
                        }
                    }
                }
                return null;
            }
            AsstunitIds = assetunitBLL.GetAllAssetUnitModel().Where(a => a.TraderIdsInt.Contains(UserId)).Select(a => a.id).ToList();
            ClientIds = GetClientSelectItems().Select(a => Convert.ToInt32(a.Value)).ToList();

            if ((UserBLL.GetAccountPostEnum(UserId) & (int)AccountPostEnum.交易员) > 0)
            {
                tradeIds = trades.Where(a => AsstunitIds.Contains(a.AssetId)).Select(a => a.id).ToList();
            }
            else if ((UserBLL.GetAccountPostEnum(UserId) & (int)AccountPostEnum.客户经理) > 0)
            {
                tradeIds = trades.Where(a => ClientIds.Contains(a.ClientId)).Select(a => a.id).ToList();
            }
            else if ((UserBLL.GetAccountPostEnum(UserId) & (int)AccountPostEnum.交易员) > 0 && (UserBLL.GetAccountPostEnum(UserId) & (int)AccountPostEnum.客户经理) > 0)
            {
                tradeIds = trades.Where(a => AsstunitIds.Contains(a.AssetId) || ClientIds.Contains(a.ClientId)).Select(a => a.id).ToList();
            }
            else
            {
                tradeIds = new List<int>();
            }

            return tradeIds;
        }

        public List<int> GetAssetUnitIds()
        {
            return GetAssetunits(a => a.id).ToList();
        }

        /// <summary>
        /// 根据系统帐号查找所有对应簿记帐号
        /// </summary>
        public List<T> GetAssetunits<T>(Func<AssetUnit, T> converter)
        {
            if (converter is null)
            {
                throw new ArgumentNullException(nameof(converter));
            }

            if (交易管理_查看所有交易)
            {
                var query = DataCacheProvider.GetAssetUnitDataSource().AsQueryable();

                if (ConsUserGroup.HasGroup)
                {
                    var group = UserBLL.GetById(UserId).UserGroup;

                    if (!string.IsNullOrEmpty(group))
                    {
                        query = query.Where(n => n.UserGroup == group);
                    }
                }

                return query.Select(converter).ToList();
            }
            else if (!交易管理_查看所有交易 && (UserBLL.GetAccountPostEnum(UserId) & (int)AccountPostEnum.交易员) > 0)
            {
                return DataCacheProvider.GetAssetUnitDataSource().AsQueryable()
                    .Where(a => a.TraderIdsInt.Contains(UserId)).Select(converter).ToList();
            }
            else
            {
                return new List<T>();
            }
        }

        /// <summary>
        /// 这个方法返回空时,某些页面会认为没有权限,不应该查到数据,比如资金监控页面;
        /// </summary>
        /// <param name="IsAll">true 开户列表与客户列表在没有查看所有交易的情况下，以及也没有账号岗位设置为客户经理，则需要查看所有客户信息,false 返回空</param>
        /// <returns></returns>
        public List<int> GetClientIdsByCurUser(bool IsAll = false)
        {
            var clients = DbContextFactory.GetClientDbContext(this).client.AsNoTracking().Select(p => new ClientManagerDto { Id = p.id, CustomerManagerId = p.CustomerManagerId }).AsQueryable().ToList();
            if (IsAll)
            {
                return clients.Select(a => a.Id).ToList();
            }

            var clientCustomerManager = new ClientDataService(this).GetClientsByCustomerManager(clients, false);
            if (clientCustomerManager.Any())
            {
                return clientCustomerManager;
            }

            return new List<int>();
        }

        /// <summary>
        /// 有客户经理角色，则找到客户经理下面的客户
        /// 没有客户经理角色，则找到所有客户列表
        /// </summary>
        /// <returns></returns>
        public List<int> GetClientIdsByCustomerManager()
        {
            var clients = DbContextFactory.GetClientDbContext(this).client.AsQueryable().ToList();

            var clientCustomerManager = new ClientDataService(this).GetClientsByCustomerManager(clients, true);
            if (clientCustomerManager.Any())
            {
                return clientCustomerManager.Select(a => a.id).ToList();
            }
            return new List<int>();
        }

        /// <summary>
        /// 客户列表
        /// </summary>
        /// <param name="IsAll"> true 开户列表与客户列表在没有查看所有交易的情况下，以及也没有账号岗位设置为客户经理，则需要查看所有客户信息,false 为 空</param>
        /// <returns></returns>
        public List<SelectItem> GetClientSelectItems(bool IsAll = false)
        {
            var clients = DataCacheProvider.GetClientDataSource().AsQueryable()
            .Where(s => s.ProcessStatus == "已开户" || s.ProcessStatus == "已休眠" || s.ProcessStatus == "已销户").ToList();
            if (IsAll)
            {
                return clients.Select(m => new SelectItem
                {
                    Text = m.Name,
                    Value = m.id.ToString()
                }).ToList();
            }
            else
            {
                var clientCustomerManager = new ClientDataService(this).GetClientsByCustomerManager(clients, true);
                if (clientCustomerManager.Any())
                {
                    return clientCustomerManager.Select(m => new SelectItem
                    {
                        Text = m.Name,
                        Value = m.id.ToString()
                    }).ToList();
                }
                return new List<SelectItem>();
            }
        }

        public void CheckClientPowerByClientId(int clientId)
        {
            if (clientId == 0)
            {
                throw new ServiceException("请选择客户后再查询");
            }

            var curUserClientIds = GetClientIdsByCustomerManager();
            if (!curUserClientIds.Any(a => a == clientId))
            {
                throw new ServiceException("当前账户没有权限查询此客户信息");
            }
        }


        public static List<SystemUser> GetUsersByRoleName(string rolename)
        {
            if (string.IsNullOrEmpty(rolename))
            {
                return new List<SystemUser>();
            }

            var cacheKey = string.Format("GetUsersByRoleName_{0}", rolename);
            var users = MemoryCacheProvider.Default.Get<List<SystemUser>>(cacheKey);
            if (users != null)
            {
                return users;
            }

            using (var cdb = new ErpBaseContext())
            {
                var userList = (from roleuser in cdb.RoleUsers
                                join role in cdb.Roles on roleuser.RoleId equals role.Id
                                join user in cdb.SystemUsers on roleuser.UserId equals user.Id
                                where role.Name.Contains(rolename) && user.State != 1
                                select new { roleId = role.Id, user }).Distinct().ToList();
                users = userList.Where(u => UserBLL.HasRightForVariety(u.roleId)).Select(u => u.user).ToList();
                MemoryCacheProvider.Default.Set(cacheKey, users, DateTime.Now.AddSeconds(5.0));
                return users;
            }
        }

        public bool HasRight(string right)
        {
            return FunctionHelper.TryGetFunctionId(right, out var functionId) && Rights.Contains(functionId);
        }

        public static UserInfo FromDbUser(SystemUser systemuser)
        {
            var user = new UserInfo();
            if (systemuser == null)
            {
                user.UserId = 0;
                user.UserName = "找不到用户资料";
                user.Roles = new List<Role>();
                user.Departments = new List<Department>();
                user.Rights = new int[0];
            }
            else
            {
                user.UserGroup = ConsUserGroup.HasGroup ? systemuser.UserGroup : string.Empty;
                user.LoginName = systemuser.LoginName;
                user.UserToken = systemuser.UserToken;
                user.UserId = systemuser.Id;
                user.UserName = systemuser.Name;
                user.OaAccount = systemuser.OaAccount;
                using (var db = new ErpBaseContext())
                {
                    user.Roles = (from o in db.RoleUsers
                                  join p in db.Roles.AsNoTracking() on o.RoleId equals p.Id
                                  where o.UserId == user.UserId
                                  select p).ToList().AsReadOnly();

                    user.Departments = (from o in db.DepartmentUsers
                                        join p in db.Departments.AsNoTracking() on o.DepartmentId equals p.Id
                                        where o.UserId == user.UserId
                                        select p).ToList().AsReadOnly();

                    if (user.Roles.Any(n => n.Name == "权限管理员"))
                    {
                        var rightStrs = new string[] { "部门管理", "系统管理", "角色管理", "角色新增", "角色修改", "用户管理", "用户新增", "用户修改", "用户禁用", "基础缓存" };
                        var query1 = db.Functions.Where(o => rightStrs.Contains(o.Name)).Select(n => n.Id);
                        var query2 = from roleFunc in db.RoleFunctions
                                     join roleUsr in db.RoleUsers on roleFunc.RoleId equals roleUsr.RoleId
                                     where roleUsr.UserId == user.UserId
                                     select roleFunc.FunctionId;
                        user.Rights = query1.Union(query2).ToList().AsReadOnly();
                    }
                    else
                    {
                        user.Rights = (from roleFunc in db.RoleFunctions
                                       join roleUsr in db.RoleUsers on roleFunc.RoleId equals roleUsr.RoleId
                                       where roleUsr.UserId == user.UserId
                                       select roleFunc.FunctionId).ToList().AsReadOnly();
                    }
                }
            }
            return user;
        }
    }
}