using Gameplay;
using Sirenix.OdinInspector;
using Sirenix.OdinInspector.Editor;
using Sirenix.Utilities;
using Sirenix.Utilities.Editor;
using System;
using System.Collections;
using System.Collections.Generic;
using TGS;
using UnityEditor;
using UnityEngine;
using UnityEngine.InputSystem.EnhancedTouch;
using ObjectFieldAlignment = Sirenix.OdinInspector.ObjectFieldAlignment;

namespace MapEditor
{
    public class MapGridWindow : OdinEditorWindow
    {
        #region Fields And Properties

        private static MapGridWindow _thisWindow;

        private static Dictionary<int, TerrainTypeProperty> _terrainTypeConfig;

        private static Dictionary<int, LegionTerrainTypeProperty> _legionTerrainTypeConfig;

        private MapData _currentMapData;

        private MapManager _currMapManager;

        private Map _map;

        private bool _isLegionMap;

        #endregion

        #region 显示地图索引功能

        [BoxGroup("显示地格索引")]
        [LabelText("显示类型"), Indent]
        [OnValueChanged("ShowCellIndex")]
        [LabelWidth(100)]
        [SerializeField]
        private CellDebugInfo cellDebugInfo = CellDebugInfo.Nothing;

        private void ShowCellIndex()
        {
            if (_map == null || _map.TerrainGridSystem == null) return;
            _map.TerrainGridSystem.displayCellDebugInfo = cellDebugInfo;
            var obj = FindObjectOfType<TerrainGridSystem>().gameObject;
            Selection.activeGameObject = obj;
        }

        #endregion

        #region 刷地块信息

        [BoxGroup("地块信息")]
        [LabelText("刷地块"), Indent]
        [OnValueChanged("OnCanBrushTerrainTypeChanged")]
        [LabelWidth(100)]
        [SerializeField]
        [ShowIf("@!canEditorArea")]
        private bool canBrushTerrainType;

        private void OnCanBrushTerrainTypeChanged()
        {
            if (canBrushTerrainType && _map != null)
            {
                canEditorArea = false;
                ClearRegionColor();
            }
        }

        [HorizontalGroup("地块信息/Territory")]
        [ValueDropdown("GetTerrainTypeProperties")]
        [Indent]
        [LabelText("选择地块")]
        [ShowIf("canBrushTerrainType")]
        public int terrainTypeIndex = 0;

        private IEnumerable GetTerrainTypeProperties()
        {
            ValueDropdownList<int> list = new();
            if (!_isLegionMap)
                foreach (var terrainTypeProperty in TerrainTypeConfig.DicTerrainTypePropertie.Values)
                {
                    list.Add(terrainTypeProperty.name, terrainTypeProperty.id);
                }
            else
                foreach (var legionTerrainTypeProperty in LegionTerrainTypeConfig.DicTerrainTypePropertie.Values)
                {
                    list.Add(legionTerrainTypeProperty.name, legionTerrainTypeProperty.id);
                }

            return list;
        }

        [ShowIf("canBrushTerrainType")]
        [HorizontalGroup("地块信息/Territory")]
        [Button(SdfIconType.GearFill, "编辑地块")]
        public void EditTerrainTypeConfig()
        {
            if (!_isLegionMap)
            {
                var window = GetWindow<TerrainTypeConfigWindow>();
                window.Show();
            }
            else
            {
                var window = GetWindow<LegionTerrainTypeConfigWindow>();
                window.Show();
            }
        }

        private void SetCellBlockType(int cellIndex, int terrainTypeIndex)
        {
            if (!_isLegionMap)
            {
                if (!_terrainTypeConfig.TryGetValue(terrainTypeIndex, out TerrainTypeProperty terrainTypeProperty))
                {
                    DebugUtil.LogError($"没有取到地格属性，id:{terrainTypeIndex}");
                    return;
                }

                var map = _map;
                // Key: terrainTypeIndex Value: tgs.territories.index
                if (!map.TerrainTypeIndexDic.ContainsKey(terrainTypeIndex))
                    map.TerrainTypeIndexDic.Add(terrainTypeIndex, map.TerrainTypeIndexDic.Count);

                map.TerrainGridSystem.CellSetBorderVisible(cellIndex, false);
                map.SetTerrainType(cellIndex, terrainTypeIndex);
                map.TerrainGridSystem.CellToggleRegionSurface(cellIndex, true, terrainTypeProperty.Color);
                var buffPath = terrainTypeProperty.buffObjectPath;
                if (!string.IsNullOrEmpty(buffPath))
                    AddBuffCell(cellIndex, buffPath);

                Debug.Log(
                    $"设置地格: ({cellIndex}), 地格类型: ({terrainTypeIndex}), 名字: ({terrainTypeProperty.name})");
            }
            else
            {
                if (!_legionTerrainTypeConfig.TryGetValue(terrainTypeIndex, out var terrainTypeProperty))
                {
                    DebugUtil.LogError($"没有取到军团地格属性，id:{terrainTypeIndex}");
                    return;
                }

                var map = _map;
                // Key: terrainTypeIndex Value: tgs.territories.index
                if (!map.LegionTerrainTypeIndexDic.ContainsKey(terrainTypeIndex))
                    map.LegionTerrainTypeIndexDic.Add(terrainTypeIndex, map.LegionTerrainTypeIndexDic.Count);

                map.TerrainGridSystem.CellSetBorderVisible(cellIndex, false);
                map.SetTerrainType(cellIndex, terrainTypeIndex, true);
                map.TerrainGridSystem.CellToggleRegionSurface(cellIndex, true, terrainTypeProperty.Color);
                var buffPath = terrainTypeProperty.buffObjectPath;
                if (!string.IsNullOrEmpty(buffPath))
                {
                    AddBuffCell(cellIndex, buffPath);
                }

                Debug.Log(
                    $"设置军团地格: ({cellIndex}), 地格类型: ({terrainTypeIndex}), 名字: ({terrainTypeProperty.name})");
            }
        }

        private void ClearCellBlockType(int cellIndex)
        {
            if (!_isLegionMap)
            {
                if (!_terrainTypeConfig.TryGetValue(terrainTypeIndex, out TerrainTypeProperty terrainTypeProperty))
                {
                    DebugUtil.LogError($"没有取到地格属性,id:{terrainTypeIndex}");
                    return;
                }

                var map = _map;
                map.TerrainGridSystem.CellSetBorderVisible(cellIndex, true);
                map.TerrainGridSystem.CellHideRegionSurface(cellIndex);

                _map.SetBlockColor(cellIndex, false, terrainTypeProperty.Color);
                map.SetTerrainType(cellIndex, -1);
                var buffPath = terrainTypeProperty.buffObjectPath;
                if (!string.IsNullOrEmpty(buffPath))
                {
                    RemoveBuffCell(cellIndex);
                }

                Debug.Log($"清除地格cellIndex: ({cellIndex})");
            }
            else
            {
                if (!_legionTerrainTypeConfig.TryGetValue(terrainTypeIndex, out var terrainTypeProperty))
                {
                    DebugUtil.LogError($"没有取到军团地格属性,id:{terrainTypeIndex}");
                    return;
                }

                var map = _map;
                map.TerrainGridSystem.CellSetBorderVisible(cellIndex, true);
                map.TerrainGridSystem.CellHideRegionSurface(cellIndex);

                _map.SetBlockColor(cellIndex, false, terrainTypeProperty.Color);
                map.SetTerrainType(cellIndex, -1, true);
                var buffPath = terrainTypeProperty.buffObjectPath;
                if (!string.IsNullOrEmpty(buffPath))
                {
                    RemoveBuffCell(cellIndex);
                }

                Debug.Log($"清除军团地格cellIndex: ({cellIndex})");
            }
        }

