using SharpDX.Direct3D11;
using SharpDX.DXGI;
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Valve.VR;
using VDash.WindowSelectors;

namespace VDash.Overlay
{
    public class WindowOverlay : IOverlay
    {

        public event EventHandler OverlayShown;
        public event EventHandler OverlayHidden;

        public CVRSystem VRSystem { get; private set; }
        private Task m_EventPumpTask = null;
        bool m_Created = false;
        bool m_Running = true;
        public bool UpdateDashboardName { get; set; } = false;

        internal ulong m_Handle;
        public ulong Handle
        {
            get
            {
                return m_Handle;
            }
        }

        internal string m_Key;
        public string Key { get { return m_Key; } }

        internal string m_Name;
        public string Name { get { return m_Name; } }

        IWindowSelector m_Selector = null;

        public WindowOverlay(string key, string name, IWindowSelector selector, bool updateDashboardName)
        {
            m_Key = key;
            m_Name = name;
            m_Selector = selector;
            UpdateDashboardName = updateDashboardName;
        }

        public void Create()
        {
            if (m_Created) { throw new Exception("This overlay has already been created."); }
            ConsoleManager.Show();
            ulong thumbHandle = OpenVR.k_ulOverlayHandleInvalid;

            //Actually create the overlay
            var overlay = OpenVR.Overlay;
            EVROverlayError err = overlay.CreateDashboardOverlay(m_Key, m_Name, ref m_Handle, ref thumbHandle);

            if (err != EVROverlayError.None)
            {
                throw new Exception($"Error creating overlay: {err}");
            }

            overlay.SetOverlayWidthInMeters(m_Handle, 2.5f);
            overlay.SetOverlayInputMethod(m_Handle, VROverlayInputMethod.Mouse);

            m_Running = true;
            m_EventPumpTask = Task.Factory.StartNew(() => { EventPump(); });
            m_Created = true;
        }

        public void Destroy()
        {
            if (!m_Created) { throw new Exception("This object is not created."); }
            m_Created = false;

            //Signal render thread to exit
            m_Running = false;

            //Wait for render thread to exit
            m_EventPumpTask.Wait();

            var err = OpenVR.Overlay.DestroyOverlay(m_Handle);

            if( err != EVROverlayError.None)
            {
                throw new Exception($"Error destroying overlay: {err}");
            }
        }

