//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, February 25, 2019
//--------------------------------------------------------
using System;
using System.Collections.Generic;
using Snxxz.UI;
using System.Linq;


namespace Snxxz.UI
{
    public class AuctionModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<string, AuctionItem> m_AuctionItems = new Dictionary<string, AuctionItem>();
        Dictionary<int, DateTime> m_FocusAuctionTimeDict = new Dictionary<int, DateTime>();

        List<string> m_ServerAuctionItemGuids = new List<string>();//全服拍品列表
        List<string> m_FairyAuctionItemGuids = new List<string>();// 拍卖行仙盟拍卖中的物品信息
        List<string> m_MyAuctionItemGuids = new List<string>();//自身玩家上架的拍品
        List<string> m_MyBiddingItemGuids = new List<string>();//拍卖行玩家竞价中的物品信息 
        List<string> m_MyFocusAuctionItemGuids = new List<string>();//拍卖行关注中的拍品详情
        List<string> m_AuctionRecords = new List<string>();//拍卖行玩家拍卖记录
        List<FocusAuctionItem> m_FocusItems = new List<FocusAuctionItem>();//关注的拍品的上架提醒（弹框显示）

        List<int> m_MyFocusItemIds = new List<int>();//关注的物品ID

        public const int REDPOINT_BASE = 217;
        public readonly Redpoint redpoint = new Redpoint(2, REDPOINT_BASE);//拍卖行红点

        public bool isLocationQuery { get; set; }
        public string locationGuid { get; set; }
        public string locationMyFocusGuid { get; set; }
        public bool isServerPrepare { get; private set; }
        public bool isAuctionWindowOpen { get; set; }
        public bool isQueryFront { get; set; }
        public bool queryFowardAble { get; set; }
        public bool queryAfterwardAble { get; set; }
        public DateTime queryTime = DateTime.Now;
        public DateTime locationMyFocusTime = DateTime.Now;
        public bool alreadyQueryMyFocus { get; set; }

        int m_SelectClassifyId = 0;
        public int selectClassifyId
        {
            get { return m_SelectClassifyId; }
            set
            {
                if (m_SelectClassifyId != value)
                {
                    m_SelectClassifyId = value;
                    if (selectClassifyRefresh != null)
                    {
                        selectClassifyRefresh();
                    }
                }
            }
        }

        public Int2 childClassifyIndex = Int2.zero;

        public event Action myAuctionRefresh;
        public event Action serverAuctionRefresh;//全服拍品数据请求
        public event Action myFocusItemRefresh;//关注物品ID刷新
        public event Action myBiddingAuctionRefresh;//卖行玩家竞价中的物品信息刷新
        public event Action auctionRecordRefresh;//拍卖记录新增拍卖记录
        public event Action fairyAuctionRefresh;//仙盟拍卖的物品添加刷新
        public event Action myFocusAuctionRefresh;//拍卖行关注中的拍品信息变更（信息每次重置）
        public event Action auctionItemRefresh;//拍卖行数据刷新(仅用于数据刷新)
        public event Action onAuctionRemove;//拍卖行物品清除
        public event Action onFocusAuctionRefresh;
        public event Action selectClassifyRefresh;

        AuctionHelpModel auctionHelpModel { get { return ModelCenter.Instance.GetModel<AuctionHelpModel>(); } }

        public override void Init()
        {
            StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
        }

        public void OnBeforePlayerDataInitialize()
        {
            isLocationQuery = false;
            isServerPrepare = false;

            m_MyAuctionItemGuids.Clear();
            m_FairyAuctionItemGuids.Clear();
            m_AuctionRecords.Clear();
            m_MyBiddingItemGuids.Clear();
            m_MyFocusAuctionItemGuids.Clear();
            m_MyFocusItemIds.Clear();

            PlayerDatas.Instance.fairyData.OnRefreshFairyMine -= OnRefreshFairyMine;
        }

        public void OnPlayerLoginOk()
        {
            PlayerDatas.Instance.fairyData.OnRefreshFairyMine += OnRefreshFairyMine;

            isServerPrepare = true;
            RefreshRedpoint();
        }


        public override void UnInit()
        {
            StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
        }

