// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// Copyright (C) LibreHardwareMonitor and Contributors.
// Partial Copyright (C) Michael Möller <mmoeller@openhardwaremonitor.org> and Contributors.
// All Rights Reserved.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Text;
using System.Threading;

namespace LibreHardwareMonitor.Hardware.Motherboard.Lpc
{
    internal class Nct677X : ISuperIO
    {
        private readonly struct TemperatureSourceData
        {
            public TemperatureSourceData(Enum source, ushort register, ushort halfRegister = 0, int halfBit = -1, ushort sourceRegister = 0, ushort? alternateRegister = null)
            {
                Source = source;
                Register = register;
                HalfRegister = halfRegister;
                HalfBit = halfBit;
                SourceRegister = sourceRegister;
                AlternateRegister = alternateRegister;
            }
            public readonly Enum Source;
            public readonly ushort Register;
            public readonly ushort HalfRegister;
            public readonly int HalfBit;
            public readonly ushort SourceRegister;
            public readonly ushort? AlternateRegister;
        }

        private readonly ushort[] _fanCountRegister;
        private readonly ushort[] _fanRpmRegister;
        private readonly byte[] _initialFanControlMode = new byte[7];
        private readonly byte[] _initialFanPwmCommand = new byte[7];
        private readonly bool _isNuvotonVendor;
        private readonly LpcPort _lpcPort;
        private readonly int _maxFanCount;
        private readonly int _minFanCount;
        private readonly int _minFanRpm;
        private readonly ushort _port;
        private readonly bool[] _restoreDefaultFanControlRequired = new bool[7];
        private readonly byte _revision;
        private readonly TemperatureSourceData[] _temperaturesSource;
        private readonly ushort _vBatMonitorControlRegister;
        private readonly ushort[] _voltageRegisters;
        private readonly ushort _voltageVBatRegister;