        #region 地块指示物

        private Dictionary<int, GameObject> _buffPrefabDic;

        private GameObject buffRoot;

        private void AddBuffCell(int cellIndex, string path)
        {
            // 阵地buff指示
            if (!_buffPrefabDic.ContainsKey(cellIndex))
            {
                var buff = CreateBuffObj(cellIndex, path);
                if (buff == null) return;
                _buffPrefabDic.Add(cellIndex, buff);
                /*var showBuffData = new MapData.ShowBuffData
                _currentMapData.showBuffPoints.Add();*/
                DebugUtil.Log("格子{0}添加指示图标，路径为{1}", cellIndex, path);
            }
        }

        private void RemoveBuffCell(int cellIndex)
        {
            if (_buffPrefabDic.TryGetValue(cellIndex, out var buff))
            {
                if (buff != null)
                {
                    DestroyImmediate(buff);
                }

                _buffPrefabDic.Remove(cellIndex);

                DebugUtil.Log("格子{0}移除指示图标", cellIndex);
            }
        }

        private GameObject CreateBuffObj(int cellIndex, string path)
        {
            var buffObj = AssetDatabase.LoadAssetAtPath<GameObject>(path);
            if (buffObj == null)
            {
                DebugUtil.LogError($"{path} 路径下无Buff指示预制体 ");
                return null;
            }

            if (buffRoot == null)
                buffRoot = new GameObject("buffRoot");
            var posV3 = _map.TGSCellIndex2WorldPosition(cellIndex);
            var buff = Instantiate(buffObj, posV3, buffObj.transform.rotation, buffRoot.transform);
            buff.SetActive(true);

            return buff;
        }

        #endregion

        #endregion

        #region 地区信息

        private static readonly Color regionColor = MapUtils.GetRGBAColor("FF960072");

        private static bool canEditorSingleRegion = false;

        private RegionArea _currEditRegionArea;

        [Serializable]
        public class RegionArea
        {
            [HorizontalGroup("1")] [ReadOnly] public int id;

            [HorizontalGroup("1")] [ReadOnly] [LabelText("数量")]
            public int regionCount;

            [LabelText("备注"), HorizontalGroup("1")] [OnValueChanged("OnNoteValueChanged")]
            public string note;

            private void OnNoteValueChanged()
            {
                _region.note = note;
            }

            public List<int> positions => _region.positions;

            private MapData.Region _region;

            public RegionArea(MapData.Region region)
            {
                _region = region;
                note = _region.note;
            }

            [Button("编辑"), HorizontalGroup("1")]
            private void EditorRegion()
            {
                var map = _thisWindow._map;
                _thisWindow._currEditRegionArea = this;
                var regionslist = map.MapData.regions;
                for (int i = 0; i < regionslist.Count; i++)
                {
                    map.SetRegionColor(i, false, regionColor);
                }

                map.SetRegionColor(_region, true, regionColor);
                canEditorSingleRegion = true;
            }


            public void AddPosition(int cellIndex)
            {
                if (positions.Contains(cellIndex))
                    return;
                positions.Add(cellIndex);
                regionCount++;
                _thisWindow._map.TerrainGridSystem.CellToggleRegionSurface(cellIndex, true, regionColor);
            }

            public void RemovePosition(int cellIndex)
            {
                if (!positions.Contains(cellIndex))
                    return;
                positions.Remove(cellIndex);
                regionCount--;
                _thisWindow._map.TerrainGridSystem.CellHideRegionSurface(cellIndex);
            }
        }

        [BoxGroup("地区信息")]
        [HorizontalGroup("地区信息/Region")]
        [LabelText("编辑地区"), Indent]
        [ShowIf("@!_isLegionMap")]
        [OnValueChanged("OnCanEditorAreaTypeChanged")]
        [LabelWidth(100)]
        [SerializeField]
        private bool canEditorArea;

        private void OnCanEditorAreaTypeChanged()
        {
            if (canEditorArea)
            {
                canBrushTerrainType = false;
            }
            else
            {
                ClearRegionColor();
                SceneView.RepaintAll();
                canEditorSingleRegion = false;
                _currEditRegionArea = null;
            }
        }

        [LabelText("地区列表")]
        [ShowIf("@!_isLegionMap&&canEditorArea")]
        [VerticalGroup("地区信息/RegionInfo"), Indent]
        [ListDrawerSettings(CustomAddFunction = "CustomAddRegion", CustomRemoveIndexFunction = "CustomRemoveRegion",
            DraggableItems = false)]
        public List<RegionArea> RegionList = new();

        private void CustomAddRegion()
        {
            var region = new MapData.Region();
            _currentMapData.regions.Add(region);
            UpdateRegion();
        }

        private void CustomRemoveRegion(int index)
        {
            ClearRegionColor();
            _currentMapData.regions.RemoveAt(index);
            UpdateRegion();
        }

        private void UpdateRegion()
        {
            RegionList.Clear();
            if (_currentMapData != null)
            {
                int index = 0;
                foreach (var region in _currentMapData.regions)
                {
                    RegionArea ra = new RegionArea(region);
                    ra.id = index;
                    ra.regionCount = ra.positions.Count;
                    RegionList.Add(ra);
                    index++;
                }
            }
        }

        private void ClearRegionColor()
        {
            if (_map == null)
                return;
            for (int i = 0; i < _map.MapData.regions.Count; i++)
            {
                _map.SetRegionColor(i, false, regionColor);
            }
        }

        #endregion