        private void OnFuncStateChangeEvent(int id)
        {
            if (id == (int)FuncOpenEnum.Market)
            {
                RefreshRedpoint();
            }
        }

        private void OnStageLoadFinish()
        {
            if (!(StageLoad.Instance.currentStage is DungeonStage))
            {
                m_ServerAuctionItemGuids.Clear();
                m_AuctionItems.Clear();
                m_FocusItems.Clear();
                m_FocusAuctionTimeDict.Clear();
            }
        }

        private void OnRefreshFairyMine()//用于被提出仙盟清除仙盟拍品
        {
            if (PlayerDatas.Instance.baseData.FamilyId == 0)
            {
                m_FairyAuctionItemGuids.Clear();
                if (fairyAuctionRefresh != null)
                {
                    fairyAuctionRefresh();
                }
            }
        }

        public void ResetServerAuctionInquiry()
        {
            if (!isLocationQuery)
            {
                m_ServerAuctionItemGuids.Clear();
            }
            queryFowardAble = isLocationQuery;
            queryAfterwardAble = true;
            queryTime = DateTime.Now;
        }

        void RemoveAuctionItems(List<string> itemGuids)
        {
            foreach (var guid in itemGuids)
            {
                RemoveAuctionItem(guid);
            }
        }

        void RemoveAuctionItem(string guid)
        {
            if (m_AuctionItems.ContainsKey(guid))
            {
                m_AuctionItems.Remove(guid);
            }
        }

        void PushAuctionItem(AuctionItem item)
        {
            if (m_AuctionItems.ContainsKey(item.itemGuid))
            {
                DebugEx.LogFormat("重复添加{0}", item.itemGuid);
                return;
            }
            m_AuctionItems.Add(item.itemGuid, item);
        }

        public bool TryGetAuctionItem(string guid,out AuctionItem item)
        {
            return m_AuctionItems.TryGetValue(guid, out item);
        }

        public bool TryGetServerAuctionItem(string guid, out AuctionItem item)
        {
            item = null;
            if (TryGetMyBiddingAuctionItem(guid, out item))
            {
                return true;
            }
            if (m_ServerAuctionItemGuids.Contains(guid))
            {
                return TryGetAuctionItem(guid, out item);
            }
            return false;
        }

        public bool TryGetMyBiddingAuctionItem(string guid, out AuctionItem item)
        {
            item = null;
            if (m_MyBiddingItemGuids.Contains(guid))
            {
                return TryGetAuctionItem(guid, out item);
            }
            return false;
        }

        public bool TryGetFairyAuctionItem(string guid, out AuctionItem item)
        {
            item = null;
            if (m_FairyAuctionItemGuids.Contains(guid))
            {
                return TryGetAuctionItem(guid, out item);
            }
            return false;
        }

        public bool TryGetMyAuctionItem(string guid, out AuctionItem item)
        {
            item = null;
            if (m_MyAuctionItemGuids.Contains(guid))
            {
                return TryGetAuctionItem(guid, out item);
            }
            return TryGetFairyAuctionItem(guid, out item);
        }

        public bool TryGetMyFocusAuctionItem(string guid, out AuctionItem item)
        {
            if (m_MyFocusAuctionItemGuids.Contains(guid))
            {
                return TryGetAuctionItem(guid, out item);
            }
            return TryGetFairyAuctionItem(guid, out item);
        }

        public bool TryGetAuctionRecordItem(string guid, out AuctionItem item)
        {
            item = null;
            if (m_AuctionRecords.Contains(guid))
            {
                return TryGetAuctionItem(guid, out item);
            }
            return false;
        }

        public bool TryGetFocusAuctionPop(out FocusAuctionItem item)
        {
            item = default(FocusAuctionItem);
            if (m_FocusItems.Count > 0)
            {
                item = m_FocusItems[0];
                m_FocusAuctionTimeDict[item.itemId] = DateTime.Now;
                return true;
            }
            return false;
        }

        public List<string> GetServerAuctionItems()
        {
            List<string> guids = new List<string>();
            foreach (var guid in m_ServerAuctionItemGuids)
            {
                guids.Add(guid);
            }
            return guids;
        }