        public Nct677X(Chip chip, byte revision, ushort port, LpcPort lpcPort)
        {
            Chip = chip;
            _revision = revision;
            _port = port;
            _lpcPort = lpcPort;

            if (chip == Chip.NCT610XD)
            {
                VENDOR_ID_HIGH_REGISTER = 0x80FE;
                VENDOR_ID_LOW_REGISTER = 0x00FE;

                FAN_PWM_OUT_REG = new ushort[] { 0x04A, 0x04B, 0x04C };
                FAN_PWM_COMMAND_REG = new ushort[] { 0x119, 0x129, 0x139 };
                FAN_CONTROL_MODE_REG = new ushort[] { 0x113, 0x123, 0x133 };

                _vBatMonitorControlRegister = 0x0318;
            }
            else if (chip is Chip.NCT6687D or Chip.NCT6683D)
            {
                FAN_PWM_OUT_REG = new ushort[] { 0x160, 0x161, 0x162, 0x163, 0x164, 0x165, 0x166, 0x167 };
                FAN_PWM_COMMAND_REG = new ushort[] { 0xA28, 0xA29, 0xA2A, 0xA2B, 0xA2C, 0xA2D, 0xA2E, 0xA2F };
                FAN_CONTROL_MODE_REG = new ushort[] { 0xA00, 0xA00, 0xA00, 0xA00, 0xA00, 0xA00, 0xA00, 0xA00 };
                FAN_PWM_REQUEST_REG = new ushort[] { 0xA01, 0xA01, 0xA01, 0xA01, 0xA01, 0xA01, 0xA01, 0xA01 };
            }
            else
            {
                VENDOR_ID_HIGH_REGISTER = 0x804F;
                VENDOR_ID_LOW_REGISTER = 0x004F;

                FAN_PWM_OUT_REG = chip is Chip.NCT6797D or Chip.NCT6798D
                    ? new ushort[] { 0x001, 0x003, 0x011, 0x013, 0x015, 0xA09, 0xB09 }
                    : new ushort[] { 0x001, 0x003, 0x011, 0x013, 0x015, 0x017, 0x029 };

                FAN_PWM_COMMAND_REG = new ushort[] { 0x109, 0x209, 0x309, 0x809, 0x909, 0xA09, 0xB09 };
                FAN_CONTROL_MODE_REG = new ushort[] { 0x102, 0x202, 0x302, 0x802, 0x902, 0xA02, 0xB02 };

                _vBatMonitorControlRegister = 0x005D;
            }

            _isNuvotonVendor = IsNuvotonVendor();

            if (!_isNuvotonVendor)
                return;

            switch (chip)
            {
                case Chip.NCT6771F:
                case Chip.NCT6776F:
                    if (chip == Chip.NCT6771F)
                    {
                        Fans = new float?[4];

                        // min value RPM value with 16-bit fan counter
                        _minFanRpm = (int)(1.35e6 / 0xFFFF);
                    }
                    else
                    {
                        Fans = new float?[5];

                        // min value RPM value with 13-bit fan counter
                        _minFanRpm = (int)(1.35e6 / 0x1FFF);
                    }

                    _fanRpmRegister = new ushort[5];
                    for (int i = 0; i < _fanRpmRegister.Length; i++)
                        _fanRpmRegister[i] = (ushort)(0x656 + (i << 1));

                    Controls = new float?[3];

                    Voltages = new float?[9];
                    _voltageRegisters = new ushort[] { 0x020, 0x021, 0x022, 0x023, 0x024, 0x025, 0x026, 0x550, 0x551 };
                    _voltageVBatRegister = 0x551;
                    _temperaturesSource = new TemperatureSourceData[]
                    {
                        new(chip == Chip.NCT6771F ?  SourceNct6771F.PECI_0 : SourceNct6776F.PECI_0, 0x027, 0, -1, 0x621),
                        new(chip == Chip.NCT6771F ?  SourceNct6771F.CPUTIN : SourceNct6776F.CPUTIN, 0x073, 0x074, 7, 0x100),
                        new(chip == Chip.NCT6771F ?  SourceNct6771F.AUXTIN : SourceNct6776F.AUXTIN, 0x075, 0x076, 7, 0x200),
                        new(chip == Chip.NCT6771F ?  SourceNct6771F.SYSTIN : SourceNct6776F.SYSTIN, 0x077, 0x078, 7, 0x300),
                        new(null, 0x150, 0x151, 7, 0x622),
                        new(null, 0x250, 0x251, 7, 0x623),
                        new(null, 0x62B, 0x62E, 0, 0x624),
                        new(null, 0x62C, 0x62E, 1, 0x625),
                        new(null, 0x62D, 0x62E, 2, 0x626)
                    };

                    Temperatures = new float?[4];
                    break;

                case Chip.NCT6779D:
                case Chip.NCT6791D:
                case Chip.NCT6792D:
                case Chip.NCT6792DA:
                case Chip.NCT6793D:
                case Chip.NCT6795D:
                case Chip.NCT6796D:
                case Chip.NCT6796DR:
                case Chip.NCT6797D:
                case Chip.NCT6798D:
                    switch (chip)
                    {
                        case Chip.NCT6779D:
                            Fans = new float?[5];
                            Controls = new float?[5];
                            break;

                        case Chip.NCT6796DR:
                        case Chip.NCT6797D:
                        case Chip.NCT6798D:
                            Fans = new float?[7];
                            Controls = new float?[7];
                            break;

                        default:
                            Fans = new float?[6];
                            Controls = new float?[6];
                            break;
                    }

                    _fanCountRegister = new ushort[] { 0x4B0, 0x4B2, 0x4B4, 0x4B6, 0x4B8, 0x4BA, 0x4CC };

                    // max value for 13-bit fan counter
                    _maxFanCount = 0x1FFF;

                    // min value that could be transferred to 16-bit RPM registers
                    _minFanCount = 0x15;

                    Voltages = new float?[15];
                    _voltageRegisters = new ushort[] { 0x480, 0x481, 0x482, 0x483, 0x484, 0x485, 0x486, 0x487, 0x488, 0x489, 0x48A, 0x48B, 0x48C, 0x48D, 0x48E };
                    _voltageVBatRegister = 0x488;
                    var temperaturesSources = new List<TemperatureSourceData>();

                    switch (chip)
                    {
                        case Chip.NCT6796D:
                        case Chip.NCT6796DR:
                        case Chip.NCT6797D:
                        case Chip.NCT6798D:
                            temperaturesSources.AddRange(new TemperatureSourceData[]
                                {
                                new(SourceNct67Xxd.PECI_0, 0x073, 0x074, 7, 0x100),
                                new(SourceNct67Xxd.CPUTIN, 0x075, 0x076, 7, 0x200, 0x491),
                                new(SourceNct67Xxd.SYSTIN, 0x077, 0x078, 7, 0x300, 0x490),
                                new(SourceNct67Xxd.AUXTIN0, 0x079, 0x07A, 7, 0x800, 0x492),
                                new(SourceNct67Xxd.AUXTIN1, 0x07B, 0x07C, 7, 0x900, 0x493),
                                new(SourceNct67Xxd.AUXTIN2, 0x07D, 0x07E, 7, 0xA00, 0x494),
                                new(SourceNct67Xxd.AUXTIN3, 0x4A0, 0x49E, 6, 0xB00, 0x495),
                                new(SourceNct67Xxd.AUXTIN4, 0x027, 0, -1, 0x621),
                                new(SourceNct67Xxd.SMBUSMASTER0, 0x150, 0x151, 7, 0x622),
                                new(SourceNct67Xxd.SMBUSMASTER1, 0x670, 0, -1, 0xC26),
                                new(SourceNct67Xxd.PECI_1, 0x672, 0, -1, 0xC27),
                                new(SourceNct67Xxd.PCH_CHIP_CPU_MAX_TEMP, 0x674, 0, -1, 0xC28, 0x400),
                                new(SourceNct67Xxd.PCH_CHIP_TEMP, 0x676, 0, -1, 0xC29, 0x401),
                                new(SourceNct67Xxd.PCH_CPU_TEMP,  0x678, 0, -1, 0xC2A, 0x402),
                                new(SourceNct67Xxd.PCH_MCH_TEMP, 0x67A, 0, -1, 0xC2B, 0x404),
                                new(SourceNct67Xxd.AGENT0_DIMM0, 0),
                                new(SourceNct67Xxd.AGENT0_DIMM1, 0),
                                new(SourceNct67Xxd.AGENT1_DIMM0, 0),
                                new(SourceNct67Xxd.AGENT1_DIMM1, 0),
                                new(SourceNct67Xxd.BYTE_TEMP0, 0),
                                new(SourceNct67Xxd.BYTE_TEMP1, 0),
                                new(SourceNct67Xxd.PECI_0_CAL, 0),
                                new(SourceNct67Xxd.PECI_1_CAL, 0),
                                new(SourceNct67Xxd.VIRTUAL_TEMP, 0)
                                });
                            break;

                        default:
                            temperaturesSources.AddRange(new TemperatureSourceData[]
                                {
                                new(SourceNct67Xxd.PECI_0, 0x027, 0, -1, 0x621),
                                new(SourceNct67Xxd.CPUTIN, 0x073, 0x074, 7, 0x100, 0x491),
                                new(SourceNct67Xxd.SYSTIN, 0x075, 0x076, 7, 0x200, 0x490),
                                new(SourceNct67Xxd.AUXTIN0, 0x077, 0x078, 7, 0x300, 0x492),
                                new(SourceNct67Xxd.AUXTIN1, 0x079, 0x07A, 7, 0x800, 0x493),
                                new(SourceNct67Xxd.AUXTIN2, 0x07B, 0x07C, 7, 0x900, 0x494),
                                new(SourceNct67Xxd.AUXTIN3, 0x150, 0x151, 7, 0x622, 0x495)
                                });
                            break;
                    }

                    _temperaturesSource = temperaturesSources.ToArray();
                    Temperatures = new float?[_temperaturesSource.Length];
                    break;

                case Chip.NCT610XD:
                    Fans = new float?[3];
                    Controls = new float?[3];

                    _fanRpmRegister = new ushort[3];
                    for (int i = 0; i < _fanRpmRegister.Length; i++)
                        _fanRpmRegister[i] = (ushort)(0x030 + (i << 1));

                    // min value RPM value with 13-bit fan counter
                    _minFanRpm = (int)(1.35e6 / 0x1FFF);

                    Voltages = new float?[9];
                    _voltageRegisters = new ushort[] { 0x300, 0x301, 0x302, 0x303, 0x304, 0x305, 0x307, 0x308, 0x309 };
                    _voltageVBatRegister = 0x308;
                    Temperatures = new float?[4];
                    _temperaturesSource = new TemperatureSourceData[] {
                        new(SourceNct610X.PECI_0, 0x027, 0, -1, 0x621),
                        new(SourceNct610X.SYSTIN, 0x018, 0x01B, 7, 0x100, 0x018),
                        new(SourceNct610X.CPUTIN, 0x019, 0x11B, 7, 0x200, 0x019),
                        new(SourceNct610X.AUXTIN, 0x01A, 0x21B, 7, 0x300, 0x01A)
                    };
                    break;

                case Chip.NCT6683D:
                case Chip.NCT6687D:
                    Fans = new float?[8];
                    Controls = new float?[8];
                    Voltages = new float?[14];
                    Temperatures = new float?[7];

                    // CPU
                    // System
                    // MOS
                    // PCH
                    // CPU Socket
                    // PCIE_1
                    // M2_1
                    _temperaturesSource = new TemperatureSourceData[] {
                        new(null, 0x100),
                        new(null, 0x102),
                        new(null, 0x104),
                        new(null, 0x106),
                        new(null, 0x108),
                        new(null, 0x10A),
                        new(null, 0x10C)
                    };

                    // VIN0 +12V
                    // VIN1 +5V
                    // VIN2 VCore
                    // VIN3 SIO
                    // VIN4 DRAM
                    // VIN5 CPU IO
                    // VIN6 CPU SA
                    // VIN7 SIO
                    // 3VCC I/O +3.3
                    // SIO VTT
                    // SIO VREF
                    // SIO VSB
                    // SIO AVSB
                    // SIO VBAT
                    _voltageRegisters = new ushort[] { 0x120, 0x122, 0x124, 0x126, 0x128, 0x12A, 0x12C, 0x12E, 0x130, 0x13A, 0x13E, 0x136, 0x138, 0x13C };

                    // CPU Fan
                    // PUMP Fan
                    // SYS Fan 1
                    // SYS Fan 2
                    // SYS Fan 3
                    // SYS Fan 4
                    // SYS Fan 5
                    // SYS Fan 6
                    _fanRpmRegister = new ushort[] { 0x140, 0x142, 0x144, 0x146, 0x148, 0x14A, 0x14C, 0x14E };

                    _restoreDefaultFanControlRequired = new bool[_fanRpmRegister.Length];
                    _initialFanControlMode = new byte[_fanRpmRegister.Length];
                    _initialFanPwmCommand = new byte[_fanRpmRegister.Length];

                    // initialize
                    const ushort initRegister = 0x180;
                    byte data = ReadByte(initRegister);
                    if ((data & 0x80) == 0)
                    {
                        WriteByte(initRegister, (byte)(data | 0x80));
                    }

                    // enable SIO voltage
                    WriteByte(0x1BB, 0x61);
                    WriteByte(0x1BC, 0x62);
                    WriteByte(0x1BD, 0x63);
                    WriteByte(0x1BE, 0x64);
                    WriteByte(0x1BF, 0x65);
                    break;
            }
        }