        /*#region 雷区

        private static readonly Color MinesColor = MapUtils.GetRGBAColor("2D004CFF");

        private static bool canEditorSingleMinesRegion;

        private MinesRegionArea _currEditMinesRegionArea;

        [Serializable]
        public class MinesRegionArea
        {
            [HorizontalGroup("1")] [ReadOnly] public int id;

            [HorizontalGroup("1")] [ReadOnly] [LabelText("数量")]
            public int regionCount;

            [LabelText("备注"), HorizontalGroup("1")] [OnValueChanged("OnNoteValueChanged")]
            public string note;

            private void OnNoteValueChanged()
            {
                _region.note = note;
            }

            public List<int> positions => _region.positions;

            private MapData.Region _region;

            public MinesRegionArea(MapData.Region region)
            {
                _region = region;
                note = _region.note;
            }

            [Button("编辑"), HorizontalGroup("1")]
            private void EditorRegion()
            {
                var map = _thisWindow._map;
                _thisWindow._currEditMinesRegionArea = this;
                var regionList = map.MapData.minesRegions;
                foreach (var region in regionList)
                {
                    map.SetBlocksColor(region.positions, false, MinesColor);
                }

                map.SetBlocksColor(_region.positions, true, MinesColor);
                canEditorSingleMinesRegion = true;
            }

            public void AddPosition(int cellIndex)
            {
                if (positions.Contains(cellIndex))
                    return;
                positions.Add(cellIndex);
                regionCount++;
                _thisWindow._map.TerrainGridSystem.CellToggleRegionSurface(cellIndex, true, MinesColor);
            }

            public void RemovePosition(int cellIndex)
            {
                if (!positions.Contains(cellIndex))
                    return;
                positions.Remove(cellIndex);
                regionCount--;
                _thisWindow._map.TerrainGridSystem.CellHideRegionSurface(cellIndex);
            }
        }

        [BoxGroup("雷区信息")]
        [HorizontalGroup("雷区信息/Region")]
        [LabelText("编辑雷区"), Indent]
        [ShowIf("@!_isLegionMap")]
        [OnValueChanged("OnCanEditorMinesAreaTypeChanged")]
        [LabelWidth(100)]
        [SerializeField]
        private bool canEditorMinesArea;

        private void OnCanEditorMinesAreaTypeChanged()
        {
            if (canEditorMinesArea)
            {
                canEditorArea = false;
                canBrushTerrainType = false;
                canEditorBlockArea = false;
                canEditorDefenseArea = false;
                canEditorSingleBlockRegion = false;
                canEditorSingleDefenseRegion = false;
                ClearDefenseRegionColor();
                ClearBlockRegionColor();
                ClearRegionColor();
            }
            else
            {
                ClearMinesRegionColor();
                SceneView.RepaintAll();
                canEditorSingleMinesRegion = false;
                _currEditMinesRegionArea = null;
            }
        }

        [LabelText("雷区列表")]
        [ShowIf("@!_isLegionMap&&canEditorMinesArea")]
        [VerticalGroup("雷区信息/RegionInfo"), Indent]
        [ListDrawerSettings(CustomAddFunction = "CustomAddMinesRegion",
            CustomRemoveIndexFunction = "CustomRemoveMinesRegion",
            DraggableItems = false)]
        public List<MinesRegionArea> minesRegionList = new();

        private void CustomAddMinesRegion()
        {
            var region = new MapData.Region();
            _currentMapData.minesRegions.Add(region);
            UpdateMinesRegion();
        }

        private void CustomRemoveMinesRegion(int index)
        {
            ClearMinesRegionColor();
            _currentMapData.minesRegions.RemoveAt(index);
            UpdateMinesRegion();
        }

        private void UpdateMinesRegion()
        {
            minesRegionList.Clear();
            if (_currentMapData != null)
            {
                var index = 0;
                foreach (var region in _currentMapData.minesRegions)
                {
                    MinesRegionArea ra = new MinesRegionArea(region)
                    {
                        id = index
                    };
                    ra.regionCount = ra.positions.Count;
                    minesRegionList.Add(ra);
                    index++;
                }
            }
        }

        private void ClearMinesRegionColor()
        {
            if (_map == null)
                return;

            foreach (var region in _map.MapData.minesRegions)
            {
                _map.SetBlocksColor(region.positions, false, MinesColor);
            }
        }

        #endregion

        #region 阻挡区信息

        private static readonly Color BlockRegionColor = Color.blue;

        private BlockRegionArea _currEditBlockRegion;

        private static bool canEditorSingleBlockRegion = false;

        private Dictionary<int, GameObject> _blockPrefabDic;

        private GameObject blockRoot;

        [Serializable]
        public class BlockRegionArea
        {
            private const string BuffPrefabPath = "Art_Out/Other/BuffPoint";

            [HorizontalGroup("1")] [ReadOnly] public int id;

            [HorizontalGroup("1")] [ReadOnly] [LabelText("数量")]
            public int regionCount;

            [LabelText("备注"), HorizontalGroup("1")] [OnValueChanged("OnNoteValueChanged")]
            public string note;

            private void OnNoteValueChanged()
            {
                _region.note = note;
            }

            [Button("编辑"), HorizontalGroup("1")]
            private void EditorRegion()
            {
                var map = _thisWindow._map;
                _thisWindow._currEditBlockRegion = this;
                var regionsList = map.MapData.blockRegions;
                foreach (var blockRegion in regionsList)
                {
                    map.SetBlocksColor(blockRegion.positions, false, BlockRegionColor);
                }

                map.SetBlocksColor(_region.positions, true, BlockRegionColor);
                canEditorSingleBlockRegion = true;
            }


            [HorizontalGroup("3")]
            [PreviewField(50, ObjectFieldAlignment.Center)]
            [LabelText("指示预览图"), OnValueChanged("OnObjectValueChanged")]
            [AssetList(Path = BuffPrefabPath)]
            public GameObject buffObject;

            private void OnObjectValueChanged()
            {
                if (buffObject != null)
                {
                    _region.path = "Assets/" + BuffPrefabPath + "/" + buffObject.name + ".prefab";
                }
            }

            [HorizontalGroup("2")] [LabelText("指示位置"), OnValueChanged("OnPosValueChanged")]
            public Vector3 pos = Vector3.zero;

            private void OnPosValueChanged()
            {
                _region.centerPos = pos;
                if (obj != null)
                {
                    obj.transform.position = pos;
                }
            }

            [Button("添加至场景"), HorizontalGroup("3")]
            [ShowIf("NeedAdd")]
            private void AddToScene()
            {
                obj = _thisWindow.CreateBlockObj(_region.path, pos);
            }

            [Button("更换指示"), HorizontalGroup("3")]
            [HideIf("NeedAdd")]
            private void ChangeObj()
            {
                if (obj) DestroyImmediate(obj);
                obj = _thisWindow.CreateBlockObj(_region.path, pos);
            }

            private bool NeedAdd => obj == null;
            [HideInInspector] public GameObject obj;

            public List<int> Positions => _region.positions;

            [HideInInspector] public MapData.BlockRegion _region;

            public BlockRegionArea(MapData.BlockRegion region)
            {
                _region = region;
                pos = _region.centerPos;
                note = _region.note;
                if (!string.IsNullOrEmpty(region.path))
                {
                    obj = _thisWindow.CreateBlockObj(_region.path, _region.centerPos);
                    buffObject = AssetDatabase.LoadAssetAtPath<GameObject>(_region.path);
                }
            }

            public void AddPosition(int cellIndex)
            {
                if (Positions.Contains(cellIndex))
                    return;
                Positions.Add(cellIndex);
                DebugUtil.Log($"{id}阻挡区添加地格{cellIndex}");
                regionCount++;
                _thisWindow._map.TerrainGridSystem.CellToggleRegionSurface(cellIndex, true, BlockRegionColor);
            }

            public void RemovePosition(int cellIndex)
            {
                if (!Positions.Contains(cellIndex))
                    return;
                Positions.Remove(cellIndex);

                DebugUtil.Log($"{id}阻挡区移除地格{cellIndex}");
                regionCount--;
                _thisWindow._map.TerrainGridSystem.CellHideRegionSurface(cellIndex);
            }
        }

        [BoxGroup("阻挡区信息")]
        [HorizontalGroup("阻挡区信息/Region")]
        [ShowIf("@!_isLegionMap")]
        [LabelText("编辑阻挡区"), Indent]
        [OnValueChanged("OnCanEditorBlockAreaChanged")]
        [LabelWidth(100)]
        [SerializeField]
        private bool canEditorBlockArea;

        private void OnCanEditorBlockAreaChanged()
        {
            if (canEditorBlockArea)
            {
                canEditorArea = false;
                canEditorMinesArea = false;
                canBrushTerrainType = false;
                canEditorDefenseArea = false;
                canEditorSingleRegion = false;
                canEditorSingleDefenseRegion = false;
                ClearDefenseRegionColor();
                ClearRegionColor();
                ClearMinesRegionColor();
            }
            else
            {
                ClearBlockRegionColor();
                SceneView.RepaintAll();
                _currEditBlockRegion = null;
                canEditorSingleBlockRegion = false;
            }
        }

        [LabelText("阻挡区列表")]
        [ShowIf("@!_isLegionMap&&canEditorBlockArea")]
        [VerticalGroup("阻挡区信息/RegionInfo"), Indent]
        [ListDrawerSettings(CustomAddFunction = "CustomAddBlockRegion",
            CustomRemoveIndexFunction = "CustomRemoveBlockRegionIndex",
            DraggableItems = false)]
        public List<BlockRegionArea> blockRegionList = new();

        private void CustomAddBlockRegion()
        {
            var region = new MapData.BlockRegion();
            _currentMapData.blockRegions.Add(region);
            UpdateBlockRegion();
        }

        private void CustomRemoveBlockRegionIndex(int index)
        {
            if (index < blockRegionList.Count)
            {
                if (blockRegionList[index].obj != null)
                {
                    DebugUtil.LogError($"删除{blockRegionList[index].id}的指示");
                    DestroyImmediate(blockRegionList[index].obj);
                }
            }

            ClearBlockRegionColor();
            _currentMapData.blockRegions.RemoveAt(index);
            UpdateBlockRegion();
        }

        private void UpdateBlockRegion()
        {
            blockRegionList.Clear();
            if (_currentMapData != null)
            {
                var index = 0;
                foreach (var region in _currentMapData.blockRegions)
                {
                    var blockRegion = new BlockRegionArea(region)
                    {
                        id = index,
                        regionCount = region.positions.Count,
                    };

                    blockRegionList.Add(blockRegion);
                    index++;
                }
            }
        }

        private void ClearBlockRegionColor()
        {
            if (_map == null)
                return;
            foreach (var blockRegion in _map.MapData.blockRegions)
            {
                _map.SetBlocksColor(blockRegion.positions, false, BlockRegionColor);
            }
        }

        private GameObject CreateBlockObj(string path, Vector3 pos)
        {
            var blockObj = AssetDatabase.LoadAssetAtPath<GameObject>(path);
            if (blockObj == null)
            {
                DebugUtil.LogError($"{path} 路径下无Block指示预制体 ");
                return null;
            }

            if (blockRoot == null)
                blockRoot = new GameObject("BlockRoot");
            var obj = Instantiate(blockObj, pos, blockObj.transform.rotation, blockRoot.transform);
            obj.SetActive(true);

            return obj;
        }

        private void DestroyAllBlockObj()
        {
            if (blockRoot)
                DestroyImmediate(blockRoot);
            foreach (var blockRegion in blockRegionList)
            {
                if (blockRegion.obj)
                    DestroyImmediate(blockRegion.obj);
            }
        }

        #endregion

        #region 刷怪触发区

        private static readonly Color DefenseRegionColor = Color.magenta;

        private DefenseRegionArea _currEditDefenseRegion;

        private static bool canEditorSingleDefenseRegion = false;

        [Serializable]
        public class DefenseRegionArea
        {
            [HorizontalGroup("1")] [ReadOnly] public int id;

            [HorizontalGroup("1")] [ReadOnly] [LabelText("数量")]
            public int regionCount;

            [LabelText("备注"), HorizontalGroup("1")] [OnValueChanged("OnNoteValueChanged")]
            public string note;

            private void OnNoteValueChanged()
            {
                _region.note = note;
            }

            public List<int> Positions => _region.positions;

            private MapData.Region _region;

            public DefenseRegionArea(MapData.Region region)
            {
                _region = region;
                note = _region.note;
            }

            [Button("编辑"), HorizontalGroup("1")]
            private void EditorRegion()
            {
                var map = _thisWindow._map;
                _thisWindow._currEditDefenseRegion = this;
                var regionsList = map.MapData.defenseRegions;
                foreach (var defenseRegion in regionsList)
                {
                    map.SetBlocksColor(defenseRegion.positions, false, DefenseRegionColor);
                }

                map.SetBlocksColor(_region.positions, true, DefenseRegionColor);
                canEditorSingleDefenseRegion = true;
            }

            public void AddPosition(int cellIndex)
            {
                if (Positions.Contains(cellIndex))
                    return;
                Positions.Add(cellIndex);
                DebugUtil.Log($"{id}防守区添加地格{cellIndex}");
                regionCount++;
                _thisWindow._map.TerrainGridSystem.CellToggleRegionSurface(cellIndex, true, DefenseRegionColor);
            }

            public void RemovePosition(int cellIndex)
            {
                if (!Positions.Contains(cellIndex))
                    return;
                Positions.Remove(cellIndex);

                DebugUtil.Log($"{id}防守区移除地格{cellIndex}");
                regionCount--;
                _thisWindow._map.TerrainGridSystem.CellHideRegionSurface(cellIndex);
            }
        }

        [BoxGroup("刷怪触发区")]
        [HorizontalGroup("刷怪触发区/Region")]
        [ShowIf("@!_isLegionMap")]
        [LabelText("编辑触发区"), Indent]
        [OnValueChanged("OnCanEditorDefenseAreaChanged")]
        [LabelWidth(100)]
        [SerializeField]
        private bool canEditorDefenseArea;

        private void OnCanEditorDefenseAreaChanged()
        {
            if (canEditorDefenseArea)
            {
                canEditorBlockArea = false;
                canEditorArea = false;
                canEditorMinesArea = false;
                canBrushTerrainType = false;
                canEditorSingleRegion = false;
                canEditorSingleBlockRegion = false;
                ClearBlockRegionColor();
                ClearRegionColor();
                ClearMinesRegionColor();
            }
            else
            {
                ClearDefenseRegionColor();
                SceneView.RepaintAll();
                _currEditDefenseRegion = null;
                canEditorSingleDefenseRegion = false;
            }
        }

        [LabelText("刷怪触发区列表")]
        [ShowIf("@!_isLegionMap&&canEditorDefenseArea")]
        [VerticalGroup("刷怪触发区/RegionInfo"), Indent]
        [ListDrawerSettings(CustomAddFunction = "CustomAddDefenseRegion",
            CustomRemoveIndexFunction = "CustomRemoveDefenseRegion",
            DraggableItems = false)]
        public List<DefenseRegionArea> defenseRegionList = new();

        private void CustomAddDefenseRegion()
        {
            var region = new MapData.Region();
            _currentMapData.defenseRegions.Add(region);
            UpdateDefenseRegion();
        }

        private void CustomRemoveDefenseRegion(int index)
        {
            ClearDefenseRegionColor();
            _currentMapData.defenseRegions.RemoveAt(index);
            UpdateDefenseRegion();
        }

        private void UpdateDefenseRegion()
        {
            defenseRegionList.Clear();
            if (_currentMapData != null)
            {
                var index = 0;
                foreach (var region in _currentMapData.defenseRegions)
                {
                    var defenseRegion = new DefenseRegionArea(region)
                    {
                        id = index,
                        regionCount = region.positions.Count,
                    };

                    defenseRegionList.Add(defenseRegion);
                    index++;
                }
            }
        }

        private void ClearDefenseRegionColor()
        {
            if (_map == null)
                return;
            foreach (var defenseRegion in _map.MapData.defenseRegions)
            {
                _map.SetBlocksColor(defenseRegion.positions, false, DefenseRegionColor);
            }
        }

        #endregion*/