        private void EventPump()
        {
            #region Rendering setup
            var overlay = OpenVR.Overlay;

            //Partially taken from here: https://stackoverflow.com/questions/6812068/c-sharp-which-is-the-fastest-way-to-take-a-screen-shot
            //Desktop Duplication didn't work well, hence is why we're sticking with GDI. Still this is faster than using SetTextureRaw.

            var factory = new Factory1();
            //Get first adapter
            var adapter = factory.GetAdapter1(0);
            //Get device from adapter
            var device = new SharpDX.Direct3D11.Device(adapter);
            #endregion

            //For FPS counter.
            int frames = 0;
            DateTime lastFps = DateTime.MinValue;
            DateTime lastNameCheck = DateTime.MinValue;
            while (m_Running)
            {
                //Update the SteamVR dash name if necessary, only once a second.
                if (UpdateDashboardName && DateTime.Now.Subtract(lastNameCheck).TotalMilliseconds >= 1000)
                {
                    var window = m_Selector.GetWindowInfo();
                    if(GetOverlayName() != window.Title)
                    {
                        SetOverlayName(window.Title);
                    }

                    lastNameCheck = DateTime.Now;
                }

                //Skip rendering if overlay isn't visible
                //if ((m_Handle == OpenVR.k_ulOverlayHandleInvalid) || overlay == null || (!overlay.IsOverlayVisible(m_Handle)))
                //{
                //    Thread.Sleep(100);
                //    continue;
                //}


                #region VR Events
                VREvent_t vrEvent = new VREvent_t();

                while (OpenVR.Overlay.PollNextOverlayEvent(m_Handle, ref vrEvent, (uint)Marshal.SizeOf(vrEvent)))
                {
                    switch ((EVREventType)vrEvent.eventType)
                    {
                        case EVREventType.VREvent_MouseMove:
                            {
                                var x = vrEvent.data.mouse.x;
                                var y = vrEvent.data.mouse.y;
                                break;
                            }

                        case EVREventType.VREvent_MouseButtonDown:
                            {
                                var clickType = (EVRMouseButton)vrEvent.data.mouse.button;
                                break;
                            }

                        case EVREventType.VREvent_MouseButtonUp:
                            {
                                var clickType = (EVRMouseButton)vrEvent.data.mouse.button;
                                break;
                            }
                        case EVREventType.VREvent_OverlayShown:
                            {
                                OverlayShown?.Invoke(this, new EventArgs());
                                break;
                            }
                        case EVREventType.VREvent_OverlayHidden:
                            {
                                OverlayHidden?.Invoke(this, new EventArgs());
                                break;
                            }
                    }

                }
                #endregion

                #region Acutally Render
                IntPtr windowHandle = IntPtr.Zero;
                try
                {
                    windowHandle = m_Selector.GetWindowHandle();
                }
                catch (WindowNotFoundException)
                {
                    //Console.WriteLine($"[{m_Key}] {m_Name}: Window not found.");
                }

                if (windowHandle != IntPtr.Zero)
                {
                    var rect = new User32.Rect();
                    User32.GetWindowRect(windowHandle, ref rect);

                    int width = rect.right - rect.left;
                    int height = rect.bottom - rect.top;

                    using (var bmp = new Bitmap(width, height, PixelFormat.Format32bppArgb))
                    {
                        using (Graphics graphics = Graphics.FromImage(bmp))
                        {
                            graphics.CopyFromScreen(rect.left, rect.top, 0, 0, new Size(width, height), CopyPixelOperation.SourceCopy);

                            var data = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);

                            //Render using graphics card, in DirectX context.
                            // Create Staging texture CPU-accessible
                            var textureDesc = new Texture2DDescription
                            {
                                CpuAccessFlags = CpuAccessFlags.Read,
                                BindFlags = BindFlags.None,
                                Format = Format.B8G8R8A8_UNorm,
                                Width = width,
                                Height = height,
                                OptionFlags = ResourceOptionFlags.None,
                                MipLevels = 1,
                                ArraySize = 1,
                                SampleDescription = { Count = 1, Quality = 0 },
                                Usage = ResourceUsage.Staging
                            };

                            using (var screenTexture = new Texture2D(device, textureDesc, new SharpDX.DataRectangle(data.Scan0, data.Stride)))
                            {
                                var texture = new Texture_t();
                                texture.handle = screenTexture.NativePointer;
                                texture.eType = ETextureType.DirectX;
                                texture.eColorSpace = EColorSpace.Auto;
                                EVROverlayError result = overlay.SetOverlayTexture(m_Handle, ref texture);
                                if (result != EVROverlayError.None)
                                {
                                    Console.WriteLine($"Error rendering: {result}");
                                }

                                frames++;

                                bmp.UnlockBits(data);
                            }
                            //Dispose not freeing screenTexture: https://gamedev.stackexchange.com/questions/93311/freeing-texture-memory-in-sharpdx-what-am-i-missing
                            device.ImmediateContext.ClearState();
                            device.ImmediateContext.Flush();
                        }
                    }
                }
                #endregion

                Thread.Sleep(20);

                if (DateTime.Now.Subtract(lastFps).TotalMilliseconds > 1000)
                {
                    Console.WriteLine($"{frames} fps.");
                    frames = 0;
                    lastFps = DateTime.Now;
                }
            }

            //Clean up after we exit while loop.
            device.Dispose();
            adapter.Dispose();
            factory.Dispose();
        }

        private class User32
        {
            [StructLayout(LayoutKind.Sequential)]
            public struct Rect
            {
                public int left;
                public int top;
                public int right;
                public int bottom;
            }

            [DllImport("user32.dll")]
            public static extern IntPtr GetWindowRect(IntPtr hWnd, ref Rect rect);
        }

        public void Dispose()
        {
            Destroy();
        }

        public string GetOverlayName()
        {
            EVROverlayError err = EVROverlayError.None;
            StringBuilder sb = new StringBuilder(255);
            uint res = OpenVR.Overlay.GetOverlayName(m_Handle, sb, 255, ref err);
            return sb.ToString();
        }

        public void SetOverlayName(string newName)
        {
            OpenVR.Overlay.SetOverlayName(m_Handle, newName);
            m_Name = newName;
        }
    }
}