        public ICollection<string> GetMyBiddingAuctionItems()
        {
            return m_MyBiddingItemGuids;
        }

        public ICollection<string> GetFairyAuctionItems()
        {
            return m_FairyAuctionItemGuids;
        }

        public ICollection<string> GetAuctionRecords()
        {
            return m_AuctionRecords;
        }

        public void GetMyAuctionItems(ref List<string> itemGuids)
        {
            itemGuids.Clear();
            itemGuids.AddRange(m_MyAuctionItemGuids);

            var playerId = PlayerDatas.Instance.baseData.PlayerID;
            foreach (var guid in m_FairyAuctionItemGuids)
            {
                if (itemGuids.Contains(guid))
                {
                    continue;
                }
                AuctionItem item;
                if (TryGetAuctionItem(guid, out item))
                {
                    if (item.familyPlayers != null && item.familyPlayers.Contains((int)playerId))
                    {
                        itemGuids.Add(item.itemGuid);
                    }
                }
            }
        }

        public void GetMyFocusAutionItems(ref List<string> itemGuids)
        {
            itemGuids.Clear();
            itemGuids.AddRange(m_MyFocusAuctionItemGuids);

            var playerId = PlayerDatas.Instance.baseData.PlayerID;
            foreach (var guid in m_FairyAuctionItemGuids)
            {
                if (itemGuids.Contains(guid))
                {
                    continue;
                }
                AuctionItem item;
                if (TryGetAuctionItem(guid, out item))
                {
                    if (IsMyFocusItem(item.itemId))
                    {
                        itemGuids.Add(item.itemGuid);
                    }
                }
            }
        }

        public int GetMyFocusItemCount()
        {
            return m_MyFocusItemIds.Count;
        }

        public int GetQueryIndex()
        {
            var config = AuctionConfig.Get(selectClassifyId);
            if (config == null)
            {
                return 0;
            }

            var index = config.TypeId;
            if (config.ChooseItem1 != null && childClassifyIndex.x < config.ChooseItem1.Length)
            {
                index += config.ChooseItem1[childClassifyIndex.x];
            }
            if (config.ChooseItem2 != null && childClassifyIndex.y < config.ChooseItem2.Length)
            {
                index += config.ChooseItem2[childClassifyIndex.y];
            }
            return index;
        }

        public bool IsParticipateInBidding(string guid)
        {
            return m_MyBiddingItemGuids.Contains(guid);
        }

        public bool IsMyTopPrice(string guid)
        {
            var isMyTopPrice = false;
            if (IsParticipateInBidding(guid))
            {
                AuctionItem myBiddingItem;
                if (TryGetMyBiddingAuctionItem(guid, out myBiddingItem))
                {
                    isMyTopPrice = AuctionLogicUtil.IsMyTopPrice(myBiddingItem);
                }
            }
            return isMyTopPrice;
        }

        public bool IsMyFocusItem(int id)
        {
            return m_MyFocusItemIds.Contains(id);
        }

        public void RemoveFocusItemPop()
        {
            if (m_FocusItems.Count > 0)
            {
                m_FocusItems.RemoveAt(0);
            }
        }

