using System;
using System.Collections.Generic;
using System.Linq;
using ProtoCSStruct;
using Sog;

namespace Game
{
    public class BattlePassSvc
    {
        public static void OnRoleEnter(PlayerOnGame player, ActivityType type)
        {
        }

        public static void OnStateChange(PlayerOnGame player, int actId, ActivityState state)
        {
            switch (state)
            {
                case ActivityState.ActivityEnded:
                    SendRewardMail(player, actId);
                    RemoveBattlePass(player, actId);
                    RemoveBattleItem(player, actId);
                    break;
                case ActivityState.InProgress:
                    AddBattlePass(player, actId);
                    break;
                case ActivityState.GameplayEnded:
                    RemoveBattlePass(player, actId);
                    break;
            }
        }


        public static void OnDailyRefresh(PlayerOnGame player, ref DBActInfo activityInfo)
        {
            return;
            //由于任务配置在活动上面得到，所以这里不需要处理
            var actId = activityInfo.ActID;
            var index = -1;
            ref var battlePassData = ref player.RoleData.ActExtraInfo.BattlePassData;

            for (var i = 0; i < battlePassData.Count; i++)
            {
                if (battlePassData[i].ActId == actId)
                {
                    index = i;
                    break;
                }
            }

            if (index < 0)
            {
                return;
            }

            ref var battlePass = ref battlePassData[index];
            var type = battlePass.ReasonType;
            switch ((ReasonType)type)
            {
                case ReasonType.QuestEXDesc:
                    //todo 刷新任务
                    break;
            }
        }


        //购买成功之后
        public static void OnBuySuccess(PlayerOnGame player, int itemId, uint payDiamond, uint addDiamond, uint money,
            bool isPlayerFirstPay,
            long payTime3rd, ref CSPayGoogleSuccessRes csRes)

        {
            var payDiamondDesc = PayDiamondDescMgr.Instance.GetConfig(itemId);
            if (payDiamondDesc == null || payDiamondDesc.passCardType == 0)
            {
                return;
            }

            var activityId = payDiamondDesc.activityId;
            var state = ActivitySvc.GetActivityState(player, activityId);
            if (state != ActivityState.InProgress)
            {
                return;
            }

            var activityDesc = ActivityDescMgr.Instance.GetConfig(activityId);
            ref var battlePassData = ref player.RoleData.ActExtraInfo.BattlePassData;
            var index = -1;
            for (var i = 0; i < battlePassData.Count; i++)
            {
                if (battlePassData[i].ActId == activityId)
                {
                    index = i;
                    break;
                }
            }

            if (index >= 0)
            {
                var activeIndex = activityDesc.subType == payDiamondDesc.passCardType ? 0 : 1; //激活的挡位，默认为0.高级档1
                battlePassData[index].Active[activeIndex] = true;
                BuyUnLockSeq(player, activityId, payDiamondDesc.unlockToLevel);
                player.MakeDirty();
                SyncBattlesInfo(player);
            }
        }


        private static void BuyUnLockSeq(PlayerOnGame player, int actId, int seq)
        {
            if (seq == 0)
            {
                return;
            }

            ref var battlePassData = ref player.RoleData.ActExtraInfo.BattlePassData;
            var index = -1;
            for (var i = 0; i < battlePassData.Count; i++)
            {
                if (battlePassData[i].ActId == actId)
                {
                    index = i;
                    break;
                }
            }

            if (index < 0)
            {
                return;
            }

            var activityDesc = ActivityDescMgr.Instance.GetConfig(actId);
            ref var battlePass = ref battlePassData[index];
            var groupDesc = PassCardDescMgr.Instance.GetGroup(activityDesc.subType);
            var type = groupDesc.First().Value.reasonType;
            switch (type)
            {
                case ReasonType.PowerCostY:
                case ReasonType.PowerCost:
                {
                    var point = 0;

                    foreach (var kv in groupDesc)
                    {
                        if (kv.Value.seq == seq)
                        {
                            point = kv.Value.reasonTypeNum[0];
                            break;
                        }
                    }
                    battlePass.Point = Math.Max(point, battlePass.Point);
                }
                    break;
                default:
                    TraceLog.Debug("BattlePass.BuyUnLockSeq type not supported type={0}", type);
                    break;
            }
        }


