using System.Collections.Generic;
using EventPartnerGatherRequests;
using System.Linq;
using asap.core;
using game;
using System;


namespace EventPartner
{
    /// <summary>
    /// Store invitation data, but not necessarrily the info shown on panel, meaning, no potential robot info.
    /// </summary>
    public class InvitationData
    {
        // List block priority: Refuse = Partners > Invite > Request > Friend > Recommend
        private HashSet<string> _refusePfIdSet = new HashSet<string>();
        private HashSet<string> _invitePfIdSet = new HashSet<string>();
        private HashSet<string> _requestPfIdSet = new HashSet<string>();
        private HashSet<string> _friendPfIdSet = new HashSet<string>();
        private HashSet<string> _recommendPfIdSet = new HashSet<string>();
        // private DateTime _recommendExpiryTime = DateTime.MinValue;
        private IEventPartnerArchitecture _arc;

        public HashSet<string> RefusePfIdSet => _refusePfIdSet;
        public HashSet<string> InvitePfIdSet => _invitePfIdSet;
        public HashSet<string> RequestPfIdSet => _requestPfIdSet;
        public HashSet<string> FriendPfIdSet => _friendPfIdSet;
        public HashSet<string> RecommendPfIdSet => _recommendPfIdSet;

        private int _invitationCount;
        private readonly cfg.Tables _tables = GContext.container.Resolve<cfg.Tables>();
        public int ActiveFriendCountThreshold => _tables.TbEventPartnerConfig.FriendRecommendParam1[0];
        public int RecommendCount => _tables.TbEventPartnerConfig.FriendRecommendParam2[GContext.container.Resolve<FriendService>().FriendList.Count < ActiveFriendCountThreshold ? 0 : 1];
        public int RecommendTriggerCount => _tables.TbEventPartnerConfig.RobotRecommendTriggerCount;
        public bool DoRecommendBot => _invitationCount >= RecommendTriggerCount;
        public float RobotRecommendRatio => _tables.TbEventPartnerConfig.RobotRecommendCount;
        public int InvitationCount => _invitationCount;
        // public DateTime RecommendExpiryTime => _recommendExpiryTime;
        public InvitationData(IEventPartnerArchitecture arc)
        {
            _arc = arc;
        }

        public void Init(HashSet<string> refusePfIdSet, InvitationCache recommendCache)
        {
            _refusePfIdSet = refusePfIdSet;
            // _recommendExpiryTime = recommendCache.ExpiryTime;
            _recommendPfIdSet = recommendCache.RecommendPfIds.ToHashSet();
            _invitationCount = recommendCache.InvitationCount;
        }

        public void FillInDetail(HashSet<string> partners, EventPartnerGatherDetail detail)
        {
            var selfPfId = GContext.container.Resolve<IUserService>().UserId;
            _invitePfIdSet = detail.InvitePartners
                .Select(x => x.PlayFabId)
                .Where(s => !_refusePfIdSet.Contains(s) && !partners.Contains(s) && s != selfPfId)
                .ToHashSet();
            _requestPfIdSet = detail.RequestPartners
                .Select(x => x.PlayFabId)
                .Where(s => !_refusePfIdSet.Contains(s) && !partners.Contains(s) && s != selfPfId
                    && !_invitePfIdSet.Contains(s))
                .ToHashSet();
            _friendPfIdSet = GContext.container.Resolve<FriendService>().FriendList
                .Select(x => x.playFabId)
                .Where(s => !_refusePfIdSet.Contains(s) && !partners.Contains(s) && s != selfPfId
                    && !_invitePfIdSet.Contains(s) && !_requestPfIdSet.Contains(s))
                .ToHashSet();

            // if (ZZTimeHelper.UtcNow() < _recommendExpiryTime)
            //     _recommendPfIdSet = _recommendPfIdSet
            //         .Where(s => !_refusePfIdSet.Contains(s) && !partners.Contains(s) && s != selfPfId
            //             && !_invitePfIdSet.Contains(s) && !_requestPfIdSet.Contains(s) && !_friendPfIdSet.Contains(s))
            //         .ToHashSet();
            // else
            // {
            _recommendPfIdSet = GenerateNewRecommendList(detail).ToHashSet();
            // _recommendExpiryTime = ZZTimeHelper.UtcNow() + TimeSpan.FromSeconds(GContext.container.Resolve<cfg.Tables>().TbEventPartnerConfig.FriendRecommendListRefreshTime);
            // }
            _arc.SavePlayerPreference();
        }

