using System.Collections.Concurrent;
using System.Diagnostics;
using System.Threading.Channels;
using LibreHardwareMonitor.Hardware;

namespace ThingHK;

/// <summary>
/// 硬件访问层：封装 LibreHardwareMonitor Computer，
/// 负责硬件发现、分层 Update（快/慢通道）、快照构建。
///
/// 设计要点：
/// - Computer 非 IDisposable（LHB 0.9.5），用 Close() 显式释放
/// - 传感器按 SensorType 分快/慢通道：
///   * 快通道（temp/load/clock/power/voltage/throughput）：高频，1s
///   * 慢通道（data/smalldata/factor/level/control/timing/energy 等）：低频，5s
///   原因：SMART 查询会阻塞，混在一起会拖慢整体；data 类（如内存使用量）变化缓慢
/// - Update 只作用于硬件设备，传感器读取由 visitor 遍历收集（LHB 设计）
/// </summary>
internal sealed class HardwareManager : IDisposable
{
    private readonly Computer _computer;
    private readonly SnapshotVisitor _visitor = new();
    private readonly bool _isAdmin;
    private readonly double _coldStartMs;
    private readonly Stopwatch _startupSw;
    // 传感器 ID 缓存：避免每秒为每个传感器重复拼接字符串（减少 GC 压力）
    private readonly Dictionary<ISensor, string> _sensorIdCache = new();
    private bool _coldStartSent;
    private bool _ready;
    private bool _closed;
    private HardwareConfig _config;

    // 缓存"哪个硬件属于快通道"——按 hardware type 判断更稳定（不同机型传感器命名不一致）
    // 实际分频逻辑见 SamplingScheduler，此处只暴露硬件列表给调度器
    public IReadOnlyList<IHardware> AllHardware => _visitor.AllHardware;

    public bool IsAdmin => _isAdmin;
    public double ColdStartMs => _coldStartMs;
    public bool Ready => _ready;
    public HardwareConfig Config => _config;

    public HardwareManager(HardwareConfig config)
    {
        _config = config ?? HardwareConfig.Default;
        _isAdmin = IsRunningAsAdmin();
        _startupSw = Stopwatch.StartNew();

        // LHB 行为：主板的传感器实际通过 SubHardware（SuperIO/EC）暴露，
        // 而 SuperIO 作为顶层硬件时需 IsControllerEnabled 才能枚举。
        // 联动策略：启用 motherboard 时自动启用 controller，避免主板勾选后无数据。
        bool motherboardEnabled = _config.IsHardwareEnabled("motherboard");
        bool controllerEnabled = _config.IsHardwareEnabled("controller") || motherboardEnabled;

        _computer = new Computer
        {
            IsCpuEnabled = _config.IsHardwareEnabled("cpu"),
            IsGpuEnabled = _config.IsHardwareEnabled("gpu"),
            IsMemoryEnabled = _config.IsHardwareEnabled("memory"),
            IsStorageEnabled = _config.IsHardwareEnabled("storage"),
            IsMotherboardEnabled = motherboardEnabled,
            IsControllerEnabled = controllerEnabled,
            IsBatteryEnabled = _config.IsHardwareEnabled("battery"),
            IsNetworkEnabled = _config.IsHardwareEnabled("network"),
            IsPsuEnabled = _config.IsHardwareEnabled("psu"),
        };

        _computer.Open();

        // 首轮扫描：发现所有硬件（Update 前的 Sensors 通常为空，但 Hardware 列表就绪）
        _computer.Accept(_visitor);

        // 首轮 Update：填充传感器值
        // 注意：部分传感器第二轮才有值，调度器会持续 Update
        UpdateAll();

        _coldStartMs = _startupSw.Elapsed.TotalMilliseconds;
        _startupSw.Stop();
        _ready = true;
    }

    /// <summary>热更新传感器类型过滤（无需重启 Kernel，下次 BuildSnapshot 生效）</summary>
    public void UpdateConfig(HardwareConfig newConfig)
    {
        _config = newConfig;
    }

    /// <summary>
    /// 全量 Update 所有硬件。
    /// 仅用于构造函数首轮填充，运行期由调度器分频调用 UpdateFastOnly/UpdateSlowOnly。
    /// </summary>
    public void UpdateAll()
    {
        foreach (var hw in _visitor.AllHardware)
        {
            try { hw.Update(); } catch { /* 单个硬件 Update 失败不影响整体 */ }
        }
    }