        public void ReceivePackage(HB501_tagGCAuctionItemInfo package)// 拍卖行拍卖中的物品信息
        {
            List<string> fullServiceAuctionList = new List<string>();
            for (int i = 0; i < package.AuctionItemCount; i++)
            {
                var data = package.AuctionItemList[i];
                var guid = UIHelper.ServerStringTrim(data.ItemGUID);
                AuctionItem item;
                if (!TryGetAuctionItem(guid, out item))
                {
                    item = new AuctionItem(guid);
                    PushAuctionItem(item);
                }
                item.itemGuid = UIHelper.ServerStringTrim(data.ItemGUID);
                item.familyId = (int)data.FamilyID;
                item.itemId = (int)data.ItemID;
                item.itemCount = (int)data.ItemCount;
                item.putAwayTime = DateTime.Parse(data.AddTime);
                var biddingTimeLabel = UIHelper.ServerStringTrim(data.BiddingTime);
                item.biddingTime = string.IsNullOrEmpty(biddingTimeLabel) ? DateTime.MinValue : DateTime.Parse(biddingTimeLabel);
                item.biddingPrice = data.BidderPrice;
                item.customData = data.UserData;

                if (!m_ServerAuctionItemGuids.Contains(guid))
                {
                    fullServiceAuctionList.Add(guid);
                }
            }

            if (package.QueryDir == 1)//往后查询
            {
                queryAfterwardAble = package.QueryRemainlCount != 0;
                m_ServerAuctionItemGuids.AddRange(fullServiceAuctionList);
            }
            else if (package.QueryDir == 2)//往前查询
            {
                queryFowardAble = package.QueryRemainlCount != 0;
                m_ServerAuctionItemGuids.InsertRange(0, fullServiceAuctionList);
                if (WindowCenter.Instance.IsOpen<FullServiceAuctionWin>())
                {
                    isQueryFront = true;
                }
            }
            else if (package.QueryDir == 3)//定位查询
            {
                if (WindowCenter.Instance.IsOpen<AuctionHouseWin>())
                {
                    return;
                }
                m_ServerAuctionItemGuids.Clear();
                m_ServerAuctionItemGuids.AddRange(fullServiceAuctionList);
                isLocationQuery = true;
                WindowCenter.Instance.Open<AuctionHouseWin>(true, 0);//定位查询
            }

            if (serverAuctionRefresh != null)
            {
                serverAuctionRefresh();
            }
        }

        public void ReceivePackage(HB502_tagGCPlayerAuctionItemInfo package)//拍卖行玩家拍卖中的物品信息
        {
            for (int i = 0; i < package.AuctionItemCount; i++)
            {
                var data = package.AuctionItemList[i];
                var guid = UIHelper.ServerStringTrim(data.ItemGUID);

                AuctionItem item;
                if (!TryGetAuctionItem(guid, out item))
                {
                    item = new AuctionItem(guid);
                    PushAuctionItem(item);
                }

                item.itemGuid = UIHelper.ServerStringTrim(data.ItemGUID);
                item.familyId = (int)data.FamilyID;
                item.itemId = (int)data.ItemID;
                item.itemCount = (int)data.ItemCount;
                item.putAwayTime = DateTime.Parse(data.AddTime);
                var biddingTimeLabel = UIHelper.ServerStringTrim(data.BiddingTime);
                item.biddingTime = string.IsNullOrEmpty(biddingTimeLabel) ? DateTime.MinValue : DateTime.Parse(biddingTimeLabel);
                item.biddingPrice = data.BidderPrice;
                item.customData = data.UserData;

                if (!m_MyAuctionItemGuids.Contains(guid))
                {
                    m_MyAuctionItemGuids.Add(guid);
                }
            }
            if (myAuctionRefresh != null)
            {
                myAuctionRefresh();
            }
        }

        public void ReceivePackage(HB503_tagGCPlayerAuctionRecordInfo package)//拍卖行玩家拍卖记录
        {
            for (int i = 0; i < package.Count; i++)
            {
                var data = package.AuctionRecordList[i];
                var guid = UIHelper.ServerStringTrim(data.ItemGUID);

                AuctionItem item;
                if (!TryGetAuctionItem(guid, out item))
                {
                    item = new AuctionItem(guid);
                    PushAuctionItem(item);
                }

                item.familyId = (int)data.FamilyID;
                item.putAwayTime = DateTime.Parse(data.RecordTime);
                item.recordType = data.RecordType;//记录类型 0-我的拍品记录 1-仙盟拍品记录 2-我的竞拍记录
                item.recordResult = data.RecordResult;//记录结果 0-流拍 1-拍卖成交 2-回收 3-竞价成功 4-竞价失败
                item.biddingPrice = (int)data.BidderPrice;//成交价格
                item.biddingPlayerName = data.BidderName;//玩家名
                item.itemId = (int)data.ItemID;
                item.itemCount = (int)data.ItemCount;
                item.customData = data.UserData;
                if (!m_AuctionRecords.Contains(guid))
                {
                    m_AuctionRecords.Add(guid);
                }
            }
            if (auctionRecordRefresh != null)
            {
                auctionRecordRefresh();
            }
        }

