MTP2.0_CSharp/Muchinfo.MTPClient/Fx4.0/Main/04.Infrastructure/Muchinfo.TASClient.Infrastructure/Cache/CacheManager.cs

//----------------------------------------------------------------
//Module Name:  CacheManager
//Purpose:      
//CopyRight:    Muchinfo
//History:
//----------------------------------------------------------------
//DateTime		Author		    Description
//----------------------------------------------------------------
//2014-03-19    deng.yinping       Create
//----------------------------------------------------------------


using Muchinfo.MTPClient.Data.Enums;
using Muchinfo.MTPClient.Data.Model.GoodRules;
using Muchinfo.MTPClient.Data.Model.Sale;
using Muchinfo.MTPClient.Data.Quote;
using Muchinfo.PC.Common.Bosn;
using Muchinfo.MTPClient.Data.Model;
using Muchinfo.MTPClient.Data.Model.News;
using Muchinfo.MTPClient.Infrastructure.Comparers;
using Muchinfo.MTPClient.Infrastructure.Enums;
using Muchinfo.MTPClient.Infrastructure.Utilities;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using Muchinfo.MTPClient.Data.Model.Account;
using Muchinfo.MTPClient.Data.Model;
using Muchinfo.MTPClient.Data.Model.DBTableMsg;
using Muchinfo.MTPClient.Data.Model.Delivery;

namespace Muchinfo.MTPClient.Infrastructure.Cache
{
    public delegate void DataDownloadingEventHandler(int process);

    public static class CacheManager
    {
        #region Fields

        private static DateTime _startTime;
        private static Dictionary<CacheType, CacheObject> _caches = new Dictionary<CacheType, CacheObject>();
        private static AutoResetEvent _autoResetEvent = new AutoResetEvent(false);
        private static Dictionary<long, List<SaleGoods>> _saleGoodses = new Dictionary<long, List<SaleGoods>>();

      
        private static Dictionary<long, List<QuoteTradeTime>> _goodsTradeTimes = new Dictionary<long, List<QuoteTradeTime>>();   ///商品开收市时间
        private static Dictionary<ulong, List<TradePositionModel>> _holdingSummaries = new Dictionary<ulong, List<TradePositionModel>>();    ///当前资金帐号的持仓汇总信息
        private static Dictionary<long, QuoteTradePlan> _tradeDayPlan = new Dictionary<long, QuoteTradePlan>();   ///日结算计划     

        #endregion Fields

        #region Methods

        #region Public Static Methods

        #region 挂牌点选缓存属性
        private static eTradeProperty _tradeProperty_Listing;
        /// <summary>
        /// 当前商品交易属性
        /// </summary>
        public static eTradeProperty TradeProperty_Listing
        {
            get { return _tradeProperty_Listing; }
            set { _tradeProperty_Listing = value; }
        }
        

        private static bool _isHasListingData =false;
        /// <summary>
        /// 当前买卖方向是否有委托数据
        /// </summary>
        public static bool IsHasListingData
        {
            get { return _isHasListingData; }
            set { _isHasListingData = value; }
        }


        private static decimal _orderLot_Listing;
        /// <summary>
        /// 挂牌点选-选择商品-》委托数量
        /// </summary>
        public static decimal OrderLot_Listing
        {
            get { return _orderLot_Listing; }
            set { _orderLot_Listing = value; }
        }



        private static long _orderId_Listing =0;
        /// <summary>
        /// 挂牌点选-选择商品-》委托单号
        /// </summary>
        public static long OrderId_Listing
        {
            get { return _orderId_Listing; }
            set { _orderId_Listing = value; }
        }

        private static Direction _buyOrSell_Listing = Direction.Bid;
        /// <summary>
        /// //挂牌点选-选择商品-》买卖方向
        /// </summary>
        public static Direction BuyOrSell_Listing
        {
            get { return _buyOrSell_Listing; }
            set { _buyOrSell_Listing = value; }
        }

        private static decimal _orderPrice_Listing =Decimal.Zero;
        /// <summary>
        /// //挂牌点选-选择商品-》委托单号
        /// </summary>
        public static decimal OrderPrice_Listing
        {
            get { return _orderPrice_Listing; }
            set { _orderPrice_Listing = value; }
        }

        private static eOrderFormType _fromType = eOrderFormType.Commom;
        /// <summary>
        /// 一般下单/挂牌下单
        /// </summary>
        public static eOrderFormType FromType
        {
            get { return _fromType; }
            set { _fromType = value; }
        }

        /// <summary>
        /// 重置挂牌下单属性
        /// </summary>
        public static void ResetListingDefaultData()
        {
            OrderId_Listing = 0;
            BuyOrSell_Listing = Direction.Bid;
            OrderPrice_Listing = Decimal.Zero;
            FromType = eOrderFormType.Commom;
        }
        #endregion

        #region  本地缓存数据属性
        /// <summary>
        /// 平仓使用资金账号ID
        /// </summary>
        public static ulong FundsAccountId { get; set; }

