using StgSharp;
using StgSharp.Controlling;
using StgSharp.Logic;
using StgSharp.Math;

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Principal;
using System.Text;
using System.Threading;

namespace StgSharp.Graphics
{
    /// <summary>
    ///
    /// </summary>
    public abstract partial class Form
    {
        #region metadata

        internal LinkedList<Control> allControl;
        internal Vector4 backgroundColor;
        internal unsafe GLcontext* contextID;
        internal DynamicArrayList<IntPtr> formBuffer;
        internal IglFunc gl;
        internal int height;
        internal IntPtr monitor;
        internal string name;
        internal Form sharedForm;
        internal int width;
        internal IntPtr windowID;

        #endregion metadata

        #region form thread setting

        internal FrameUpdateTimer timer = new FrameUpdateTimer();
        private SemaphoreSlim _renderFinishSignal = new SemaphoreSlim(0, 1);
        private SemaphoreSlim _renderStartSignal = new SemaphoreSlim(1, 1);
        private bool isSingleThread = true;

        #endregion form thread setting

        #region glapicount

        private int missingAPIcount = 0;
        private int problemAPIcount = 0;

        #endregion glapicount

        protected Form()
        {
        }

        unsafe ~Form()
        {
            Marshal.FreeHGlobal((IntPtr)contextID);
        }

        /// <summary>
        /// OpenGL package used by current form context.
        /// </summary>
        public IglFunc GL
        {
            get => gl;
            internal set => gl = value;
        }

        /// <summary>
        /// Height of this form, represent in <see cref="int"/>
        /// </summary>
        public int Height
        {
            get => height;
            set => height = value;
        }

        /// <summary>
        /// Representing
        /// </summary>
        public bool IsDoubleRendering
        {
            get { return isSingleThread; }
        }

        private int _shouldClose = 0;

        public bool ShouldClose
        {
            get
            {
                Interlocked.Exchange(ref _shouldClose, InternalIO.glfwWindowShouldClose(windowID));
                return 0 != _shouldClose;
            }

            set
            {
                InternalIO.glfwSetWindowShouldClose(windowID, value ? 1 : 0);
                Interlocked.Exchange(ref _shouldClose, value ? 1 : 0);
            }
        }

        /// <summary>
        /// Width of this form, represent in <see cref="int"/>
        /// </summary>
        public Vec2d Size
        {
            get { return new Vec2d(width, height); }
            set
            {
                width = (int)value.X;
                height = (int)value.Y;
            }
        }

        /// <summary>
        /// Width of this form, represent in <see cref="int"/>
        /// </summary>
        public int Width
        {
            get => width;
            set => width = value;
        }

        internal bool IsSingleThread
        {
            get { return isSingleThread; }
        }

        internal SemaphoreSlim RenderFinishSignal
        {
            get { return _renderFinishSignal; }
            set { _renderFinishSignal = value; }
        }

        internal SemaphoreSlim RenderStrartSignal
        {
            get { return _renderStartSignal; }
            set { _renderStartSignal = value; }
        }

        protected FrameBufferSizeHandler FrameBufferSizeCallback
        {
            set
            {
                IntPtr handlerPtr = Marshal.GetFunctionPointerForDelegate(value);
                InternalIO.glfwSetFramebufferSizeCallback(windowID, handlerPtr);
            }
        }

