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

namespace UltraCombos.Frozen
{
    public class SnowflakeParticleUpdater : MonoBehaviour
    {
        public bool reset = false;
        [SerializeField] int fps = 30;
        float stamp = 0.0f;
        [Range(1, 1 << 20)]
        public int maxParticles = 1 << 15;
        public StructuredBuffer particleBuffer = null;
        List<Particle> buffer_data = null;

        public ComputeShader shader = null;
        ComputeBuffer args_buffer = null;

        public UniformStructuredBuffer uniformBuffer;
        ParticleUniforms uniforms = null;

        //public Klak.Chromatics.CosineGradient cosineGradient = null;
        public BlendedCosineGradient cosineGradient = null;

        bool is_initialized = false;

        [SerializeField]
        KinectOpticalFlow kinectOpticalFlow;
        [SerializeField]
        FluidSim3DProject.SmokeFluidSim smokeFluidSim;
        [SerializeField]
        ParticleViewerMesh particleViewerMesh;
        [SerializeField]
        [Range(0, 1)]
        public float rate = 1.0f;

        [SerializeField, Range(0, 1)]
        float value = 0;
        [SerializeField]
        string debug;

        private void Start()
        {
            uniforms = uniformBuffer.uniform as ParticleUniforms;
            particleViewerMesh.BufferCount = (int)(maxParticles * rate);
            StartCoroutine(Initialize());
        }

        private void Update()
        {
            if (is_initialized == false)
                return;

            float time_step = 1.0f / fps;
            if (Time.time - stamp < time_step)
                return;
            stamp = Time.time;

            if (reset)
            {
                reset = false;
                OnReset();
            }

            UpdateParticle(time_step);
        }

        private void OnDestroy()
        {
            Utilities.Release(ref args_buffer);
        }

        private void OnReset()
        {
            particleBuffer.SetData(buffer_data);
        }

        private IEnumerator Initialize()
        {
            {
                args_buffer = shader.CreateIndirectComputeArgsBuffer(maxParticles, 1, 1);
            }

            {
                buffer_data = new List<Particle>();
                yield return Utilities.GetRandomParticleData(maxParticles, buffer_data);
            }

            is_initialized = true;
            OnReset();
        }

        private void UpdateParticle(float time_step)
        {
            {
                shader.SetFloat("timeStep", time_step);
                shader.SetFloat("timeValue", Utilities.GetTimeValue());
                //shader.SetInt("home_count", kinectOpticalFlow.HomeCount);
                shader.SetFloat("bufferCount", particleBuffer.count);

                if (cosineGradient != null)
                {
                    shader.SetVector("coeffsA", cosineGradient.coeffsA);
                    shader.SetVector("coeffsB", cosineGradient.coeffsB);
                    shader.SetVector("coeffsC", cosineGradient.coeffsC2);
                    shader.SetVector("coeffsD", cosineGradient.coeffsD2);
                }

                shader.SetVector("FluidGridDim", smokeFluidSim.GridDim);
                shader.SetVector("FluidGridRoot", smokeFluidSim.GridRoot);
                shader.SetVector("FluidGridSize", smokeFluidSim.GridSize);

                shader.SetBuffer(0, particleBuffer.bufferName, particleBuffer.obj);
                shader.SetBuffer(0, uniformBuffer.bufferName, uniformBuffer.obj);
                shader.SetBuffer(0, "home_count_buffer", kinectOpticalFlow.HomeCountBuffer);
                shader.SetBuffer(0, "home_position_buffer", kinectOpticalFlow.HomePositionBuffer);
                shader.SetBuffer(0, "home_velocity_buffer", kinectOpticalFlow.HomeVelocityBuffer);
                shader.SetBuffer(0, "fluid_velocity_buffer", smokeFluidSim.VelocityBuffer);

                shader.DispatchIndirect(0, args_buffer);
            }
        }
    }
}