        private static void AddBattlePass(PlayerOnGame player, int actId)
        {
            ref var battlePassData = ref player.RoleData.ActExtraInfo.BattlePassData;
            for (int i = 0; i < battlePassData.Count; i++)
            {
                if (battlePassData[i].ActId == actId)
                {
                    return;
                }
            }

            var activityDesc = ActivityDescMgr.Instance.GetConfig(actId);
            var desc = PassCardDescMgr.Instance.GetConfig(activityDesc.subType, 1);
            var defVal = GetConductionDefaultValue(player, desc.reasonType, desc.reasonTypeNum);
            var active = new RepeatedBool_2();
            active.Add(false);
            active.Add(false);
            var battle = new BattlePassData()
            {
                Active = active,
                ActId = actId,
                StartTime = ActivitySvc.GetActOpenTimeDate(player, actId),
                EndTime = ActivitySvc.GetLastTimeToEnd(player, actId),
                Point = defVal
            };
            battlePassData.Add(battle);
            AddBattlePassQuest(player, actId);
            SyncBattlesInfo(player);
        }

        //领取奖励
        public static void Award(PlayerOnGame player, StructPacket packet)
        {
            ref var req = ref packet.GetMessage<CSBattlePassGetAwardReq>();
            var actId = req.ActId;
            var cmd = (int)CSGameMsgID.BattlePassAwardRes;
            var res = new CSBattlePassGetAwardRes();

            ref var battlePassData = ref player.RoleData.ActExtraInfo.BattlePassData;
            var index = -1;
            for (int i = 0; i < battlePassData.Count; i++)
            {
                if (battlePassData[i].ActId == actId)
                {
                    index = i;
                }
            }

            if (index == -1)
            {
                res.Ret = CSErrCode.Fail;
                player.SendToClient(cmd, ref res);
                return;
            }

            ref var battlePass = ref battlePassData[index];
            if (ActivitySvc.GetActivityState(player, actId) != ActivityState.InProgress)
            {
                res.Ret = CSErrCode.Fail;
                player.SendToClient(cmd, ref res);
                return;
            }

            var rewards = GetAllCanAwardList(player, ref battlePass, req.FreeIndex, req.PayIndex, req.SupPayIndex);
            var unifyOp = new UnifyOp(player, BillChangeItemReason.BattlePass);
            if (rewards != null)
            {
                foreach (var reward in rewards)
                {
                    unifyOp.AddGoods(reward.Type, reward.Id.ToString(), reward.Value);
                }

                unifyOp.DoOp(sendGetItemMsg: true);
            }

            player.MakeDirty();
            SyncBattlesInfo(player);
            player.SendToClient(cmd, ref res);
        }

        public static void SyncBattlesInfo(PlayerOnGame player)
        {
            //发送给客户端
            var sync = new CSBattlePassInfoSync();
            sync.BattlePassData.CopyFrom(ref player.RoleData.ActExtraInfo.BattlePassData);
            player.SendToClient((int)CSGameMsgID.BattlePassInfoSyn, ref sync);
        }

        //添加点数：可从道具、背包、任务等不同渠道
        public static void AddPoint(PlayerOnGame player, ReasonType type, int num)
        {
            ref var battlePassData = ref player.RoleData.ActExtraInfo.BattlePassData;
            var change = false;
            for (int i = 0; i < battlePassData.Count; i++)
            {
                ref var battlePass = ref battlePassData[i];
                var actId = battlePass.ActId;
                if (ActivitySvc.GetActivityState(player, actId) != ActivityState.InProgress)
                {
                    continue;
                }

                var passCardId = ActivityDescMgr.Instance.GetConfig(actId).subType;
                var group = PassCardDescMgr.Instance.GetGroup(passCardId);
                var oneType = group.Values[0].reasonType;
                if (type != oneType)
                {
                    continue;
                }

                switch (type)
                {
                    case ReasonType.Level:
                    case ReasonType.PowerCost:
                        battlePass.Point += num;
                        break;
                    case ReasonType.PowerCostY:
                        battlePass.Point = num;
                        break;
                    default:
                        break;
                }

                change = true;
            }

            if (change)
            {
                SyncBattlesInfo(player);
                player.MakeDirty();
            }
        }


