using ColorControl.Shared.Native;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NStandard;
using NWin32;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Net.Http;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using Windows.Devices.Enumeration;
using Windows.Devices.Enumeration.Pnp;
using Task = System.Threading.Tasks.Task;

namespace ColorControl.Shared.Common
{
    public static class Utils
    {
        public const int WM_BRINGTOFRONT = NativeConstants.WM_USER + 1;

        public static string PKEY_PNPX_IpAddress = "{656a3bb3-ecc0-43fd-8477-4ae0404a96cd} 12297";
        public static string PKEY_PNPX_PhysicalAddress = "{656a3bb3-ecc0-43fd-8477-4ae0404a96cd} 12294";
        public static string PKEY_DEVICE_CATEGORY = "{78c34fc8-104a-4aca-9ea4-524d52996e57} 90";
        public static string DEV_CLASS_DISPLAY_TV_LCD = "Display.TV.LCD";
        public static Guid GUID_CONSOLE_DISPLAY_STATE = Guid.Parse("6FE69556-704A-47A0-8F24-C28D936FDA47");

        public static bool ConsoleOpened { get; private set; }

        private static readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();

        public static string SERVICE_NAME = "Color Control Service";

        public static string ELEVATION_MSG = @"Elevation is needed in some cases where ColorControl needs administrator rights.
Some operations like installing a service, changing the priority of a process or creating a temporary IP-route for improved WOL-functionality will not work without those rights.

These methods are available:

- None: no administrator operations can be executed (unless program already manually is started as admin)

- Run as admin: only available when starting automatically after login (configures scheduled task with highest privileges)

- Use Windows Service: this will install a Windows Service that handles the operations which need admin rights. This is the preferred method.

- Use dedicated elevated process: a second ColorControl-process will be spawned that is run as administrator.

The best and suggested method to provide this is via a Windows Service. Only when installing the service a User Account Control window may popup.";

        public static Bitmap SubPixelShift(Bitmap bitmap)
        {
            Bitmap bitmap2 = (Bitmap)bitmap.Clone();

            int shift = -1;
            bool shiftRed = true;
            bool shiftGreen = true;
            bool shiftBlue = false;

            for (int i = 0; i < bitmap.Width; i++)
            {
                for (int j = 0; j < bitmap.Height; j++)
                {
                    Color pixel = bitmap.GetPixel(i, j);

                    if (shift > 0 && i < bitmap.Width - shift)
                    {
                        Color pixel2 = bitmap2.GetPixel(i + shift, j);

                        Color pixel3 = Color.FromArgb(shiftRed ? pixel.R : pixel2.R, shiftGreen ? pixel.G : pixel2.G, shiftBlue ? pixel.B : pixel2.B);

                        bitmap2.SetPixel(i + shift, j, pixel3);

                    }
                    else if (i + shift >= 0)
                    {
                        Color pixel2 = bitmap2.GetPixel(i + shift, j);

                        Color pixel3 = Color.FromArgb(shiftRed ? pixel.R : pixel2.R, shiftGreen ? pixel.G : pixel2.G, shiftBlue ? pixel.B : pixel2.B);

                        bitmap2.SetPixel(i + shift, j, pixel3);

                    }
                }
            }

            return bitmap2;
            //bitmap2.Save("d:\\ss_shifted.bmp");
        }

        public static string GetDataPath(string subDir = "")
        {
            var path = Directory.GetParent(Application.UserAppDataPath).FullName;
            if (!string.IsNullOrEmpty(subDir))
            {
                path = Path.Combine(path, subDir);
                if (!Directory.Exists(path))
                {
                    Directory.CreateDirectory(path);
                }
            }
            return path;
        }