    /// <summary>
    /// 仅 Update 快通道硬件（CPU/GPU/Memory/Network 等）。
    /// 由调度器快通道 tick 高频调用，避免 SMART 等重查询拖慢采样节奏。
    /// </summary>
    public void UpdateFastOnly()
    {
        foreach (var hw in _visitor.AllHardware)
        {
            if (!IsSlowHardware(hw.HardwareType))
            {
                try { hw.Update(); } catch { /* 单个硬件 Update 失败不影响整体 */ }
            }
        }
    }

    /// <summary>
    /// 仅 Update 慢通道硬件（Storage/PSU/Battery 等）。
    /// 快通道硬件（CPU/GPU/Memory/Network）由调度器更高频调用 UpdateFastOnly。
    /// </summary>
    public void UpdateSlowOnly()
    {
        foreach (var hw in _visitor.AllHardware)
        {
            if (IsSlowHardware(hw.HardwareType))
            {
                try { hw.Update(); } catch { /* ignore */ }
            }
        }
    }

    /// <summary>
    /// 构建 SensorSnapshot：遍历当前所有传感器，不触发 Update。
    /// 调用者应先 Update 再 Snapshot，避免读到旧值。
    /// </summary>
    public SensorSnapshot BuildSnapshot()
    {
        var snap = new SensorSnapshot
        {
            SchemaVersion = 1,
            Timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
            IsAdmin = _isAdmin,
            Ready = _ready,
        };

        // 首个快照带上冷启动耗时，后续为 0（修复：此前每个快照都携带 ColdStartMs）
        if (_coldStartMs > 0 && !_coldStartSent)
        {
            snap.ColdStartMs = Math.Round(_coldStartMs, 1);
            _coldStartSent = true;
        }

        // 重新遍历以读取最新传感器值（visitor 缓存的是 hardware 引用，sensor 值实时）
        var groups = new Dictionary<string, SensorGroup>();

        // 为已启用但 LHB 未枚举到的硬件类型预创建空分组，
        // 确保前端能显示"已启用但无数据"的硬件（而不是直接隐藏，让用户误以为配置未生效）
        EnsureGroupsForEnabledHardware(groups, snap);

        foreach (var hw in _visitor.AllHardware)
        {
            string groupId = hw.HardwareType.ToString().ToLowerInvariant();
            string groupName = hw.HardwareType.ToString();
            if (!groups.TryGetValue(groupId, out var g))
            {
                g = new SensorGroup { Id = groupId, Name = groupName };
                groups[groupId] = g;
                snap.Groups.Add(g);
            }

            foreach (var s in hw.Sensors)
            {
                // 按配置过滤传感器类型：关闭的类型不加入快照，减少传输数据量
                string sensorType = s.SensorType.ToString().ToLowerInvariant();
                if (!_config.IsSensorTypeEnabled(sensorType))
                    continue;

                g.Sensors.Add(new SensorEntry
                {
                    Id = GetSensorId(s, groupId, hw.Name),
                    Name = s.Name,
                    Type = sensorType,
                    Value = s.Value,
                    Unit = UnitFor(s.SensorType),
                    HardwareName = hw.Name,
                });
            }
        }

        return snap;
    }

    /// <summary>
    /// 获取传感器稳定 ID（带缓存）。
    /// ID 格式：{groupId}/{hwName}/{sensorType}/{sensorName}，空格转下划线、小写化。
    /// 缓存命中直接返回，未命中（新传感器）计算后入缓存。
    /// </summary>
    private string GetSensorId(ISensor s, string groupId, string hwName)
    {
        if (!_sensorIdCache.TryGetValue(s, out var id))
        {
            id = $"{groupId}/{hwName}/{s.SensorType}/{s.Name}".Replace(' ', '_').ToLowerInvariant();
            _sensorIdCache[s] = id;
        }
        return id;
    }

