using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AddressableAssets;
using cfg;
using asap.core;
using UnityEngine.ResourceManagement.AsyncOperations;
public class BlockManager : MonoBehaviour
{
    private Dictionary<string, GameObject> _blockPrefabs = new Dictionary<string, GameObject>();
    //[SerializeField] private BoxCollider2D _deathWall;
    [SerializeField] List<Block> _blocks = new List<Block>();
    [SerializeField] private Transform _focus;
    public Block CurrentBlock;
    private TbConstructionBasicUnits _blockTypesTable;
    private TbConstructionUnits _blocksTable;
    private TbConstructionHeightEvent _heightEventTable;
    private InfiniteBuildingConf _cfg;
    private InfiniteBuildingData _data;
    private EventAggregator _eventAggregator;
    private List<AsyncOperationHandle> _prefabOps;
    public List<Block> Blocks => _blocks;
    private void Start()
    {
        _blockTypesTable = GContext.container.Resolve<Tables>().TbConstructionBasicUnits;
        _blocksTable = GContext.container.Resolve<Tables>().TbConstructionUnits;
        _prefabOps = new List<AsyncOperationHandle>();
    }
    private void OnDestroy()
    {
        foreach (var op in _prefabOps)
            Addressables.Release(op);
    }
    public void Init(InfiniteBuildingConf cfg, InfiniteBuildingData data, EventAggregator ea)
    {
        _cfg = cfg;
        _data = data;
        _eventAggregator = ea;
        _heightEventTable = GContext.container.Resolve<Tables>().TbConstructionHeightEvent;
    }


    /// <summary>
    /// Get prefab according to PrefabID, will be used in init and block generation
    /// </summary>
    /// <param name="id">name of the prefab in addressables</param>
    /// <returns>the prefab GameObject</returns>
    private async System.Threading.Tasks.Task<GameObject> GetBlockPrefab(string id)
    {
        if (_blockPrefabs.TryGetValue(id, out var prefab))
            return prefab;
        _prefabOps.Add(Addressables.LoadAssetAsync<object>(id));
        var go = (GameObject) await _prefabOps[^1].Task;
        _blockPrefabs.Add(id, go);
        return go;
    }
    private int GetRandomIDFromWeightTable(Dictionary<int, float> weightTable)
    {
        Dictionary<int, float> weightSum = new Dictionary<int, float>();
        float sum = 0;
        foreach (var e in weightTable)
        {
            sum += e.Value;
            weightSum.Add(e.Key, sum);
        }
        float randomNum = UnityEngine.Random.Range(0, sum);
        foreach (var e in weightSum)
        {
            if (randomNum <= e.Value)
            {
                return e.Key;
            }
        }
        Debug.LogError($"Random ID not available. WeightTable entries count: {weightTable.Count}.");
        return -1;
    }
    public async System.Threading.Tasks.Task<Block> GenerateBlock(Vector3 spawnPos, bool isFirst = false)
    {
        Block generatedBlock;
        Dictionary<int, float> weightTable = new Dictionary<int, float>();
        //_crane.ResetPosition();
        //await Awaiters.NextFrame;
        int type, block;
        foreach (var bt in _blockTypesTable.DataList)
        {
            weightTable.Add(bt.ID, bt.Weight);
        }
        type = GetRandomIDFromWeightTable(weightTable);
        weightTable.Clear();
        foreach (int blockID in _blockTypesTable[type].UnitList)
        {
            if (_data.Lvl < _blocksTable[blockID].UnlockedHeight)
                continue;
            weightTable.Add(blockID, _blocksTable[blockID].Weight);
        }
        block = GetRandomIDFromWeightTable(weightTable);
        if (isFirst && _data.LastHangingBlock != -1)
        {
            block = _data.LastHangingBlock;
            _data.LastHangingBlock = -1;
        }
        TbConstructionInfiniteInit initTable = GContext.container.Resolve<Tables>().TbConstructionInfiniteInit;
        if (_data.Lvl < initTable.DataList.Count)
            block = GContext.container.Resolve<Tables>().TbConstructionInfiniteInit.DataList[_data.Lvl].UnitID;
#if UNITY_EDITOR
        if (_cfg.NextBlockToSpawn != -1 && _blocksTable.DataMap.ContainsKey(_cfg.NextBlockToSpawn))
            block = _cfg.NextBlockToSpawn;
#endif
        string id = _blocksTable[block].Prefab;
        GameObject prefab = await GetBlockPrefab(id);
        //GameObject prefab = await GetBlockPrefab("block_000");//Get test prefab
        //Debug.Log($"<color=red>{_crane.transform.position}</color>");
        //Debug.Log($"<color=red>{_cfg.blockSpawnOffset}</color>");
        generatedBlock = Instantiate(prefab, spawnPos + _blocksTable[block].Height * Vector3.down,
            prefab.transform.rotation, transform).GetComponent<Block>();
        generatedBlock.InitHangingBlock(BlockState.Hanging, block, _eventAggregator, _cfg);
        generatedBlock.Rb.angularDrag = GetDataByIBLvl(_data.Lvl, _heightEventTable.DataList).AngularDrag;
        generatedBlock.Rb.drag = GetDataByIBLvl(_data.Lvl, _heightEventTable.DataList).LinearDrag;
        //_currentBlock.SetParams(_cfg, _deathWall.name, block, _focus);
        //generatedBlock.OnRest += async d => await OnBlockRest(d);
        //generatedBlock.OnDestroy += async () => await OnBlockDestroy();
        //_currentBlock.AttachJoints(_crane);
        //_crane.AttachJoints(generatedBlock);
        //await _crane.Descend();
        //if (doSwitchState)
        //    _stateMachine.SetState(EInfiniteBuildingState.PlayerCtrl);
        return generatedBlock;
    }
    private async System.Threading.Tasks.Task<GameObject> GenerateBlock(InfiniteBuildingData.BlockRecord record, IEventAggregator ea)
    {
        GameObject b = Instantiate(await GetBlockPrefab(record.PrefabID),
            new Vector3(record.Pos.x, record.Pos.y, _cfg.blockDepth), Quaternion.identity, transform);
        b.GetComponent<Rigidbody2D>().isKinematic = true;
        b.GetComponent<Rigidbody2D>().velocity = Vector2.zero;
        b.GetComponent<Block>().Idx = record.ID;
        b.GetComponent<Block>().EventAggregator = ea;
        //_blocks[^1].SetParams(_cfg, _deathWall.name, record.id, _focus);
        return b;
    }