        public static string[] GetDeviceProperty(PnpObject device, string propertyName)
        {
            object objValue;
            string[] values = null;

            //foreach (var key in device.Properties.Keys)
            //{
            //    Debug.WriteLine(key);
            //}

            if (device.Properties.TryGetValue(propertyName, out objValue))
            {
                if (objValue is string[] strValues)
                {
                    values = strValues.Where(s => !s.IsNullOrWhiteSpace()).ToArray();
                }
                else if (objValue is byte[])
                {
                    values = new[] { BitConverter.ToString((byte[])objValue) };
                }
                else
                {
                    values = new[] { objValue?.ToString() };
                }
            }

            return values;
        }

        public static async Task<List<PnpDev>> GetPnpDevices(string deviceName, string category = null)
        {
            var devices = new List<PnpDev>();

            var list = await DeviceInformation.FindAllAsync("", new List<string>());

            var reqs = new List<string>
            {
                PKEY_PNPX_IpAddress,
                PKEY_PNPX_PhysicalAddress,
                PKEY_DEVICE_CATEGORY
            };

            foreach (var dev in list)
            {
                string name = dev.Name;
                if (/*dev.IsEnabled &&*/ dev.Name.Contains(deviceName, StringComparison.OrdinalIgnoreCase))
                {
                    var guid = dev.Properties["System.Devices.DeviceInstanceId"];

                    var aqs = "System.Devices.DeviceInstanceId:=\"" + guid + "\"";
                    var list2 = await PnpObject.FindAllAsync(PnpObjectType.Device, reqs, aqs);

                    foreach (var dev2 in list2)
                    {
                        var devCategories = GetDeviceProperty(dev2, PKEY_DEVICE_CATEGORY);

                        if (category != null && devCategories?.Any(c => c == category) == false)
                        {
                            continue;
                        }

                        var ipAddresses = GetDeviceProperty(dev2, "System.Devices.IpAddress");
                        var macAddresses = GetDeviceProperty(dev2, PKEY_PNPX_PhysicalAddress);

                        var ipAddress = ipAddresses?.FirstOrDefault();
                        var macAddress = macAddresses?.FirstOrDefault();

                        if (!devices.Any(x => x.Name.Equals(name) && x.IpAddress != null && x.IpAddress.Equals(ipAddress)))
                        {
                            var device = new PnpDev(dev, dev2, name, ipAddress, macAddress);
                            devices.Add(device);
                        }
                    }

                }
            }
            return devices;
        }

        public static Image GenerateGradientBitmap(int width, int height)
        {
            var bitmap = new Bitmap(512, height);

            for (var i = 0; i < 256; i++)
            {
                var pixel = Color.FromArgb(i, i, i);

                for (var h = 0; h < height; h++)
                {
                    bitmap.SetPixel(i * 2, h, pixel);
                    bitmap.SetPixel(i * 2 + 1, h, pixel);
                }
            }

            return bitmap;
        }

        public static string FirstCharUpperCase(string name)
        {
            return name.Substring(0, 1).ToUpper() + name.Substring(1);
        }

        public static Dictionary<T, string> EnumToDictionary<T>(IEnumerable<T> skipValues = null) where T : struct, Enum
        {
            return Enum.GetValues<T>().Where(v => skipValues == null || !skipValues.Contains(v)).ToDictionary(k => k, e => e.GetDescription());
        }

        public static string GetDescriptionByEnumName<T>(string value) where T : IConvertible
        {
            string description = null;

            if (Enum.TryParse(typeof(T), value, out var result))
            {
                description = (result as IConvertible)?.GetDescription();
            }

            description = description ?? FirstCharUpperCase(value);

            return description;
        }

        public static string GetDescription<T>(this T e) where T : IConvertible
        {
            return GetDescription(e.GetType(), e);
        }

