using SharpDX;
using SharpDX.Direct3D11;
using SharpDX.DXGI;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Valve.VR;
using VDash.Overlay.Actions;
using VDash.Utilities;
using VDash.WindowSelectors;
using System.Linq;

namespace VDash.Overlay
{
    public class WindowOverlay : IOverlay
    {

        public event EventHandler OverlayShown;
        public event EventHandler OverlayHidden;

        public bool UpdateDashboardName { get; set; } = false;
        public bool DestroyOnNoWindowFound { get; set; } = false;
        public int CurrentFPS { get; private set; }

        private Task m_EventPumpTask = null;
        /// <summary>
        /// Tracks whether or not this overlay is actually created.
        /// </summary>
        bool m_Created = false;
        bool m_Running = true;

        internal ulong m_OverlayHandle;
        public ulong OverlayHandle { get { return m_OverlayHandle; } }
        internal ulong m_ThumbnailIcon;
        public ulong ThumbnailIcon { get { return m_ThumbnailIcon; } }

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

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


        public IWindowSelector Selector { get; private set; } = null;

        public List<IOverlayAction> OverlayShownActions { get; private set; } = new List<IOverlayAction>();
        public List<IOverlayAction> OverlayHiddenActions { get; private set; } = new List<IOverlayAction>();

        char[] specialKeys = { '+', '^', '%', '~', '(', ')', '{', '}', '[', ']' };

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

        /// <summary>
        /// Represents whether or not an external caller wants this to stay destroyed, really. 
        /// To keep the DestroyOnNoWindowFound stuff in check. Don't want it creating when it shouldn't.
        /// </summary>
        bool m_Destroyed = true;

        public void Create()
        {
            m_Destroyed = false;
            createInternal();
        }

        private void createInternal()
        {
            if (m_Created) { throw new Exception("This overlay has already been created."); }
            

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

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

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

        public bool IsCreated() { return m_Created; }


        public void Destroy()
        {
            m_Destroyed = true;
            destroyInternal();
        }

        private void destroyInternal()
        {
            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_OverlayHandle);

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

            m_OverlayHandle = OpenVR.k_ulOverlayHandleInvalid;
            m_ThumbnailIcon = OpenVR.k_ulOverlayHandleInvalid;
        }