        #region 阻挡球编辑

        /// <summary>
        /// 球体根节点
        /// </summary>
        private GameObject blockSphereRoot;

        /// <summary>
        /// 已修改阻挡球字典
        /// </summary>
        private readonly Dictionary<int, MapData.BlockSphereInfo> blockSphereInfo = new();

        /// <summary>
        /// 被隐藏的物体列表，用于后续恢复显示
        /// </summary>
        private readonly List<GameObject> hideObjs = new List<GameObject>();

        /// <summary>
        /// 所有禁止攻击的格子
        /// </summary>
        private readonly List<int> banAttackCells = new();

        /// <summary>
        /// 标准六边形内接圆直径
        /// </summary>
        private static readonly float Calibre = 3f;

        /// <summary>
        /// 编辑时颜色
        /// </summary>
        private static readonly Color EditingSphereColor = Color.red;

        /// <summary>
        /// 已编辑过的数据颜色
        /// </summary>
        private static readonly Color ChangedSphereColor = Color.green;

        [Serializable]
        public class BlockSpereEditorInfo
        {
            [HideInInspector] public MapData.BlockSphereInfo blockSphereInfo;

            #region 可视字段

            [HorizontalGroup("1", 0.1f)] [LabelText("地格")] [LabelWidth(30)] [ReadOnly]
            public int cellIndex;