        /// <summary>
        ///缓存登陆后可用的市场列表 MTP2.0
        /// </summary>
        public static List<uint> CacheAvailableMarketList { get; set; }

        public static List<DeliveryGoodsInfoModel> CacheDeliveryGoodsInfo { get; set; }
        /// <summary>
        ///缓存最后更新时间戳 MTP2.0
        /// </summary>
        public static List<LastUpdateTimeKeyValueModel> CacheLastUpdateTimeList { get; set; }
        /// <summary>
        /// 缓存资金账户列表信息
        /// </summary>
        public static List<TAAccountAllModel> CacheTAAcountList { get; set; }
        /// <summary>
        /// 缓存商品个性化列表信息
        /// </summary>
        public static List<TradeGoodsFeeRule> CacheGoodsRuleAndFeeList { get; set; }

        /// <summary>
        /// 缓存实物持仓列表【全额持仓】 MTP2.0
        /// </summary>
        public static List<HoldingOrder> CacheRealGoodsPositionList { get; set; }

        /// <summary>
        /// 缓存持仓头寸列表【保证金持仓】 MTP2.0
        /// </summary>
        public static List<HoldingOrder> CacheGoodsPositionList { get; set; }
        /// <summary>
        /// 缓存买/卖可用持仓头寸数量 MTP2.0
        /// </summary>
        /// <returns></returns>
        public static uint GetGoodsPositionAvailableQty(Direction dir, uint goodsId, eTradeProperty TradeProperty)
        {
            switch (TradeProperty)
            {
                case eTradeProperty.TRADEPROPERTY_NOSHORT://全额：
                    if (CacheRealGoodsPositionList != null)
                    {
                        return CacheRealGoodsPositionList.Where(x => x.GoodsId == goodsId).Select(x => x.HolderQty - x.FreezeQty-x.limitCount).FirstOrDefault();
                    }
                    return 0;
                default://保证金[查询相反方向的持仓数量]
                    if (CacheGoodsPositionList != null && dir == Direction.Bid)
                    {
                        return CacheGoodsPositionList.Where(x => x.GoodsId == goodsId).Select(x => x.BuyCurPositionQty - x.BuyFrozenQty - x.BuyOtherFrozenQty).FirstOrDefault();
                    }
                    else if (CacheGoodsPositionList != null && dir == Direction.Ask)
                    {
                        return CacheGoodsPositionList.Where(x => x.GoodsId == goodsId).Select(x => x.SellCurPositionQty - x.SellFrozenQty - x.SellOtherFrozenQty).FirstOrDefault();
                    }
                    return 0;
            }
            
        }

        /// <summary>
        /// 获取缓存持仓全额、保证金列表 MTP2.0
        /// </summary>
        /// <returns></returns>
        public static List<HoldingOrder> GetGoodsPositionList(Direction buyOrSell, uint goodsId, eTradeMode tradeMode)
        {
            return CacheGoodsPositionList.Where(x => x.GoodsId == goodsId).ToList();

            //switch (tradeMode)
            //{
            //    case eTradeMode.Full_Transfer://全额：
            //        if (CacheRealGoodsPositionList != null)
            //        {
            //            return CacheRealGoodsPositionList.Where(x => x.GoodsId == goodsId).ToList();
            //        }
            //        return null;
            //    default://保证金
            //        if (CacheGoodsPositionList != null)
            //        {
            //            return CacheGoodsPositionList.Where(x => x.GoodsId == goodsId).ToList();
            //        }
            //        return null;
            //}
        }

        /// <summary>
        /// 获取缓存持仓全额、保证金列表 MTP2.0
        /// </summary>
        /// <returns></returns>
        public static TradePositionModel GetHoldingSummary(uint goodsId, string currentFundId)
        {
            return HoldingSummaries[UInt64.Parse(currentFundId)].Where(x => x.GoodsId == goodsId).FirstOrDefault();
        }

        ///缓存最大通知id MTP2.0
        public static long CacheServerLastNoticeId { get; set; }
        public static List<Exchange> CacheExchanges
        {
            get
            {
                var emptyResult = new List<Exchange>();
                if (!_caches.ContainsKey(CacheType.Exchange) || _caches[CacheType.Exchange].CacheList == null) return emptyResult;
                var result = _caches[CacheType.Exchange].CacheList.OfType<Exchange>().Where(z => z != null).Distinct(new ExchangeDataModelComparer());
                return result.ToList();
            }
        }

