using System;
using System.Collections.Generic;
using System.Linq;

namespace ET.Server
{
    [FriendOf(typeof (HGHuangHuangComponent))]
    public static class HGHuangHuangComponentSystem
    {
        [ObjectSystem]
        public class HGHuangHuangComponentAwakeSystem: AwakeSystem<HGHuangHuangComponent>
        {
            protected override void Awake(HGHuangHuangComponent self)
            {
                Room room = self.GetParent<Room>();
                if (room == null)
                {
                    Log.Error($"黄冈晃晃主逻辑组件获取不到主实体...");
                    return;
                }
                
                Log.Info($"创建黄冈晃晃主逻辑组件...");
                self.Flag = false;
                self.Time = 0;
                self.State = 0;
                self.Players = new Player[4];
                self.CurrentRound = 0;
                self.ZhuangPos = 0;
                self.Rand = new[] { 0, 0 };
                self.AdmitDefeatList = new List<long>();
                self.CanHuIds = new List<Player>();
                self.CanPgIds = new List<Player>();
                self.OperableList = new List<Player>();
                self.ClickHuIds = new List<Player>();
                self.CardList = new List<int>();
                self.UpdateTime = 0;
                // 初始化玩家
                int index = 0;
                foreach (Player player in room.GetAllPlayers().Values)
                {
                    if (player != null)
                    {
                        self.Players[index] = player;
                        index++;
                    }
                }
                // 初始化牌库
                for (int i = 0; i < 4; i++)
                {
                    foreach (int value in HGHuangHuangConst.Values)
                    {
                        self.CardList.Add(value);
                    }
                    RandomGenerator.Shuffle(self.CardList);
                }
            }
        }
    
        [ObjectSystem]
        public class HGHuangHuangComponentDestroySystem: DestroySystem<HGHuangHuangComponent>
        {
            protected override void Destroy(HGHuangHuangComponent self)
            {
                Log.Info($"销毁黄冈晃晃主逻辑组件...");
            }
        }

        [ObjectSystem]
        [FriendOf(typeof(Room))]
        public class HGHuangHuangComponentUpdateSystem : UpdateSystem<HGHuangHuangComponent>
        {
            protected override void Update(HGHuangHuangComponent self)
            {
                long timeNow = TimeHelper.ClientNow();
                // 每秒执行一次
                if (timeNow - self.UpdateTime <= 1000)
                {
                    return;
                }
                self.UpdateTime = timeNow;

                Room room = self.GetParent<Room>();
                if (room == null)
                {
                    Log.Error($"黄冈晃晃主逻辑组件获取不到主实体...");
                    return;
                }

                switch (self.State)
                {
                    case 0:
                        // 等待状态
                        Log.Debug($"检测: 黄冈晃晃-房间号:{room.RoomId}, 房间人数:{room.Players.Count}, 状态:检测是否可开局...");
                        if (self.CheckReadyStart(room))
                        {
                            self.State = 1;
                            self.Flag = false;
                            self.Time = 0;
                        }
                        
                        // 120秒未开始直接解散
                        if (self.Time >= 120)
                        {
                            room.Dispose();
                        }
                        break;
                    case 1:
                        // 开局
                        if (!self.Flag)
                        {
                            if (self.Time >= 3)
                            {
                                self.Start(room);
                                self.Flag = true;
                                self.Time = 0;
                                Log.Debug($"检测: 黄冈晃晃-房间号:{room.RoomId}, 房间人数:{room.Players.Count}, 状态:开局...VS动画...");
                            }
                        }
                        else
                        {
                            if (self.Time > 0)
                            {
                                self.State = 2;
                                self.Flag = false;
                                self.Time = 0;
                            }
                        }
                        break;
                    case 2:
                        // 进行中
                        if (!self.Flag)
                        {
                            self.Flag = true;
                            self.Time = 0;
                            // 摸牌
                            self.DrawCard(room);
                        }
                        else
                        {
                            // 强制操作
                            if (self.Time > 30)
                            {

                            }
                        }
                        break;
                    case 3:
                        // 已结束

                        break;
                }

                self.Time++;
            }
        }

        /// <summary>
        /// 检测是否可开始 3秒倒计时开始
        /// </summary>
        /// <param name="self"></param>
        /// <param name="room"></param>
        /// <returns></returns>
        private static bool CheckReadyStart(this HGHuangHuangComponent self, Room room)
        {
            if (!room.IsStart() || self.State != 0)
            {
                return false;
            }
            
            // 通知客户端3秒倒计时
            foreach (Player player in room.GetAllPlayers().Values.Where(player => player != null))
            {
                MessageHelper.SendToClient(player, new G2C_ReadyStartPush(){ReadyStartTime = 3});
            }

            return true;
        }

        
        /// <summary>
        /// 发牌
        /// </summary>
        /// <param name="self"></param>
        /// <param name="room"></param>
        private static void SendCard(this HGHuangHuangComponent self, Room room)
        {
            foreach (Player player in room.GetAllPlayers().Values)
            {
                if (player == null)
                {
                    continue;
                }

                for (int i = 0; i < 13; i++)
                {
                    int card = self.CardList[0];
                    player.RemainCards = CardHelper.Add(player.RemainCards, card);
                    self.CardList.RemoveAt(0);
                }
            }
        }