        public static string GetDescription(Type enumType, IConvertible value)
        {
            if (enumType.BaseType == typeof(Enum))
            {
                var val = value.ToInt32(CultureInfo.InvariantCulture);

                var enumName = enumType.GetEnumName(val);
                if (enumName == null)
                {
                    return string.Empty;
                }

                var memInfo = enumType.GetMember(enumName);
                var descriptionAttribute = memInfo[0]
                    .GetCustomAttributes(typeof(DescriptionAttribute), false)
                    .FirstOrDefault() as DescriptionAttribute;

                if (descriptionAttribute != null)
                {
                    return descriptionAttribute.Description;
                }

                return enumName;
            }

            return null; // could also return string.Empty
        }

        public static T GetEnumValueByDescription<T>(string value) where T : struct
        {
            var enumName = GetEnumNameByDescription(typeof(T), value);
            if (enumName != null)
            {
                value = enumName;
            }

            return Enum.Parse<T>(value);
        }

        public static string RemoveFirstUnderscore(this string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                return text;
            }

            if (text[0] == '_')
            {
                return text.Substring(1);
            }

            return text;
        }

        public static string GetEnumNameByDescription(Type enumType, string description)
        {
            if (enumType.BaseType == typeof(Enum))
            {
                foreach (var enumValue in Enum.GetValues(enumType))
                {
                    if (description.Equals(GetDescription(enumType, enumValue as IConvertible), StringComparison.Ordinal))
                    {
                        return Enum.GetName(enumType, enumValue).RemoveFirstUnderscore();
                    }
                }
            }

            return null; // could also return string.Empty
        }

        public static List<string> GetDescriptions<T>(int value = -1, int fromValue = 0) where T : IConvertible
        {
            return GetDescriptions(typeof(T), value, fromValue);
        }

        public static List<string> GetDescriptions(Type enumType, int value = -1, int fromValue = 0, bool replaceUnderscore = false)
        {
            var list = new List<string>();
            foreach (var enumValue in Enum.GetValues(enumType))
            {
                if (value > -1 || fromValue > 0)
                {
                    var enumIntValue = Convert.ToInt32(enumValue);

                    if (enumIntValue < fromValue || value >= 0 && (enumIntValue & value) == 0)
                    {
                        continue;
                    }
                }

                list.Add(GetDescription(enumType, enumValue as IConvertible) ?? (replaceUnderscore ? enumValue.ToString().Replace("_", "") : enumValue.ToString()));
            }
            return list;
        }

        public static bool OpenConsole()
        {
            if (ConsoleOpened)
            {
                return true;
            }

            if (!WinApi.AttachConsole(-1))
            {
                WinApi.AllocConsole();

                SetConsoleWriter();

                return true;
            }
            ConsoleOpened = true;

            SetConsoleWriter();

            return false;
        }

