//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//     file="Partical.cs"
//     Project: StgSharp
//     AuthorGroup: Nitload Space
//     Copyright (c) Nitload Space. 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.Math;
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 = provider.SpanLengthLowPrecession;
            float angle = provider.CurrentSecond * 2;
            return ( new Vec3( Scaler.Cos( angle ), Scaler.Sin( angle ),
                               0 ) ) * provider.SpanLengthLowPrecession;
        }

        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 = Scaler.Abs( i - 5.0f );
                for( int t = 0; t < 10; t++ ) {
                    float at = Scaler.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 =
                        Scaler.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( (0, 0, -100), (0, 0, 0), (0, 1, 0) );
            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 );
        }

    }
}