            [HorizontalGroup("1", 0.12f)]
            [LabelText("缩放")]
            [LabelWidth(30)]
            [EnableIf("canEditor")]
            [ShowIf("@isChanged||canEditor")]
            [OnValueChanged("OnScaleValueChanged")]
            public float scale = 1f;

            [HorizontalGroup("1", 0.25f)]
            [LabelText("偏移")]
            [LabelWidth(30)]
            [EnableIf("canEditor")]
            [ShowIf("@isChanged||canEditor")]
            [OnValueChanged("OnOffestValueChanged")]
            public Vector2 offest;

            [HorizontalGroup("1", 0.25f)]
            [LabelText("备注")]
            [LabelWidth(30)]
            [EnableIf("canEditor")]
            // [ShowIf("@isChanged||canEditor")]
            [OnValueChanged("OnNoteValueChanged")]
            public string note;

            #endregion

            #region 字段

            /// <summary>
            /// 可编辑
            /// </summary>
            [HideInInspector] public bool canEditor;

            /// <summary>
            /// 数据已经变化
            /// </summary>
            [HideInInspector] public bool isChanged;

            /// <summary>
            /// 阻挡球物体
            /// </summary>
            [HideInInspector] public GameObject sphere;

            /// <summary>
            /// 原始共享材质
            /// </summary>
            [HideInInspector] public Material originalSharedMaterial;

            /// <summary>
            /// 编辑时的临时材质
            /// </summary>
            [HideInInspector] public Material editingMaterial;

            /// <summary>
            /// 地格中心位置
            /// </summary>
            [HideInInspector] public Vector3 originalPos;

            #endregion

            #region 构造函数

            public BlockSpereEditorInfo(int cellIndex, GameObject sphere)
            {
                var map = _thisWindow._map;
                this.cellIndex = cellIndex;
                blockSphereInfo = new MapData.BlockSphereInfo()
                {
                    cellIndex = cellIndex,
                };
                originalPos = map.TGSCellIndex2WorldPosition(cellIndex);
                if (sphere != null)
                {
                    this.sphere = sphere;
                    SetSphereColor(Color.white);
                }

                isChanged = false;
            }

            public BlockSpereEditorInfo(MapData.BlockSphereInfo blockInfo, GameObject sphere)
            {
                var map = _thisWindow._map;
                blockSphereInfo = new MapData.BlockSphereInfo
                {
                    cellIndex = blockInfo.cellIndex,
                    scale = blockInfo.scale,
                    note = blockInfo.note,
                    offestPos = blockInfo.offestPos,
                };

                cellIndex = blockInfo.cellIndex;
                originalPos = map.TGSCellIndex2WorldPosition(blockInfo.cellIndex);
                offest = new Vector2(blockInfo.offestPos.x - originalPos.x, blockInfo.offestPos.z - originalPos.z);
                scale = blockInfo.scale / Calibre;
                if (sphere != null)
                {
                    this.sphere = sphere;
                }

                UpdateChangedData();
            }

            #endregion

            #region 按钮

            [Button("恢复默认")]
            [HorizontalGroup("1")]
            [ShowIf("isChanged")]
            public void Revert()
            {
                if (!isChanged) return;
                isChanged = false;
                if (sphere != null)
                {
                    scale = 1f;
                    offest = new Vector2(0f, 0f);

                    blockSphereInfo.offestPos = originalPos;
                    blockSphereInfo.scale = Calibre;

                    sphere.transform.localScale = Vector3.one * Calibre;
                    sphere.transform.position = originalPos;

                    // 如果正在监听这个球体，更新监听的位置和缩放
                    if (_thisWindow.currentEditingSphere == this)
                    {
                        _thisWindow.lastPosition = originalPos;
                        _thisWindow.lastScale = Vector3.one * Calibre;
                    }

                    if (!canEditor)
                    {
                        SetSphereColor(Color.white);
                    }
                }
            }

            [Button("编辑")]
            [HorizontalGroup("1")]
            [HideIf("canEditor")]
            private void EditorBlockAttack()
            {
                canEditor = true;
                if (sphere != null)
                {
                    var renderer = sphere.GetComponent<Renderer>();

                    // 保存原始材质（可能已经是绿色的编辑过材质）
                    originalSharedMaterial = renderer.sharedMaterial;

                    // 创建编辑用的红色材质
                    editingMaterial = new Material(originalSharedMaterial);
                    editingMaterial.color = EditingSphereColor;
                    renderer.sharedMaterial = editingMaterial;

                    if (_thisWindow.currentEditingSphere != null)
                    {
                        _thisWindow.currentEditingSphere.ExitEditorBlockAttack();
                    }

                    Selection.activeGameObject = sphere;
                    _thisWindow.StartMonitoringSphere(this);
                }
            }

