using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;

namespace OpenHardwareMonitor.Hardware;

internal static class Ring0
{
    private static KernelDriver _driver;
    private static string _filePath;

    private static readonly StringBuilder _report = new();

    public static bool IsOpen => _driver != null;

    internal static KernelDriver KernelDriver => _driver;

    public static void Open(bool portable)
    {
        // no implementation for unix systems
        if (OperatingSystemHelper.IsUnix)
            return;

        if (!OperatingSystemHelper.IsCompatible(false, out var _, out var _))
            return;

        if (_driver != null)
            return;

        // clear the current report
        _report.Length = 0;

        _driver = new KernelDriver(GetServiceName(), "WinRing0_1_2_0");
        _driver.Open();

        if (!_driver.IsOpen)
        {
            // driver is not loaded, try to install and open
            _filePath = GetFilePath(portable);
            if (_filePath != null && Extract(_filePath))
            {
                if (_driver.Install(_filePath, out string installError))
                {
                    _driver.Open();

                    if (!_driver.IsOpen)
                        _report.AppendLine("Status: Opening driver failed after install");
                }
                else
                {
                    // install failed, try to delete and reinstall
                    _driver.Delete();

                    // wait a short moment to give the OS a chance to remove the driver
                    Thread.Sleep(2000);

                    if (_driver.Install(_filePath, out string secondError))
                    {
                        _driver.Open();

                        if (!_driver.IsOpen)
                            _report.AppendLine("Status: Opening driver failed after reinstall");
                    }
                    else
                    {
                        _report.Append($"Status: Installing driver \"{_filePath}\" failed").AppendLine(File.Exists(_filePath) ? " and file exists" : string.Empty);
                        _report.Append("First Exception: ").AppendLine(installError);
                        _report.Append("Second Exception: ").AppendLine(secondError);
                    }
                }

                if (!_driver.IsOpen)
                {
                    _driver.Delete();
                    Delete();
                }
            }
            else
            {
                _report.AppendLine("Status: Extracting driver failed");
            }
        }

        if (!_driver.IsOpen)
            _driver = null;
    }

    private static bool Extract(string filePath)
    {
        string resourceName = $"{nameof(OpenHardwareMonitor)}.Resources.{(OperatingSystemHelper.Is64Bit ? "WinRing0x64.gz" : "WinRing0.gz")}";

        Assembly assembly = typeof(Ring0).Assembly;
        long requiredLength = 0;

        try
        {
            using Stream stream = assembly.GetManifestResourceStream(resourceName);

            if (stream != null)
            {
                using FileStream target = new(filePath, FileMode.Create);
                stream.Position = 1; // Skip first byte.
                using var gzipStream = new GZipStream(stream, CompressionMode.Decompress);
                gzipStream.CopyTo(target);
                requiredLength = target.Length;
            }
        }
        catch
        {
            return false;
        }

        if (HasValidFile())
            return true;

        // Ensure the file is actually written to the file system.
        var stopwatch = new Stopwatch();
        stopwatch.Start();

        while (stopwatch.ElapsedMilliseconds < 2000)
        {
            if (HasValidFile())
                return true;

            Thread.Yield();
        }

        return false;

        bool HasValidFile()
        {
            try
            {
                return File.Exists(filePath) && new FileInfo(filePath).Length == requiredLength;
            }
            catch
            {
                return false;
            }
        }
    }

    private static void Delete()
    {
        try
        {
            // Try to delete the driver file
            if (_filePath != null && File.Exists(_filePath))
                File.Delete(_filePath);

            _filePath = null;
        }
        catch
        {
            // Ignored.
        }
    }

    private static string GetServiceName()
    {
        string name;

        try
        {
            ProcessModule processModule = Process.GetCurrentProcess().MainModule;
            if (!string.IsNullOrEmpty(processModule?.FileName))
            {
                name = Path.GetFileNameWithoutExtension(processModule.FileName);
                if (!string.IsNullOrEmpty(name))
                    return GetName(name);
            }
        }
        catch
        {
            // Continue with the other options.
        }

        name = GetNameFromAssembly(Assembly.GetExecutingAssembly());
        if (!string.IsNullOrEmpty(name))
            return GetName(name);

        name = GetNameFromAssembly(typeof(Ring0).Assembly);
        if (!string.IsNullOrEmpty(name))
            return GetName(name);

        name = nameof(OpenHardwareMonitor);
        return GetName(name);

        static string GetNameFromAssembly(Assembly assembly)
        {
            return assembly?.GetName().Name;
        }

        static string GetName(string name)
        {
            return $"R0{name}".Replace(" ", string.Empty).Replace(".", "_");
        }
    }