        public Chip Chip { get; }

        public float?[] Controls { get; } = Array.Empty<float?>();

        public float?[] Fans { get; } = Array.Empty<float?>();

        public float?[] Temperatures { get; } = Array.Empty<float?>();

        public float?[] Voltages { get; } = Array.Empty<float?>();

        public byte? ReadGpio(int index)
        {
            return null;
        }

        public void WriteGpio(int index, byte value)
        { }

        public void SetControl(int index, byte? value)
        {
            if (!_isNuvotonVendor)
                return;

            if (index < 0 || index >= Controls.Length)
                throw new ArgumentOutOfRangeException(nameof(index));

            if (!Ring0.WaitIsaBusMutex(10))
                return;

            if (value.HasValue)
            {
                SaveDefaultFanControl(index);

                if (Chip is not Chip.NCT6687D and not Chip.NCT6683D)
                {
                    // set manual mode
                    WriteByte(FAN_CONTROL_MODE_REG[index], 0);

                    // set output value
                    WriteByte(FAN_PWM_COMMAND_REG[index], value.Value);
                }
                else
                {
                    // Manual mode, bit(1 : set, 0 : unset)
                    // bit 0 : CPU Fan
                    // bit 1 : PUMP Fan
                    // bit 2 : SYS Fan 1
                    // bit 3 : SYS Fan 2
                    // bit 4 : SYS Fan 3
                    // bit 5 : SYS Fan 4
                    // bit 6 : SYS Fan 5
                    // bit 7 : SYS Fan 6

                    byte mode = ReadByte(FAN_CONTROL_MODE_REG[index]);
                    byte bitMask = (byte)(0x01 << index);
                    mode = (byte)(mode | bitMask);
                    WriteByte(FAN_CONTROL_MODE_REG[index], mode);

                    WriteByte(FAN_PWM_REQUEST_REG[index], 0x80);
                    Thread.Sleep(50);

                    WriteByte(FAN_PWM_COMMAND_REG[index], value.Value);
                    WriteByte(FAN_PWM_REQUEST_REG[index], 0x40);
                    Thread.Sleep(50);
                }
            }
            else
            {
                RestoreDefaultFanControl(index);
            }

            Ring0.ReleaseIsaBusMutex();
        }