        public static List<GoodsGroup> CacheGoodsGroups
        {
            get
            {
                var emptyResult = new List<GoodsGroup>();
                if (!_caches.ContainsKey(CacheType.GoodsGroup) || _caches[CacheType.GoodsGroup].CacheList == null) return emptyResult;
                var result = _caches[CacheType.GoodsGroup].CacheList.OfType<GoodsGroup>().Where(z => z != null);
                return result.ToList();
            }
        }
        /// <summary>
        /// 缓存市场组MTP2.0
        /// </summary>
        public static List<MarketsInfoModel> CacheMarketsGroups
        {
            get
            {
                var emptyResult = new List<MarketsInfoModel>();
                if (!_caches.ContainsKey(CacheType.MarketGroup) || _caches[CacheType.MarketGroup].CacheList == null) return emptyResult;
                var result = _caches[CacheType.MarketGroup].CacheList.OfType<MarketsInfoModel>().Where(z => z != null);
                return result.ToList();
            }
        }
        /// <summary>
        /// 缓存商品信息MTP2.0
        /// </summary>
        public static List<QuoteGoods> CacheGoodsBaseInfos
        {
            get
            {
                var emptyResult = new List<QuoteGoods>();
                if (!_caches.ContainsKey(CacheType.GoodsBaseInfo) || _caches[CacheType.GoodsBaseInfo].CacheList == null) return emptyResult;
                //var result = _caches[CacheType.GoodsBaseInfo].CacheList.OfType<Goods>().Where(z => z != null && z.IsValid);
                var result = _caches[CacheType.GoodsBaseInfo].CacheList.OfType<QuoteGoods>().Where(z => z != null);

                return result.ToList();
            }
        }

        /// <summary>
        /// 商品开收市时间
        /// </summary>
        public static Dictionary<long, List<QuoteTradeTime>> GoodsTradeTimes
        {
            get
            {
                return _goodsTradeTimes;
            }
        }

        /// <summary>
        /// 日结算计划
        /// </summary>
        public static Dictionary<long, QuoteTradePlan> TradeDayPlan
        {
            get
            {
                return _tradeDayPlan;
            }
        }
        /// <summary>
        /// 资金账户对应的持仓信息-MTP2.0无用
        /// </summary>
        public static Dictionary<ulong, List<TradePositionModel>> HoldingSummaries
        {
            get
            {
                return _holdingSummaries;
            }
        }

        /// <summary>
        ///  发售商品组，商品
        /// </summary>
        public static Dictionary<long, List<SaleGoods>> SaleGoodses
        {
            get { return _saleGoodses; }
             
        }

        public static List<NewsCategory> CacheNewsCategory
        {
            get
            {
                var emptyResult = new List<NewsCategory>();
                if (!_caches.ContainsKey(CacheType.NewsCategory) || _caches[CacheType.NewsCategory].CacheList == null) return emptyResult;
                var result = _caches[CacheType.NewsCategory].CacheList.OfType<NewsCategory>().Where(z => z != null);
                return result.ToList();
            }
        }


        private static Dictionary<int, TradeGoodsFeeRule> _tradeGoodsFeeRules=new Dictionary<int, TradeGoodsFeeRule>();
 
        /// <summary>
        /// /交易商品的费用计算方式，与交易规则
        /// </summary>
        public static Dictionary<int, TradeGoodsFeeRule> TradeGoodsFeeRules
        {
            get
            {
                return _tradeGoodsFeeRules;
            }
             set
            {
                _tradeGoodsFeeRules = value;
            }
        }


        private static Dictionary<int, int> _marketStatus = new Dictionary<int, int>();

        /// <summary>
        /// 保存市场类型状态
        /// </summary>
        public static Dictionary<int, int> MarketStatus
        {   
            get
            {
                return _marketStatus;
            }
            set
            {
                _marketStatus = value;
            }
        }

        private static List<MarketRunModelNew> _marketRunsNew = new List<MarketRunModelNew>();

        /// <summary>
        /// 缓存市场状态
        /// </summary>
        /// <value>The market runs.</value>
        public static List<MarketRunModelNew> MarketRuns
        {
            get
            {
                return _marketRunsNew;
            }
            set
            {
                _marketRunsNew = value;
            }
        }

        #region 获取服务交易日

        /// <summary>
        /// 获取服务运行状态
        /// </summary>
        /// <param name="marketid">The marketid.</param>
        /// <returns>MarketRunModelNew.</returns>
        public static MarketRunModelNew GetMarketRunById(int marketid)
        {
            if (MarketRuns == null || !MarketRuns.Any()) return null;
            var model = MarketRuns.FirstOrDefault(z => z.MarketId == marketid);
            return model;
        }

        /// <summary>
        /// 更新服务运行状态
        /// </summary>
        /// <param name="models">The models.</param>
        public static void UpdateMarketRun(List<MarketRunModelNew> models)
        {
            if (models == null || !models.Any()) return;
            foreach (var model in models)
            {
                var item = GetMarketRunById(model.MarketId);
                if (item != null)MarketRuns.Remove(item);
                MarketRuns.Add(model);
            }
        }

        #endregion

        #region 交易商品的合约单位缓存
        private static List<GoodsUnit> _tradeGoodsUnit = new List<GoodsUnit>();

        /// <summary>
        /// 交易商品的合约单位
        /// </summary>
        public static List<GoodsUnit> TradeGoodsUnit
        {
            get
            {
                return _tradeGoodsUnit;
            }
            set
            {
                _tradeGoodsUnit = value;
            }
        } 
        #endregion


        #region p+x交割商品信息LIST缓存
        private static List<RelationPAndXGoodsInfoModel> _allDeliveryRelationList = new List<RelationPAndXGoodsInfoModel>();

