using System;
using System.Collections.Generic;
using GamePlay;
using R3;
using Reflex.Attributes;
using UnityEditor;
using UnityEngine;
using UnityEngine.UI;
using VoxelMap;
namespace UI
{
    public class WorldMap : MonoBehaviour
    {
        private const int ColumnPerFrame = 1;

        private const string ClearHeight = "ClearHeight";
        private const string UpdateHeight = "UpdateHeight";
        private const string UpdateChunk = "UpdateChunk";

        private static readonly int HeightBuffer = Shader.PropertyToID("HeightBuffer");
        private static readonly int VertexBuffer = Shader.PropertyToID("VertexBuffer");
        private static readonly int MapTexture = Shader.PropertyToID("MapTexture");
        private static readonly int MeshPositionOffset = Shader.PropertyToID("MeshPositionOffset");
        private static readonly int ChunkSize = Shader.PropertyToID("ChunkSize");

        [SerializeField] private ComputeShader computeShader;
        [SerializeField] private RawImage mapImage;

        private MapProvider _mapProvider;
        private EntityContainerService _entityContainer;

        private ComputeBuffer _heightBuffer;
        private int _updateHeightKernel;
        private int _updateChunkKernel;
        private int _clearHeightKernel;

        [field: SerializeField] public CanvasGroup CanvasGroup { get; private set; }
        public RenderTexture MainTexture { get; private set; }
        private readonly Queue<(int x, int z)> _regeneratingColumns = new Queue<(int x, int z)>();


        [Inject]
        private void Construct(MapProvider mapProvider)
        {
            _mapProvider = mapProvider;

            _heightBuffer = new ComputeBuffer(Chunk.ChunkSizeSquared, sizeof(uint));
            _clearHeightKernel = computeShader.FindKernel(ClearHeight);
            _updateHeightKernel = computeShader.FindKernel(UpdateHeight);
            _updateChunkKernel = computeShader.FindKernel(UpdateChunk);

            computeShader.SetFloat(ChunkSize, Chunk.ChunkSize);
        }

        public void Initialize()
        {
            if (MainTexture != null)
            {
                MainTexture.Release();
            }

            MainTexture = new RenderTexture(_mapProvider.Map.Width, _mapProvider.Map.Depth, 0, RenderTextureFormat.ARGB32)
            {
                enableRandomWrite = true,
                filterMode = FilterMode.Point
            };

            MainTexture.Create();
            mapImage.texture = MainTexture;

            _mapProvider.Map.ChunkUpdated.Subscribe(OnChunkUpdated).AddTo(_mapProvider.Map);

            _regeneratingColumns.Clear();

            for (int x = 0; x < _mapProvider.Map.Width / Chunk.ChunkSize; x++)
            {
                for (var z = 0; z < _mapProvider.Map.Depth / Chunk.ChunkSize; z++)
                {
                    _regeneratingColumns.Enqueue((x, z));
                }
            }
        }

        private void Update()
        {
            if (_mapProvider.Map == null)
            {
                return;
            }

            for (var i = 0; i < Math.Min(_regeneratingColumns.Count, ColumnPerFrame); i++)
            {
                (int x, int z) = _regeneratingColumns.Dequeue();
                RefreshChunkColumn(x, z);
            }
        }

        private void RefreshChunkColumn(int x, int z)
        {
            computeShader.SetBuffer(_clearHeightKernel, HeightBuffer, _heightBuffer);
            computeShader.Dispatch(_clearHeightKernel, Chunk.ChunkSize / 8, Chunk.ChunkSize / 8, 1);

            for (var y = 0; y < _mapProvider.Map.Height / Chunk.ChunkSize; y++)
            {
                int chunkIndex = GetChunkIndex(x, y, z);
                Chunk chunk = _mapProvider.Map.Chunks[chunkIndex];

                if (chunk.Mesh.vertexCount == 0)
                {
                    continue;
                }

                chunk.Mesh.vertexBufferTarget |= GraphicsBuffer.Target.Raw;
                using GraphicsBuffer vertexBuffer = chunk.Mesh.GetVertexBuffer(0);

                int quadCount = chunk.Mesh.vertexCount / 4;

                computeShader.SetBuffer(_updateHeightKernel, VertexBuffer, vertexBuffer);
                computeShader.SetBuffer(_updateHeightKernel, HeightBuffer, _heightBuffer);
                computeShader.SetFloats(MeshPositionOffset, chunk.Position.x, chunk.Position.y, chunk.Position.z);
                computeShader.Dispatch(_updateHeightKernel, Mathf.Max(1, quadCount / 16), 1, 1);

                computeShader.SetBuffer(_updateChunkKernel, VertexBuffer, vertexBuffer);
                computeShader.SetBuffer(_updateChunkKernel, HeightBuffer, _heightBuffer);
                computeShader.SetTexture(_updateChunkKernel, MapTexture, MainTexture);
                computeShader.SetFloats(MeshPositionOffset, chunk.Position.x, chunk.Position.y, chunk.Position.z);
                computeShader.Dispatch(_updateChunkKernel, Mathf.Max(1, quadCount / 16), 1, 1);
            }
        }

        private void OnChunkUpdated(Chunk chunk)
        {
            _regeneratingColumns.Enqueue((chunk.Position.x / Chunk.ChunkSize, chunk.Position.z / Chunk.ChunkSize));
        }

        private int GetChunkIndex(int x, int y, int z)
        {
            return x * (_mapProvider.Map.Height * _mapProvider.Map.Depth / Chunk.ChunkSizeSquared)
                   + y * (_mapProvider.Map.Depth / Chunk.ChunkSize) + z;
        }

        private void OnDestroy()
        {
            _heightBuffer.Release();
            MainTexture.Release();
        }
    }
}