        public void Update()
        {
            if (!_isNuvotonVendor)
                return;

            if (!Ring0.WaitIsaBusMutex(10))
                return;

            DisableIOSpaceLock();

            for (int i = 0; i < Voltages.Length; i++)
            {
                if (Chip != Chip.NCT6687D)
                {
                    float value = 0.008f * ReadByte(_voltageRegisters[i]);
                    bool valid = value > 0;

                    // check if battery voltage monitor is enabled
                    if (valid && _voltageRegisters[i] == _voltageVBatRegister)
                        valid = (ReadByte(_vBatMonitorControlRegister) & 0x01) > 0;

                    Voltages[i] = valid ? value : null;
                }
                else
                {
                    float value = 0.001f * ((16 * ReadByte(_voltageRegisters[i])) + (ReadByte((ushort)(_voltageRegisters[i] + 1)) >> 4));

                    Voltages[i] = i switch
                    {
                        // 12V
                        0 => value * 12.0f,
                        // 5V
                        1 => value * 5.0f,
                        // DRAM
                        4 => value * 2.0f,
                        _ => value
                    };
                }
            }

            System.Diagnostics.Debug.WriteLine("Updating temperatures.");
            long temperatureSourceMask = 0;
            for (int i = 0; i < _temperaturesSource.Length; i++)
            {
                TemperatureSourceData ts = _temperaturesSource[i];
                int value;
                SourceNct67Xxd source;
                float? temperature;

                switch (Chip)
                {
                    case Chip.NCT6687D:
                    case Chip.NCT6683D:
                        value = (sbyte)ReadByte(ts.Register);
                        int half = (ReadByte((ushort)(ts.Register + 1)) >> 7) & 0x1;
                        Temperatures[i] = value + (0.5f * half);
                        break;

                    case Chip.NCT6796D:
                    case Chip.NCT6796DR:
                    case Chip.NCT6797D:
                    case Chip.NCT6798D:
                        if (_temperaturesSource[i].Register == 0)
                        {
                            System.Diagnostics.Debug.WriteLine("Temperature register {0} skipped, address 0.", i);
                            continue;
                        }

                        value = (sbyte)ReadByte(_temperaturesSource[i].Register) << 1;
                        System.Diagnostics.Debug.WriteLine("Temperature register {0} at 0x{1:X3} value (integer): {2}/2", i, ts.Register, value);
                        if (_temperaturesSource[i].HalfBit > 0)
                        {
                            value |= (ReadByte(_temperaturesSource[i].HalfRegister) >> ts.HalfBit) & 0x1;
                            System.Diagnostics.Debug.WriteLine("Temperature register {0} value updated from 0x{1:X3} (fractional): {2}/2", i, ts.HalfRegister, value);
                        }

                        if (ts.SourceRegister > 0)
                        {
                            source = (SourceNct67Xxd)(ReadByte(ts.SourceRegister) & 0x1F);
                            System.Diagnostics.Debug.WriteLine("Temperature register {0} source at 0x{1:X3}: {2:G} ({2:D})", i, ts.SourceRegister, source);
                        }
                        else
                        {
                            source = (SourceNct67Xxd)ts.Source;
                            System.Diagnostics.Debug.WriteLine("Temperature register {0} source register is 0, source set to: {1:G} ({1:D})", i, source);
                        }

                        // Skip reading when already filled, because later values are without fractional
                        if ((temperatureSourceMask & (1L << (byte)source)) > 0)
                        {
                            System.Diagnostics.Debug.WriteLine("Temperature register {0} discarded, because source seen before.", i);
                            continue;
                        }

                        temperature = 0.5f * value;
                        System.Diagnostics.Debug.WriteLine("Temperature register {0} final temperature: {1}.", i, temperature);
                        if (temperature is > 125 or < -55)
                        {
                            temperature = null;
                            System.Diagnostics.Debug.WriteLine("Temperature register {0} discarded: Out of range.", i);
                        }
                        else
                        {
                            temperatureSourceMask |= 1L << (byte)source;
                            System.Diagnostics.Debug.WriteLine("Temperature register {0} accepted.", i);
                        }

                        for (int j = 0; j < Temperatures.Length; j++)
                        {
                            if ((SourceNct67Xxd)_temperaturesSource[j].Source == source)
                            {
                                Temperatures[j] = temperature;
                                System.Diagnostics.Debug.WriteLine("Temperature register {0}, value from source {1:G} ({1:D}), written at position {2}.", i, _temperaturesSource[j].Source, j);
                            }
                        }
                        break;

                    default:
                        value = (sbyte)ReadByte(ts.Register) << 1;
                        if (ts.HalfBit > 0)
                        {
                            value |= (ReadByte(ts.HalfRegister) >> ts.HalfBit) & 0x1;
                        }

                        source = (SourceNct67Xxd)ReadByte(ts.SourceRegister);
                        temperatureSourceMask |= 1L << (byte)source;

                        temperature = 0.5f * value;
                        if (temperature is > 125 or < -55)
                            temperature = null;

                        for (int j = 0; j < Temperatures.Length; j++)
                        {
                            if ((SourceNct67Xxd)_temperaturesSource[j].Source == source)
                                Temperatures[j] = temperature;
                        }
                        break;
                }
            }

            for (int i = 0; i < _temperaturesSource.Length; i++)
            {
                TemperatureSourceData ts = _temperaturesSource[i];
                if (!ts.AlternateRegister.HasValue)
                {
                    System.Diagnostics.Debug.WriteLine("Alternate temperature register for temperature {0}, {1:G} ({1:D}), skipped, because address is null.", i, ts.Source);
                    continue;
                }

                if ((temperatureSourceMask & (1L << (byte)(SourceNct67Xxd)ts.Source)) > 0)
                {
                    System.Diagnostics.Debug.WriteLine("Alternate temperature register for temperature {0}, {1:G} ({1:D}), at 0x{2:X3} skipped, because value already set.", i, ts.Source, ts.AlternateRegister.Value);
                    continue;
                }

                float? temperature = (sbyte)ReadByte(ts.AlternateRegister.Value);
                System.Diagnostics.Debug.WriteLine("Alternate temperature register for temperature {0}, {1:G} ({1:D}), at 0x{2:X3} final temperature: {3}.", i, ts.Source, ts.AlternateRegister.Value, temperature);

                if (temperature is > 125 or <= 0)
                {
                    temperature = null;
                    System.Diagnostics.Debug.WriteLine("Alternate Temperature register for temperature {0}, {1:G} ({1:D}), discarded: Out of range.", i, ts.Source);
                }

                Temperatures[i] = temperature;
            }

            for (int i = 0; i < Fans.Length; i++)
            {
                if (Chip is not Chip.NCT6687D and not Chip.NCT6683D)
                {
                    if (_fanCountRegister != null)
                    {
                        byte high = ReadByte(_fanCountRegister[i]);
                        byte low = ReadByte((ushort)(_fanCountRegister[i] + 1));

                        int count = (high << 5) | (low & 0x1F);
                        if (count < _maxFanCount)
                        {
                            if (count >= _minFanCount)
                            {
                                Fans[i] = 1.35e6f / count;
                            }
                            else
                            {
                                Fans[i] = null;
                            }
                        }
                        else
                        {
                            Fans[i] = 0;
                        }
                    }
                    else
                    {
                        byte high = ReadByte(_fanRpmRegister[i]);
                        byte low = ReadByte((ushort)(_fanRpmRegister[i] + 1));
                        int value = (high << 8) | low;

                        Fans[i] = value > _minFanRpm ? value : 0;
                    }
                }
                else
                {
                    Fans[i] = (ReadByte(_fanRpmRegister[i]) << 8) | ReadByte((ushort)(_fanRpmRegister[i] + 1));
                }
            }

            for (int i = 0; i < Controls.Length; i++)
            {
                if (Chip is not Chip.NCT6687D and not Chip.NCT6683D)
                {
                    int value = ReadByte(FAN_PWM_OUT_REG[i]);
                    Controls[i] = value / 2.55f;
                }
                else
                {
                    int value = ReadByte(FAN_PWM_OUT_REG[i]);
                    Controls[i] = (float)Math.Round(value / 2.55f);
                }
            }

            Ring0.ReleaseIsaBusMutex();
        }