        /// <summary>
        /// p+x交割商品信息LIST缓存
        /// </summary>
        public static List<RelationPAndXGoodsInfoModel> AllDeliveryRelationList
        {
            get
            {
                return _allDeliveryRelationList;
            }
            set
            {
                _allDeliveryRelationList = value;
            }
        }
        #endregion
        /// <summary>
        /// 获取指定的更新时间戳
        /// </summary>
        /// <returns></returns>
        public static ulong GetLastUpdateTimeBy(LastUpdateTimeType currentType)
        {
            ulong defalutValue = 0;
            if (CacheLastUpdateTimeList != null && CacheLastUpdateTimeList.Any())
            {
                string currentValue =CacheLastUpdateTimeList.Where(x => x.TimeKey == currentType).Select(x => x.TimeValue).FirstOrDefault();
                UInt64.TryParse(currentValue,out defalutValue);
            }
            return defalutValue;
        }

        /// <summary>
        ///获取交易规则，优先使用个人的,可能返回空
        /// </summary>
        /// <param name="goodId"></param>
        /// <param name="ruleId"></param>
        /// <returns></returns>
        public static GoodsFeeType  GetTradeRule(int goodId, int ruleId)
        {
            GoodsFeeType resultRule = null;
            if (TradeGoodsFeeRules!=null&&TradeGoodsFeeRules.ContainsKey(goodId))
            {
                if (TradeGoodsFeeRules[goodId].AccountGoodsRules.ContainsKey(ruleId))
                {
                    resultRule= TradeGoodsFeeRules[goodId].AccountGoodsRules[ruleId];
                }
                else if (TradeGoodsFeeRules[goodId].GoodsRules.ContainsKey(ruleId))
                {
                    resultRule = TradeGoodsFeeRules[goodId].GoodsRules[ruleId];
                }
            }
            return resultRule;
        }

        
        /// <summary>
        /// 获取商品费用信息
        /// </summary>
        /// <param name="goodsId">商品ID</param>
        /// <param name="feeId">费用类型</param>
        /// <param name="isGoods">是否商品的</param>
        /// <returns></returns>
        public static GoodsFeeType GetGoodsTradeFeeType(int goodsId, int feeId, bool isGoods = true)
        {
            GoodsFeeType feeRule = null;
            if (TradeGoodsFeeRules != null && TradeGoodsFeeRules.ContainsKey(goodsId))
            {
                if (isGoods)
                {
                    if (TradeGoodsFeeRules[goodsId].GoodsFees.ContainsKey(feeId))
                    {
                        feeRule = TradeGoodsFeeRules[goodsId].GoodsFees[feeId];
                    } 
                }
                else
                {
                    if (TradeGoodsFeeRules[goodsId].AccountGoodsFees.ContainsKey(feeId))
                    {
                        feeRule = TradeGoodsFeeRules[goodsId].AccountGoodsFees[feeId];
                    } 
                }
            }
            return feeRule;
        }

        #endregion

        ///// <summary>
        ///// 开多任务 加载交易信息
        ///// </summary>
        //public static void LoadBaseInfo()
        //{
        //    TaskSuppleTable();
        //    Task.Factory.TryStartNew(GetExchangeListAndMerage, () => { });
        //    Task.Factory.TryStartNew(GetMarketDetailListAndMerage, () => { });
        //}
        /// <summary>
        /// 缓存登陆后基本信息MTP2.0
        /// </summary>
        /// <param name="accountInfoEntity"></param>
        public static void LoadLoginBaseInfo(AccountBaseInfoModel accountInfoEntity)
        {
            if (null != accountInfoEntity && accountInfoEntity.ServerLastNoticeId !=0)   ////最后更新时间列表
            {
                //登录取到的ID为最后的ID,注释此代码-dyp
                //CacheServerLastNoticeId = accountInfoEntity.ServerLastNoticeId;
            }
            if (null != accountInfoEntity && accountInfoEntity.LastUpdateTimeList.Any() && accountInfoEntity.LastUpdateTimeList.Count > 0)   ////最后更新时间列表
            {
                CacheLastUpdateTimeList = accountInfoEntity.LastUpdateTimeList;
            }

            if (null != accountInfoEntity && accountInfoEntity.TAAccountList.Any() && accountInfoEntity.TAAccountList.Count > 0)   ////用户资金账户列表信息
            {
                CacheTAAcountList = accountInfoEntity.TAAccountList;
                if (CacheAvailableMarketList == null)
                    CacheAvailableMarketList = new List<uint>();
                else
                    CacheAvailableMarketList.Clear();
                HoldingSummaries.Clear();
                foreach (var account in accountInfoEntity.TAAccountList)
                {
                    HoldingSummaries.Add(account.FundsAccounts.AccountId, account.GoodsPositionList);
                    CacheAvailableMarketList.AddRange(account.MarketsIdList);
                }
                CacheAvailableMarketList = CacheAvailableMarketList.Distinct().ToList();
            }
            if (null != accountInfoEntity && accountInfoEntity.GoodsRuleAndFeeList.Any() && accountInfoEntity.GoodsRuleAndFeeList.Count > 0)
            {
                CacheGoodsRuleAndFeeList = accountInfoEntity.GoodsRuleAndFeeList;
            }
        }