        private static void SetConsoleWriter()
        {
            var writer = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true };
            Console.SetOut(writer);
        }

        public static bool CloseConsole()
        {
            if (!ConsoleOpened)
            {
                return false;
            }

            SendKeys.SendWait("{ENTER}");
            var result = WinApi.FreeConsole();

            return result;
        }

        public static Process GetProcessByName(string name, bool skipCurrent = true)
        {
            var currentProcessId = Environment.ProcessId;
            foreach (var process in Process.GetProcesses())
            {
                if (process.ProcessName.Equals(name) && (!skipCurrent || process.Id != currentProcessId))
                {
                    return process;
                }
            }

            return null;
        }

        public static string GetResourceFile(string resourceName)
        {
            resourceName = "ColorControl.Resources." + resourceName;

            var assembly = Assembly.GetEntryAssembly();

            using (Stream stream = assembly.GetManifestResourceStream(resourceName))
            using (StreamReader reader = new StreamReader(stream))
            {
                var result = reader.ReadToEnd();

                return result;
            }
        }

        public static void ParseWords(List<string> target, string text)
        {
            target.Clear();

            if (string.IsNullOrEmpty(text))
            {
                return;
            }
            var words = text.Split(',');
            for (var i = 0; i < words.Length; i++)
            {
                var word = words[i];
                if (word.IndexOf("(") > -1)
                {
                    words[i] = word.Trim();
                }
                else
                {
                    words[i] = word.Replace(" ", string.Empty);
                }
            }
            target.AddRange(words);
        }

        public static int ParseInt(string value, int def = 0)
        {
            if (int.TryParse(value, out var result))
            {
                return result;
            }

            return def;
        }

        public static uint ParseUInt(string value, uint def = 0)
        {
            if (uint.TryParse(value, out var result))
            {
                return result;
            }

            return def;
        }

        public static int ParseDynamicAsInt(dynamic value, int def = 0)
        {
            if (value.Type == JTokenType.Integer)
            {
                return (int)value.Value;
            }
            if (value.Type == JTokenType.String)
            {
                return ParseInt(value.Value, def);
            }
            return def;
        }

        public static async Task<dynamic> GetRestJsonAsync(string url, Action<dynamic> callBack = null)
        {
            var httpClient = new HttpClient();
            httpClient.DefaultRequestHeaders.UserAgent.TryParseAdd("request");

            var response = await httpClient.GetAsync(url);
            if (response.IsSuccessStatusCode)
            {
                var result = await response.Content.ReadAsStringAsync();

                var data = JsonConvert.DeserializeObject<dynamic>(result);

                if (callBack != null)
                {
                    callBack(data);
                }

                return data;
            }

            if (callBack != null)
            {
                callBack(null);
            }

            return null;
        }

        public static FileInfo SelectFile(string ext = "*.exe", string filter = "Application EXE Name|*.exe|Application Absolute Path|*.exe")
        {
            var openDialog = new System.Windows.Forms.OpenFileDialog();
            openDialog.DefaultExt = ext;
            openDialog.Filter = filter;

            if (openDialog.ShowDialog() == DialogResult.OK)
            {
                return new FileInfo(openDialog.FileName);
                //if (openDialog.FilterIndex == 2)
                //    applicationName = openDialog.FileName;

                //return applicationName;
            }

            return null;
        }

        public static bool NormEquals(this string str1, string str2)
        {
            return str1.Trim().Replace(" ", string.Empty).Equals(str2.Trim().Replace(" ", string.Empty), StringComparison.OrdinalIgnoreCase);
        }

        public static async Task<bool> PingHost(string nameOrAddress)
        {
            try
            {
                using var pinger = new Ping();
                var reply = await pinger.SendPingAsync(nameOrAddress, 2000);

                return reply.Status == IPStatus.Success;
            }
            catch (PingException)
            {
                // Discard PingExceptions and return false;
                return false;
            }
        }

        public static bool WriteText(string fileName, string data)
        {
            var doWrite = !File.Exists(fileName);

            if (!doWrite)
            {
                var writtenData = File.ReadAllText(fileName);

                doWrite = !writtenData.Equals(data);
            }

            if (doWrite)
            {
                try
                {
                    File.WriteAllText(fileName, data);
                }
                catch (Exception e)
                {
                    Logger.Error(e.ToLogString());
                }
            }

            return doWrite;
        }

        public static string ReadText(string fileName, bool reverse = false)
        {
            var exists = File.Exists(fileName);

            if (!exists)
            {
                return null;
            }

            try
            {
                var lines = new StringBuilder();

                using var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);

                using var reader = new StreamReader(fs);

                string line;

                while ((line = reader.ReadLine()) != null)
                {
                    if (reverse)
                    {
                        lines.Insert(0, line + "\r\n");
                        continue;
                    }

                    lines.AppendLine(line);
                }

                return lines.ToString();
            }
            catch (Exception e)
            {
                Logger.Error(e.ToLogString());
            }

            return null;
        }

        public static List<string> ReadLines(string fileName, bool reverse = false)
        {
            var exists = File.Exists(fileName);

            if (!exists)
            {
                return null;
            }

            try
            {
                var lines = new List<string>();

                using var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);

                using var reader = new StreamReader(fs);

                string line;

                while ((line = reader.ReadLine()) != null)
                {
                    if (reverse)
                    {
                        lines.Insert(0, line + "\r\n");
                        continue;
                    }

                    lines.Add(line);
                }

                return lines;
            }
            catch (Exception e)
            {
                Logger.Error(e.ToLogString());
            }

            return null;
        }

        public static bool WriteObject(string fileName, object value)
        {
            var data = JsonConvert.SerializeObject(value);

            return WriteText(fileName, data);
        }

        public static T DeserializeJson<T>(string fileName)
        {
            try
            {
                var json = File.ReadAllText(fileName);
                var data = JsonConvert.DeserializeObject<T>(json);

                return data;
            }
            catch (Exception e)
            {
                Logger.Error(e.ToLogString());

                return default;
            }
        }

        public static string Base64Encode(string plainText)
        {
            var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
            return Convert.ToBase64String(plainTextBytes);
        }

        public static string Base64Decode(string base64EncodedData)
        {
            var base64EncodedBytes = Convert.FromBase64String(base64EncodedData);
            return Encoding.UTF8.GetString(base64EncodedBytes);
        }

        public static async Task DownloadFileAsync(string url, string filePath)
        {
            var httpClient = new HttpClient();
            using var stream = await httpClient.GetStreamAsync(url);

            if (File.Exists(filePath))
            {
                File.Delete(filePath);
            }

            using var fileStream = new FileStream(filePath, FileMode.CreateNew);

            await stream.CopyToAsync(fileStream);
        }

        public static void UnZipFile(string zipFile, string filePath)
        {
            ZipFile.ExtractToDirectory(zipFile, filePath);
        }

        public static void UpdateFiles(string clientPath, string updatePath)
        {
            var infos = new List<FileSystemInfo>();

            GetFileSystemInfos(updatePath, infos);

            foreach (var info in infos)
            {
                var subPath = info.FullName.Replace(updatePath, "");

                if (subPath[0] == '\\')
                {
                    subPath = subPath.Substring(1);
                }

                var targetPath = Path.Combine(clientPath, subPath);

                //Logger.Debug($"Path: {updatePath}, info: {info.FullName}, target: {targetPath}");

                if (info is DirectoryInfo)
                {
                    if (!Directory.Exists(targetPath))
                    {
                        Directory.CreateDirectory(targetPath);
                    }

                    continue;
                }

                var fileInfo = info as FileInfo;

                var oldPath = targetPath + ".old";

                if (File.Exists(oldPath))
                {
                    File.Delete(oldPath);
                }

                if (File.Exists(targetPath))
                {
                    if (CompareFiles(fileInfo.FullName, targetPath))
                    {
                        continue;
                    }

                    File.Move(targetPath, targetPath + ".old");
                }

                fileInfo.CopyTo(targetPath);
            }
        }

        public static void GetFileSystemInfos(string path, List<FileSystemInfo> infos)
        {
            var directory = new DirectoryInfo(path);

            foreach (var dir in directory.GetDirectories())
            {
                infos.Add(dir);
                GetFileSystemInfos(dir.FullName, infos);
            }

            foreach (var file in directory.GetFiles())
            {
                infos.Add(file);
            }
        }

        public static string SHA256CheckSum(string filePath)
        {
            using (SHA256 SHA256 = SHA256.Create())
            {
                using (FileStream fileStream = File.OpenRead(filePath))
                    return Convert.ToBase64String(SHA256.ComputeHash(fileStream));
            }
        }

        public static bool CompareFiles(string filePath1, string filePath2)
        {
            return SHA256CheckSum(filePath1) == SHA256CheckSum(filePath2);
        }

        public static string ToUnitString(this uint value, int div = 1000, string units = "MHz") => $"{value / div}{units}";
        public static string ToUnitString(this int value, int div = 1000, string units = "MHz") => $"{value / div}{units}";
    }
}