        public void ReceivePackage(HB504_tagGCAddAuctionItemInfo package)//拍卖行新上架拍品(玩家有关注的拍品 )
        {
            if (!isServerPrepare)
            {
                return;
            }
            for (int i = 0; i < package.AddCount; i++)
            {
                var data = package.AddAuctionItemList[i];
                var guid = UIHelper.ServerStringTrim(data.ItemGUID);
                if (m_FocusItems.FindIndex((x) =>
                {
                    return x.itemId == data.ItemID || x.itemGuid.Equals(guid);
                }) != -1)
                {
                    continue;
                }
                DateTime lastFocusTime;
                if (m_FocusAuctionTimeDict.TryGetValue((int)data.ItemID, out lastFocusTime))
                {
                    if ((DateTime.Now - lastFocusTime).TotalMinutes < 1)
                    {
                        continue;
                    }
                }
                var focusItem = new FocusAuctionItem()
                {
                    itemGuid = guid,
                    itemId = (int)data.ItemID,
                };
                m_FocusItems.Add(focusItem);
            }

            if (onFocusAuctionRefresh != null)
            {
                onFocusAuctionRefresh();
            }
        }

        public void ReceivePackage(HB505_tagGCFamilyAuctionItemInfo package)//拍卖行仙盟拍卖中的物品信息(上线同步，刷新同步)
        {
            for (int i = 0; i < package.AuctionItemCount; i++)
            {
                var data = package.AuctionItemList[i];
                var guid = UIHelper.ServerStringTrim(data.ItemGUID);

                AuctionItem item;
                if (!TryGetAuctionItem(guid, out item))
                {
                    item = new AuctionItem(guid);
                    PushAuctionItem(item);
                }

                item.itemGuid = UIHelper.ServerStringTrim(data.ItemGUID);
                item.familyId = (int)data.FamilyID;
                item.itemId = (int)data.ItemID;
                item.itemCount = (int)data.ItemCount;
                item.putAwayTime = DateTime.Parse(data.AddTime);
                var biddingTimeLabel = UIHelper.ServerStringTrim(data.BiddingTime);
                item.biddingTime = string.IsNullOrEmpty(biddingTimeLabel) ? DateTime.MinValue : DateTime.Parse(biddingTimeLabel);
                item.biddingPrice = data.BidderPrice;
                item.customData = data.UserData;
                item.familyPlayers = new List<int>();
                item.familyPlayers = ParseFairyPlayers(data.FamilyPlayerIDInfo);
                item.auctionType = data.AuctionType;

                if (!m_FairyAuctionItemGuids.Contains(guid))
                {
                    m_FairyAuctionItemGuids.Add(guid);
                }
            }
            if (fairyAuctionRefresh != null)
            {
                fairyAuctionRefresh();
            }
        }

        public void ReceivePackage(HB506_tagGCAttentionAuctionItemInfo package)//拍卖行关注中的拍品信息
        {
            bool existLocationAuction = false;

            m_MyFocusAuctionItemGuids.Clear();
            for (int i = 0; i < package.AuctionItemCount; i++)
            {
                var data = package.AuctionItemList[i];
                var guid = UIHelper.ServerStringTrim(data.ItemGUID);

                AuctionItem item;
                if (!TryGetAuctionItem(guid, out item))
                {
                    item = new AuctionItem(guid);
                    PushAuctionItem(item);
                }

                item.itemGuid = UIHelper.ServerStringTrim(data.ItemGUID);
                item.familyId = (int)data.FamilyID;
                item.itemId = (int)data.ItemID;
                item.itemCount = (int)data.ItemCount;
                item.putAwayTime = DateTime.Parse(data.AddTime);
                var biddingTimeLabel = UIHelper.ServerStringTrim(data.BiddingTime);
                item.biddingTime = string.IsNullOrEmpty(biddingTimeLabel) ? DateTime.MinValue : DateTime.Parse(biddingTimeLabel);
                item.biddingPrice = data.BidderPrice;
                item.customData = data.UserData;

                if (!m_MyFocusAuctionItemGuids.Contains(guid))
                {
                    m_MyFocusAuctionItemGuids.Add(guid);
                }

                if (guid.Equals(locationMyFocusGuid) &&
                    (DateTime.Now - locationMyFocusTime).TotalSeconds < 5)
                {
                    existLocationAuction = true;
                }
            }
            if (myFocusAuctionRefresh != null)
            {
                myFocusAuctionRefresh();
            }

            if (existLocationAuction)
            {
                alreadyQueryMyFocus = true;
                WindowCenter.Instance.Open<AuctionHouseWin>(true, 3);
            }
        }