        /// <summary>
        /// 缓存市场信息MTP2.0
        /// </summary>
        /// <param name="accountInfoEntity"></param>
        public static void LoadMarketInfoList(List<MarketsInfoModel> marketsEntity)
        {
            TaskSuppleTable();
            if (null != marketsEntity && marketsEntity.Any())   ////市场信息
            {
                marketsEntity = UpdateMarketsGroup(marketsEntity, GoodsFromScr.Trade);  ////更新市场组
                var lastModifyTime = ApplicationParameter.BasicDateTime;
                UpdateTable(CacheType.MarketGroup, lastModifyTime, marketsEntity.ToArray());
            }
        }

        /// <summary>
        /// 缓存商品GOODS信息MTP2.0
        /// </summary>
        /// <param name="accountInfoEntity"></param>
        public static void LoadGoodsInfoList(List<QuoteGoods> goodsEntity, GoodsFromScr goodsScr)
        {
            TaskSuppleTable();
            if (null != goodsEntity && goodsEntity.Any() && CacheAvailableMarketList != null)  ////交易商品
            {
                //商品市场权限过滤，MTP2.0NEW
                var result = goodsEntity.Distinct(new QuoteGoodsComparer()).Where(x => CacheAvailableMarketList.Contains(x.MarketID)).ToList();
                result = UpdateGoods(result, goodsScr);  ////设置商品来源
                var lastModifyTime = ApplicationParameter.BasicDateTime;
                UpdateTable(CacheType.GoodsBaseInfo, lastModifyTime, result.ToArray());
            }
        }

        /// <summary>
        /// 商品、市场，交易所信息缓存
        /// </summary>
        /// <param name="accountInfoEntity">用户有权限的交易信息</param>
        public static void LoadGoodsBaseInfo(AccountInfoEntity accountInfoEntity)
        {
            LoadGoodsBaseInfo(accountInfoEntity.QuoteGoodses, accountInfoEntity.GoodsGroups, GoodsFromScr.Trade);
        }        

        public static void LoadExchangeInfo(List<Exchange> Exchanges)
        {
            if (null != Exchanges && Exchanges.Any())   ////交易所信息
            {
                var lastModifyTime = ApplicationParameter.BasicDateTime;// allExchanges.Max(z => z.LastModifiedTime);
                UpdateTable(CacheType.Exchange, lastModifyTime, Exchanges.ToArray());
            }
        }

        /// <summary>
        /// 缓存商品组
        /// </summary>
        /// <param name="goodsGroupsEntity"></param>
        public static void LoadGoodsGroupList(List<GoodsGroup> goodsGroupsEntity)
        {
            TaskSuppleTable();
            if (null != goodsGroupsEntity && goodsGroupsEntity.Any())   ////市场信息
            {
                var newEntity = UpdateGoodsGroup(goodsGroupsEntity, GoodsFromScr.Trade);  ////更新市场组
                var lastModifyTime = ApplicationParameter.BasicDateTime;
                UpdateTable(CacheType.GoodsGroup, lastModifyTime, newEntity.ToArray());
            }
        }

        /// <summary>
        /// 商品、市场，交易所信息缓存
        /// </summary>
        public static void LoadGoodsBaseInfo(List<QuoteGoods> goodses, List<GoodsGroup> goodsGroups,  GoodsFromScr goodsScr)
        {
            TaskSuppleTable();
            //if (null != Exchanges && Exchanges.Any())   ////交易所信息
            //{
            //    var lastModifyTime = ApplicationParameter.BasicDateTime;// allExchanges.Max(z => z.LastModifiedTime);
            //    UpdateTable(CacheType.Exchange, lastModifyTime, Exchanges.ToArray());
            //}

            if (null != goodsGroups && goodsGroups.Any())   ////市场信息
            {
                goodsGroups = UpdateGoodsGroup(goodsGroups, goodsScr);  ////更新商品组
                var lastModifyTime = ApplicationParameter.BasicDateTime;//allExchanges.Max(z => z.LastModifiedTime);
                UpdateTable(CacheType.GoodsGroup, lastModifyTime, goodsGroups.ToArray());
            }
            if (null != goodses && goodses.Any())  ////交易商品
            {
                var result = goodses.Distinct(new QuoteGoodsComparer()).ToList();

                result = UpdateGoods(result, goodsScr);  ////设置商品来源
                var lastModifyTime = ApplicationParameter.BasicDateTime; //allExchanges.Max(z => z.LastModifiedTime);
                UpdateTable(CacheType.GoodsBaseInfo, lastModifyTime, result.ToArray());
            }
        }