    private static string GetFilePath(bool portable)
    {
        string filePath = null;

        if (portable)
        {
            try
            {
                ProcessModule processModule = Process.GetCurrentProcess().MainModule;
                if (!string.IsNullOrEmpty(processModule?.FileName))
                {
                    filePath = Path.ChangeExtension(processModule.FileName, ".sys");
                    if (CanCreate(filePath))
                        return filePath;
                }
            }
            catch
            {
                // Continue with the other options.
            }

            string previousFilePath = filePath;
            filePath = GetPathFromAssembly(Assembly.GetExecutingAssembly());
            if (previousFilePath != filePath && !string.IsNullOrEmpty(filePath) && CanCreate(filePath))
                return filePath;

            previousFilePath = filePath;
            filePath = GetPathFromAssembly(typeof(Ring0).Assembly);
            if (previousFilePath != filePath && !string.IsNullOrEmpty(filePath) && CanCreate(filePath))
                return filePath;
        }

        try
        {
            filePath = Path.GetTempFileName();
            if (!string.IsNullOrEmpty(filePath))
            {
                filePath = Path.ChangeExtension(filePath, ".sys");
                if (CanCreate(filePath))
                    return filePath;
            }
        }
        catch
        {
            return null;
        }

        return null;

        static string GetPathFromAssembly(Assembly assembly)
        {
            try
            {
                string location = assembly?.Location;
                return !string.IsNullOrEmpty(location) ? Path.ChangeExtension(location, ".sys") : null;
            }
            catch
            {
                return null;
            }
        }

        static bool CanCreate(string path)
        {
            try
            {
                using (File.Create(path, 1, FileOptions.DeleteOnClose))
                    return true;
            }
            catch
            {
                return false;
            }
        }
    }

    public static void Close()
    {
        if (_driver != null)
        {
            uint refCount = 0;
            _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_GET_REFCOUNT, null, ref refCount);
            _driver.Close();

            if (refCount <= 1)
                _driver.Delete();

            _driver = null;
        }

        // try to delete temporary driver file again if failed during open
        Delete();
    }

    public static string GetReport()
    {
        if (_report.Length > 0)
        {
            StringBuilder r = new();
            r.AppendLine("Ring0");
            r.AppendLine();
            r.Append(_report);
            r.AppendLine();
            return r.ToString();
        }

        return null;
    }

    public static bool ReadMsr(uint index, out uint eax, out uint edx)
    {
        if (_driver == null)
        {
            eax = 0;
            edx = 0;
            return false;
        }

        ulong buffer = 0;
        bool result = _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_READ_MSR, index, ref buffer);
        edx = (uint)((buffer >> 32) & 0xFFFFFFFF);
        eax = (uint)(buffer & 0xFFFFFFFF);
        return result;
    }

    public static bool ReadMsr(uint index, out ulong edxeax)
    {
        if (_driver == null)
        {
            edxeax = 0;
            return false;
        }

        ulong buffer = 0;
        bool result = _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_READ_MSR, index, ref buffer);
        edxeax = buffer;
        return result;
    }

    public static bool ReadMsr(uint index, out uint eax, out uint edx, GroupAffinity affinity)
    {
        GroupAffinity previousAffinity = ThreadAffinity.Set(affinity);
        bool result = ReadMsr(index, out eax, out edx);
        ThreadAffinity.Set(previousAffinity);
        return result;
    }

    public static bool WriteMsr(uint index, uint eax, uint edx)
    {
        if (_driver == null)
            return false;

        WriteMsrInput input = new() { Register = index, Value = ((ulong)edx << 32) | eax };
        return _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_WRITE_MSR, input);
    }

    public static byte ReadIoPort(uint port)
    {
        if (_driver == null)
            return 0;

        uint value = 0;
        _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_READ_IO_PORT_BYTE, port, ref value);
        return (byte)(value & 0xFF);
    }

    public static void WriteIoPort(uint port, byte value)
    {
        if (_driver == null)
            return;

        WriteIoPortInput input = new() { PortNumber = port, Value = value };
        _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_WRITE_IO_PORT_BYTE, input);
    }

    public static uint GetPciAddress(byte bus, byte device, byte function)
    {
        return (uint)(((bus & 0xFF) << 8) | ((device & 0x1F) << 3) | (function & 7));
    }

    public static bool ReadPciConfig(uint pciAddress, uint regAddress, out uint value)
    {
        if (_driver == null || (regAddress & 3) != 0)
        {
            value = 0;
            return false;
        }

        ReadPciConfigInput input = new() { PciAddress = pciAddress, RegAddress = regAddress };

        value = 0;
        return _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_READ_PCI_CONFIG, input, ref value);
    }

    public static bool WritePciConfig(uint pciAddress, uint regAddress, uint value)
    {
        if (_driver == null || (regAddress & 3) != 0)
            return false;

        WritePciConfigInput input = new() { PciAddress = pciAddress, RegAddress = regAddress, Value = value };
        return _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_WRITE_PCI_CONFIG, input);
    }

    public static bool ReadMemory<T>(ulong address, ref T buffer)
    {
        if (_driver == null)
            return false;

        ReadMemoryInput input = new() { Address = address, UnitSize = 1, Count = (uint)Marshal.SizeOf(buffer) };
        return _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_READ_MEMORY, input, ref buffer);
    }

    public static bool ReadMemory<T>(ulong address, ref T[] buffer)
    {
        if (_driver == null)
            return false;

        ReadMemoryInput input = new() { Address = address, UnitSize = (uint)Marshal.SizeOf(typeof(T)), Count = (uint)buffer.Length };
        return _driver.DeviceIOControl(Interop.Ring0.IOCTL_OLS_READ_MEMORY, input, ref buffer);
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private struct WriteMsrInput
    {
        public uint Register;
        public ulong Value;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private struct WriteIoPortInput
    {
        public uint PortNumber;
        public byte Value;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private struct ReadPciConfigInput
    {
        public uint PciAddress;
        public uint RegAddress;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private struct WritePciConfigInput
    {
        public uint PciAddress;
        public uint RegAddress;
        public uint Value;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private struct ReadMemoryInput
    {
        public ulong Address;
        public uint UnitSize;
        public uint Count;
    }
}