        public string GetReport()
        {
            StringBuilder r = new();

            r.AppendLine("LPC " + GetType().Name);
            r.AppendLine();
            r.Append("Chip Id: 0x");
            r.AppendLine(Chip.ToString("X"));
            r.Append("Chip Revision: 0x");
            r.AppendLine(_revision.ToString("X", CultureInfo.InvariantCulture));
            r.Append("Base Address: 0x");
            r.AppendLine(_port.ToString("X4", CultureInfo.InvariantCulture));
            r.AppendLine();

            if (!Ring0.WaitIsaBusMutex(100))
                return r.ToString();

            ushort[] addresses =
            {
                0x000,
                0x010,
                0x020,
                0x030,
                0x040,
                0x050,
                0x060,
                0x070,
                0x0F0,
                0x100,
                0x110,
                0x120,
                0x130,
                0x140,
                0x150,
                0x200,
                0x210,
                0x220,
                0x230,
                0x240,
                0x250,
                0x260,
                0x300,
                0x320,
                0x330,
                0x340,
                0x360,
                0x400,
                0x410,
                0x420,
                0x440,
                0x450,
                0x460,
                0x480,
                0x490,
                0x4B0,
                0x4C0,
                0x4F0,
                0x500,
                0x550,
                0x560,
                0x600,
                0x610,
                0x620,
                0x630,
                0x640,
                0x650,
                0x660,
                0x670,
                0x700,
                0x710,
                0x720,
                0x730,
                0x800,
                0x820,
                0x830,
                0x840,
                0x900,
                0x920,
                0x930,
                0x940,
                0x960,
                0xA00,
                0xA10,
                0xA20,
                0xA30,
                0xA40,
                0xA50,
                0xA60,
                0xA70,
                0xB00,
                0xB10,
                0xB20,
                0xB30,
                0xB50,
                0xB60,
                0xB70,
                0xC00,
                0xC10,
                0xC20,
                0xC30,
                0xC50,
                0xC60,
                0xC70,
                0xD00,
                0xD10,
                0xD20,
                0xD30,
                0xD50,
                0xD60,
                0xE00,
                0xE10,
                0xE20,
                0xE30,
                0xF00,
                0xF10,
                0xF20,
                0xF30,
                0x8040,
                0x80F0
            };

            r.AppendLine("Hardware Monitor Registers");
            r.AppendLine();
            r.AppendLine("        00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F");
            r.AppendLine();

            if (Chip is not Chip.NCT6687D and not Chip.NCT6683D)
            {
                foreach (ushort address in addresses)
                {
                    r.Append(" ");
                    r.Append(address.ToString("X4", CultureInfo.InvariantCulture));
                    r.Append("  ");
                    for (ushort j = 0; j <= 0xF; j++)
                    {
                        r.Append(" ");
                        r.Append(ReadByte((ushort)(address | j)).ToString("X2", CultureInfo.InvariantCulture));
                    }

                    r.AppendLine();
                }
            }
            else
            {
                for (int i = 0; i <= 0xFF; i++)
                {
                    r.Append(" ");
                    r.Append((i << 4).ToString("X4", CultureInfo.InvariantCulture));
                    r.Append("  ");
                    for (int j = 0; j <= 0xF; j++)
                    {
                        ushort address = (ushort)(i << 4 | j);
                        r.Append(" ");
                        r.Append(ReadByte(address).ToString("X2", CultureInfo.InvariantCulture));
                    }

                    r.AppendLine();
                }
            }

            r.AppendLine();

            Ring0.ReleaseIsaBusMutex();

            return r.ToString();
        }