        /// <summary>
        /// 更新商品并设置商品来源
        /// </summary>
        /// <param name="goodses">商品列表</param>
        /// <param name="goodsScr">商品来源</param>
        /// <returns></returns>
        private static List<QuoteGoods> UpdateGoods(List<QuoteGoods> goodses, GoodsFromScr goodsScr)
        {
            if (CacheGoodsBaseInfos == null || !CacheGoodsBaseInfos.Any())  ////当前没有商品添加
            {
                foreach (var quoteGoodse in goodses)
                {
                    quoteGoodse.ContainsGoodsSrc = (int) goodsScr;   ////设置商品来源
                    quoteGoodse.TradeMode = CacheMarketsGroups.Where(x => x.MarketID == quoteGoodse.MarketID).Select(x=>x.TradeMode).FirstOrDefault();
                    quoteGoodse.TradeProperty = CacheMarketsGroups.Where(x => x.MarketID == quoteGoodse.MarketID).Select(x => x.TradeProperty).FirstOrDefault();
                }
                return goodses;
            }
            else
            {
                var temGoodses = new List<QuoteGoods>();
                var list = CacheGoodsBaseInfos;
                foreach (var quoteGoodse in goodses)
                {
                    var existGoods = CacheGoodsBaseInfos.FirstOrDefault((goods) => goods.Symbol == quoteGoodse.Symbol);
                    quoteGoodse.TradeMode = CacheMarketsGroups.Where(x => x.MarketID == quoteGoodse.MarketID).Select(x => x.TradeMode).FirstOrDefault();
                    if (existGoods == null) ////商品不存在需添加
                    {
                        quoteGoodse.ContainsGoodsSrc = (int) goodsScr;
                        temGoodses.Add(quoteGoodse);
                    }
                    else
                    {
                        if (goodsScr == GoodsFromScr.Trade)   ////如果存在更新从交易更新的。则先移除旧的
                        {
                            list.Remove(existGoods);
                            quoteGoodse.ContainsGoodsSrc = (int) GoodsFromScr.Trade | (int) existGoods.ContainsGoodsSrc;   ////或运算
                            temGoodses.Add(quoteGoodse);
                        }
                        else
                        {
                            existGoods.ContainsGoodsSrc = existGoods.ContainsGoodsSrc | (int)goodsScr;   //// 商品包括多个来源 ////或运算
                        }
                    }
                }
            
              list.AddRange(temGoodses);
                return list;
            }
        }

        /// <summary>
        /// 更新商品组
        /// </summary>
        /// <param name="goodsGroups">商品组列表</param>
        ///  <param name="GoodsFromScr">商品组更新来源</param>
        /// <returns></returns>
        private static List<GoodsGroup> UpdateGoodsGroup(List<GoodsGroup> goodsGroups, GoodsFromScr goodsScr)
        {
            if (CacheGoodsGroups == null || !CacheGoodsGroups.Any()) ////当前没有商品添加
            {
                foreach (var goodsGroup in goodsGroups)
                {
                    MarketStatus[goodsGroup.MarketTypeID] = 0;
                }
                return goodsGroups;
            }
            else
            {
                var temGroups = new List<GoodsGroup>();
                var cacheGroups = CacheGoodsGroups;
                foreach (var goodsGroup in goodsGroups)
                {
                   var groupItem= cacheGroups.FirstOrDefault((item) => item.GoodsGroupid == goodsGroup.GoodsGroupid);
                    if (groupItem != null)
                    {
                        if (goodsScr == GoodsFromScr.Trade)   ////如果存在更新从交易更新的。则先移除旧的
                        {
                            cacheGroups.Remove(groupItem);
                            temGroups.Add(goodsGroup);
                            MarketStatus[goodsGroup.MarketTypeID] = 0;
                        }
                    }
                    else
                    {
                        temGroups.Add(goodsGroup);
                    }
                }
                cacheGroups.AddRange(temGroups);
                return cacheGroups;
            }
        }

        /// <summary>
        /// 更新市场组MTP2.0
        /// </summary>
        /// <param name="marketsGroups">市场组列表</param>
        ///  <param name="GoodsFromScr">市场组更新来源</param>
        /// <returns></returns>
        private static List<MarketsInfoModel> UpdateMarketsGroup(List<MarketsInfoModel> marketGroups, GoodsFromScr goodsScr)
        {
            if (CacheMarketsGroups == null || !CacheMarketsGroups.Any()) ////当前没有市场添加
            {
                foreach (var marketGroup in marketGroups)
                {
                    MarketStatus[(int)marketGroup.MarketID] = 0;
                }
                return marketGroups;
            }
            else
            {
                var temGroups = new List<MarketsInfoModel>();
                var cacheGroups = CacheMarketsGroups;
                foreach (var marketGroup in marketGroups)
                {
                    var groupItem = cacheGroups.FirstOrDefault((item) => item.MarketID == marketGroup.MarketID);
                    if (groupItem != null)
                    {
                        if (goodsScr == GoodsFromScr.Trade)   ////如果存在更新从交易更新的。则先移除旧的
                        {
                            cacheGroups.Remove(groupItem);
                            temGroups.Add(marketGroup);
                            MarketStatus[(int)marketGroup.MarketID] = 0;
                        }
                    }
                    else
                    {
                        temGroups.Add(marketGroup);
                    }
                }
                cacheGroups.AddRange(temGroups);
                return cacheGroups;
            }
        }
        #endregion Public Static Methods