    public int GetExcellentScore()
    {
        int fallingBlockScore = _blocksTable[CurrentBlock.Idx].FallPoint;
        int stackedBlockScore = _blocks is { Count: > 0 } ? _blocksTable[_blocks[^1].Idx].StackPoint : 0;
        // Debug.Log($"<color=red>Incoming: {fallingBlockScore}, stacked: {stackedBlockScore}</color>");
        return fallingBlockScore + stackedBlockScore;
    }
    public bool TrySnap()
    {
        if (_blocks is not { Count: > 0 })
        {
            if (Mathf.Abs(CurrentBlock.Rb.position.x - _focus.position.x) > _cfg.snapThresh)
                return false;
            CurrentBlock.Rb.MovePosition(new Vector2(_focus.position.x, CurrentBlock.Rb.position.y));
            return true;
        }
        if (Mathf.Abs(CurrentBlock.Rb.position.x - _blocks[^1].Rb.position.x) > _cfg.snapThresh)
            return false;
        CurrentBlock.Rb.MovePosition(new Vector2(_blocks[^1].Rb.position.x, CurrentBlock.Rb.position.y));
        return true;
    }
    public async void AlignBlocks(IEventAggregator ea)
    {
        Block b;
        for (int j = _blocks.Count - 1; j >= 0; j--)
        {
            b = _blocks[j];
            //_blocks.RemoveAt(j);
            if (b != null)
                Destroy(b.gameObject);
        }
        Vector3 pivot = _focus.position;
        for (int i = _data.Record.Count - 1; i >= 0; i--)
        {
            InfiniteBuildingData.BlockRecord r = _data.Record[i];
            b = Instantiate(await GetBlockPrefab(r.PrefabID),
                pivot + r.Height * Vector3.down,
                Quaternion.identity, transform).GetComponent<Block>();
            pivot += r.Height * Vector3.down;
            //_blocks[_data.Record.Count - 1 - i] = b;
            _blocks[i] = b;
            b.Rb.isKinematic = true;
            b.Rb.velocity = Vector2.zero;
            b.Idx = r.ID;
            b.EventAggregator = ea;
        }
        for (int i = _blocks.Count - 1; i >= 0; i--)
        {
            b = _blocks[i];
            if (b.WorldHeight < _focus.position.y + _cfg.blockDestroyOffset)
            {
                _blocks.RemoveAt(i);
                Destroy(b.gameObject);
            }
            else if (b.WorldHeight < _focus.position.y + _cfg.blockRestingOffset)
            {
                b.Rb.isKinematic = true;
                b.State = BlockState.Locked;
            }
            else
            {
                b.Rb.isKinematic = false;
                b.State = BlockState.Resting;
            }
        }
        //for (int i = 0; i < _blocks.Count; i++)
        //{
        //    if (_blocks[i] == null)
        //        continue;
        //    _blocks[i].Rb.MovePosition(new Vector2(0, _data.Record[i].pos.y));
        //}
    }
    private float _blockDestructionTimer = 1000f;
    public void BlockFallFixedUpdate()
    {
        float rot = CurrentBlock.Rb.rotation;
        _blockDestructionTimer -= Time.fixedDeltaTime;
        if (_blockDestructionTimer < 0)
        {
            _eventAggregator.Publish(new EventInfiniteBuildingFail());
            return;
        }
        if (!CurrentBlock.Freezable || !CurrentBlock.IsCurrentBlockStill)
            return;

        if ((rot <= _cfg.blockDestroyThreshAngle && rot > -_cfg.blockDestroyThreshAngle)
                || (rot >= 180 - _cfg.blockDestroyThreshAngle && rot <= 180)
                || (rot >= -180 && rot <= -180 + _cfg.blockDestroyThreshAngle))
            _eventAggregator.Publish(new EventInfiniteBuildingSucceed());
        else
            _eventAggregator.Publish(new EventInfiniteBuildingFail());
    }
    public void StartDestroyCountDown()
    {
        //Debug.Log("111111111111111");
        _blockDestructionTimer = _cfg.blockDestroyDelay;
    }
    public void ResetDestroyCountDown()
    {
        _blockDestructionTimer = float.PositiveInfinity;
    }
    public void AddCurrentBlock()
    {
        _blocks.Add(CurrentBlock);
    }
    private void CurrentBlockFail()
    {
        Debug.Log("Build failure.");
    }
    /// <summary>
    /// Lock or clear blocks according to their height, need focus updated first
    /// </summary>
    public void LockOrClearBlocks(bool isFilterOnly = false)
    {
        for (int i = _blocks.Count - 1; i >= 0; i--)
        {
            Block b = _blocks[i];
            if (b.WorldHeight < _cfg.blockDestroyOffset + _focus.position.y)
            {
                _blocks.RemoveAt(i);
                Destroy(b.gameObject);
            }
            else if (b.WorldHeight < _cfg.blockRestingOffset + _focus.position.y )
            {
                b.Rb.velocity = Vector2.zero;
                b.Rb.rotation = 0;
                b.Rb.angularVelocity = 0;
                b.Rb.isKinematic = true;
            }
            else if (!isFilterOnly)
                b.Rb.isKinematic = false;
        }
    }
    /// <summary>
    /// Clear stage, generate blocks according to data, and reset focus position
    /// </summary>
    /// <returns>Task</returns>
    public async System.Threading.Tasks.Task RebuildAllBlocks()
    {
        //clear the act
        if (CurrentBlock != null)
            Destroy(CurrentBlock.gameObject);
        await RebuildBlocks();
    }
    /// <summary>
    /// reset stage, bug leave the current block alone
    /// </summary>
    /// <returns></returns>
    public async System.Threading.Tasks.Task RebuildBlocks(bool doesLockAll = false)
    {
        Block b;
        for (int j = _blocks.Count - 1; j >= 0; j--)
        {
            b = _blocks[j];
            _blocks.RemoveAt(j);
            if (b != null)
                Destroy(b.gameObject);
        }
        //regenerate
        _focus.position = new Vector3(_focus.position.x, 0, _focus.position.z);
        foreach (var record in _data.Record)
        {
            b = (await GenerateBlock(record, _eventAggregator)).GetComponent<Block>();
            b.InitRecordBlock(_cfg);
            b.LitBlock();
            _blocks.Add(b);
            if (_focus.position.y < b.WorldHeight)
                _focus.position = new Vector3(_focus.position.x, b.WorldHeight, _focus.position.z);
        }
        for (int i = _blocks.Count - 1; i >= 0; i--)
        {
            b = _blocks[i];
            if (b.WorldHeight < _focus.position.y + _cfg.blockDestroyOffset)
            {
                _blocks.RemoveAt(i);
                Destroy(b.gameObject);
            }
            else if (b.WorldHeight < _focus.position.y + _cfg.blockRestingOffset || doesLockAll)
            {
                b.Rb.isKinematic = true;
                b.State = BlockState.Locked;
            }
            else
            {
                b.Rb.isKinematic = false;
                b.State = BlockState.Resting;
            }
        }
    }
    private ConstructionHeightEvent GetDataByIBLvl(int lvl, List<ConstructionHeightEvent> dataList)
    {
        for (int i = 0; i < dataList.Count - 1; i++)
        {
            if (lvl < dataList[i + 1].Height)
                return dataList[i];
        }
        return dataList[^1];
    }
}