        public void ReceivePackage(HB507_tagGCAttentionAuctionItemID package)//关注的物品ID（需要主动查询）
        {
            m_MyFocusItemIds.Clear();
            for (int i = 0; i < package.AttentionCount; i++)
            {
                var itemId = (int)package.AttentionItemIDList[i];
                if (!m_MyFocusItemIds.Contains(itemId))
                {
                    m_MyFocusItemIds.Add(itemId);
                }
            }
            if (myFocusItemRefresh != null)
            {
                myFocusItemRefresh();
            }

        }

        public void ReceivePackage(HB508_tagGCRefreshAuctionItemInfo package)//拍卖行刷新拍品(只进行刷新)
        {
            var refreshFairyAuction = false;

            for (int i = 0; i < package.RefreshCount; i++)
            {
                var data = package.RefreshAuctionItemList[i];

                var guid = UIHelper.ServerStringTrim(data.ItemGUID);

                AuctionItem item;
                if (!TryGetAuctionItem(guid, out item))
                {
                    item = new AuctionItem(guid);
                    PushAuctionItem(item);
                }

                var _autionType = item.auctionType;

                item.auctionType = data.AuctionType;
                item.putAwayTime = DateTime.Parse(data.AddTime);
                var biddingTimeLabel = UIHelper.ServerStringTrim(data.BiddingTime);
                item.biddingTime = string.IsNullOrEmpty(biddingTimeLabel) ? DateTime.MinValue : DateTime.Parse(biddingTimeLabel);
                item.biddingPlayer = (int)data.BidderID;
                item.biddingPrice = (int)data.BidderPrice;

                if (_autionType == 1 && item.auctionType != 1)// 拍卖行仙盟拍卖中的物品信息
                {
                    refreshFairyAuction = true;
                }
            }

            if (refreshFairyAuction)
            {
                if (fairyAuctionRefresh != null)
                {
                    fairyAuctionRefresh();
                }
            }

            if (auctionItemRefresh != null)
            {
                auctionItemRefresh();
            }
        }

        public void ReceivePackage(HB509_tagGCClearAuctionItemInfo package)//拍卖行清除拍品 
        {
            var refreshFairyAuction = false;

            for (int i = 0; i < package.ClearCount; i++)
            {
                var ItemGUIDList = package.ClearAuctionItemList[i];
                var guid = UIHelper.ServerStringTrim(ItemGUIDList.ItemGUID);

                if (m_MyBiddingItemGuids.Contains(guid))//清除拍卖行玩家参与竞价中的物品信息 
                {
                    m_MyBiddingItemGuids.Remove(guid);
                }
                if (m_FairyAuctionItemGuids.Contains(guid))// 清除拍卖行仙盟拍卖中的物品信息
                {
                    m_FairyAuctionItemGuids.Remove(guid);
                    refreshFairyAuction = true;
                }
                var index = m_ServerAuctionItemGuids.IndexOf(guid);
                if (index != -1)//清除全服拍品的某一件物品
                {
                    m_ServerAuctionItemGuids.RemoveAt(index);
                }
                if (m_MyAuctionItemGuids.Contains(guid))//我的拍品清除
                {
                    m_MyAuctionItemGuids.Remove(guid);
                }
                if (m_MyFocusAuctionItemGuids.Contains(guid))
                {
                    m_MyFocusAuctionItemGuids.Remove(guid);
                }

                RemoveAuctionItem(guid);
            }
            if (refreshFairyAuction)
            {
                if (fairyAuctionRefresh != null)
                {
                    fairyAuctionRefresh();
                }
            }
            if (onAuctionRemove != null)
            {
                onAuctionRemove();
            }
        }