        #region Private Static Methods

        private static List<CacheType> GetAllCacheTypes()
        {
            var result = new List<CacheType>();
            var values = Enum.GetValues(typeof(CacheType));
            foreach (var value in values)
            {
                result.Add((CacheType)value);
            }

            return result;
        }

        ///// <summary>
        ///// 多任务使用查询交易所信息
        ///// </summary>
        //private static void GetExchangeListAndMerage()
        //{
        //    int errorCode = 0;

        //    var tradeAccount = UserManager.CurrentTradeAccount;
        //    if (tradeAccount == null) return;
        //    var allExchanges = new List<Exchange>();
        //    var basicDataService = SimpleIoc.Default.GetInstance<IBasicDataService>();
        //    try
        //    {
        //        var exchanges = basicDataService.GetExchanges(new List<string>() { tradeAccount.ExchangeId.ToString() });

        //        if (exchanges == null || !exchanges.Any())
        //        {
        //            throw new Exception(Client_Resource.Infrastructure_TradingFailurePleaseTryAgain);
        //        }

        //        allExchanges.AddRange(exchanges);
        //        foreach (var exchange in allExchanges)
        //        {
        //            //等待服务联调
        //            basicDataService.GetExchangesParamer(exchange);
        //        }
        //    }
        //    catch (MuchinfoException muchinfo)
        //    {
        //        errorCode = muchinfo.ReturnCode;
        //    }
        //    catch (Exception ex)
        //    {
        //        errorCode = ExceptionManager.QueryExchangeError;

        //    }
        //    MessengerHelper.DefaultSend(new DisplayMessage()
        //    {
        //        ErrorCode = errorCode,
        //        Result = errorCode == 0,
        //        QueryType = QueryType.Exchange,
        //    }, MessengerTokens.LoadBaseInfo);
        //    if (allExchanges.Any())
        //    {
        //        var lastModifyTime = ApplicationParameter.BasicDateTime;// allExchanges.Max(z => z.LastModifiedTime);
        //        UpdateTable(CacheType.Exchange, lastModifyTime, allExchanges.ToArray());
        //    }
        //}

        ///// <summary>
        ///// 多任务使用查询市场信息
        ///// </summary>
        ///// <exception cref="System.Exception"></exception>
        //private static void GetMarketDetailListAndMerage()
        //{
        //    int errorCode = 0;
        //    var tradeAccount = UserManager.CurrentTradeAccount;
        //    if (tradeAccount == null) return;
        //    var allMarkets = new List<Market>();
        //    var basicDataService = SimpleIoc.Default.GetInstance<IBasicDataService>();
        //    try
        //    {
        //        var markets = basicDataService.GetMarkets(tradeAccount.TradeCode);
        //        if (markets == null || !markets.Any())
        //        {
        //            throw new Exception(Client_Resource.Infrastructure_MatketFailurePleaseTrayAgain);
        //        }
        //        allMarkets.AddRange(markets);

        //    }
        //    catch (MuchinfoException muchinfo)
        //    {
        //        errorCode = muchinfo.ReturnCode;
        //    }
        //    catch (Exception ex)
        //    {
        //        errorCode = ExceptionManager.QueryMarketsError;
        //    }
        //    MessengerHelper.DefaultSend(new DisplayMessage()
        //    {
        //        ErrorCode = errorCode,
        //        Result = errorCode == 0,
        //        QueryType = QueryType.Markets,
        //    }, MessengerTokens.LoadBaseInfo);

        //    if (allMarkets.Any())
        //    {
        //        var lastModifyTime = ApplicationParameter.BasicDateTime;//allExchanges.Max(z => z.LastModifiedTime);
        //        UpdateTable(CacheType.MarketDetail, lastModifyTime, allMarkets.ToArray());
        //    }

        //    _autoResetEvent.Set();
        //}

        private static List<object> ConvertCacheList<T>(CacheObject cacheObject) where T : class
        {
            if (cacheObject == null || cacheObject.CacheList == null || !cacheObject.CacheList.Any()) return null;
            var models = cacheObject.CacheList.Select(z =>
            {
                var jObject = z as JObject;
                return jObject != null ? jObject.ToObject<T>() : default(T);
            });

            return models.ToList<object>();
        }

        /// <summary>
        /// Loads the table.
        /// </summary>
        /// <param name="cacheType">Type of the cache.</param>
        private static void LoadTable(CacheType cacheType)
        {
            if (!_caches.ContainsKey(cacheType))
            {
                var cacheObject = LoadCacheObject(cacheType);

                if (_caches.ContainsKey(cacheObject.CacheType))
                {
                    _caches.Remove(cacheObject.CacheType);
                }
                _caches.Add(cacheObject.CacheType, cacheObject);
            }
        }