        private byte ReadByte(ushort address)
        {
            if (Chip is not Chip.NCT6687D and not Chip.NCT6683D)
            {
                byte bank = (byte)(address >> 8);
                byte register = (byte)(address & 0xFF);
                Ring0.WriteIoPort(_port + ADDRESS_REGISTER_OFFSET, BANK_SELECT_REGISTER);
                Ring0.WriteIoPort(_port + DATA_REGISTER_OFFSET, bank);
                Ring0.WriteIoPort(_port + ADDRESS_REGISTER_OFFSET, register);
                return Ring0.ReadIoPort(_port + DATA_REGISTER_OFFSET);
            }

            byte page = (byte)(address >> 8);
            byte index = (byte)(address & 0xFF);
            Ring0.WriteIoPort(_port + EC_SPACE_PAGE_REGISTER_OFFSET, EC_SPACE_PAGE_SELECT);
            Ring0.WriteIoPort(_port + EC_SPACE_PAGE_REGISTER_OFFSET, page);
            Ring0.WriteIoPort(_port + EC_SPACE_INDEX_REGISTER_OFFSET, index);
            return Ring0.ReadIoPort(_port + EC_SPACE_DATA_REGISTER_OFFSET);
        }

        private void WriteByte(ushort address, byte value)
        {
            if (Chip is not Chip.NCT6687D and not Chip.NCT6683D)
            {
                byte bank = (byte)(address >> 8);
                byte register = (byte)(address & 0xFF);
                Ring0.WriteIoPort(_port + ADDRESS_REGISTER_OFFSET, BANK_SELECT_REGISTER);
                Ring0.WriteIoPort(_port + DATA_REGISTER_OFFSET, bank);
                Ring0.WriteIoPort(_port + ADDRESS_REGISTER_OFFSET, register);
                Ring0.WriteIoPort(_port + DATA_REGISTER_OFFSET, value);
            }
            else
            {
                byte page = (byte)(address >> 8);
                byte index = (byte)(address & 0xFF);
                Ring0.WriteIoPort(_port + EC_SPACE_PAGE_REGISTER_OFFSET, EC_SPACE_PAGE_SELECT);
                Ring0.WriteIoPort(_port + EC_SPACE_PAGE_REGISTER_OFFSET, page);
                Ring0.WriteIoPort(_port + EC_SPACE_INDEX_REGISTER_OFFSET, index);
                Ring0.WriteIoPort(_port + EC_SPACE_DATA_REGISTER_OFFSET, value);
            }
        }