        public void ReceivePackage(HB510_tagGCBiddingItemInfo package)//拍卖行玩家竞价中的物品信息 (每次上线同步一次)
        {
            for (int i = 0; i < package.AuctionItemCount; i++)
            {
                var data = package.AuctionItemList[i];

                var guid = UIHelper.ServerStringTrim(data.ItemGUID);

                AuctionItem item;
                if (!TryGetAuctionItem(guid, out item))
                {
                    item = new AuctionItem(guid);
                    PushAuctionItem(item);
                }

                item.itemId = (int)data.ItemID;
                item.itemCount = data.ItemCount;
                item.familyId = (int)data.FamilyID;
                item.putAwayTime = DateTime.Parse(data.AddTime);
                var biddingTimeLabel = UIHelper.ServerStringTrim(data.BiddingTime);
                item.biddingTime = string.IsNullOrEmpty(biddingTimeLabel) ? DateTime.MinValue : DateTime.Parse(biddingTimeLabel);
                item.biddingPrice = data.BidderPrice;//竞拍玩家出价
                item.biddingPlayer = (int)data.BidderID;//竞拍玩家ID，也就是当前最高竞价玩家ID
                item.customData = data.UserData;

                if (!m_MyBiddingItemGuids.Contains(guid))
                {
                    m_MyBiddingItemGuids.Add(guid);
                }
            }
            if (myBiddingAuctionRefresh != null)
            {
                myBiddingAuctionRefresh();
            }
        }