    /// <summary>
    /// 为已启用但 LHB 未枚举到的硬件类型预创建空分组。
    /// 场景：用户在设置中勾选了主板/电池/电源等，但 LHB 在当前权限或机型下检测不到对应硬件，
    /// 此时仍创建空分组让前端显示"已启用但无数据"，避免用户误以为配置未生效。
    /// GPU 特殊处理：LHB 会枚举到 GpuIntel/GpuAmd/GpuNvidia 之一，不预创建通用分组。
    /// </summary>
    private void EnsureGroupsForEnabledHardware(Dictionary<string, SensorGroup> groups, SensorSnapshot snap)
    {
        // (configKey, groupId, groupName)
        // 注意：controller 对应 SuperIO 和 EmbeddedController 两个 HardwareType
        var mapping = new (string, string, string)[]
        {
            ("cpu", "cpu", "CPU"),
            ("memory", "memory", "Memory"),
            ("storage", "storage", "Storage"),
            ("motherboard", "motherboard", "Motherboard"),
            ("controller", "superio", "SuperIO"),
            ("controller", "embeddedcontroller", "EmbeddedController"),
            ("battery", "battery", "Battery"),
            ("network", "network", "Network"),
            ("psu", "psu", "Psu"),
        };

        foreach (var (key, groupId, groupName) in mapping)
        {
            if (_config.IsHardwareEnabled(key) && !groups.ContainsKey(groupId))
            {
                var g = new SensorGroup { Id = groupId, Name = groupName };
                groups[groupId] = g;
                snap.Groups.Add(g);
            }
        }
    }

    /// <summary>
    /// 判断硬件是否属于慢通道（低频 Update 即可）。
    /// 快通道：CPU/GPU/Memory/Network（变化快、查询轻量）
    /// 慢通道：Storage/PSU/Motherboard/Battery/SuperIO/EmbeddedController（查询重或变化慢）
    /// </summary>
    public static bool IsSlowHardware(HardwareType t) => t switch
    {
        HardwareType.Storage => true,
        HardwareType.Psu => true,
        HardwareType.Motherboard => true,
        HardwareType.Battery => true,
        HardwareType.SuperIO => true,
        HardwareType.EmbeddedController => true,
        _ => false,
    };

    private static string UnitFor(SensorType t) => t switch
    {
        SensorType.Temperature => "°C",
        SensorType.Load => "%",
        SensorType.Power => "W",
        SensorType.Voltage => "V",
        SensorType.Fan => "RPM",
        SensorType.Clock => "MHz",
        SensorType.Data => "GB",
        SensorType.SmallData => "MB",
        SensorType.Frequency => "Hz",
        SensorType.Throughput => "B/s",
        SensorType.Level => "%",
        SensorType.Factor => "",
        SensorType.Control => "%",
        SensorType.Flow => "L/h",
        SensorType.TimeSpan => "s",
        SensorType.Energy => "mWh",
        SensorType.Noise => "dBA",
        SensorType.Conductivity => "µS/cm",
        SensorType.Humidity => "%",
        _ => "",
    };

    private static bool IsRunningAsAdmin()
    {
        try
        {
            using var identity = System.Security.Principal.WindowsIdentity.GetCurrent();
            var principal = new System.Security.Principal.WindowsPrincipal(identity);
            return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);
        }
        catch
        {
            return false;
        }
    }

    public void Dispose()
    {
        if (_closed) return;
        _closed = true;
        try { _computer.Close(); } catch { /* Close 在 AOT 下偶有反射清理异常 */ }
    }
}

/// <summary>
/// 遍历 Computer，收集所有 Hardware（含 SubHardware）。
/// LHB 的 Visit 会递归到 SubHardware。
/// 引用缓存：visitor 持有 hardware 引用，传感器值通过 hardware.Sensors 实时读取。
/// </summary>
internal sealed class SnapshotVisitor : IVisitor
{
    public List<IHardware> AllHardware { get; } = new();

    public void VisitComputer(IComputer computer)
    {
        foreach (var hw in computer.Hardware) hw.Accept(this);
    }

    public void VisitHardware(IHardware hardware)
    {
        AllHardware.Add(hardware);
        foreach (var sub in hardware.SubHardware) sub.Accept(this);
    }

    public void VisitSensor(ISensor sensor) { }
    public void VisitParameter(IParameter parameter) { }
}

/// <summary>
/// 采样调度器：按快/慢通道分频驱动 HardwareManager 的分层 Update。
/// 使用 Channel 向 SSE 推送层广播快照（解耦：调度器不关心有几个订阅者）。
///
/// 调度策略：
/// - 快通道 tick：UpdateFastOnly（仅 CPU/GPU/Memory/Network 等轻量硬件），
///   避免 SMART 等重查询每秒执行拖慢采样节奏
/// - 慢通道 tick：UpdateSlowOnly（仅 Storage/PSU/Motherboard 等）
/// - 快通道每个 tick 结束后构建快照并广播（慢通道更新后的值随下一帧带出）
/// </summary>
internal sealed class SamplingScheduler : IDisposable
{
    private readonly HardwareManager _hw;
    private readonly CancellationTokenSource _cts = new();
    private readonly Channel<SensorSnapshot> _broadcast;
    private readonly SnapshotCache _cache;