        /// <summary>
        /// Init an OpenGl context if current form has not been binded to any context.
        /// and set the context binded to current form as current OpenGL context.
        /// </summary>
        /// <exception cref="Exception">Something goes wrong and
        /// StgSharp fails in creating a new OpenGL context. </exception>
        public unsafe void MakeAsCurrentContext()
        {
            if (windowID == default)
            {
                IntPtr windowPtr;
                byte[] tittleBytes = Encoding.UTF8.GetBytes(name);
                if (sharedForm == null)
                {
                    windowPtr = InternalIO.glfwCreateWindow(
                        width, height, tittleBytes, monitor, IntPtr.Zero);
                }
                else
                {
                    windowPtr = InternalIO.glfwCreateWindow(
                        width, height, tittleBytes, monitor, sharedForm.windowID);
                }
                if ((long)windowPtr == -1 || (long)windowPtr == -2)
                {
                    throw new Exception("Cannot create window instance!");
                }
                else
                {
                    windowID = windowPtr;
                }

                IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(GLcontext)));
                contextID = (GLcontext*)ptr;
                *contextID = new GLcontext();
                contextID->glGetString = (delegate*<uint, IntPtr>)IntPtr.Zero;
                gl = new GLonRender(contextID);
            }
            InternalIO.glfwMakeContextCurrent(windowID);
            gl.SwitchContext();
        }

        /// <summary>
        /// Set all necessary metadata to current form instance
        /// </summary>
        public void SetMetadata(int width, int height, string name, IntPtr monitor, Form sharedForm)
        {
            this.width = width;
            this.height = height;
            this.name = name;
            this.sharedForm = sharedForm;
            this.monitor = monitor;
        }

        /// <summary>
        /// Resize the current form
        /// </summary>
        /// <param name="width">New width of the window</param>
        /// <param name="height">New height of the window</param>
        public void SetSize(int width, int height)
        {
            this.Width = width;
            this.Height = height;
            InternalIO.glfwSetWindowSize(this.windowID, width, height);
        }

        /// <summary>
        /// Resize the current form
        /// </summary>
        /// <param name="size">
        /// A <see cref="Vec2d"/> (width,height) representing the new size of current form
        /// </param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetSize(Vec2d size)
        {
            this.Size = size;
            InternalIO.glfwSetWindowSize(this.windowID, (int)size.X, (int)size.Y);
        }

        /// <summary>
        /// Set the size limit of current form
        /// </summary>
        /// <param name="minWidth">Minimum width of current form </param>
        /// <param name="minHeight">Minimum height of current form</param>
        /// <param name="maxWidth">Maximum width of curent form</param>
        /// <param name="maxHeight">Maximum height of current form</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetSizeLimit(int minWidth, int minHeight, int maxWidth, int maxHeight)
        {
            InternalIO.glfwSetWindowSizeLimits(
                this.windowID,
                minWidth, minHeight, maxWidth, maxHeight);
        }

        /// <summary>
        /// Set the size limit of current form
        /// </summary>
        /// <param name="minSize">
        /// Minimun size of current form. In form of a <see cref="Vec2d"/> of (width,height)
        /// </param>
        /// <param name="maxSize">
        /// Maximum size of current form. In form of a <see cref="Vec2d"/> of (width,height)
        /// </param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void SetSizeLimit(Vec2d minSize, Vec2d maxSize)
        {
            InternalIO.glfwSetWindowSizeLimits(
                this.windowID,
                (int)minSize.X, (int)minSize.Y, (int)maxSize.X, (int)maxSize.Y);
        }

        #region form main

        private static unsafe delegate*<void> pollEventPtr = &InternalIO.glfwPollEvents;

        private static unsafe delegate*<void> swapBufferPtr = &InternalSwapBuffers;

        public abstract void Deinit(params object[] args);

        /// <summary>
        /// Necessary operation to init this form.
        /// </summary>
        /// <param name="args"></param>
        public abstract void Init(params object[] args);

        /// <summary>
        /// Behaviour of current form when in a render cycle.
        /// When  this form
        /// </summary>
        /// <param name="args"></param>
        public abstract void Main(params object[] args);

        public unsafe void PollEvents()
        {
            if (isSingleThread)
            {
                InternalIO.glfwPollEvents();
            }
            else
            {
                gl.frameworkHandleEnqueue((IntPtr)pollEventPtr);
            }
        }

        /// <summary>
        /// Init this form and render it on screen, and respond with operation
        /// </summary>
        public unsafe void Show(params object[] args)
        {
            if (gl == null)
            {
                InternalIO.InternalWriteLog($"Attempt to show form {name} before init", LogType.Error);
            }
            else if (isSingleThread)
            {
                while (!ShouldClose)
                {
                    Main(args);
                }
            }
            else
            {
                gl = new GLonUpdate(contextID);
                Thread renderThread = new Thread(new ThreadStart(InternalRender));
                renderThread.Start();
                int a = 0;
                while (!ShouldClose)
                {
                    if (gl.FrameCanUpdate)
                    {
                        Main(args);
                    }
                }
                //TODO 对逻辑线程和渲染线程进行同步，两种gl模式包需要改名字
                renderThread.Join();
                //Thread.Sleep(1000 * 20);
                //ShouldClose = true;
                //(gl as GLonUpdate).GLactionQueue.Clear();
            }
        }

        public unsafe void SwapBuffers()
        {
            if (isSingleThread)
            {
                InternalIO.glfwSwapBuffers(windowID);
            }
            else
            {
                M128 m = new M128();
                m.Write<ulong>(0, (ulong)windowID);
                gl.frameworkHandleEnqueue((IntPtr)swapBufferPtr, m);
            }
        }

        internal static unsafe void InternalSwapBuffers()
        {
            IntPtr winHandle = default;
            GLonUpdate.ParamQueue.TryDequeue(out winHandle);
            InternalIO.glfwSwapBuffers(winHandle);
        }

        internal void InternalDeinit(params object[] args)
        {
            Deinit(args);
        }

        internal void InternalInit(params object[] args)
        {
            Init(args);
        }

        /// <summary>
        /// Get OpenGL library of this form's context.
        /// </summary>
        /// <returns>A <see cref="IglFunc"/> package contains all opengl APIs </returns>
        protected IglFunc GetGL()
        {
            if (Platform.API == GraphicAPI.GL)
            {
                return this.GL;
            }
            else
            {
                InternalIO.InternalWriteLog("Attempt to get OpenGL API package in other graphic envitronment.", LogType.Error);
                throw new InvalidOperationException("Attempt to get OpenGL API package in other graphic envitronment.");
            }
        }

        /// <summary>
        /// Define how current form render in one frame.
        /// </summary>
        /// <param name="leastThreds">
        /// Please define this befor calling any OpenGL api and other graphic methods.
        /// </param>
        protected unsafe void SetRenderThreads(int leastThreds)
        {
            if (gl != default)
            {
                throw new InvalidOperationException("Cannot define threads after loading gl context.");
            }
            if (leastThreds == 1)
            {
                isSingleThread = true;
            }
            else if (leastThreds >= 2)
            {
                isSingleThread = false;
            }
            else
            {
                throw new ArgumentException("Amount of threads should be bigger than 0");
            }
            IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(GLcontext)));
            contextID = (GLcontext*)ptr;
            *contextID = new GLcontext();
            contextID->glGetString = (delegate*<uint, IntPtr>)IntPtr.Zero;
        }

        private unsafe void InternalRender()
        {
#pragma warning disable CS8602
            ConcurrentQueue<IntPtr> glActions = (gl as GLonUpdate).GLactionQueue;
#pragma warning restore CS8602
            IntPtr currentOperation;
            try
            {
                while (_shouldClose == 0)
                {
                    if (glActions.TryDequeue(out currentOperation))
                    {
                        ((delegate*<void>)currentOperation)();
                    }
                }
            }
            catch (Exception e)
            {
                this.ShouldClose = true;
                throw;
            }
        }

        #endregion form main
    }
}