            [Button("保存")]
            [HorizontalGroup("1")]
            [ShowIf("canEditor")]
            public void ExitEditorBlockAttack()
            {
                canEditor = false;
                if (sphere != null)
                {
                    var renderer = sphere.GetComponent<Renderer>();

                    // 清理临时材质并恢复原始材质
                    if (editingMaterial != null)
                    {
                        DestroyImmediate(editingMaterial);
                        editingMaterial = null;
                    }

                    // 恢复原始材质
                    if (originalSharedMaterial != null)
                    {
                        renderer.sharedMaterial = originalSharedMaterial;
                    }

                    blockSphereInfo.scale = Calibre * scale;
                    blockSphereInfo.offestPos = sphere.transform.position;
                    DebugUtil.Log(
                        $"保存 ：{blockSphereInfo.cellIndex} 上的阻挡攻击球体真实直径为: {blockSphereInfo.scale}, 具体位置为: {blockSphereInfo.offestPos}, " +
                        $"原始的位置是:{originalPos}, 原始直径是：{Calibre}");

                    UpdateChangedData();
                }

                // 停止监听Transform变化
                _thisWindow.StopMonitoringSphere();
            }

            #endregion

            #region 值变化

            private void OnScaleValueChanged()
            {
                var realScale = Calibre * scale;
                if (sphere != null)
                {
                    sphere.transform.localScale = Vector3.one * realScale;
                }

                UpdateChangedData();
            }

            private void OnOffestValueChanged()
            {
                var realOffestX = offest.x + originalPos.x;
                var realOffestZ = offest.y + originalPos.z;
                var newPos = new Vector3(realOffestX, 0f, realOffestZ);
                if (sphere != null)
                {
                    sphere.transform.position = newPos;
                }

                UpdateChangedData();
            }

            private void OnNoteValueChanged()
            {
                blockSphereInfo.note = note;
            }

            public void UpdateChangedData()
            {
                isChanged = offest != Vector2.zero ||
                            !Mathf.Approximately(1f, scale);

                // 如果状态发生变化且不在编辑状态，更新球体颜色
                if (!canEditor && sphere != null)
                {
                    SetSphereColor(isChanged ? ChangedSphereColor : Color.white);
                }
            }

            /// <summary>
            /// 设置球体颜色
            /// </summary>
            private void SetSphereColor(Color color)
            {
                if (sphere == null) return;

                var renderer = sphere.GetComponent<Renderer>();
                if (renderer != null)
                {
                    if (!canEditor)
                    {
                        if (renderer.sharedMaterial != null)
                        {
                            var material = new Material(renderer.sharedMaterial);
                            material.color = color;
                            renderer.sharedMaterial = material;
                        }
                    }
                }
            }

            #endregion
        }

        [BoxGroup("攻击阻挡球")]
        [HorizontalGroup("攻击阻挡球/Block")]
        [LabelText("编辑攻击阻挡球"), Indent]
        [ShowIf("@!_isLegionMap")]
        [OnValueChanged("OnCanEditorBlockSphereChanged")]
        [LabelWidth(100)]
        [SerializeField]
        private bool canEditorBlockSphere;

        private void OnCanEditorBlockSphereChanged()
        {
            if (canEditorBlockSphere)
            {
                showBuildings = false;
                HideObjectsExcept();

                blockSphereEditorList.Clear();
                UpdateBlockSphereInfo();
                foreach (var cellIndex in banAttackCells)
                {
                    if (blockSphereInfo.TryGetValue(cellIndex, out var sphereInfo))
                    {
                        var sphere = CreateSphere(cellIndex, sphereInfo.offestPos, Vector3.one * sphereInfo.scale);
                        var blockEditorInfo = new BlockSpereEditorInfo(sphereInfo, sphere);
                        blockSphereEditorList.Add(blockEditorInfo);
                    }
                    else
                    {
                        var pos = _map.TGSCellIndex2WorldPosition(cellIndex);
                        var sphere = CreateSphere(cellIndex, pos, Vector3.one * Calibre);
                        var blockEditorInfo = new BlockSpereEditorInfo(cellIndex, sphere);
                        blockSphereEditorList.Add(blockEditorInfo);
                    }
                }

                editingBlockSphereList.Clear();
                foreach (var editorInfo in blockSphereEditorList)
                {
                    if (editorInfo.isChanged)
                    {
                        editingBlockSphereList.Add(editorInfo);
                    }
                }
            }
            else
            {
                // 清理所有临时材质
                foreach (var editorInfo in blockSphereEditorList)
                {
                    if (editorInfo.editingMaterial != null)
                    {
                        if (editorInfo.sphere != null)
                        {
                            var renderer = editorInfo.sphere.GetComponent<Renderer>();
                            if (renderer != null)
                            {
                                renderer.sharedMaterial = editorInfo.originalSharedMaterial;
                            }
                        }

                        DestroyImmediate(editorInfo.editingMaterial);
                    }
                }

                showBuildings = true;
                ShowHiddenObjects();
                DestroyBlockSphere();
            }
        }

        /// <summary>
        /// 更新阻挡球信息
        /// </summary>
        private void UpdateBlockSphereInfo()
        {
            blockSphereInfo.Clear();
            GetAllBanAttackCell();
            foreach (var blockInfo in _currentMapData.BlockSphereInfos)
            {
                blockSphereInfo[blockInfo.cellIndex] = blockInfo;
            }
        }

        /// <summary>
        /// 获取所有禁止攻击地格
        /// </summary>
        private void GetAllBanAttackCell()
        {
            banAttackCells.Clear();
            var allCells = _currentMapData.BlocksData;
            for (var i = 0; i < allCells.Count; i++)
            {
                var blockData = allCells[i];
                if (!blockData.IsDefaultTerrainType())
                {
                    var blockInfo = blockData.GetTerrainTypeProperty();
                    if (blockInfo.banAttack)
                    {
                        banAttackCells.Add(i);
                    }
                }
            }
        }

        [LabelText("展示建筑")]
        [HorizontalGroup("攻击阻挡球/BlockBuildings"), Indent]
        [ShowIf("@!_isLegionMap&&canEditorBlockSphere")]
        [OnValueChanged("OnShowBuildingsChanged")]
        public bool showBuildings;

        private void OnShowBuildingsChanged()
        {
            if (showBuildings)
            {
                ShowHiddenObjects();
            }
            else
            {
                HideObjectsExcept();
            }
        }

        [LabelText("添加地格")] [HorizontalGroup("攻击阻挡球/新数据"), Indent] [ShowIf("canEditorBlockSphere")]
        public int addCellIndex;

        [Button("添加编辑")]
        [HorizontalGroup("攻击阻挡球/新数据/Add"), Indent]
        [ShowIf("@!_isLegionMap&&canEditorBlockSphere")]
        public void AddBlockSphere()
        {
            if (!banAttackCells.Contains(addCellIndex))
            {
                EditorUtility.DisplayDialog("错误", $"地格 {addCellIndex} 不是攻击阻挡地格！", "确定");
                return;
            }

            foreach (var blockSpereEditor in editingBlockSphereList)
            {
                if (blockSpereEditor.cellIndex == addCellIndex)
                {
                    return;
                }
            }

            foreach (var blockSpereEditor in blockSphereEditorList)
            {
                if (blockSpereEditor.cellIndex == addCellIndex)
                {
                    editingBlockSphereList.Add(blockSpereEditor);
                    break;
                }
            }
        }

