//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Partical"
// Project: StgSharp
// AuthorGroup: Nitload
// Copyright (c) Nitload. All rights reserved.
//     
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//     
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using StgSharp.Controls;
using StgSharp.Geometries;
using StgSharp.Graphics;
using StgSharp.Graphics.OpenGL;
using StgSharp.Mathematics;
using StgSharp.Mathematics.Graphic;
using StgSharp.Timing;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StgSharp
{
    public class ParticleRenderStream : glRender
    {

        private AutoTextureGL autoT;

        private ElementBuffer ebo;
        private ElementBuffer f_ebo;
        private FrameBuffer fbo;
        private Image i;

        private int temp = 0;
        private PlainInstancingBuffer<ParticleOnPlain> buffer;
        private RenderBuffer rbo;
        private ShaderProgram frameMainShader;
        private ShaderProgram s;
        private TextureGL f_t;
        private TextureGL t;
        private Uniform<int> texUniform;
        private Uniform<float> time;
        private VertexArray f_vao;
        private VertexArray vao;

        private VertexBuffer f_vbo;
        private VertexBuffer vbo;

        public ParticleRenderStream() { }

        public override bool IsContextSharable => true;

        public Rectangle ButtonBounding { get; private set; }

        public TextureProvider ButtonTextureProvider { get; private set; }

        // render a controlling item
        public void ButtonMain(IEnumerable<PlainGeometryMesh> items)
        {
            // Console.WriteLine("Render Button Itself");

            GL.BindFrameBuffer(FrameBufferTarget.All, GlHandle.Zero);     /*GL.Assert(true);/**/
            GL.ClearColor(0.4f, TimePassed % 1.0f, 0f, 1.0f);                /*GL.Assert(true);/**/
            GL.Clear(MaskBufferBit.COLOR /**/ | MaskBufferBit.DEPTH/**/);         /*GL.Assert(true);/**/

            f_vao.Bind(0); //GL.Assert(true);

            foreach (PlainGeometryMesh mesh in items)
            {
                // autoT.SelectTextureAndBind(mesh.TextureImage);
                f_t.LoadTexture(0, mesh.TextureImage);

                // GL.Assert(true);

                frameMainShader.Use(); //GL.Assert(true);

                GL.DrawElements(GeometryType.TRIANGLES, 6, TypeCode.UInt32, IntPtr.Zero);
            }

            // GL.ClearError();
            // GL.Assert(true);
        }

        public void Main()
        {
            temp++;

            // GL.ClearError();
            GL.Viewport(0, 0, (uint)Width, (uint)Height);

            // Console.Clear();
            buffer.UpdateAllParticles();

            // Console.WriteLine(GL.CheckFrameBufferStatus(FrameBufferTarget.All));

            fbo.Bind(0); //GL.Assert(true);
            vao.Bind(0); //GL.Assert(true);
            t.Bind2D(0); //GL.Assert(false);

            GL.Viewport(0, 0, (uint)Width, (uint)Height);

            /**/

            GL.TextureImage2d<byte>(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel, (uint)Width,
                                    (uint)Height, ImageChannel.WithAlphaChannel, PixelChannelLayout.Byte, null);
            /**/

            // GL.Assert(false);
            // Console.WriteLine(GL.CheckFrameBufferStatus(FrameBufferTarget.All));

            GL.ClearColor((0.6f + TimePassed) % 1.0f, 0.1f, 0.3f, 1);

            // GL.Assert( false );

            // Console.WriteLine(GL.CheckFrameBufferStatus(FrameBufferTarget.All));
            GL.Clear(MaskBufferBit.COLOR /**/ | MaskBufferBit.DEPTH/**/);


            // GL.Assert(false);

            vbo.Bind(1);
            vbo.WriteVectorData<Vec4>(1, buffer.CoordAndRotationSpan, BufferUsage.StreamDraw);


            s.Use();
            NativeCamera.SetAllUniforms();
            GL.SetUniformValue(time, TimePassed);

            GL.DrawElementsInstanced(GeometryType.TRIANGLES, 6, TypeCode.UInt32, IntPtr.Zero, 100);

            // Console.WriteLine(TimePassed);
            // GL.Assert(true);
            
            GL.WaitAccomplishment();
            GL.BindVertexArray(GlHandle.Zero);
            /**/

            // GL.Assert(true);

            ImageHelper.Resize(i, Width, Height, ImageMovement.Discard);

            // GL.ClearError();
            // Console.Write($"Size set to {Height},{Width}");
            // Console.WriteLine($"Image resized to {i.Height} {i.Width}");
            GL.GetTextureImage(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel, PixelChannelLayout.Byte,
                               i.PixelBuffer);
            /*
            for (int num = 0; num < i.PixelBuffer.Length; num+=10000)
            {
                Console.Write($"{i.PixelBuffer[num]}\t");
            }
            /**/

            // GL.Assert(true);
            // Array.Fill<byte>(i.PixelBuffer, 24);

            GL.BindFrameBuffer(FrameBufferTarget.All, GlHandle.Zero);

            // GL.Assert(true);
            /**/
        }

        public void NothingMain()
        {
            GL.ClearError();

            // GL.BindFrameBuffer(FrameBufferTarget.All, GlHandle.Zero);
            GL.ClearColor(0.5f, 0.2f, 0.3f, 1.0f);
            GL.Assert(false);
        }

        public void RenderButton(ButtonStatus status, float statusBegin, in TextureProvider provider)
        {
            provider.UpdateFromImage(i);
        }

        internal static Vec3 DefaultRotation(TimeSpanProvider provider, out float rotation)
        {
            rotation = 1.0f / 60;
            float angle = (float)provider.CurrentSecond * 2;
            return (new Vec3(Scalar.Cos(angle), Scalar.Sin(angle),
                             0)) * rotation;
        }

        protected override void CustomizeDeinit() { }

        protected override void CustomizeInit()
        {
            // GL.ClearError();
            // GL.Assert(true);

            buffer = new PlainInstancingBuffer<ParticleOnPlain>();
            for (int i = 0; i < 10; i++)
            {
                float ai = Scalar.Abs(i - 5.0f);
                for (int t = 0; t < 10; t++)
                {
                    float at = Scalar.Abs(t - 5.0f);

                    ParticleOnPlain p = new ParticleOnPlain(buffer);
                    ((IInstancing)p).Coord = new Vec3(
                        (((-5) + i) * 0.2f) + 0.1f, (((-5) + t) * 0.2f) + 0.1f, 0);
                    ((IInstancing)p).Scale =
                        Scalar.MinOf(i, t) * 0.15f;
                    ((IInstancing)p).Motion = new GeometryMotion(
                        true, TimeProvider, DefaultRotation);
                }
            }

            // GL.Assert(true);

            // SetSizeLimit(800, 800, 800, 800);

            s = CreateShaderProgram();
            frameMainShader = CreateShaderProgram();
            Shader pvs = CreateShaderSegment(ShaderType.Vertex, 2);
            Shader pfs = CreateShaderSegment(ShaderType.Fragment, 2);

            // GL.Assert(true);
            pvs.Compile(0, Shader.FromCodeFile("Shader\\particle.vert"));

            // GL.Assert(true);
            pvs.AttachTo(0, s);

            // GL.Assert(true);
            pfs.Compile(0, Shader.FromCodeFile("Shader\\particle.frag"));
            pfs.AttachTo(0, s);
            s.Link();

            // GL.Assert(true);

            pvs.Compile(1, Shader.FromCodeFile("Shader\\fbo.vert"));
            pvs.AttachTo(1, frameMainShader);
            pfs.Compile(1, Shader.FromCodeFile("Shader\\fbo.frag"));
            pfs.AttachTo(1, frameMainShader);
            frameMainShader.Link();

            // GL.Assert(true);
            vbo = CreateVertexBuffer(3);
            vao = CreateVertexArray(1);
            ebo = CreateElementBuffer(1);
            vbo.Bind(0);

            Rectangle rec = new Rectangle(0.05f, 0.05f, 0.05f, -0.05f, -0.05f, -0.05f, -0.05f, 0.05f);

            // GL.Assert(true);
            vao.Bind(0);
            vbo.WriteVectorData(0, rec.VertexStream, BufferUsage.StaticDraw);
            ebo.SetValue(0, rec.VertexIndices, BufferUsage.StaticDraw);
            vao.SetVertexAttribute(0, 3, TypeCode.Single, false, 4 * sizeof(float), 0);

            vbo.WriteVectorData<Vec4>(1, buffer.CoordAndRotationSpan, BufferUsage.StreamDraw);
            vao.SetVertexAttribute(1, 3, TypeCode.Single, false, 4 * sizeof(float), 0);
            vao.SetVertexAttribute(2, 1, TypeCode.Single, false, 4 * sizeof(float), 3 * sizeof(float));

            GL.VertexAttributeDivisor(1, 1);
            GL.VertexAttributeDivisor(2, 1);

            vbo.WriteScalerData<float>(2, buffer.ScalingSpan, BufferUsage.StaticDraw);
            vao.SetVertexAttribute(3, 1, TypeCode.Single, false, sizeof(float), 0);

            GL.VertexAttributeDivisor(3, 1);

            vbo.Unbind();
            GL.BindVertexArray(GlHandle.Zero);

            NativeCameraViewTarget([
                0f,
                0f,
                -100f
            ], [
                0f,
                0f,
                0f
            ], [
                0f,
                1f,
                0f
            ]);
            NativeCameraViewRange(new Degree(1.5f), Vec2.Zero, (50, 50));
            NativeCameraUniform(s, "Camera");

            s.Use();

            fbo = CreateFrameBuffer(1);
            rbo = CreateRenderBuffer(1);
            fbo.Bind(0);
            rbo.Bind(0);

            // GL.Assert(true);
            t = CreateTexture(1);
            t.Bind2D(0);
            GL.TextureImage2d<byte>(Texture2DTarget.Texture2D, 0, ImageChannel.WithAlphaChannel, (uint)Width,
                                    (uint)Height, ImageChannel.WithAlphaChannel, PixelChannelLayout.Byte, null!);
            t.Set2dWrapProperty(0, TextureWrap.Repeat, TextureWrap.Repeat);
            t.Set2dFilterProperty(0, TextureFilter.Linear, TextureFilter.Linear);

            // GL.Assert(true);
            GL.FrameBufferTexture2d(FrameBufferTarget.All, glAttachment.Color(0), Texture2DTarget.Texture2D, t[0], 0);

            GL.SetRenderBufferStorage(RenderBufferInternalFormat.Depth24_Stencil8, this.Size);
            GL.CombineFrameBufferRenderBuffer(FrameBufferAttachment.DepthAndStencil, rbo[0]);

            Console.WriteLine(GL.CheckFrameBufferStatus(FrameBufferTarget.All));

            FrameBuffer.BindNull();

            // GL.Assert(true);
            int streamLength = this.Width * this.Height * 4;
            byte[] imageStream = new byte[streamLength];
            i = Image.FromMemory(this.Size, ImageChannel.WithAlphaChannel, imageStream);


            time = s.GetUniform<float>("time");

            Vec2[] buttonTextureCoordArray = {
                (0f, 1f),
                (1f, 1f),
                (1f, 0f),
                (0f, 0f)
            };
            ButtonBounding = new Rectangle(-0.9f, 0.9f, 0.9f, 0.9f, 0.9f, -0.9f, -0.9f, -0.9f);

            // GL.Assert(true);
            ButtonTextureProvider = new TextureProvider(i, buttonTextureCoordArray);

            f_vao = CreateVertexArray(1);
            f_vbo = CreateVertexBuffer(2);
            f_ebo = CreateElementBuffer(1);

            // GL.Assert(true);
            f_vao.Bind(0);

            f_ebo.Bind(0);
            f_ebo.SetValue(0, ButtonBounding.VertexIndices, BufferUsage.StaticDraw);

            // GL.Assert(true);
            f_vbo.Bind(0);
            f_vbo.WriteVectorData(0, ButtonBounding.VertexStream, BufferUsage.StaticDraw);
            f_vao.SetVertexAttribute(0, 3, TypeCode.Single, false, 4 * sizeof(float), 0);

            // GL.Assert(true);
            f_vbo.Bind(1);
            f_vbo.WriteVectorData(1, buttonTextureCoordArray, BufferUsage.StaticDraw);
            f_vao.SetVertexAttribute(1, 3, TypeCode.Single, false, 4 * sizeof(float), 0);

            // GL.Assert(true);

            autoT = CreateAutoTexture(4);
            autoT.DefaultTextureProperty = new TextureProperty(TextureFilter.Nearest, TextureFilter.Nearest,
                                                               TextureWrap.Repeat, TextureWrap.Repeat);

            f_t = CreateTexture(1);
            f_t.Bind2D(0);
            f_t.Set2dWrapProperty(0, TextureWrap.Repeat, TextureWrap.Repeat);
            f_t.Set2dFilterProperty(0, TextureFilter.Nearest, TextureFilter.Nearest);

            // GL.Assert(true);
            f_t.ActivateAs(TextureUnit.Unit1);

            // GL.Assert(true);
            frameMainShader.Use();
            texUniform = frameMainShader.GetUniform<int>("tex");

            // GL.Assert(true);
            GL.SetUniformValue(texUniform, 1);

            // GL.Assert(true);

            GL.ClearError();
            GL.Assert(true);
        }

    }
}