using System.Collections.Generic;
using Gameplay.Area;
using Gameplay.Character;
using Gameplay.Level;
using Gameplay.Unit;
using Gameplay.Unit.Data;
using Gameplay.Vehicle.Impl;
using PhxhSDK;
using UnityEngine;
using Constants = Framework.Constants;
namespace Gameplay.PostProcess.BlackArea
{
    public class BlackAreaManager
    {
        private static BlackAreaManager _instance;
        public static BlackAreaManager instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new BlackAreaManager();
                }
                return _instance;
            }
        }

        public bool enableBlackArea
        {
            get;
            private set;
        }

        private List<LightPoint> _pointList = new List<LightPoint>();
        public List<LightPoint> pointList
        {
            get
            {
                return _pointList;
            }
        }
        
        private Dictionary<int, LightPoint> _pointDic = new Dictionary<int, LightPoint>();
        private GameObject _rootObj;

        public void Init(bool enable)
        {
            enableBlackArea = enable;
            if (!enableBlackArea) return;
            _InitLightMap();
        }

        private void _InitLightMap()
        {
            _pointList.Clear();
            _pointDic.Clear();
            _rootObj = new GameObject("[BlackAreaRoot]");
            var allCells = LevelManager.Instance.CurrentLevel.Map.TerrainGridSystem.cells;
            var sampleObj = AssetManager.Instance.GetPreLoadResult<GameObject>(Constants.FIGHT_LIGHT_AREA_PATH);
            for (int i = 0; i < allCells.Count; i++)
            {
                var cell = allCells[i];
                var cellIndex = cell.index;
                var cellWorldPos = AreaManager.instance.GetCellPosByIndex(cellIndex);
                var instObj = Object.Instantiate(sampleObj, cellWorldPos, Quaternion.identity, _rootObj.transform);
                
                var lightPoint = new LightPoint(cellIndex, instObj);
                lightPoint.LightOff();
                _pointList.Add(lightPoint);
                _pointDic.Add(cellIndex, lightPoint);
            }
        }

        public void AutoLightUpReadyArea()
        {
            if (!enableBlackArea) return;
            var readyArea = AreaManager.instance.readyAreaManager.mapReadyCellIndexs;
            for (int i = 0; i < readyArea.Count; i++)
            {
                LightUpCell(readyArea[i], 0.1f);
            }
        }

        public void LightUpCell(int cellIndex, float during)
        {
            if (!enableBlackArea) return;
            if (_pointDic.TryGetValue(cellIndex, out var lightPoint))
            {
                lightPoint.MarkLight(during);
            }
            else
            {
                DebugUtil.LogError("LightUpCell failed, cellIndex:{0} is invalid!", cellIndex);
            }
        }

        private void _AutoLightCharacterArea()
        {
            var allUnits = GameUnitManager.instance.infightUnits.unitList;
            for (int i = 0; i < allUnits.Count; i++)
            {
                var unit = allUnits[i];
                if (unit.statusData.isDead) continue;
                if (unit.commonData.troopId != ETroopsId.Self) continue;
                var lightUpDistance = unit.fightData.lightUpArea;
                var cellIndexs = AreaManager.instance.GetCellIndexsAround(unit.transData.cellIndex, lightUpDistance);
                for (int j = 0; j < cellIndexs.Count; j++)
                {
                    LightUpCell(cellIndexs[j], 0.1f);
                }
            }
        }

        public bool CheckIsInLightArea(int cellIndex)
        {
            if (!enableBlackArea)
            {
                return true;
            }
            if (_pointDic.TryGetValue(cellIndex, out var lightPoint))
            {
                return lightPoint.isLight;
            }
            return false;
        }

        public void LogicUpdate(float dt)
        {
            if (!enableBlackArea)
            {
                return;
            }
            _AutoLightCharacterArea();
            for (int i = 0; i < _pointList.Count; i++)
            {
                _pointList[i].LogicUpdate(dt);
            }
        }

        public void Dispose()
        {
            if (_rootObj != null)
            {
                Object.Destroy(_rootObj);
                _rootObj = null;
            }
            enableBlackArea = false;
        }
    }
}