    private int _fastIntervalMs = 1000;
    private int _slowIntervalMs = 5000;

    public SnapshotCache Cache => _cache;
    public int FastIntervalMs => _fastIntervalMs;
    public int SlowIntervalMs => _slowIntervalMs;

    public SamplingScheduler(HardwareManager hw, int fastIntervalMs, int slowIntervalMs)
    {
        _hw = hw;
        _fastIntervalMs = Math.Max(200, fastIntervalMs);
        _slowIntervalMs = Math.Max(_fastIntervalMs, slowIntervalMs);
        // unbounded channel：快照丢失风险 < 内存爆涨风险（消费慢时丢弃最旧的）
        // 这里用 bounded + DropOldest：保证 SSE 慢消费者不阻塞调度器
        _broadcast = Channel.CreateBounded<SensorSnapshot>(new BoundedChannelOptions(8)
        {
            FullMode = BoundedChannelFullMode.DropOldest,
            SingleReader = false,
            SingleWriter = true,
        });
        _cache = new SnapshotCache();
    }

    /// <summary>
    /// 启动调度循环。立即推送首个快照（已由 HardwareManager 构造时 Update 过）。
    /// </summary>
    public Task StartAsync()
    {
        // 首个快照（含 ColdStartMs）
        var first = _hw.BuildSnapshot();
        _cache.Update(first);
        _broadcast.Writer.TryWrite(first);

        // 快/慢通道并行循环
        _ = Task.Run(() => FastLoopAsync(_cts.Token));
        _ = Task.Run(() => SlowLoopAsync(_cts.Token));
        return Task.CompletedTask;
    }

    private async Task FastLoopAsync(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromMilliseconds(_fastIntervalMs));
        while (await timer.WaitForNextTickAsync(ct).ConfigureAwait(false))
        {
            try
            {
                _hw.UpdateFastOnly();
                var snap = _hw.BuildSnapshot();
                _cache.Update(snap);
                _broadcast.Writer.TryWrite(snap);
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"[Scheduler] 快通道异常: {ex.Message}");
            }
        }
    }

    private async Task SlowLoopAsync(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromMilliseconds(_slowIntervalMs));
        while (await timer.WaitForNextTickAsync(ct).ConfigureAwait(false))
        {
            try
            {
                // 慢通道单独 Update，避免依赖快通道的 UpdateAll
                // 注：下一次快通道 tick 构建的快照会包含本次慢通道更新后的值
                _hw.UpdateSlowOnly();
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"[Scheduler] 慢通道异常: {ex.Message}");
            }
        }
    }

    /// <summary>
    /// 订阅快照流。每个 SSE 客户端调用一次。
    /// 返回的 IAsyncEnumerable 会在调度器停止或订阅者取消时结束。
    /// </summary>
    public IAsyncEnumerable<SensorSnapshot> SubscribeAsync(CancellationToken ct) =>
        _broadcast.Reader.ReadAllAsync(ct);

    public void UpdateIntervals(int? fastMs, int? slowMs)
    {
        // 注意：PeriodicTimer 已启动后无法修改间隔，下次重启 Kernel 才生效。
        // 阶段二简化处理：记录新值，实际生效需重启。阶段三若需热更新可重建 timer。
        if (fastMs.HasValue && fastMs.Value >= 200) _fastIntervalMs = fastMs.Value;
        if (slowMs.HasValue && slowMs.Value >= _fastIntervalMs) _slowIntervalMs = slowMs.Value;
    }

    public void Dispose()
    {
        _cts.Cancel();
        _broadcast.Writer.TryComplete();
        _cts.Dispose();
    }
}

/// <summary>
/// 快照缓存：存储最新快照，供 GET /snapshot 直接返回，避免触发底层重扫描。
/// 线程安全：读写均加锁，快照对象本身不可变（每次 Update 替换引用）。
/// </summary>
internal sealed class SnapshotCache
{
    private readonly object _lock = new();
    private SensorSnapshot? _latest;
    private int _sensorCount;

    public void Update(SensorSnapshot snap)
    {
        lock (_lock)
        {
            _latest = snap;
            _sensorCount = snap.Groups.Sum(g => g.Sensors.Count);
        }
    }

    public SensorSnapshot? GetLatest()
    {
        lock (_lock)
        {
            return _latest;
        }
    }

    public int SensorCount
    {
        get { lock (_lock) return _sensorCount; }
    }
}