        /// <summary>
        /// 游戏开局
        /// </summary>
        /// <param name="self"></param>
        /// <param name="room"></param>
        private static void Start(this HGHuangHuangComponent self, Room room)
        {
            self.CurrentRound += 1;
            // 摇骰子
            int rand1 = RandomGenerator.RandomNumber(1, 7);
            int rand2 = RandomGenerator.RandomNumber(1, 7);
            self.Rand = new[] { rand1, rand2 };
            // 定庄
            self.ZhuangPos = (rand1 + rand2) % 4;
            // 设置当前操作玩家
            self.CurrentPlayer = room.GetAllPlayers()[self.ZhuangPos];
            // 设置当前摸牌玩家
            self.DrawCardPlayer = room.GetAllPlayers()[self.ZhuangPos];
            // 发牌
            self.SendCard(room);
            // 广播
            foreach (Player player in room.GetAllPlayers().Values)
            {
                if (player == null)
                {
                    continue;
                }

                player.State = 2;
                    
                MessageHelper.SendToClient(player, new G2C_StartPush(){info = ProtoHelper.RoomToProto(room, player, null)});
                    
                Log.Info($"游戏开局, 房间id={room.RoomId}, 玩家id={player.Id}, 玩家={player.Name}, 手牌信息={player.RemainCards}");
            }
        }
        
        /// <summary>
        /// 摸牌
        /// </summary>
        /// <param name="self"></param>
        /// <param name="room"></param>
        private static void DrawCard(this HGHuangHuangComponent self, Room room)
        {
            // 2个以上玩家认输或牌库没牌了直接结束
            if (self.AdmitDefeatList.Count > 2 || self.CardList.Count <= 0)
            {
                self.GameOver(room);
                return;
            }
            
            Player drawCardPlayer = self.DrawCardPlayer;
            if (drawCardPlayer == null)
            {
                Log.Error($"房间id={room.RoomId}, 摸牌玩家为空...");
                return;
            }
            // 摸牌
            int card = self.CardList[0];
            drawCardPlayer.RemainCards = CardHelper.Add(drawCardPlayer.RemainCards, card);
            self.CardList.RemoveAt(0);
            // 当前摸的牌
            self.DrawCard = card;
            // 吃,碰,杠,胡,过
            bool hasAct = false;
            // 检测摸牌人动作, 校验摸牌是否胡
            Struct.HuRes huRes = HGHuangHuangHelper.CheckHu(drawCardPlayer.RemainCards);
            if (huRes.Type != HGHuangHuangConst.HU_DEFAULT)
            {
                hasAct = true;
                drawCardPlayer.Act[3] = 1;
                self.CanHuIds.Add(drawCardPlayer);
                if (!self.OperableList.Contains(drawCardPlayer))
                {
                    self.OperableList.Add(drawCardPlayer);
                }
            }
            // todo 玩家听牌状态不允许杠
            // 检测摸牌人动作, 校验摸牌是否杠
            List<Struct.Kezi> gang = HGHuangHuangHelper.IsDrawGang(drawCardPlayer);
            if (gang is { Count: > 0 })
            {
                hasAct = true;
                drawCardPlayer.Act[2] = 1;
                if (!self.OperableList.Contains(drawCardPlayer))
                {
                    self.OperableList.Add(drawCardPlayer);
                }
                if (!self.CanPgIds.Contains(drawCardPlayer))
                {
                    self.CanPgIds.Add(drawCardPlayer);
                }
            }
            // 过牌
            drawCardPlayer.Act[4] = hasAct? 1 : 0;
            if (drawCardPlayer.HuCards.Any(_card => _card > 0 && _card == self.DrawCard))
            {
                drawCardPlayer.Act[4] = 0;
            }
            // 推送摸牌广播
            foreach (Player player in room.GetAllPlayers().Values)
            {
                if (player == null)
                {
                    continue;
                }

                MessageHelper.SendToClient(player, new G2C_DrawCardPush(){info = ProtoHelper.RoomToProto(room, player, drawCardPlayer)});
                    
                Log.Info($"摸牌, 房间id={room.RoomId}, 玩家id={player.Id}, 玩家={player.Name}, 摸牌玩家={player.Id == drawCardPlayer.Id}, 手牌信息={player.RemainCards}, 摸的牌={card}");
            }
        }

        /// <summary>
        /// 结束
        /// </summary>
        /// <param name="self"></param>
        /// <param name="room"></param>
        private static void GameOver(this HGHuangHuangComponent self, Room room)
        {
            
        }
    }
}