using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace UltraCombos
{
    [RequireComponent(typeof(MeshFilter))]
    [RequireComponent(typeof(MeshRenderer))]
    public class ParticleViewerMesh : ParticleViewer
    {
        public ComputeShader shader;
        ComputeBuffer args_buffer = null;
        ComputeBuffer origin_buffer = null;
        ComputeBuffer vertex_buffer = null;
        public List<Mesh> references;
        Mesh mesh = null;
        System.IntPtr mesh_buffer_handle;

        public ComputeBuffer vertexBuffer { get { return vertex_buffer; } }

        int buffer_count = 0;
        public int BufferCount { set { buffer_count = value; } }

        protected override void OnFixedUpdate()
        {
            shader.SetBuffer(0, buffer.bufferName, buffer.obj);
            shader.SetBuffer(0, "origin_buffer", origin_buffer);
            shader.SetBuffer(0, "vertex_buffer", vertex_buffer);
            shader.DispatchIndirect(0, args_buffer);
            
            Utility.Buffer.Copy(mesh_buffer_handle, vertex_buffer.GetNativeBufferPtr());
        }

        protected override void OnUpdate()
        {
            material.SetBuffer(buffer.bufferName, buffer.obj);

        }

        protected override void Release()
        {
            if (origin_buffer != null)
            {
                origin_buffer.Release();
                origin_buffer = null;
            }

            if (vertex_buffer != null)
            {
                vertex_buffer.Release();
                vertex_buffer = null;
            }

            if (args_buffer != null)
            {
                args_buffer.Release();
                args_buffer = null;
            }
        }

        protected override IEnumerator Initialize()
        {
            if (references.Count == 0)
            {
                var vertices = new List<Vector3>();
                var normals = new List<Vector3>();
                var colors = new List<Color>();
                var uvs = new List<Vector2>();
                var indices = new List<int>();
                int side = 3;
                float delta = Mathf.PI * 2.0f / side;
                for (int i = 0; i < side; i++)
                {
                    float a = -delta * i;
                    float x = Mathf.Cos(a);
                    float y = Mathf.Sin(a);
                    vertices.Add(new Vector3(x, 0, y));
                    normals.Add(new Vector3(0, 1, 0));
                    colors.Add(Color.white);
                    uvs.Add(new Vector2(x * 0.5f + 0.5f, y * 0.5f + 0.5f));
                    indices.Add(i);
                }
                var m = new Mesh();
                m.SetVertices(vertices);
                m.SetNormals(normals);
                m.SetColors(colors);
                m.SetUVs(0, uvs);
                m.SetIndices(indices.ToArray(), MeshTopology.Triangles, 0);
                m.UploadMeshData(false);
                m.name = string.Format("{0} sides mesh", side);
                references.Add(m);
            }

            mesh = new Mesh();
            int max_particles = buffer_count > 0 ? buffer_count : buffer.count;
            yield return Utilities.GetReferencesParticleMesh(references, max_particles, mesh);

            {
                mesh.name = string.Format("v: {0}", mesh.vertexCount);
                var mesh_filter = GetComponent<MeshFilter>();
                mesh_filter.sharedMesh = mesh;
                //var mesh_renderer = GetComponent<MeshRenderer>();
                //mesh_renderer.material = material;
                //mesh_renderer.allowOcclusionWhenDynamic = false;
            }

            {
                mesh_buffer_handle = mesh.GetNativeVertexBufferPtr(0);
                int size = Utility.Buffer.GetSize(mesh_buffer_handle);
                int count = mesh.vertexCount;
                int stride = size / count;
                //print("size: " + size);
                //print("count: " + count);
                //print("stride: " + stride);
                origin_buffer = new ComputeBuffer(count, stride);
                Utility.Buffer.Copy(origin_buffer.GetNativeBufferPtr(), mesh_buffer_handle);
                vertex_buffer = new ComputeBuffer(count, stride);
                Utility.Buffer.Copy(vertex_buffer.GetNativeBufferPtr(), mesh_buffer_handle);

                args_buffer = shader.CreateIndirectComputeArgsBuffer(count, 1, 1);
            }
        }
    }
}