        //把没有领取的奖励通过邮件发送给玩家
        private static void SendRewardMail(PlayerOnGame player, int actId)
        {
            var activityDesc = ActivityDescMgr.Instance.GetConfig(actId);
            if (activityDesc.mailId == 0)
            {
                return;
            }

            ref var battlePassData = ref player.RoleData.ActExtraInfo.BattlePassData;
            var index = -1;
            for (int i = 0; i < battlePassData.Count; i++)
            {
                if (battlePassData[i].ActId == actId)
                {
                    index = i;
                    break;
                }
            }

            if (index <= -1)
            {
                return;
            }

            ref var battlePass = ref battlePassData[index];
            if (battlePass.SendReward)
            {
                return;
            }

            var rewards = GetAllCanAwardList(player, ref battlePass);
            battlePass.SendReward = true;
            if ((rewards == null || rewards.Count == 0))
            {
                return;
            }

            var list = new List<RewardItemRW>();
            for (var i = 0; i < rewards.Count; i++)
            {
                if (rewards[i].Type == 0 || rewards[i].Value == 0 || string.IsNullOrEmpty(rewards[i].Id.ToString()))
                {
                    continue;
                }

                list.Add(new RewardItemRW()
                    { type = rewards[i].Type, code = rewards[i].Id.ToString(), amount = rewards[i].Value });
            }

            MailSender.SendNewMailToPlayer(player, activityDesc.mailId, list);
        }


        private static void RemoveBattlePass(PlayerOnGame player, int actId)
        {
            ref var battlePassData = ref player.RoleData.ActExtraInfo.BattlePassData;
            for (int i = 0; i < battlePassData.Count; i++)
            {
                if (battlePassData[i].ActId == actId)
                {
                    battlePassData.RemoveAt(i);
                    return;
                }
            }

            SyncBattlesInfo(player);
            RemoveBattlePassQuest(player, actId);
        }

        private static void AddBattlePassQuest(PlayerOnGame player, int actId)
        {
        }

        private static void RemoveBattlePassQuest(PlayerOnGame player, int actId)
        {
        }

        private static void RemoveBattleItem(PlayerOnGame player, int actId)
        {
            var passCardId = ActivityDescMgr.Instance.GetConfig(actId).subType;
            var passCardDescList = PassCardDescMgr.Instance.GetGroup(passCardId);
            var desc = passCardDescList.First().Value;
            if (desc.reasonType != ReasonType.ItemNum)
            {
                return;
            }

            var itemInternalId = desc.reasonTypeNum[0];
            var itemDesc = ItemDescMgr.Instance.GetConfigByInternal(itemInternalId);

            if (itemDesc == null)
            {
                return;
            }

            var unifyOp = new UnifyOp(player, BillChangeItemReason.BattlePass);
            var itemCount = unifyOp.GetItemCount(itemDesc.itemID);
            if (itemCount > 0)
            {
                unifyOp.CostItem(itemDesc.itemID, itemCount);
                unifyOp.DoOp();
                player.MakeDirty();
            }
        }

        //检查battlepass栏目上的奖励是否达到领取条件
        public static bool CheckItemGainRewardConduction(PlayerOnGame player, PassCardDesc desc, int point)
        {
            switch (desc.reasonType)
            {
                case ReasonType.Level: //level
                    return player.RoleBase.Level >= desc.reasonTypeNum[0];
                case ReasonType.QuestEXDesc: //QUEST   //todo
                    return TaskEXSvc.IsCompleteTask(player, desc.reasonTypeNum[0]) ||
                           TaskEXSvc.IsFinishTask(player, desc.reasonTypeNum[0]);
                case ReasonType.PowerCost: //point
                case ReasonType.PowerCostY: //point
                {
                    return point >= desc.reasonTypeNum[0];
                }
                case ReasonType.ItemNum: //item num
                {
                    var itemInternalId = desc.reasonTypeNum[0];
                    var itemDesc = ItemDescMgr.Instance.GetConfigByInternal(itemInternalId);
                    var itemCount = UnifyOp.GetItemCount(player, itemDesc.itemID);
                    return itemCount >= desc.reasonTypeNum[1];
                }
                case ReasonType.ChapterPass:
                    return desc.reasonTypeNum[1] <= player.RoleData.ChapterData.BattleId;
            }

            return false;
        }

        public static int GetConductionDefaultValue(PlayerOnGame player, ReasonType reasonType, int[] value)
        {
            switch (reasonType)
            {
                case ReasonType.Level: //level
                    return player.RoleBase.Level;
                case ReasonType.PowerCostY:
                    return player.RoleData.PowerPointData.CostPower;
                    break;
            }

            return 0;
        }