        private bool IsNuvotonVendor()
        {
            return Chip == Chip.NCT6687D || Chip == Chip.NCT6683D || ((ReadByte(VENDOR_ID_HIGH_REGISTER) << 8) | ReadByte(VENDOR_ID_LOW_REGISTER)) == NUVOTON_VENDOR_ID;
        }

        private void SaveDefaultFanControl(int index)
        {
            if (!_restoreDefaultFanControlRequired[index])
            {
                if (Chip is not Chip.NCT6687D and not Chip.NCT6683D)
                {
                    _initialFanControlMode[index] = ReadByte(FAN_CONTROL_MODE_REG[index]);
                }
                else
                {
                    byte mode = ReadByte(FAN_CONTROL_MODE_REG[index]);
                    byte bitMask = (byte)(0x01 << index);
                    _initialFanControlMode[index] = (byte)(mode & bitMask);
                }

                _initialFanPwmCommand[index] = ReadByte(FAN_PWM_COMMAND_REG[index]);
                _restoreDefaultFanControlRequired[index] = true;
            }
        }

        private void RestoreDefaultFanControl(int index)
        {
            if (_restoreDefaultFanControlRequired[index])
            {
                if (Chip is not Chip.NCT6687D and not Chip.NCT6683D)
                {
                    WriteByte(FAN_CONTROL_MODE_REG[index], _initialFanControlMode[index]);
                    WriteByte(FAN_PWM_COMMAND_REG[index], _initialFanPwmCommand[index]);
                }
                else
                {
                    byte mode = ReadByte(FAN_CONTROL_MODE_REG[index]);
                    mode = (byte)(mode & ~_initialFanControlMode[index]);
                    WriteByte(FAN_CONTROL_MODE_REG[index], mode);

                    WriteByte(FAN_PWM_REQUEST_REG[index], 0x80);
                    Thread.Sleep(50);

                    WriteByte(FAN_PWM_COMMAND_REG[index], _initialFanPwmCommand[index]);
                    WriteByte(FAN_PWM_REQUEST_REG[index], 0x40);
                    Thread.Sleep(50);
                }

                _restoreDefaultFanControlRequired[index] = false;
            }
        }