        [LabelText("阻挡球列表")]
        [HorizontalGroup("攻击阻挡球/EditList"), Indent]
        [ShowIf("@!_isLegionMap&&canEditorBlockSphere")]
        [ListDrawerSettings(HideAddButton = true, CustomRemoveIndexFunction = "CustomRemoveBlockSphereIndex")]
        public List<BlockSpereEditorInfo> editingBlockSphereList = new();

        [HideInInspector] public List<BlockSpereEditorInfo> blockSphereEditorList = new();

        private void CustomRemoveBlockSphereIndex(int index)
        {
            if (index < editingBlockSphereList.Count)
            {
                editingBlockSphereList[index].Revert();
                DebugUtil.Log($"删除并还原{editingBlockSphereList[index].cellIndex}的阻挡球编辑数据");
                editingBlockSphereList.RemoveAt(index);
            }
        }

        /// <summary>
        /// 创建球体
        /// </summary>
        private GameObject CreateSphere(int cellIndex, Vector3 pos, Vector3 scale)
        {
            var sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            sphere.transform.position = pos;
            sphere.transform.localScale = scale;
            if (blockSphereRoot == null)
                blockSphereRoot = new GameObject("blockSphereRoot");
            sphere.transform.SetParent(blockSphereRoot.transform);
            sphere.name = "sphere" + cellIndex;
            return sphere;
        }

        private void DestroyBlockSphere()
        {
            DestroyImmediate(blockSphereRoot);
        }

        /// <summary>
        /// 保存数据
        /// </summary>
        private void SaveBlockSphereInfo()
        {
            _currentMapData.BlockSphereInfos.Clear();
            foreach (var blockSpereEditor in editingBlockSphereList)
            {
                _currentMapData.BlockSphereInfos.Add(blockSpereEditor.blockSphereInfo);
            }
        }

        /// <summary>
        /// 加载数据
        /// </summary>
        private void LoadBlockSphereInfo()
        {
            blockSphereInfo.Clear();
            foreach (var blockInfo in _currentMapData.BlockSphereInfos)
            {
                blockSphereInfo[blockInfo.cellIndex] = blockInfo;
            }
        }

        #region Sphere物体编辑器监听

        /// <summary>
        /// 当前正在编辑的球体信息
        /// </summary>
        [HideInInspector] public BlockSpereEditorInfo currentEditingSphere;

        /// <summary>
        /// 上次记录的位置
        /// </summary>
        [HideInInspector] public Vector3 lastPosition;

        /// <summary>
        /// 上次记录的缩放
        /// </summary>
        [HideInInspector] public Vector3 lastScale;

        /// <summary>
        /// 开始监听球体Transform变化
        /// </summary>
        private void StartMonitoringSphere(BlockSpereEditorInfo editorInfo)
        {
            currentEditingSphere = editorInfo;
            if (editorInfo.sphere != null)
            {
                lastPosition = editorInfo.sphere.transform.position;
                lastScale = editorInfo.sphere.transform.localScale;

                // 注册编辑器更新回调
                EditorApplication.update += OnEditorUpdate;
            }
        }

        /// <summary>
        /// 停止监听球体Transform变化
        /// </summary>
        private void StopMonitoringSphere()
        {
            currentEditingSphere = null;
            EditorApplication.update -= OnEditorUpdate;
        }

        /// <summary>
        /// 编辑器更新回调
        /// </summary>
        private void OnEditorUpdate()
        {
            if (currentEditingSphere?.sphere == null || !currentEditingSphere.canEditor)
            {
                StopMonitoringSphere();
                return;
            }

            var sphere = currentEditingSphere.sphere;
            var transform = sphere.transform;

            // 检查位置变化
            if (Vector3.Distance(transform.position, lastPosition) > 0.001f)
            {
                // 锁定Y轴
                var newPos = transform.position;
                newPos.y = 0f;
                transform.position = newPos;

                // 更新偏移值
                var offsetX = newPos.x - currentEditingSphere.originalPos.x;
                var offsetZ = newPos.z - currentEditingSphere.originalPos.z;
                currentEditingSphere.offest = new Vector2(offsetX, offsetZ);

                lastPosition = newPos;

                // 标记为已修改
                currentEditingSphere.UpdateChangedData();
            }

            // 检查缩放变化
            if (Vector3.Distance(transform.localScale, lastScale) > 0.001f)
            {
                var newScale = transform.localScale.x;
                transform.localScale = Vector3.one * newScale;
                currentEditingSphere.scale = newScale / Calibre;
                lastScale = transform.localScale;
                currentEditingSphere.UpdateChangedData();
            }
        }

        #endregion

        #region 物体隐藏/显示管理

        /// <summary>
        /// 需要隐藏的物体节点名字
        /// </summary>
        private readonly List<string> hideObjsRoot = new()
        {
            "Art", "BackGround", "Buildings", "enemyObjRoot", "midObjRoot", "selfObjRoot"
        };

        /// <summary>
        /// 不需要隐藏的物体节点名字
        /// </summary>
        private readonly List<string> noHideObjsRoot = new()
        {
            "Ground", "Ground2", "Lights", "Fog", "Global Volume", "Effects"
        };

        /// <summary>
        /// 隐藏指定节点下的物体（排除白名单中的物体）
        /// </summary>
        public void HideObjectsExcept()
        {
            if (hideObjsRoot == null || hideObjsRoot.Count == 0)
            {
                return;
            }

            // 清空之前的隐藏物体列表
            hideObjs.Clear();

            foreach (string nodeName in hideObjsRoot)
            {
                GameObject node = GameObject.Find(nodeName);
                if (node == null)
                {
                    continue;
                }

                HideChildrenRecursively(node.transform, noHideObjsRoot);
            }
        }

        /// <summary>
        /// 递归隐藏子物体
        /// </summary>
        /// <param name="parent">父级Transform</param>
        /// <param name="excludeNames">排除的物体名列表</param>
        private void HideChildrenRecursively(Transform parent, List<string> excludeNames)
        {
            for (int i = 0; i < parent.childCount; i++)
            {
                Transform child = parent.GetChild(i);
                GameObject childObj = child.gameObject;

                // 检查是否在排除列表中（完全匹配）
                bool shouldExclude = false;
                if (excludeNames != null)
                {
                    foreach (string excludeName in excludeNames)
                    {
                        if (childObj.name.Equals(excludeName, System.StringComparison.OrdinalIgnoreCase))
                        {
                            shouldExclude = true;
                            break;
                        }
                    }
                }

                if (shouldExclude)
                {
                    continue;
                }
                else
                {
                    // 不在排除列表中，隐藏此物体
                    if (childObj.activeSelf)
                    {
                        childObj.SetActive(false);
                        hideObjs.Add(childObj);
                    }

                    // 继续递归处理子物体
                    HideChildrenRecursively(child, excludeNames);
                }
            }
        }