        public void SendBiddingItem(AuctionItem item, bool immediatly)
        {
            if (item == null)
            {
                return;
            }
            var config = AuctionItemConfig.Get(item.itemId);
            var cost = immediatly ? config.BuyoutPrice * item.itemCount : AuctionLogicUtil.GetBiddingRequireMoney(item);
            var label = Language.Get(immediatly ? "PMH_02" : "PMH_01", cost);
            ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), label, (bool isOk) =>
            {
                if (isOk)
                {
                    var money = PlayerDatas.Instance.baseData.diamond;
                    if (money >= cost)
                    {
                        AuctionInquiry.Instance.SendSellAuctionItem(item.itemGuid, cost);
                    }
                    else
                    {
                        WindowCenter.Instance.Open<RechargeTipWin>();
                    }
                }
            });
        }

        #region 定位查询
        public void SendInquiryServerAcution(int inquiryIndex, string guid, int inquiryDir, int inquiryCount = 10)
        {
            var inquiryConfig = AuctionIndexConfig.Get(inquiryIndex);

            if (inquiryConfig == null)
            {
                DebugEx.LogErrorFormat("不存在的查询Index:{0}", inquiryIndex);
                return;
            }

            uint[] itemTypes = null;
            if (inquiryConfig.ItemType != null
                && inquiryConfig.ItemType.Length > 0)
            {
                itemTypes = new uint[inquiryConfig.ItemType.Length];
                for (int i = 0; i < inquiryConfig.ItemType.Length; i++)
                {
                    itemTypes[i] = (uint)inquiryConfig.ItemType[i];
                }
            }

            uint[] specialItemIds = null;
            if (inquiryConfig.SpecItemID != null
                && inquiryConfig.SpecItemID.Length > 0)
            {
                specialItemIds = new uint[inquiryConfig.SpecItemID.Length];
                for (int i = 0; i < inquiryConfig.SpecItemID.Length; i++)
                {
                    specialItemIds[i] = (uint)inquiryConfig.SpecItemID[i];
                }
            }

            queryTime = DateTime.Now;

            var pak = new CB510_tagCGQueryAuctionItem();
            pak.Job = (byte)inquiryConfig.Job;
            pak.ItemTypeCount = itemTypes == null ? (byte)0 : (byte)itemTypes.Length;
            pak.ItemTypeList = itemTypes == null ? new uint[0] : itemTypes;
            pak.ClassLV = (byte)inquiryConfig.Order;

            pak.SpecItemIDCount = specialItemIds == null ? (byte)0 : (byte)specialItemIds.Length;
            pak.SpecItemIDList = specialItemIds == null ? new uint[0] : specialItemIds;

            pak.FromItemGUID = guid;
            pak.QueryDir = (byte)inquiryDir;
            pak.QueryCount = (byte)inquiryCount;
            GameNetSystem.Instance.SendInfo(pak);
        }

        public void SendLocationServerItem(string guid)
        {
            var pak = new CB517_tagCGQueryTagAuctionItem();
            pak.ItemGUID = guid;
            GameNetSystem.Instance.SendInfo(pak);
        }

        public void LocationItemByGuid(string guid)
        {
            AuctionItem item;
            if (TryGetFairyAuctionItem(guid, out item)
                && item.auctionType == 1)
            {
                locationGuid = guid;
                WindowCenter.Instance.Open<AuctionHouseWin>(true, 1);
            }
            else if (TryGetMyBiddingAuctionItem(guid, out item))
            {
                locationGuid = guid;
                WindowCenter.Instance.Open<AuctionHouseWin>(true, 0);
            }
            else
            {
                SendLocationServerItem(guid);
            }
        }

        public void LocationMyFocusItem(string guid)
        {
            locationMyFocusGuid = guid;
            locationMyFocusTime = DateTime.Now;
            AuctionItem item;
            if (TryGetMyFocusAuctionItem(guid, out item))
            {
                WindowCenter.Instance.Open<AuctionHouseWin>(true, 3);
                return;
            }
            AuctionInquiry.Instance.SendQueryAttentionAuctionItem();
        }
        #endregion

        public void SetDayRemind()
        {
            if (redpoint.state == RedPointState.Simple)
            {
                DayRemind.Instance.SetDayRemind(DayRemind.AUCTION_REDPOINT, true);
                RefreshRedpoint();
            }
        }

        private void RefreshRedpoint()
        {
            var redpointable = false;
            if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Market))
            {
                if (!DayRemind.Instance.GetDayRemind(DayRemind.AUCTION_REDPOINT))
                {
                    redpointable = true;
                }
            }
            redpoint.state = redpointable ? RedPointState.Simple : RedPointState.None;
        }

        public bool SatisfyQuitFairy(int playerId)//可否退出仙盟
        {
            foreach (var key in m_FairyAuctionItemGuids)//判断玩家是否有在竞价仙盟拍品(且是最高价)
            {
                AuctionItem item;
                if (TryGetAuctionItem(key, out item) && item.biddingPlayer == playerId)
                {
                    return false;
                }
            }
            return true;
        }

        public bool SatisfyQueryAuction(int direction)
        {
            var seconds = (DateTime.Now - queryTime).TotalSeconds;
            if (direction == 1)
            {
                return isAuctionWindowOpen && queryAfterwardAble && seconds >= 1f;
            }
            else if (direction == 2)
            {
                return isAuctionWindowOpen && queryFowardAble && seconds >= 1f;
            }
            return true;
        }

        static List<int> ParseFairyPlayers(string familyPlayerIdStr)
        {
            List<int> list = new List<int>();
            var intArray = LitJson.JsonMapper.ToObject<int[]>(familyPlayerIdStr);
            if (intArray != null)
            {
                list.AddRange(intArray);
            }
            return list;
        }
    }

    public class AuctionItem
    {
        public string itemGuid;
        public int itemId;                        //物品ID
        public int itemCount;

        public int auctionType;                   //拍品类型，0-全服拍品，1-仙盟拍品

        public DateTime putAwayTime;              //上架时间
        public DateTime biddingTime;              //最新竞价时间

        public string customData;                 //自定义数据

        public int familyId;		              //有值时为仙盟拍品
        public List<int> familyPlayers;           //可获得收益的仙盟玩家ID信息存储

        public int recordType;                    //记录类型 0-我的拍品记录 1-仙盟拍品记录 2-我的竞拍记录
        public int recordResult;                  //记录结果 0-流拍 1-拍卖成交 2-回收 3-竞价成功 4-竞价失败

        public int biddingPrice;                  //竞拍玩家出价
        public int biddingPlayer;                 //竞拍玩家ID，也就是当前最高竞价玩家ID
        public string biddingPlayerName;          //成交玩家名

        public AuctionItem(string guid)
        {
            itemGuid = guid;
        }
    }

    public struct FocusAuctionItem
    {
        public string itemGuid;//物品GUID
        public int itemId;//物品ID
    }
}