        //获取免费奖励
        public static List<TypeIDValueString> GetFreeAward(PassCardDesc passCard)
        {
            return passCard.free.Select(t => new TypeIDValueString
            {
                Type = t.Type,
                Id = new FixedStructString64(t.Id), Value = t.Value
            }).ToList();
        }

        //获取付费档奖励
        public static List<TypeIDValueString> GetPayAward(PassCardDesc passCard)
        {
            return passCard.pay.Select(t => new TypeIDValueString
            {
                Type = t.Type,
                Id = new FixedStructString64(t.Id), Value = t.Value
            }).ToList();
        }


        //获取当前可以领取的奖励
        private static List<TypeIDValueString> GetAllCanAwardList(PlayerOnGame player, ref BattlePassData battlePass,
            int freeIndex = 0, int payIndex = 0, int subPayIndex = 0)
        {
            var list = new List<TypeIDValueString>();

            var activityDesc = ActivityDescMgr.Instance.GetConfig(battlePass.ActId);
            if (activityDesc.subType == 0)
            {
                return list;
            }

            var passCardDesc = PassCardDescMgr.Instance.GetGroup(activityDesc.subType);
            var desc = PassCardDescMgr.Instance.GetConfig(activityDesc.subType, Math.Max(freeIndex, payIndex));
            list = GetCanAward(player, ref battlePass, desc, freeIndex > 0, payIndex > 0);
            if (subPayIndex > 0 && activityDesc.param1.Length != 0)
            {
                var passCard = PassCardDescMgr.Instance.GetConfig(int.Parse(activityDesc.param1[0]), subPayIndex);
                var reward = GetCanSupAward(player, ref battlePass, passCard);
                if (reward != null)
                {
                    GenericUtils.Merge(list, reward);
                }
            }

            if (freeIndex > 0 || payIndex > 0 || subPayIndex > 0) //单独领取其中某一个
            {
                return list;
            }

            foreach (var passCard in passCardDesc.Select(kv => kv.Value))
            {
                var reward = GetCanAward(player, ref battlePass, passCard);
                if (reward != null)
                {
                    GenericUtils.Merge(list, reward);
                }
            }

            if (activityDesc.param1.Length != 0)
            {
                var supPassCardDesc = PassCardDescMgr.Instance.GetGroup(int.Parse(activityDesc.param1[0]));
                foreach (var passCard in supPassCardDesc.Select(kv => kv.Value))
                {
                    var reward = GetCanSupAward(player, ref battlePass, passCard);
                    if (reward != null)
                    {
                        GenericUtils.Merge(list, reward);
                    }
                }
            }

            return list;
        }

        private static List<TypeIDValueString> GetCanAward(PlayerOnGame player, ref BattlePassData battlePass,
            PassCardDesc passCard, bool gainFree = true, bool gainPay = true)
        {
            var ret = new List<TypeIDValueString>();
            if (passCard == null)
            {
                return ret;
            }

            var canGain = CheckItemGainRewardConduction(player, passCard, battlePass.Point);
            if (!canGain)
            {
                return ret;
            }

            if (gainFree && !battlePass.FreeIndex.Contains(passCard.seq))
            {
                var freeAward = GetFreeAward(passCard);
                GenericUtils.Merge(ret, freeAward);
                battlePass.FreeIndex.Add(passCard.seq);
            }

            if (battlePass.Active.Count == 0)
            {
                return ret;
            }

            if (gainPay && battlePass.Active[0] && !battlePass.PayIndex.Contains(passCard.seq))
            {
                var payAward = GetPayAward(passCard);
                GenericUtils.Merge(ret, payAward);
                battlePass.PayIndex.Add(passCard.seq);
            }

            return ret;
        }

        private static List<TypeIDValueString> GetCanSupAward(PlayerOnGame player, ref BattlePassData battlePass,
            PassCardDesc passCard)
        {
            var canGain = CheckItemGainRewardConduction(player, passCard, battlePass.Point);
            if (!canGain)
            {
                return null;
            }

            if (battlePass.Active.Count != 2)
            {
                return null;
            }

            if (battlePass.Active[1] && !battlePass.SupPayIndex.Contains(passCard.seq))
            {
                var payAward = GetPayAward(passCard);
                battlePass.SupPayIndex.Add(passCard.seq);
                return payAward;
            }

            return null;
        }
    }
}