        private static CacheObject LoadCacheObject(CacheType cacheType)
        {
            string cacheObjectFile = Path.Combine(UserManager.UserDataFolder, cacheType.ToString() + UserManager.LocalDataExtensionName);

            var cacheObject = BsonHelper.LoadData<CacheObject>(cacheObjectFile).FirstOrDefault();
            if (cacheObject == null) cacheObject = new CacheObject(cacheType) { CacheTime = DateTime.MinValue };
            if (cacheObject.CacheList != null && cacheObject.CacheList.Count > 0)
            {
                switch (cacheObject.CacheType)
                {
                    case CacheType.Exchange:
                        cacheObject.CacheList = ConvertCacheList<Exchange>(cacheObject);
                        break;
                    //case CacheType.ExchangeChange:
                    //    cacheObject.CacheList = ConvertCacheList<ExchangeChangeDataModel>(cacheObject);
                    //    break;
                    case CacheType.GoodsBaseInfo:
                        cacheObject.CacheList = ConvertCacheList<QuoteGoods>(cacheObject);
                        break;
                    case CacheType.MarketGroup:
                        cacheObject.CacheList = ConvertCacheList<MarketsInfoModel>(cacheObject);
                        break;
                    case CacheType.GoodsGroup:
                        cacheObject.CacheList = ConvertCacheList<Market>(cacheObject);
                        break;

                    //case CacheType.QuoteHead:
                    //    cacheObject.CacheList = ConvertCacheList<QuoteHeadStyleDataModel>(cacheObject);
                    //    break;
                    //case CacheType.QuoteHeadDetail:
                    //    cacheObject.CacheList = ConvertCacheList<QuoteHeadDetailDataModel>(cacheObject);
                    //    break;
                    //case CacheType.Sector:
                    //    cacheObject.CacheList = ConvertCacheList<SectorDataModel>(cacheObject);
                    //    break;
                    //case CacheType.Warning:
                    //    cacheObject.CacheList = ConvertCacheList<Warning>(cacheObject);
                    //    break;
                    case CacheType.NewsCategory:
                        cacheObject.CacheList = ConvertCacheList<NewsCategory>(cacheObject);
                        break;
                }
            }

            return cacheObject;
        }

        ///// <summary>
        ///// Saves the table.
        ///// </summary>
        ///// <param name="cacheType">Type of the cache.</param>
        //private static void SaveTable(CacheType cacheType)
        //{
        //    var tableFile = Path.Combine(UserManager.UserDataFolder, cacheType.ToString() + UserManager.LocalDataExtensionName);
        //    var table = _caches[cacheType];
        //    BsonHelper.SaveData(tableFile, table, null, true);
        //}

        /// <summary>
        /// 多任务添加缓存类型
        /// </summary>
        private static void TaskSuppleTable()
        {
            var typeList = GetAllCacheTypes();

            foreach (CacheType type in typeList)
            {
                switch (type)
                {
                    case CacheType.Other:
                    case CacheType.Finished:
                        break;
                    //case CacheType.Warning:
                    //    LoadTable(CacheType.Warning);
                    //    break;
                    default:
                        LoadTable(type);
                        break;
                }
            }

        }

        private static void UpdateTable<T>(CacheType cacheType, DateTime lastModifyTime, T[] newRecords, bool isSave = true)
        {
            if (!_caches.ContainsKey(cacheType))
                return;
            if (null == newRecords || newRecords.Length == 0) return;
            var data = _caches[cacheType] ?? new CacheObject(cacheType);
            if (data.CacheList == null) data.CacheList = new List<object>();
            var newList = new List<object>();

            foreach (var newRecord in newRecords)
            {
                newList.Add(newRecord);
            }

            //test
            data.CacheList.Clear();
            //end

            data.CacheList.AddRange(newList);

            //更新缓存时间
            data.CacheTime = lastModifyTime;
            _caches[cacheType] = data;
        }


        #endregion Private Static Methods

        #endregion Methods

#region 存储外部交易所、商品组、商品的关系

        public static void LoadExChangeGroupGoods(ExChangeCheckModel exChangeCheckModel)
        {
            TaskSuppleTable();
            if (null != exChangeCheckModel) // 
            {
                var lastModifyTime = ApplicationParameter.BasicDateTime;
                List<ExChangeCheckModel> list = new List<ExChangeCheckModel>() {exChangeCheckModel};
                UpdateTable(CacheType.ExChangeGroupGoods, lastModifyTime, list.ToArray());
            }
        }

        public static List<ExChangeCheckModel> CacheExChangeGroupGoods
        {
            get
            {
                if (!_caches.ContainsKey(CacheType.ExChangeGroupGoods) || _caches[CacheType.ExChangeGroupGoods].CacheList == null) return null;
                //var result = _caches[CacheType.GoodsBaseInfo].CacheList.OfType<Goods>().Where(z => z != null && z.IsValid);
                IEnumerable<ExChangeCheckModel> result = _caches[CacheType.ExChangeGroupGoods].CacheList.OfType<ExChangeCheckModel>().Where(z => z != null);

                return result.ToList();
            }
        }


        /// <summary>
        /// 终端启动时通过通用查许从quotesourcegroup表获取行情交易日
        /// </summary>
        public static List<QuoteSourceGroupMarketData> QuoteSourceGroupMarketDatas { get; set; }

        #endregion
    }
}