using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.AddressableAssets;

namespace HexGrid
{
    
    public interface IBuildMediator
    {
        void Build();
        void CheckForBuilding(List<HexSubZone> zoneDataSubZones);
    }
    
    public class HexBuildingData
    {
        public string buildingPrefabName;
        
        public Vector3 position;
    }

    public class BuildingData
    {
        // 
        public string BuildingName;
        // 地块状态
        public Dictionary<string, int> TileStateMap;
        
        public Vector3 position;
    }
    
    public class BuildingManager : MonoBehaviour,IHexGridMediatable
    {
        //
        private IHexGridMediator _mediator;
        
        // public List<string> conditions = new List<string>();
        // private List<HexBuilding> _buildings;
        //[zoneId,[[build1,[tile1,tile2,tile3,....],],[build1,[tile1,tile2,tile3,....],]]
        private readonly Dictionary<int ,List<BuildingData>>  _unFinishBuildMap= new ();
        //<zoneId, [build1,build2,...]>
        private readonly Dictionary<int ,List<BuildingData>> _finishBuildMaps = new ();
        
        
        private void Awake()
        {
            // conditions.Clear();
        }

        public async void Build(Transform root,BuildingData buildingData)
        {
            // var build = Instantiate(buildingData.buildModel,root);
            //var build  = await Addressables.InstantiateAsync("BuildModel", root, true).Task;
            //build.transform.localPosition = buildingData.position;
            //build.name = "highbuilding";
            Log($"Build-> {root} {buildingData}");
            var buildTrans = root.Find(buildingData.BuildingName);
            if (buildTrans)
            {
                buildTrans.gameObject.SetActive(true);
            }
            // await RunBuildAnimation(buildingData);
        }

        public async Task RunBuildAnimation(BuildingData buildingData)
        {
            
        }
        
        public void LoadBuildings(List<HexBuilding> buildings)
        {
            // _buildings = buildings;
            _finishBuildMaps.Clear();
            _unFinishBuildMap.Clear();
            
            foreach (var hexBuilding in buildings)
            {
                var tileStateMap = hexBuilding.hasTiles.ToDictionary(tile => tile, tile => 0);
                _unFinishBuildMap.TryGetValue(hexBuilding.zoneId, out var buildingDatas);
                if (buildingDatas == null)
                {
                    buildingDatas = new List<BuildingData>();
                    _unFinishBuildMap.Add(hexBuilding.zoneId, buildingDatas);
                }
                buildingDatas.Add(new BuildingData()
                {
                    BuildingName = hexBuilding.buildingName,
                    TileStateMap = tileStateMap,
                });
            }
            Log($"LoadBuildings -> {_unFinishBuildMap}");
        }
        public void CheckForBuilding(List<HexSubZone> zoneDataSubZones)
        {
           
        }

        public void CheckBuildingAfterBuildImme(HexTile tiler)
        {
            if (_unFinishBuildMap.TryGetValue(tiler.zoneId, out var buildingDatas))
            {
                foreach (var buildingData in buildingDatas.Where(buildingData => buildingData.TileStateMap.ContainsKey(tiler.tileId)))
                {
                    buildingData.TileStateMap[tiler.tileId] = 1;
                    var full = buildingData.TileStateMap.Values.All(value => value == 1);
                    if (full)
                    {
                        buildingDatas.Remove(buildingData);
                        AddFinishBuilding(tiler.zoneId,buildingData);
                        _mediator.Build(tiler.zoneId, buildingData,true);
                    }
                    break;
                }
            }
        }
        public async Task CheckBuildingAfterBuild(HexTile tiler)
        {
            Log($"CheckBuildingAfterBuild ->{tiler}");
            //tiler.zoneId;

            if (_unFinishBuildMap.TryGetValue(tiler.zoneId, out var buildingDatas))
            {
                foreach (var buildingData in buildingDatas.Where(buildingData => buildingData.TileStateMap.ContainsKey(tiler.tileId)))
                {
                    buildingData.TileStateMap[tiler.tileId] = 1;
                    var full = buildingData.TileStateMap.Values.All(value => value == 1);
                    if (full)
                    {
                        buildingDatas.Remove(buildingData);
                        AddFinishBuilding(tiler.zoneId,buildingData);
                        await Awaiters.Seconds(0.5f);
                        _mediator.Build(tiler.zoneId, buildingData,false);
                        await Awaiters.Seconds(0.5f);
                    }
                    break;
                }
            }

            // _unFinishBuildMap.
            // conditions.Add(tiler.tileId);
            // if (conditions.Contains("cube012") && conditions.Contains("cube011"))
            // {
            //     _mediator.Build(tiler.zoneId);
            //     conditions.Clear();
            // }
        }
        private void AddFinishBuilding(int zoneId, BuildingData buildingData)
        {
            _finishBuildMaps.TryGetValue(zoneId, out var buildingDatas);
            if (buildingDatas == null)
            {
                buildingDatas = new List<BuildingData>();
                _finishBuildMaps.Add(zoneId, buildingDatas);
            }
            buildingDatas.Add(buildingData);
        }
        
        private static void Log(object t)
        {
            Debug.Log($"<color=orange>BuildingManager -> {t} </color>");
        }
        
        public void SetMediator(IHexGridMediator mediator)
        {
            _mediator = mediator;
        }

        // public HexBuildingData GetCurBuildModelData()
        // {
        //     return BuildingData;
        // }
    }
}