        public void FillInFriends()
        {
            var selfPfId = GContext.container.Resolve<IUserService>().UserId;
            var partners = _arc.Model.PartnerIdSet;
            _friendPfIdSet = GContext.container.Resolve<FriendService>().FriendList
                .Select(x => x.playFabId)
                .Where(s => !_refusePfIdSet.Contains(s) && !partners.Contains(s) && s != selfPfId
                    && !_invitePfIdSet.Contains(s) && !_requestPfIdSet.Contains(s))
                .ToHashSet();
        }

        public bool IsRefused(string pfId)
        {
            return _refusePfIdSet.Contains(pfId);
        }

        public void OnInvite(string pfId)
        {
            _invitePfIdSet.Add(pfId);
            _requestPfIdSet.Remove(pfId);
            _friendPfIdSet.Remove(pfId);
            _recommendPfIdSet.Remove(pfId);
            _refusePfIdSet.Remove(pfId);
            _invitationCount++;
        }

        public void OnAccept(string pfId)
        {
            _invitePfIdSet.Remove(pfId);
            _requestPfIdSet.Remove(pfId);
            _friendPfIdSet.Remove(pfId);
            _recommendPfIdSet.Remove(pfId);
            _refusePfIdSet.Remove(pfId);
        }

        public void OnRefuse(string pfId)
        {
            _invitePfIdSet.Remove(pfId);
            _requestPfIdSet.Remove(pfId);
            _friendPfIdSet.Remove(pfId);
            _recommendPfIdSet.Remove(pfId);
            _refusePfIdSet.Add(pfId);
        }

        public void OnRequest(string pfId)
        {
            _invitePfIdSet.Remove(pfId);
            _requestPfIdSet.Add(pfId);
            _friendPfIdSet.Remove(pfId);
            _recommendPfIdSet.Remove(pfId);
            _refusePfIdSet.Remove(pfId);
        }

        public InvitationCache ToCache()
        {
            var res = new InvitationCache();
            // res.ExpiryTime = _recommendExpiryTime;
            res.RecommendPfIds = _recommendPfIdSet.ToList();
            res.RefusePfIds = _refusePfIdSet.ToList();
            res.InvitationCount = _invitationCount;
            return res;
        }

        public IEnumerable<string> GenerateNewRecommendList(EventPartnerGatherDetail detail)
        {
            var count = RecommendCount;
            var res = new List<string>();
            if (DoRecommendBot)
            {
                var actualBotCount = (int)(count * RobotRecommendRatio);
                res.AddRange(detail.RecommendInfoList.Select(x => x.PlayFabId).Take(count - actualBotCount));
                res.AddRange(_arc.Ctx.GetBotRecommendIdList(actualBotCount));
            }
            else
                res.AddRange(detail.RecommendInfoList.Select(x => x.PlayFabId).Take(count));
            var partners = detail.Partners.Select(x => x.PlayFabId).ToHashSet();
            var selfPfId = GContext.container.Resolve<IUserService>().UserId;
            return res.Where(s => !_refusePfIdSet.Contains(s) && !partners.Contains(s) && s != selfPfId
                    && !_invitePfIdSet.Contains(s) && !_requestPfIdSet.Contains(s) && !_friendPfIdSet.Contains(s));
        }
        // #if UNITY_EDITOR
        //         public void RefreshInvitation()
        //         {
        //             _recommendExpiryTime = ZZTimeHelper.UtcNow();
        //         }
        // #endif
        public void SetInvitationCount(int n)
        {
            _invitationCount = n;
        }
    }

    public class InvitationCache
    {
        public List<string> RecommendPfIds { get; set; } = new List<string>();
        public List<string> RefusePfIds { get; set; } = new List<string>();
        public int InvitationCount { get; set; }
    }
}