using BaseOUDAL;
using System.Linq;
using YLErp.DBModels.Consts;
using YLErp.Model.Enum;
using YLErp.Modules.DataCacheModule;
using static YLErp.ConsGlobal;

namespace YLErp.Modules.BasicDataModule
{
    /// <summary>
    /// 簿记账户数据服务
    /// </summary>
    public class AssetUnitDataService : YLBaseService
    {
        public AssetUnitDataService(OptUserInfo userInfo) : base(userInfo)
        {
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="clientId"></param>
        /// <returns></returns>
        public IEnumerable<string> GetAssetNames(IEnumerable<int> assetIds)
        {
            if (assetIds == null || !assetIds.Any())
            {
                return Enumerable.Empty<string>();
            }
            return DataCacheManager.GetAssetUnitDataSource().AsQueryable().Where(n => assetIds.Contains(n.id)).Select(n => n.Name).ToArray();
        }

        public AssetUnit GetAssetUnit(int id)
        {
            return DataCacheManager.GetAssetUnitDataSource().AsQueryable().FirstOrDefault(n => n.id == id);
        }

        public int GetBookCategoryReferencedTradeCount(AssetUnit req)
        {
            if (req == null || req.id == 0)
            {
                return 0;
            }

            var currentBookCategory = DbContext.assetunit
                .Where(x => x.id == req.id)
                .Select(x => x.BookCategory)
                .FirstOrDefault();

            if (currentBookCategory == req.BookCategory)
            {
                return 0;
            }

            return DbContext.trade.Count(x => x.AssetId == req.id);
        }

        public AssetUnit SaveAssetUnit(AssetUnit req)
        {
            if (req is null)
            {
                throw new ArgumentNullException(nameof(req));
            }

            if (string.IsNullOrEmpty(req.Name))
            {
                throw new ServiceException("簿记账户名称 必须填写");
            }

            if (req.BookCategory != AssetUnit.BookCategoryAgency &&
                req.BookCategory != AssetUnit.BookCategorySecuritiesLending)
            {
                throw new ServiceException("簿记分类 必须填写");
            }

            AssetUnit dbModel;

            if (DbContext.assetunit.Any(x => x.id != req.id && x.Name == req.Name))
            {
                throw new ServiceException("簿记账户名称不能重复");
            }

            if (req.id == 0)
            {
                DbContext.assetunit.Add(dbModel = req);
            }
            else
            {
                dbModel = DbContext.assetunit.Find(req.id);

                if (dbModel == null)
                {
                    throw new ServiceException("要更新的数据已不存在");
                }
                if (string.Compare(dbModel.Name, req.Name) != 0)
                {
                    var assetBookNameList = DbContext.trade.Where(l => l.AssetId == dbModel.id).ToList();
                    assetBookNameList.ForEach(l => l.AssetBookName = req.Name);
                    DbContext.SaveChanges();
                }
                UpdateChanges(dbModel, req);
            }

            dbModel.TraderNames = string.Join(",", UserBLL.Where(u => dbModel.TraderIdsInt.Contains(u.Id)).Select(u => u.Name));

            SetDBModelOpt(dbModel);

            DbContext.SaveChanges();

            return dbModel;
        }

        /// <summary>
        /// 查询assetunit
        /// </summary>
        public SearchListResult<AssetUnitDto> SearchList(AssetUnitRequest req)
        {
            var predicate = PredicateBuilder.True<AssetUnit>();

            if (!string.IsNullOrEmpty(req.Name))
            {
                predicate = predicate.And(d => d.Name.Contains(req.Name));
            }

            if (!string.IsNullOrEmpty(req.UserGroup))
            {
                predicate = predicate.And(d => d.UserGroup.Contains(req.UserGroup));
            }

            if (req.TraderIds != null && req.TraderIds.Any(n => n > 0))
            {
                var traderIdPre = PredicateBuilder.False<AssetUnit>();

               
                    req.TraderIds.Where(p => p > 0).ToList().ForEach(p =>
                    {
                        var tradeIds = req.TraderIds.ToList().ConvertAll(t => t.ToString());
                        traderIdPre = traderIdPre.Or(d => (!string.IsNullOrEmpty(d.TraderIds) && (d.TraderIds.StartsWith(p + ",") || d.TraderIds.EndsWith("," + p) || d.TraderIds.Contains("," + p + ",") || tradeIds.Contains(d.TraderIds))));

                    });
                    predicate = predicate.And(traderIdPre);
                
                //if(req.TraderIds.Count() == 1)
                //{
                //    var tradeIds = req.TraderIds.ToList()[0].ToString();
                //    predicate = predicate.And(d => tradeIds == d.TraderIds);
                //}
                //predicate = predicate.And(d => req.TraderIds.Any(tId => ("," + d.TraderIds + ",").Contains("," + tId + ",")));
               
            }

            if (string.IsNullOrEmpty(req.sidx))
            {
                req.sidx = "id";
                req.sord = "desc";
            }
            
            var query = from a in DbContext.assetunit.Where(predicate)
                        join g in DbContext.assetunitgroup on a.GroupId equals g.id into g_t
                        from g in g_t.DefaultIfEmpty()
                        select new AssetUnitDto
                        {
                            id = a.id,
                            GroupId = a.GroupId,
                            BaseCurrency = a.BaseCurrency,
                            BookCategory = a.BookCategory,
                            InitialMoney = a.InitialMoney,
                            Name = a.Name,
                            OptDate = a.OptDate,
                            OptId = a.OptId,
                            OptName = a.OptName,
                            Remark = a.Remark,
                            TraderIds = a.TraderIds,
                            UserGroup = a.UserGroup,
                            GroupName = g.Name
                        };

            var result = query.ToSearchList(req);

            foreach (var item in result.rows)
            {
                var names = DataConvert.ConvertCommaValuesToInt32Array(item.TraderIds).Where(n => n > 0).Select(n => UserBLL.GetNameById(n));

                item.TraderNames = string.Join(",", names);

                item.UserGroup = ConsUserGroup.GetGroupDesc(item.UserGroup);
            }

            return result;
        }

        /// <summary>
        /// 查询assetunitgroup
        /// </summary>
        public SearchListResult<AssetUnitGroup> SearchAssetUnitGroupList(AssetUnitGroupRequest req)
        {
            var query = DbContext.assetunitgroup.AsNoTracking().AsQueryable();

            if (!string.IsNullOrEmpty(req.Name))
            {
                query = query.Where(d => d.Name.Contains(req.Name));
            }

            if (string.IsNullOrEmpty(req.sidx))
            {
                req.sidx = "id";
                req.sord = "desc";
            }

            return query.ToSearchList(req);
        }

        /// <summary>
        /// 保存簿记账户组
        /// </summary>
        public AssetUnitGroup SaveAssetUnitGroup(AssetUnitGroup req)
        {
            if (req is null)
            {
                throw new ArgumentNullException(nameof(req));
            }

            AssetUnitGroup dbModel;

            if (DbContext.assetunitgroup.Any(x => x.id != req.id && x.Name == req.Name))
            {
                throw new ServiceException("簿记账户组名称不能重复");
            }

            if (req.id == 0)
            {
                DbContext.assetunitgroup.Add(dbModel = req);
            }
            else
            {
                dbModel = DbContext.assetunitgroup.Find(req.id);

                if (dbModel == null)
                {
                    throw new ServiceException("要更新的数据已不存在");
                }

                UpdateChanges(dbModel, req);
            }

            UpdateChanges(dbModel, req);

            SetDBModelOpt(dbModel);

            DbContext.SaveChanges();

            return dbModel;
        }

        /// <summary>
        /// 
        /// </summary>
        public int RemoveAssetUnit(int id)
        {
            var r = DbContext.assetunit.Find(id);

            if (r == null)
            {
                throw new ServiceException("找不到资产单元");
            }

            if (DbContext.trade.Any(t => t.AssetId == r.id && t.ValidState != ConsGlobal.InValid) ||
                DbContext.ExchangeTrade.Any(t => t.AssetBookId == r.id))
            {
                throw new ServiceException("存在当前簿记账户的交易，不能删除!");
            }

            DbContext.assetunit.Remove(r);

            return DbContext.SaveChanges();
        }

        /// <summary>
        /// 
        /// </summary>
        public int RemoveAssetUnitGroup(int id)
        {
            var r = DbContext.assetunitgroup.Find(id);

            if (r == null)
            {
                throw new ServiceException("找不到该条记录");
            }

            if (DbContext.assetunit.Any(t => t.GroupId == r.id))
            {
                throw new ServiceException("存在该分组的簿记账户，不能删除!");
            }

            DbContext.assetunitgroup.Remove(r);

            return DbContext.SaveChanges();
        }

        public List<int> GetAssetUnitIds()
        {
            var assetUnits = DbContext.assetunit.AsQueryable().ToList();
            var assetUnitIds = new List<int>();
            using (var db = new ErpBaseContext())
            {
                if ((UserBLL.GetAccountPostEnum(OptUser.UserId) & (int)AccountPostEnum.交易员) > 0)
                {
                    if (assetUnits.Any())
                    {
                        assetUnits.ForEach(a =>
                        {
                            if (!string.IsNullOrEmpty(a.TraderIds))
                            {
                                var assetUnitTradeIds = a.TraderIds.Contains(",") ? a.TraderIds.Split(',').Select(b => Convert.ToInt32(b)) : new int[] { Convert.ToInt32(a.TraderIds) };
                                var systemUserIds = UserBLL.GetChildrenSystemUsers(OptUser.UserId, false).Select(c => c.Id).ToList();
                                if (systemUserIds.Intersect(assetUnitTradeIds).Any())
                                {
                                    assetUnitIds.Add(a.id);
                                }

                            }
                        });
                    }
                }
            }
            return assetUnitIds;
        }


        public Dictionary<int, AssetUnit> GetByIds(List<int> ids)
        {
            return DbContext.assetunit.AsNoTracking().Where(p => ids.Contains(p.id)).ToDictionary(p => p.id, v => v);
        }

        /// <summary>
        /// 获取簿记账户信息 根据 簿记Ids
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public Dictionary<int, AssetUnitDto> GetAssertByAssertIds(List<int> ids)
        {
            var query = from a in DbContext.assetunit.Where(p => ids.Contains(p.id))
                        join g in DbContext.assetunitgroup on a.GroupId equals g.id into g_t
                        from g in g_t.DefaultIfEmpty()
                        select new AssetUnitDto
                        {
                            id = a.id,
                            GroupId = a.GroupId,
                            BaseCurrency = a.BaseCurrency,
                            BookCategory = a.BookCategory,
                            InitialMoney = a.InitialMoney,
                            Name = a.Name,
                            OptDate = a.OptDate,
                            OptId = a.OptId,
                            OptName = a.OptName,
                            Remark = a.Remark,
                            TraderIds = a.TraderIds,
                            UserGroup = a.UserGroup,
                            GroupName = g.Name
                        };
            return query.ToDictionary(p => p.id, p => p);
        }
    }

    public class AssetUnitRequest : BaseSearchReq
    {
        public IEnumerable<int> TraderIds { get; set; }

        /// <summary>
        /// 资产单元名称
        /// </summary> 
        public string Name { get; set; }

        /// <summary>
        /// 所属业务组
        /// </summary> 
        public string UserGroup { get; set; }
    }

    public class AssetUnitGroupRequest : BaseSearchReq
    {
        /// <summary>
        /// 名称
        /// </summary> 
        public string Name { get; set; }
    }
}