using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Drawing;
using System.IO;

namespace DeadByDaylightHelper
{
    static class Program
    {
        private const int WH_KEYBOARD_LL = 13;
        private const int WM_KEYDOWN = 0x0100;
        private const int WH_MOUSE_LL = 14;

        [StructLayout(LayoutKind.Sequential)]
        private struct POINT
        {
            public int x;
            public int y;
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct MSLLHOOKSTRUCT
        {adaDAdd
            public POINT pt;
            public uint mouseData;
            public uint flags;
            public uint time;
            public IntPtr dwExtraInfo;
        }

        private delegate IntPtr LowLevelProc(int nCode, IntPtr wParam, IntPtr lParam);

        private static IntPtr HookKeyboardCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
            return IntPtr.Zero;// CallNextHookEx(_hookID, nCode, wParam, lParam);
        }

        private static LowLevelProc KeyboardProc = HookKeyboardCallback;

        private static IntPtr HookMouseCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
            return IntPtr.Zero;// CallNextHookEx(_hookID, nCode, wParam, lParam);
        }

        private static LowLevelProc MouseProc = HookMouseCallback;

        private static IntPtr KeyboardHookID = IntPtr.Zero;
        private static IntPtr MouseHookID = IntPtr.Zero;

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelProc lpfn, IntPtr hMod, uint dwThreadId);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool UnhookWindowsHookEx(IntPtr hhk);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr GetModuleHandle(string lpModuleName);

        private static IntPtr SetKeyboardHook(LowLevelProc proc)
        {
            using (Process curProcess = Process.GetCurrentProcess())
            using (ProcessModule curModule = curProcess.MainModule)
            {
                return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
            }
        }

        private static IntPtr SetMouseHook(LowLevelProc proc)
        {
            using (Process curProcess = Process.GetCurrentProcess())
            using (ProcessModule curModule = curProcess.MainModule)
            {
                return SetWindowsHookEx(WH_MOUSE_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
            }
        }

        static void SetHooks()
        {
            KeyboardHookID = SetKeyboardHook(KeyboardProc);
            MouseHookID = SetMouseHook(MouseProc);
        }

        static void UnsetHooks()
        {
            UnhookWindowsHookEx(KeyboardHookID);
            UnhookWindowsHookEx(MouseHookID);
        }

        public static string status_dbg = "";

        static void Main(string[] args)
        {
            RegisterHotkeys();

            ReferenceTimer.Start();

            Tools.UpdateWindowHandle();

            Overlay overlay = new Overlay();
            overlay.InitWindow();

            Thread helper_thread = new Thread(HelperStart);
            helper_thread.Start();

            Console.WriteLine("Dead by Daylight window handle: " + Tools.HWND);

            Application.Run();
        }

        public static bool WiggleActive = false;
        public static bool StruggleActive = false;

        public static bool SkillCheckActive = false;
        public static volatile int PerfectZonePos = -1;
        public static volatile int ProgressPos = -1;
        public static float SpaceHitPos = -1;
        public static Int64 ScreenCaptureDuration = 0;
        public static Int64 ProcessingDuration = 0;

        public static volatile int LastProgressPos = -1;
        public static volatile Stopwatch LastProgressTimer = new Stopwatch();
        public static Int64 LastProgressCorrection = 0;

        // 1680
        //public static Vec3 CIRCLE_OFFSET = new Vec3(784, 468, 0);
        //public static int CIRCLE_TREMBLE_RANGE = 30;
        //public static Vec3 SKILL_CHECK_IMG_OFFSET = new Vec3(15, 45, 0);
        //public static int CIRCLE_DIAMETER = 113;
        //public static Rectangle SKILL_CHECK_RECT = new Rectangle(320, 200, 1100, 600);
        //public static string SKILL_CHECK_BITMAP = "img/skill_check.bmp";
        // 1920
        public static Vec3 CIRCLE_OFFSET = new Vec3(895, 473, 0);
        public static int CIRCLE_TREMBLE_RANGE = 50;
        public static Vec3 SKILL_CHECK_IMG_OFFSET = new Vec3(19, 52, 0);
        public static int CIRCLE_DIAMETER = 133;
        public static Rectangle SKILL_CHECK_RECT = new Rectangle(234, 140, 1500, 700);
        public static string SKILL_CHECK_BITMAP = "img/skill_check_1920.bmp";

        public static Vec3 CIRCLE_CENTER = new Vec3(CIRCLE_DIAMETER * 0.5f, CIRCLE_DIAMETER * 0.5f, 0);
        public static Int64 FIXED_CORRECTION = 6;

        public static Vec3 VEC_UP = new Vec3(0, 0, 1);
        public static Vec3 INITIAL_DIR = new Vec3(0, -CIRCLE_DIAMETER * 0.5f, 0);
        public static float PROGRESS_SPEED = 0.3273f;

        public static Color PROGRESS_COLOR = Color.FromArgb(240, 30, 5);
        public static Color PROGRESS_COLOR_HEX = Color.FromArgb(250, 250, 250);
        public static Color PERFECT_ZONE_COLOR = Color.FromArgb(250, 250, 250);
        public static Color PERFECT_ZONE_COLOR_HEX = Color.FromArgb(180, 0, 0);

        public static ReaderWriterLockSlim ProgressDataLock = new ReaderWriterLockSlim();

        public static Stopwatch ReferenceTimer = new Stopwatch();

        public static float GetEstimatedProgressIndex()
        {
            ProgressDataLock.EnterReadLock();
            float estimatedTimeSinceLastProgressChange = LastProgressTimer.ElapsedMilliseconds + LastProgressCorrection;
            float value = LastProgressPos + PROGRESS_SPEED * estimatedTimeSinceLastProgressChange;
            ProgressDataLock.ExitReadLock();
            return value;
        }

        static void SpacerProc()
        {
            while (true)
            {
                AutoIt.Sleep(2);

                float estimatedProgressIndex = GetEstimatedProgressIndex();

                if (PerfectZonePos != -1 && LastProgressPos != -1 && SpaceHitPos == -1)
                {
                    if (estimatedProgressIndex >= PerfectZonePos)
                    {
                        SpaceHitPos = estimatedProgressIndex;
                        AutoIt.SendKey(Tools.HWND, Input.VirtualKeyCode.SPACE, 50);
                        AutoIt.Sleep(600);
                    }
                }
                else if (WiggleActive)
                {
                    AutoIt.SendKey(Tools.HWND, Input.VirtualKeyCode.VK_A, 50);
                    AutoIt.Sleep(50);
                    AutoIt.SendKey(Tools.HWND, Input.VirtualKeyCode.VK_D, 50);
                    AutoIt.Sleep(50);
                }
                else if (StruggleActive)
                {
                    AutoIt.SendKey(Tools.HWND, Input.VirtualKeyCode.SPACE, 50);
                    AutoIt.Sleep(50);
                }
            }
        }

        static void HelperStart()
        {
            Thread spacer_thread = new Thread(SpacerProc);
            spacer_thread.Start();

            Stopwatch processing_timer = new Stopwatch();

            Bitmap skill_check_bmp = new Bitmap(SKILL_CHECK_BITMAP);
            IntPtr skill_check_bmp_hbitmap = skill_check_bmp.GetHbitmap();
            // capture using slow method once to create bitmap with proper dimensions
            Bitmap screen_bmp = AutoIt.CaptureWindow(Tools.HWND);
            // create GDI object from out bitmap so we can use it in C++ DLL functions
            IntPtr screen_hbitmap = screen_bmp.GetHbitmap();

            AutoIt.RECT rct = new AutoIt.RECT();
            AutoIt.GetWindowRect(Tools.HWND, ref rct);

            while (true)
            {
                processing_timer.Restart();

                //AutoIt._CaptureWindowEx(Tools.HWND, screen_hbitmap); // this will work on any Windows
                AutoIt._CaptureWindow(Tools.HWND, screen_hbitmap); // this will work on Windows 8.1 and later

                ScreenCaptureDuration = processing_timer.ElapsedMilliseconds;
                processing_timer.Restart();

                bool progress_updated = false;
                int progress_pos = LastProgressPos;
                SkillCheckActive = false;

                int x = 0; int y = 0;

                if (AutoIt.ImageSearchArea(skill_check_bmp_hbitmap, 0, (int)(Program.CIRCLE_OFFSET.X + SKILL_CHECK_IMG_OFFSET.X), (int)(Program.CIRCLE_OFFSET.Y + SKILL_CHECK_IMG_OFFSET.Y), (int)Program.CIRCLE_OFFSET.X + Program.CIRCLE_DIAMETER, (int)Program.CIRCLE_OFFSET.Y + Program.CIRCLE_DIAMETER, ref x, ref y, 35, screen_hbitmap) ||
                    AutoIt.ImageSearchArea(skill_check_bmp_hbitmap, 0, (int)(Program.CIRCLE_OFFSET.X + SKILL_CHECK_IMG_OFFSET.X - CIRCLE_TREMBLE_RANGE), (int)(Program.CIRCLE_OFFSET.Y + SKILL_CHECK_IMG_OFFSET.Y - CIRCLE_TREMBLE_RANGE), (int)Program.CIRCLE_OFFSET.X + Program.CIRCLE_DIAMETER, (int)Program.CIRCLE_OFFSET.Y + Program.CIRCLE_DIAMETER, ref x, ref y, 35, screen_hbitmap) ||
                    AutoIt.ImageSearchArea(skill_check_bmp_hbitmap, 0, SKILL_CHECK_RECT.Left, SKILL_CHECK_RECT.Top, SKILL_CHECK_RECT.Right, SKILL_CHECK_RECT.Bottom, ref x, ref y, 35, screen_hbitmap))
                {
                    CIRCLE_OFFSET.X = x - SKILL_CHECK_IMG_OFFSET.X;
                    CIRCLE_OFFSET.Y = y - SKILL_CHECK_IMG_OFFSET.Y;

                    bool is_hex = false;
                    int progress_pos_min = -1;
                    int progress_pos_max = -1;

                    // find progress first
                    for (int i = (ProgressPos != -1 ? ProgressPos : 0); i < 360; ++i)
                    {
                        Vec3 dir = Vec3.Rotate(INITIAL_DIR, i, VEC_UP);

                        // check progress pixel (check a little bit outside of the circle so w don't catch success zone)
                        Vec3 pixel = CIRCLE_OFFSET + CIRCLE_CENTER + dir * 1.11f;
                        Color pixel_color = AutoIt.PixelGetColor(screen_hbitmap, (int)pixel.X, (int)pixel.Y);

                        if (Tools.IsColor(pixel_color, PROGRESS_COLOR, 20) || Tools.IsColor(pixel_color, PROGRESS_COLOR_HEX, 20))
                        {
                            if (progress_pos_min == -1)
                            {
                                progress_pos_min = progress_pos_max = i;
                            }
                            else
                            {
                                progress_pos_max = i;
                            }

                            is_hex = Tools.IsColor(pixel_color, PROGRESS_COLOR_HEX, 20);
                        }
                        else if (progress_pos_min != -1)
                        {
                            break;
                        }
                    }

                    if (progress_pos_min != -1)
                    {
                        ProgressPos = (progress_pos_max + progress_pos_min) / 2;
                        SkillCheckActive = true;

                        if (ProgressPos > progress_pos)
                        {
                            progress_updated = true;
                            progress_pos = ProgressPos;
                        }
                    }

                    // find perfect zone
                    if (PerfectZonePos == -1)
                    {
                        for (int i = 0; i < 360; ++i)
                        {
                            Vec3 dir = Vec3.Rotate(INITIAL_DIR, i, VEC_UP);

                            // check perfect zone pixel (on circle)
                            Vec3 pixel = CIRCLE_OFFSET + CIRCLE_CENTER + dir;
                            Color pixel_color = AutoIt.PixelGetColor(screen_hbitmap, (int)pixel.X, (int)pixel.Y);

                            if (Tools.IsColor(pixel_color, is_hex ? PERFECT_ZONE_COLOR_HEX : PERFECT_ZONE_COLOR, 40))
                            {
                                PerfectZonePos = i;
                                break;
                            }
                        }
                    }
                }

                if (!SkillCheckActive)
                {
                    PerfectZonePos = -1;
                    ProgressPos = -1;
                    LastProgressPos = -1;
                    SpaceHitPos = -1;
                    LastProgressTimer.Stop();

                }

                ProcessingDuration = processing_timer.ElapsedMilliseconds;

                if (progress_updated)
                {
                    ProgressDataLock.EnterWriteLock();
                    LastProgressPos = progress_pos;
                    LastProgressTimer.Restart();
                    LastProgressCorrection = processing_timer.ElapsedMilliseconds + FIXED_CORRECTION + ScreenCaptureDuration;
                    ProgressDataLock.ExitWriteLock();
                }
            }
        }

        private static void RegisterHotkeys()
        {
            HotKeyManager.RegisterHotKey(Keys.F1, KeyModifiers.NoRepeat);
            HotKeyManager.RegisterHotKey(Keys.F2, KeyModifiers.NoRepeat);
            HotKeyManager.RegisterHotKey(Keys.F3, KeyModifiers.NoRepeat);
            HotKeyManager.RegisterHotKey(Keys.OemMinus, KeyModifiers.NoRepeat);
            HotKeyManager.RegisterHotKey(Keys.Oemplus, KeyModifiers.NoRepeat);
            HotKeyManager.HotKeyPressed += new EventHandler<HotKeyEventArgs>(OnKeyPressed);
        }

        private static void OnKeyPressed(object sender, HotKeyEventArgs e)
        {
            if (e.Key == Keys.F1)
            {
                WiggleActive = true;
            }
            else if (e.Key == Keys.F2)
            {
                StruggleActive = true;
            }
            else if (e.Key == Keys.F3)
            {
                WiggleActive = StruggleActive = false;
            }
            else if (e.Key == Keys.OemMinus)
            {
                --FIXED_CORRECTION;
            }
            else if (e.Key == Keys.Oemplus)
            {
                ++FIXED_CORRECTION;
            }
        }
    }
}