        private void DisableIOSpaceLock()
        {
            if (Chip is not Chip.NCT6791D and
                not Chip.NCT6792D and
                not Chip.NCT6792DA and
                not Chip.NCT6793D and
                not Chip.NCT6795D and
                not Chip.NCT6796D and
                not Chip.NCT6796DR and
                not Chip.NCT6797D and
                not Chip.NCT6798D)
            {
                return;
            }

            // the lock is disabled already if the vendor ID can be read
            if (IsNuvotonVendor())
                return;

            _lpcPort.WinbondNuvotonFintekEnter();
            _lpcPort.NuvotonDisableIOSpaceLock();
            _lpcPort.WinbondNuvotonFintekExit();
        }

        [SuppressMessage("ReSharper", "InconsistentNaming")]
        private enum SourceNct6771F : byte
        {
            SYSTIN = 1,
            CPUTIN = 2,
            AUXTIN = 3,
            PECI_0 = 5
        }

        [SuppressMessage("ReSharper", "InconsistentNaming")]
        private enum SourceNct6776F : byte
        {
            SYSTIN = 1,
            CPUTIN = 2,
            AUXTIN = 3,
            PECI_0 = 12
        }

        [SuppressMessage("ReSharper", "InconsistentNaming")]
        private enum SourceNct67Xxd : byte
        {
            SYSTIN = 1,
            CPUTIN = 2,
            AUXTIN0 = 3,
            AUXTIN1 = 4,
            AUXTIN2 = 5,
            AUXTIN3 = 6,
            AUXTIN4 = 7,
            SMBUSMASTER0 = 8,
            SMBUSMASTER1 = 9,
            PECI_0 = 16,
            PECI_1 = 17,
            PCH_CHIP_CPU_MAX_TEMP = 18,
            PCH_CHIP_TEMP = 19,
            PCH_CPU_TEMP = 20,
            PCH_MCH_TEMP = 21,
            AGENT0_DIMM0 = 22,
            AGENT0_DIMM1 = 23,
            AGENT1_DIMM0 = 24,
            AGENT1_DIMM1 = 25,
            BYTE_TEMP0 = 26,
            BYTE_TEMP1 = 27,
            PECI_0_CAL = 28,
            PECI_1_CAL = 29,
            VIRTUAL_TEMP = 31
        }

        [SuppressMessage("ReSharper", "InconsistentNaming")]
        private enum SourceNct610X : byte
        {
            SYSTIN = 1,
            CPUTIN = 2,
            AUXTIN = 3,
            PECI_0 = 12
        }

        // ReSharper disable InconsistentNaming
        private const uint ADDRESS_REGISTER_OFFSET = 0x05;
        private const byte BANK_SELECT_REGISTER = 0x4E;
        private const uint DATA_REGISTER_OFFSET = 0x06;

        // NCT668X
        private const uint EC_SPACE_PAGE_REGISTER_OFFSET = 0x04;
        private const uint EC_SPACE_INDEX_REGISTER_OFFSET = 0x05;
        private const uint EC_SPACE_DATA_REGISTER_OFFSET = 0x06;
        private const byte EC_SPACE_PAGE_SELECT = 0xFF;

        private const ushort NUVOTON_VENDOR_ID = 0x5CA3;

        private readonly ushort[] FAN_CONTROL_MODE_REG;
        private readonly ushort[] FAN_PWM_COMMAND_REG;
        private readonly ushort[] FAN_PWM_OUT_REG;
        private readonly ushort[] FAN_PWM_REQUEST_REG;

        private readonly ushort VENDOR_ID_HIGH_REGISTER;
        private readonly ushort VENDOR_ID_LOW_REGISTER;

        // ReSharper restore InconsistentNaming
    }
}