        /// <summary>
        /// 显示之前隐藏的所有物体
        /// </summary>
        private void ShowHiddenObjects()
        {
            if (hideObjs == null || hideObjs.Count == 0)
            {
                return;
            }

            for (int i = hideObjs.Count - 1; i >= 0; i--)
            {
                GameObject obj = hideObjs[i];

                // 检查物体是否仍然存在（可能已被删除）
                if (obj != null)
                {
                    obj.SetActive(true);
                }

                hideObjs.RemoveAt(i);
            }
        }

        #endregion

        #endregion

        #region 功能

        [Button("保存")]
        private void RebuildPrefab()
        {
            SaveBlockSphereInfo();
            _currMapManager.SaveMapData();
        }

        [Button("清除网格数据")]
        private void ClearGridData()
        {
            if (EditorUtility.DisplayDialog("清理网格数据", "您是否确认清理地图网格数据", "确认", "取消"))
            {
                _currentMapData.ClearGridData();
                _map.TerrainGridSystem.TerritoryDestroyAll();
                ClearRegionColor();
                UpdateRegion();
                DestroyBlockSphere();
                _currMapManager.SaveMapData();
            }
        }

        #endregion

        #region MainLife

        public static void OpenWindow(MapManager mapSceneEditor, bool isLegionMap = false)
        {
            MapEditorSettings.Init();
            _thisWindow = GetWindow<MapGridWindow>();
            _thisWindow.name = "MapGridWindow";
            _thisWindow.position = GUIHelper.GetEditorWindowRect().AlignCenter(800, 600);
            _thisWindow._currMapManager = mapSceneEditor;
            _thisWindow._currentMapData = null;
            _thisWindow._isLegionMap = isLegionMap;
            _thisWindow.ShowTab();
            _thisWindow.LoadMap(mapSceneEditor.TGS, mapSceneEditor.MapData, mapSceneEditor.Map);
            _thisWindow.LoadBuffPrefab();
            UnityEditor.Compilation.CompilationPipeline.compilationStarted += OnCompilationStart;
        }

        private static void OnCompilationStart(object obj)
        {
            _thisWindow?.Close();
            _thisWindow = null;
        }

        private void LoadBuffPrefab()
        {
            DestroyBuffObj();
            _buffPrefabDic.Clear();
            var buffObjCells = _map.MapData.showBuffPoints;
            foreach (var cell in buffObjCells)
            {
                var buffObj = CreateBuffObj(cell.cellIndex, cell.path);
                _buffPrefabDic.TryAdd(cell.cellIndex, buffObj);
            }
        }

        private void DestroyBuffObj()
        {
            if (_buffPrefabDic == null) return;
            _buffPrefabDic.Clear();
            DestroyImmediate(buffRoot);
            buffRoot = null;
        }

        private void LoadMap(TerrainGridSystem tgs, MapData data, Map map)
        {
            _currentMapData = data;
            _map = map;
            _terrainTypeConfig = TerrainTypeConfig.DicTerrainTypePropertie;
            _legionTerrainTypeConfig = LegionTerrainTypeConfig.DicTerrainTypePropertie;
            _map.TerrainGridSystem.highlightEffect = HighlightEffect.Default;
            tgs.OnMouseClickOnGrid += OnMouseClickCell;
            UpdateRegion();
            // 加载阻挡球
            LoadBlockSphereInfo();
        }

        private void Awake()
        {
            SceneView.duringSceneGui += OnSceneGUI;
        }

        protected override void OnEnable()
        {
            EnhancedTouchSupport.Enable();
            TerrainTypeConfig.Load();
            LegionTerrainTypeConfig.Load();
            _buffPrefabDic = new Dictionary<int, GameObject>();
            base.OnEnable();
        }

        protected override void OnDisable()
        {
            DestroyBuffObj();
            _buffPrefabDic = null;
            EnhancedTouchSupport.Disable();
            DestroyBlockSphere();
            ShowHiddenObjects();
            base.OnDisable();
        }

        protected override void OnGUI()
        {
            base.OnGUI();
            if (_currMapManager == null || _currMapManager.MapData != _currentMapData)
            {
                Debug.Log("地图数据变更，请重新点击编辑网格！");
                Close();
            }
        }

        protected override void OnDestroy()
        {
            base.OnDestroy();
            ShowHiddenObjects();
            DestroyBuffObj();
            if (_currMapManager != null)
                _currMapManager.SaveMapData();
            ClearRegionColor();
            DestroyBlockSphere();
            _map.TerrainGridSystem.OnMouseClickOnGrid -= OnMouseClickCell;
            UnityEditor.Compilation.CompilationPipeline.compilationStarted -= OnCompilationStart;
            SceneView.duringSceneGui -= OnSceneGUI;
        }

        #endregion

        #region 点击事件

        private void OnMouseClickCell(TerrainGridSystem tgs, int cellIndex, int buttonIndex)
        {
            int leftButton = 0;

            OnCellOperation(tgs, cellIndex, buttonIndex == leftButton);
        }

        private void OnCellOperation(TerrainGridSystem tgs, int cellIndex, bool isOpTrue)
        {
            if (!canBrushTerrainType && !canEditorArea) return;

            if (canEditorArea && _currEditRegionArea == null) return;
 
            // 地块
            if (canBrushTerrainType)
                OnClickBlockType(cellIndex, isOpTrue);

            // 普通地区
            if (isOpTrue && canEditorSingleRegion && _currEditRegionArea != null)
            {
                _currEditRegionArea.AddPosition(cellIndex);
            }
            else if (!isOpTrue && canEditorSingleRegion && _currEditRegionArea != null)
            {
                _currEditRegionArea.RemovePosition(cellIndex);
            }
        }

        private void OnClickBlockType(int cellIndex, bool isOpTrue)
        {
            if (isOpTrue && terrainTypeIndex >= 0)
            {
                SetCellBlockType(cellIndex, terrainTypeIndex);
            }
            else if (!isOpTrue)
            {
                if (!_isLegionMap && _currentMapData.BlocksData[cellIndex].TerrainTypeIndex == terrainTypeIndex)
                {
                    ClearCellBlockType(cellIndex);
                }
                else if (_isLegionMap && _currentMapData.BlocksData[cellIndex].LegionTypeIndex == terrainTypeIndex)
                {
                    ClearCellBlockType(cellIndex);
                }
            }
        }

        #endregion

        #region Draw

        private void OnSceneGUI(SceneView sceneView)
        {
            DrawSphereID();
        }

        private GUIStyle labelStyleSphere;

        private void DrawSphereID()
        {
            if (!canEditorBlockSphere)
                return;

            labelStyleSphere ??= new GUIStyle
            {
                fontSize = 30,
                fontStyle = FontStyle.Bold,
                normal =
                {
                    textColor = Color.black
                }
            };

            foreach (var blockSpereEditor in blockSphereEditorList)
            {
                if (blockSpereEditor.sphere != null)
                {
                    var pos = new Vector3(blockSpereEditor.sphere.transform.position.x, Calibre,
                        blockSpereEditor.sphere.transform.position.z);
                    Handles.Label(pos, blockSpereEditor.cellIndex.ToString(),
                        labelStyleSphere);
                }
            }
        }

        #endregion
    }
}