using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using BattleIce;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace ET.Server
{
    [FriendOf(typeof (Map))]
    [FriendOf(typeof (BattleIceAgentComponent))]
    public static class MapSystem
    {
        public class MapAwakeSystem: AwakeSystem<Map, JObject, WNPlayer>
        {
            protected override void Awake(Map self, JObject opts, WNPlayer player)
            {
                Log.Debug($"创建场景实体...create area opts:{opts.ToString()}");
                self.RoomId = player.GetRoomId();
                self.createTime = TimeHelper.ServerNow();
                self.LogicServerId = opts.SelectToken("logicServerId") != null? Convert.ToInt32(opts.SelectToken("logicServerId")) : 0;
                self.MapId = Convert.ToInt32(opts.SelectToken("areaId"));
                self.Prop = MapConfigCategory.Instance.Get(self.MapId);
                self.Type = self.Prop.Type;
                self.Player = player;
                self.UnitPlayers = new Dictionary<string, Struct.UnitPlayerData>();
                self.DeadUnits = new List<int>();
                self.DeadUnitPlayer = new List<int>();

                // 战斗服事件组件
                self.AddComponent<MapEventComponent>();
                // 场景排行榜组件
                self.AddComponent<MapRankComponent>();
                // token为空过滤一下抖音相关组件
                if (player.GetComponent<PlayerDataComponent>().Data.TokenIsNull)
                {
                    return;
                }
                // 抖音直播礼物置顶
                self.DomainScene().GetComponent<GameDouyinComponent>().TopGifts(self.RoomId);
                // 抖音直播评论任务组件
                self.AddComponent<MapDouyinLiveCommentComponent>();
                // 抖音直播礼物任务组件
                self.AddComponent<MapDouyinLiveGiftComponent>();
                // 抖音直播点赞任务组件
                self.AddComponent<MapDouyinLiveLikeComponent>();
            }
        }

        public class MapDestroySystem: DestroySystem<Map>
        {
            protected override void Destroy(Map self)
            {
                Log.Info($"销毁场景");
            }
        }

        /// <summary>
        /// 初始化场景数据
        /// </summary>
        /// <param name="self"></param>
        public static void Init(this Map self)
        {
            self.UnitPlayers.Clear();
            self.TotalLikeNum = 0;
            self.ConfigNum = 0;
            self.DeadUnits.Clear();
            self.DeadUnitPlayer.Clear();
            self.IsGameOver = false;
            self.CurBattleIndex = 0;
        }

        public static ZoneManagerPrx GetZoneManager(this Map self)
        {
            return self.DomainScene().GetComponent<BattleIceAgentComponent>().IceZoneManager;
        }

        public static XmdsManagerPrx GetXmdsManager(this Map self)
        {
            return self.DomainScene().GetComponent<BattleIceAgentComponent>().IceXmdsManager;
        }

        /// <summary>
        /// 获取战斗服角色数据
        /// </summary>
        /// <param name="self"></param>
        /// <param name="playerId"></param>
        /// <returns></returns>
        private static GetPlayerData GetBattleServerPlayerData(this Map self, long playerId)
        {
            string result = self.GetXmdsManager().getPlayerData(playerId.ToString().Trim(), true);
            return string.IsNullOrEmpty(result)? null : JsonConvert.DeserializeObject<GetPlayerData>(result);
        }

        /// <summary>
        /// 从战斗服同步角色数据
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        public static void SyncPlayerHistoryData(this Map self, WNPlayer player)
        {
            GetPlayerData result = self.GetBattleServerPlayerData(player.GetId());
            if (result == null)
            {
                return;
            }

            player.GetComponent<PlayerTempDataComponent>().SyncNowData(self.MapId, self.InstanceId, result);
            player.GetComponent<PlayerTempDataComponent>().SyncHistoryData(self.Prop, self.InstanceId, result);
        }

        /// <summary>
        /// 获取场景角色
        /// </summary>
        /// <param name="self"></param>
        /// <param name="playerId"></param>
        /// <returns></returns>
        public static WNPlayer GetPlayer(this Map self, long playerId)
        {
            return self.Player;
        }

        /// <summary>
        /// 分配阵营
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        public static void SetForce(this Map self, WNPlayer player)
        {
            player.Force = (int)AreaForce.FORCEA;
        }

        /// <summary>
        /// 移除角色,通用框架接口 切换场景/掉线会自动调用，尽量 不要手动调用
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        /// <param name="keepObject"></param>
        public static void RemovePlayer(this Map self, WNPlayer player, bool keepObject)
        {
            Log.Info($"removePlayer: playerId={player.GetId()}, mapId={self.MapId}, ip={player.Session.RemoteAddress}");
            WNPlayer actorPlayer = self.GetPlayer(player.GetId());
            if (actorPlayer != null)
            {
                // self.Players.Remove(player.GetId());
            }
            // 重置进入场景标识
            player.GetComponent<PlayerTempDataComponent>().MapData.ready = false;
        }

        /// <summary>
        /// 玩家进入场景请求
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        public static void PlayerEnterRequest(this Map self, WNPlayer player)
        {
            bool ready = player.GetComponent<PlayerTempDataComponent>().MapData.ready;
            if (ready)
            {
                Log.Info($"PlayerEnterRequest: playerId={player.GetId()}, ready={ready}");
                return;
            }

            try
            {
                string enterData = player.ToJSON4EnterScene(self);
                Log.Debug($"{player.GetName()}, enterSceneData:{enterData}");
                self.GetZoneManager().playerEnterRequest(player.GetId().ToString().Trim(), self.Id.ToString().Trim(), enterData);
            }
            catch (Exception e)
            {
                Log.Warning(
                    $"playerEnterRequest: playerName={player.GetName()}, instanceId={self.Id}, mapName={self.Prop.Name}, serverID={self.BattleServerId}, e={e}");
            }
        }

        /// <summary>
        /// 场景添加角色
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        public static void AddPlayer(this Map self, WNPlayer player)
        {
            Log.Info($"addPlayer: playerId={player.GetId()}, mapId={self.MapId}, ip={player.Session.RemoteAddress}");
            player.Map = self;
            self.SetForce(player);
            self.Player = player;
        }

        /// <summary>
        /// 玩家进场景后推的消息
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        public static void PlayerReady(this Map self, WNPlayer player)
        {
            self.CurBattleIndex = 0;
        }

        /// <summary>
        /// 角色成功进入场景
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        public static void PlayerEntered(this Map self, WNPlayer player)
        {
        }

        /// <summary>
        /// 玩家登录事件
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        public static void PlayerLogin(this Map self, WNPlayer player)
        {
        }

        /// <summary>
        /// 玩家离开场景请求
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        /// <param name="keepObject"></param>
        public static void PlayerLeaveRequest(this Map self, WNPlayer player, bool keepObject)
        {
            try
            {
                self.GetZoneManager().playerLeaveRequest(player.GetId().ToString().Trim(), self.InstanceId.ToString().Trim(), keepObject);
            }
            catch (Exception e)
            {
                Log.Warning($"playerLeaveRequest: catch - {e}");
            }

            Log.Debug($"playerLeaveRequest--------------------{player.GetName()} - {self.InstanceId} - {self.Prop.Name}");
        }

        /// <summary>
        /// 绑定战斗服
        /// </summary>
        /// <param name="self"></param>
        /// <param name="player"></param>
        /// <param name="serverId"></param>
        public static void BindBattleServer(this Map self, WNPlayer player, string serverId)
        {
            self.BattleServerId = serverId;
        }

        /// <summary>
        /// 创建单位
        /// </summary>
        /// <param name="self"></param>
        /// <param name="data"></param>
        /// <param name="needReturn"></param>
        /// <returns></returns>
        private static async ETTask<int> AddUnits(this Map self, List<Struct.MonsterUnit> data, bool needReturn)
        {
            if (data.Count <= 0)
            {
                return 0;
            }

            int addUnitsResult = 0;

            if (needReturn) {
                addUnitsResult = self.GetXmdsManager().addUnits(self.Id.ToString().Trim(), JsonConvert.SerializeObject(data, Formatting.Indented));
                Log.Info($"addUnits needReturn : mapId={self.MapId}, instanceId={self.Id.ToString().Trim()}, data={data}, add units result={addUnitsResult}");
            } else
            {
                int objId = self.GetXmdsManager().addUnits(self.Id.ToString().Trim(), JsonConvert.SerializeObject(data, Formatting.Indented));
                Log.Info($"addUnits: mapId={self.MapId}, instanceId={self.Id.ToString().Trim()}, objId={objId}");
            }

            await ETTask.CompletedTask;
            return addUnitsResult;
        }

        private static async ETTask<int> AddUnits(this Map self, Struct.MonsterUnit data, bool needReturn)
        {
            List<Struct.MonsterUnit> listData = new List<Struct.MonsterUnit>();
            listData.Add(data);
            return await self.AddUnits(listData, needReturn);
        }

        /// <summary>
        /// 移除单位，战斗服创建的unit
        /// </summary>
        /// <param name="self"></param>
        /// <param name="objectId"></param>
        public static async ETTask RemovePointUnit(this Map self, int objectId)
        {
            self.GetXmdsManager().removePointUnit(self.Id.ToString().Trim(), objectId);
            await ETTask.CompletedTask;
        }

        /// <summary>
        /// 战斗服结束场景
        /// </summary>
        /// <param name="self"></param>
        public static void DestroyZoneRequest(this Map self)
        {
            self.GetZoneManager().destroyZoneRequest(self.Id.ToString());
        }

        /// <summary>
        /// 是否结束
        /// </summary>
        /// <param name="self"></param>
        /// <returns></returns>
        public static bool IsGameOver(this Map self)
        {
            return self.IsGameOver;
        }

        /// <summary>
        /// 增加单位玩家本地数据
        /// </summary>
        /// <param name="self"></param>
        /// <param name="openId"></param>
        /// <param name="templateId"></param>
        /// <param name="force"></param>
        /// <param name="flag"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="name"></param>
        /// <param name="url"></param>
        /// <returns></returns>
        public static async ETTask<Struct.UnitPlayerData> AddUnitPlayer(this Map self, string openId, int templateId, int force, string flag, float x, float y, string name, string url)
        {
            if (self.IsGameOver())
            {
                return null;
            }

            if (templateId <= 0)
            {
                Log.Debug("illegal templateId @AddUnitPlayer");
                return null;
            }
            if (self.UnitPlayers.ContainsKey(openId))
            {
                Log.Debug("already contain unit @AddUnitPlayer");
                return null;
            }

            // 战斗服数据
            Struct.MonsterUnit unit = new Struct.MonsterUnit();
            unit.id = templateId;
            unit.force = force;
            if (!string.IsNullOrEmpty(flag))
            {
                unit.flag = flag;
            }
            else
            {
                unit.x = x;
                unit.y = y;
            }
            unit.autoGuard = true;
            unit.name = name;
            unit.alias = url;

            int objId = await self.AddUnits(unit, true);
            var unitPlayerData = new Struct.UnitPlayerData
            {
                OpenId = openId,
                TemplateId = templateId,
                ObjId = objId,
                Name = unit.name,
                Url = unit.alias,
                Level = 1,
                Likes = 0,
                ReliveTime = 0,
                x = 0,
                y = 0,
                Map = self
            };

            self.UnitPlayers.TryAdd(openId, unitPlayerData);
            return unitPlayerData;
        }

        /// <summary>
        /// 获取单位玩家
        /// </summary>
        /// <param name="self"></param>
        /// <param name="openId"></param>
        /// <returns></returns>
        public static Struct.UnitPlayerData GetUnitPlayerByOpenId(this Map self, string openId)
        {
            if (self.UnitPlayers.TryGetValue(openId, out Struct.UnitPlayerData unitPlayer))
            {
                return unitPlayer;
            }

            return null;
        }

        /// <summary>
        /// 获取单位玩家
        /// </summary>
        /// <param name="self"></param>
        /// <param name="objId"></param>
        /// <returns></returns>
        public static Struct.UnitPlayerData GetUnitPlayerByObjId(this Map self, int objId)
        {
            return self.UnitPlayers.Values.FirstOrDefault(unitPlayer => unitPlayer != null && unitPlayer.ObjId == objId);
        }

        /// <summary>
        /// 玩家增加贡献值
        /// </summary>
        /// <param name="self"></param>
        /// <param name="openId"></param>
        /// <param name="addValue"></param>
        public static void AddContributeValue(this Map self, string openId, long addValue)
        {
            Struct.UnitPlayerData unitPlayerData = self.GetUnitPlayerByOpenId(openId);

            if (unitPlayerData == null)
            {
                return;
            }

            if (self.IsGameOver())
            {
                return;
            }

            long value = unitPlayerData.ContributeValue + addValue;

            if (value >= long.MaxValue)
            {
                value = long.MaxValue;
            }

            unitPlayerData.ContributeValue = value;
        }

        /// <summary>
        /// 获取抖音直播接口调用凭证
        /// </summary>
        /// <param name="self"></param>
        /// <returns></returns>
        public static string GetDouyinAccessToken(this Map self)
        {
            return self.DomainScene().GetComponent<GameDouyinComponent>().AccessToken;
        }

        /// <summary>
        /// 获得当前战场（当前塔位置）,随机位置
        /// </summary>
        /// <param name="self"></param>
        /// <returns></returns>
        public static Vector2 GetRandomPlayerPos(this Map self)
        {
            Vector2[] TowerPos = { new Vector2() { X = 103, Y = 197 }, new Vector2() { X = 190, Y = 133 }, new Vector2() { X = 104, Y = 69 } };
            int index = self.CurBattleIndex;
            Vector2 tower = TowerPos[index];
            Random rand = new Random();
            float r;
            double ang;
            if (index == 0)
            {
                r = (float)Math.Sqrt(rand.Next(2500)) + 10;
                ang = rand.Next(22) / 180.0f * Math.PI + Math.PI * 78f / 180f + Math.PI;
            }
            else if (index == 1)
            {
                r = (float)Math.Sqrt(rand.Next(3136)) + 10;
                ang = rand.Next(20) / 180.0f * Math.PI + Math.PI * 76f / 180f;
            }
            else
            {
                r = (float)Math.Sqrt(rand.Next(2500)) + 10;
                ang = rand.Next(22) / 180.0f * Math.PI + Math.PI * 150f / 180f;
            }

            return new Vector2(tower.X + (float)(r * Math.Cos(ang)), tower.Y - (float)(r * Math.Sin(ang)));
        }

        public static void TransferUnitsToNewTower(this Map self)
        {
            foreach(Struct.UnitPlayerData player in self.UnitPlayers.Values)
            {
                Vector2 pos = self.GetRandomPlayerPos();
                self.GetXmdsManager().transferUnit(self.Id.ToString(), player.ObjId, pos.X, pos.Y);
            }
            Log.Debug($"transfer unit: {self.UnitPlayers.Count}");
        }
    }
}