        private void EventPump()
        {
            var overlay = OpenVR.Overlay;

            DateTime lastClick = DateTime.MinValue;

            #region Rendering setup

            //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);

            int lastWidth = 0;
            int lastHeight = 0;


            // Create Staging texture CPU-accessible
            //Actual screen texture.
            //var screenTexture = new Texture2D(device, textureDesc);
            Texture2D screenTexture = null;
            DataStream stream = null;
            #endregion

            //For FPS counter.
            int frames = 0;
            DateTime lastFps = DateTime.MinValue;
            DateTime lastNameCheck = DateTime.MinValue;
            
            while (m_Running)
            {
                if (DestroyOnNoWindowFound)
                {
                    //Check to see if the window actually exists. Act accordingly.
                    if (!Selector.WindowExists())
                    {
                        if (IsCreated())
                        {
                            destroyInternal();
                            Console.WriteLine($"Destroyed {m_Key} because it's window does not exist.");
                        }

                        Thread.Sleep(100);
                        continue;
                    }
                    else if(Selector.WindowExists() && !m_Created && !m_Destroyed)
                    {
                        createInternal();
                    }
                }

                //This technically should never happen, buuuut...
                IntPtr windowHandle = IntPtr.Zero;
                try
                {
                    windowHandle = Selector.GetWindowHandle();
                }
                catch (WindowNotFoundException)
                {
                }

                //Update the SteamVR dash name if necessary, only once a second.
                if (Selector.WindowExists() && UpdateDashboardName && DateTime.Now.Subtract(lastNameCheck).TotalMilliseconds >= 1000)
                {
                    var window = Selector.GetWindowInfo();
                    if(GetOverlayName() != window.Title)
                    {
                        SetOverlayName(window.Title);
                    }

                    lastNameCheck = DateTime.Now;


                    #region Thumbnail rendering
                    using (var icon = User32.GetAppIcon(windowHandle))
                    {
                        using (var iconBmp = icon.ToBitmap())
                        {
                            var data = iconBmp.LockBits(new Rectangle(0, 0, iconBmp.Width, iconBmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);

                            overlay.SetOverlayRaw(m_ThumbnailIcon, data.Scan0, (uint)data.Width, (uint)data.Height, 4);

                            iconBmp.UnlockBits(data);
                        }
                    }
                    #endregion
                }

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

                

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

                while (OpenVR.Overlay.PollNextOverlayEvent(m_OverlayHandle, ref vrEvent, (uint)Marshal.SizeOf(vrEvent)))
                {
                    switch ((EVREventType)vrEvent.eventType)
                    {
                        case EVREventType.VREvent_MouseMove:
                            {
                                //Prevent the cursor from moving while we click. Super fkn annoying.
                                if(DateTime.Now.Subtract(lastClick).TotalMilliseconds < 400)
                                {
                                    break;
                                }
                                //Make sure the window still exists
                                if (windowHandle != IntPtr.Zero)
                                {
                                    var vrX = vrEvent.data.mouse.x;
                                    var vrY = vrEvent.data.mouse.y;

                                    var rect = new User32.Rect();
                                    
                                    User32.GetClientRect(windowHandle, ref rect);

                                    int width = rect.right - rect.left;
                                    int height = rect.bottom - rect.top;
                                    
                                    var point = new System.Drawing.Point() { X = (int)vrX, Y = height - (int)vrY };


                                    var succ = User32.ClientToScreen(windowHandle, ref point);

                                    if (!succ)
                                    {
                                        Console.WriteLine("ClientToScreen failed.");
                                    }
                                    

                                    succ = User32.SetCursorPos((int)point.X, (int)point.Y);

                                    if (!succ)
                                    {
                                        Console.WriteLine("SetCursorPos failed.");
                                    }
                                }
                                break;
                            }

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

                                var winClickType = User32.MouseEventFlags.MOUSEEVENTF_LEFTDOWN;

                                switch (clickType)
                                {
                                    case EVRMouseButton.Left:
                                        {
                                            winClickType = User32.MouseEventFlags.MOUSEEVENTF_LEFTDOWN;
                                            break;
                                        }
                                    case EVRMouseButton.Middle:
                                        {
                                            winClickType = User32.MouseEventFlags.MOUSEEVENTF_MIDDLEDOWN;
                                            break;
                                        }
                                    case EVRMouseButton.Right:
                                        {
                                            winClickType = User32.MouseEventFlags.MOUSEEVENTF_RIGHTDOWN;
                                            break;
                                        }
                                }

                                User32.mouse_event(winClickType, 0, 0, 0, UIntPtr.Zero);
                                lastClick = DateTime.Now;
                                break;
                            }

                        case EVREventType.VREvent_MouseButtonUp:
                            {
                                var clickType = (EVRMouseButton)vrEvent.data.mouse.button;
                                var winClickType = User32.MouseEventFlags.MOUSEEVENTF_LEFTUP;

                                switch (clickType)
                                {
                                    case EVRMouseButton.Left:
                                        {
                                            winClickType = User32.MouseEventFlags.MOUSEEVENTF_LEFTUP;
                                            break;
                                        }
                                    case EVRMouseButton.Middle:
                                        {
                                            winClickType = User32.MouseEventFlags.MOUSEEVENTF_MIDDLEUP;
                                            break;
                                        }
                                    case EVRMouseButton.Right:
                                        {
                                            winClickType = User32.MouseEventFlags.MOUSEEVENTF_RIGHTUP;
                                            break;
                                        }
                                }

                                User32.mouse_event(winClickType, 0, 0, 0, UIntPtr.Zero);
                                lastClick = DateTime.MinValue;
                                break;
                            }
                        case EVREventType.VREvent_OverlayShown:
                            {
                                OverlayShown?.Invoke(this, new EventArgs());

                                if (Selector.WindowExists())
                                {
                                    foreach (var action in OverlayShownActions)
                                    {
                                        action.PreformAction(this);
                                    }
                                }
                                break;
                            }
                        case EVREventType.VREvent_OverlayHidden:
                            {
                                OverlayHidden?.Invoke(this, new EventArgs());

                                if (Selector.WindowExists())
                                {
                                    foreach (var action in OverlayHiddenActions)
                                    {
                                        action.PreformAction(this);
                                    }
                                }
                                break;
                            }
                        case EVREventType.VREvent_KeyboardCharInput:
                            {
                                //Console.WriteLine($"Got char input: {vrEvent.data.keyboard.cNewInput}");
                                var input = vrEvent.data.keyboard.cNewInput;

                                //We should only be getting one keypress at a time.
                                switch (input)
                                {
                                    case "\b":
                                        {
                                            SendKeys.SendWait("{BACKSPACE}");
                                            break;
                                        }
                                    case "\n":
                                        {
                                            SendKeys.SendWait("{ENTER}");
                                            break;
                                        }
                                    default:
                                        {
                                            if (specialKeys.Contains(input[0]))
                                            {
                                                SendKeys.SendWait("{" + input + "}");
                                            }
                                            else
                                            {
                                                SendKeys.SendWait(input);
                                            }
                                            break;
                                        }
                                }
                            
                                break;
                            }
                        case EVREventType.VREvent_ButtonPress:
                            {
                                EVRButtonId button = (EVRButtonId)vrEvent.data.controller.button;
                                //Console.WriteLine($"Button pressed: {button}");

                                switch (button)
                                {
                                    case EVRButtonId.k_EButton_Knuckles_A:
                                        {
                                            overlay.ShowKeyboardForOverlay(m_OverlayHandle, (int)EGamepadTextInputMode.k_EGamepadTextInputModeNormal, 
                                                (int)EGamepadTextInputLineMode.k_EGamepadTextInputLineModeSingleLine, "desc?", 1024, "", true, 0);
                                            break;
                                        }
                                }
                                break;
                            }
                    }

                }
#endregion

                #region Acutally Render
                //Redundant check, but w/e
                if (Selector.WindowExists() && windowHandle != IntPtr.Zero)
                {
                    var rect = new User32.Rect();
                    User32.GetClientRect(windowHandle, ref rect);
                    System.Drawing.Point pnt = new Point { X = 0, Y = 0 };

                    User32.ClientToScreen(windowHandle, ref pnt);

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

                    //Make sure the coords are actually valid. Could be minimized or something.
                    if (width > 0 && height > 0)
                    {
                        using (var bmp = new Bitmap(width, height, PixelFormat.Format32bppArgb))
                        {
                            using (Graphics graphics = Graphics.FromImage(bmp))
                            {
                                graphics.CopyFromScreen((int)pnt.X, (int)pnt.Y, 0, 0, new Size(width, height), CopyPixelOperation.SourceCopy);

                                #region Cursor drawing
                                User32.CURSORINFO pci;
                                pci.cbSize = System.Runtime.InteropServices.Marshal.SizeOf(typeof(User32.CURSORINFO));

                                if (User32.GetCursorInfo(out pci))
                                {

                                    System.Drawing.Point cursorPoint = new System.Drawing.Point() { X = pci.ptScreenPos.X, Y = pci.ptScreenPos.Y };

                                    if (User32.ScreenToClient(windowHandle, ref cursorPoint))
                                    {

                                        if (pci.flags == User32.CURSOR_SHOWING)
                                        {
                                            User32.DrawIcon(graphics.GetHdc(), (int)cursorPoint.X, (int)cursorPoint.Y, pci.hCursor);
                                            graphics.ReleaseHdc();
                                        }
                                    }
                                    else
                                    {
                                        Console.WriteLine("Error getting coords to draw cursor.");
                                    }
                                }
                                else
                                {
                                    string errorMessage = new Win32Exception(Marshal.GetLastWin32Error()).Message;
                                    Console.WriteLine($"Error getting cursor info: {errorMessage}");
                                }
                                #endregion

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

                                if (screenTexture == null || (lastWidth != data.Width || lastHeight != data.Height))
                                {
                                    lastWidth = data.Width;
                                    lastHeight = data.Height;

                                    if (screenTexture != null)
                                    {
                                        screenTexture.Dispose();

                                        //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();
                                    }

                                    var textureDesc = new Texture2DDescription
                                    {
                                        CpuAccessFlags = CpuAccessFlags.Write,
                                        BindFlags = BindFlags.ShaderResource,
                                        Format = Format.B8G8R8A8_UNorm,
                                        //Format = Format.B8G8R8A8_UNorm_SRgb,
                                        Width = data.Width,
                                        Height = data.Height,
                                        OptionFlags = ResourceOptionFlags.None,
                                        MipLevels = 1,
                                        ArraySize = 1,
                                        SampleDescription = { Count = 1, Quality = 0 },
                                        Usage = ResourceUsage.Dynamic
                                    };
                                    screenTexture = new Texture2D(device, textureDesc);
                                    stream = new DataStream(4 * width * height, true, true);

                                    overlay.SetOverlayWidthInMeters(m_OverlayHandle, 2.5f);

                                    HmdVector2_t vecWindowSize = new HmdVector2_t() { v0 = data.Width, v1 = data.Height };
                                    OpenVR.Overlay.SetOverlayMouseScale(m_OverlayHandle, ref vecWindowSize);
                                    Console.WriteLine("Updated!");


                                }
                                //Render using graphics card, in DirectX context.

                                //using ()
                                {
                                    var screenView = new ShaderResourceView(device, screenTexture);
                                    device.ImmediateContext.PixelShader.SetShaderResource(0, screenView);

                                    var dr = new SharpDX.DataRectangle(data.Scan0, data.Stride);

                                    DataBox databox = device.ImmediateContext.MapSubresource(screenTexture, 0, MapMode.WriteDiscard,
                                        SharpDX.Direct3D11.MapFlags.None, out stream);



                                    if (!databox.IsEmpty)
                                    {
                                        int count = 4 * data.Width * data.Height;

                                        //Stride compensation. Sometimes the BMP and DX texture strides are different. This fixes it.
                                        if (databox.RowPitch == data.Stride)
                                        {
                                            stream.Write(data.Scan0, 0, count);
                                        }
                                        //Truncate the extra BMP bytes.
                                        else if (databox.RowPitch < data.Stride)
                                        {
                                            for (int i = 0; i < data.Height; i++)
                                            {
                                                stream.Write(data.Scan0, (data.Stride * i), databox.RowPitch);
                                            }
                                        }
                                        //Add some junk on empty bytes on the end to make everyone happy.
                                        else if (databox.RowPitch > data.Stride)
                                        {
                                            int difference = databox.RowPitch - data.Stride;
                                            byte[] junk = new byte[difference];
                                            for (int i = 0; i < data.Height; i++)
                                            {
                                                stream.Write(data.Scan0, (data.Stride * i), data.Stride);
                                                stream.Write(junk, 0, difference);
                                            }
                                        }
                                    }


                                    VRTextureBounds_t bounds = new VRTextureBounds_t();
                                    OpenVR.Overlay.GetOverlayTextureBounds(m_OverlayHandle, ref bounds);

                                    var texture = new Texture_t();
                                    texture.handle = screenTexture.NativePointer;
                                    texture.eType = ETextureType.DirectX;
                                    texture.eColorSpace = EColorSpace.Auto;
                                    EVROverlayError result = overlay.SetOverlayTexture(m_OverlayHandle, ref texture);
                                    if (result != EVROverlayError.None)
                                    {

                                        Console.WriteLine($"Error rendering: {result}");
                                    }

                                    device.ImmediateContext.UnmapSubresource(screenTexture, 0);



                                    frames++;

                                    bmp.UnlockBits(data);
                                }
                            }
                        }
                    }
                }
#endregion

                Thread.Sleep(20);

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

            //Clean up after we exit while loop.
            screenTexture.Dispose();
            device.ImmediateContext.ClearState();
            device.ImmediateContext.Flush();

            CurrentFPS = 0;

            device.Dispose();
            adapter.Dispose();
            factory.Dispose();
        }

        public void Dispose()
        {
            Destroy();
        }

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

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

        public float GetOverlayWidth()
        {
            float width = 0f;
            OpenVR.Overlay.GetOverlayWidthInMeters(m_OverlayHandle, ref width);
            return width;
        }

        public void SetOverlayWidth(float width)
        {
            OpenVR.Overlay.SetOverlayWidthInMeters(m_OverlayHandle, width);
        }
    }
}