package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"math"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"time"

	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	"github.com/gorilla/websocket"
	"github.com/shirou/gopsutil/v3/cpu"
	"github.com/shirou/gopsutil/v3/mem"
	"gopkg.in/yaml.v3"
)

var (
	Version   = "dev"
	BuildTime = "unknown"
)

// ═══════════════════════════════════════════════
//  Config (YAML 持久化)
// ═══════════════════════════════════════════════

type ClientConfig struct {
	MachineName     string `yaml:"machine_name"`
	Server          string `yaml:"server"`
	Interval        int    `yaml:"interval"`
	ReconnectDelay  int    `yaml:"reconnect_delay"`
}

func defaultConfig() ClientConfig {
	return ClientConfig{
		Interval:       3,
		ReconnectDelay: 3,
	}
}

func configPath() string {
	// 优先: 当前工作目录
	if wd, err := os.Getwd(); err == nil {
		p := filepath.Join(wd, "client.yaml")
		if _, err := os.Stat(p); err == nil {
			return p
		}
	}
	// 其次: 可执行文件目录
	if exe, err := os.Executable(); err == nil {
		return filepath.Join(filepath.Dir(exe), "client.yaml")
	}
	return "client.yaml"
}

func loadConfig() (ClientConfig, bool) {
	p := configPath()
	raw, err := os.ReadFile(p)
	if err != nil {
		return defaultConfig(), false
	}
	cfg := defaultConfig()
	if yaml.Unmarshal(raw, &cfg) != nil {
		return defaultConfig(), false
	}
	cfg.MachineName = strings.TrimSpace(cfg.MachineName)
	cfg.Server = strings.TrimSpace(cfg.Server)
	if cfg.MachineName == "" || cfg.Server == "" {
		return defaultConfig(), false
	}
	if cfg.Interval <= 0 {
		cfg.Interval = 3
	}
	if cfg.ReconnectDelay <= 0 {
		cfg.ReconnectDelay = 3
	}
	return cfg, true
}

func saveConfig(c ClientConfig) error {
	out, err := yaml.Marshal(&c)
	if err != nil {
		return err
	}
	hdr := "# Hardware Monitor Client 配置\n"
	hdr += "#\n"
	hdr += "# machine_name    : 设备名称 (默认使用主机名)\n"
	hdr += "# server          : 服务端地址 (ip:port)\n"
	hdr += "# interval        : 采集间隔 (秒, 默认 3)\n"
	hdr += "# reconnect_delay : 断线重连间隔 (秒, 默认 3)\n"
	hdr += "#\n"
	hdr += "# 删除此文件可重新配置\n\n"
	p := configPath()
	os.MkdirAll(filepath.Dir(p), 0755)
	return os.WriteFile(p, append([]byte(hdr), out...), 0644)
}

// ═══════════════════════════════════════════════
//  数据结构
// ═══════════════════════════════════════════════

type MachineData struct {
	MachineName string    `json:"machine_name"`
	Motherboard BoardInfo `json:"motherboard"`
	CPU         CPUInfo   `json:"cpu"`
	Memory      MemInfo   `json:"memory"`
	GPUs        []GPUInfo `json:"gpus"`
	Timestamp   time.Time `json:"timestamp"`
}
type BoardInfo struct {
	Manufacturer string `json:"manufacturer"`
	Product      string `json:"product"`
}
type CPUInfo struct {
	Model         string    `json:"model"`
	CoresPhysical int       `json:"cores_physical"`
	CoresLogical  int       `json:"cores_logical"`
	FreqMHz       float64   `json:"freq_current_mhz"`
	Temperature   *float64  `json:"temperature"`
	UsageTotal    float64   `json:"usage_total"`
	UsagePerCore  []float64 `json:"usage_per_core"`
}
type MemInfo struct {
	TotalBytes uint64  `json:"total_bytes"`
	UsedBytes  uint64  `json:"used_bytes"`
	Percent    float64 `json:"percent"`
}
type GPUInfo struct {
	Name           string  `json:"name"`
	VRAMTotalMB    float64 `json:"vram_total_mb"`
	VRAMUsedMB     float64 `json:"vram_used_mb"`
	Temperature    float64 `json:"temperature"`
	LoadPercent    float64 `json:"load_percent"`
	CoreClock      float64 `json:"core_clock_mhz"`
	MemClock       float64 `json:"mem_clock_mhz"`
	Power          float64 `json:"power"`
	PowerLimit     float64 `json:"power_limit"`
	PowerMax       float64 `json:"power_max"`
	FanSpeed       float64 `json:"fan_speed"`
	PState         string  `json:"pstate"`
	ComputeMode    string  `json:"compute_mode"`
	DriverVersion  string  `json:"driver_version"`
	UtilMemory     float64 `json:"util_memory"`
	UtilEncoder    float64 `json:"util_encoder"`
	UtilDecoder    float64 `json:"util_decoder"`
	ClocksMaxGfx   float64 `json:"clocks_max_graphics"`
	ClocksMaxMem   float64 `json:"clocks_max_memory"`
}

// ═══════════════════════════════════════════════
//  样式 (全部使用 lipgloss.Style，非 TerminalColor)
// ═══════════════════════════════════════════════

var (
	sAccent  = lipgloss.Color("#00e5a0")
	sWarn    = lipgloss.Color("#ffb020")
	sDanger  = lipgloss.Color("#ff4060")
	sDim     = lipgloss.Color("#5c6480")
	sFg      = lipgloss.Color("#e4e8f1")
	sBorder  = lipgloss.Color("#333852")
	sDimBar  = lipgloss.Color("#2a2e3e")
	sSurface = lipgloss.Color("#181c2a")

	stTitle = lipgloss.NewStyle().Bold(true).Foreground(sAccent)
	stDim   = lipgloss.NewStyle().Foreground(sDim)
	stFg    = lipgloss.NewStyle().Foreground(sFg)
	stBold  = lipgloss.NewStyle().Bold(true)
	stLabel = lipgloss.NewStyle().Foreground(sDim)
	stVal   = lipgloss.NewStyle().Foreground(sFg)

	stBox = lipgloss.NewStyle().
		Border(lipgloss.RoundedBorder()).
		BorderForeground(sBorder).
		Padding(0, 1)

	stBoxInner = lipgloss.NewStyle().Padding(0, 0)
)

func pctStyle(p float64) lipgloss.Style {
	if p >= 80 {
		return lipgloss.NewStyle().Foreground(sDanger)
	}
	if p >= 60 {
		return lipgloss.NewStyle().Foreground(sWarn)
	}
	return lipgloss.NewStyle().Foreground(sAccent)
}

func tempStyle(t *float64) lipgloss.Style {
	if t == nil || *t <= 0 {
		return stFg
	}
	if *t >= 85 {
		return lipgloss.NewStyle().Foreground(sDanger)
	}
	if *t >= 70 {
		return lipgloss.NewStyle().Foreground(sWarn)
	}
	return stFg
}

// ═══════════════════════════════════════════════
//  Bubbletea 消息
// ═══════════════════════════════════════════════

type tickMsg time.Time
type dataMsg struct{ data MachineData }
type wsStatusMsg struct{ online bool }
type collectorReadyMsg struct{}

// ═══════════════════════════════════════════════
//  Model
// ═══════════════════════════════════════════════

const histLen = 60

var sparkChars = []rune{'▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'}

type model struct {
	// 阶段: 0=输入, 1=监控
	phase int

	// 输入框
	nameIn textinput.Model
	addrIn textinput.Model
	focus  int // 0 or 1
	errMsg string

	// 配置
	cfg     ClientConfig
	cfgPath string

	// 连接状态
	wsOnline bool

	// 通道
	dataCh chan MachineData
	statCh chan bool
	doneCh chan struct{} // 关闭即停止采集

	// 最新数据
	cpu  CPUInfo
	mem  MemInfo
	gpus []GPUInfo

	// 历史
	cpuH  []float64
	memH  []float64
	gpuLH []float64

	// 终端尺寸
	w, h int
}

func newModel(hostname string, cfg ClientConfig, loaded bool) model {
	// 输入框: 设备名
	ni := textinput.New()
	ni.Placeholder = hostname
	ni.Prompt = " ❯ "
	ni.CharLimit = 64
	ni.Width = 38
	ni.SetValue(hostname)

	// 输入框: 服务端地址
	ai := textinput.New()
	ai.Placeholder = "localhost:8080"
	ai.Prompt = " ❯ "
	ai.CharLimit = 128
	ai.Width = 38
	ai.SetValue("localhost:8080")

	p := 0
	if loaded {
		p = 1
		ni.SetValue(cfg.MachineName)
		ai.SetValue(cfg.Server)
	} else {
		ni.Focus()
	}

	m := model{
		phase:   p,
		nameIn:  ni,
		addrIn:  ai,
		cfg:     cfg,
		cfgPath: configPath(),
		dataCh:  make(chan MachineData, 4),
		statCh:  make(chan bool, 2),
		doneCh:  make(chan struct{}),
		cpuH:    make([]float64, 0, histLen),
		memH:    make([]float64, 0, histLen),
		gpuLH:   make([]float64, 0, histLen),
		w:       100,
		h:       30,
	}
	return m
}

// ═══════════════════════════════════════════════
//  Commands
// ═══════════════════════════════════════════════

// listenCmd 阻塞等待 data/stat/timeout，返回对应消息
func (m model) listenCmd() tea.Cmd {
	dc, sc := m.dataCh, m.statCh
	return func() tea.Msg {
		select {
		case d := <-dc:
			return dataMsg{data: d}
		case s := <-sc:
			return wsStatusMsg{online: s}
		case <-time.After(time.Second):
			return tickMsg(time.Now())
		}
	}
}

// startCollectorCmd 启动采集 goroutine
func (m model) startCollectorCmd() tea.Cmd {
	cfg := m.cfg
	dc := m.dataCh
	sc := m.statCh
	done := m.doneCh
	return func() tea.Msg {
		go runCollector(done, cfg, dc, sc)
		return collectorReadyMsg{}
	}
}

// ═══════════════════════════════════════════════
//  Init
// ═══════════════════════════════════════════════

func (m model) Init() tea.Cmd {
	cmds := []tea.Cmd{tea.EnterAltScreen}
	if m.phase == 1 {
		cmds = append(cmds, m.startCollectorCmd(), m.listenCmd())
	} else {
		cmds = append(cmds, textinput.Blink)
	}
	return tea.Batch(cmds...)
}

// ═══════════════════════════════════════════════
//  Update
// ═══════════════════════════════════════════════

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {

	case tea.WindowSizeMsg:
		m.w, m.h = msg.Width, msg.Height
		return m, nil

	case collectorReadyMsg:
		return m, nil

	case tickMsg:
		if m.phase == 1 {
			return m, m.listenCmd()
		}
		return m, nil

	case dataMsg:
		m.cpu = msg.data.CPU
		m.mem = msg.data.Memory
		m.gpus = msg.data.GPUs
		m.pushHistory()
		if m.phase == 1 {
			return m, m.listenCmd()
		}
		return m, nil

	case wsStatusMsg:
		m.wsOnline = msg.online
		if m.phase == 1 {
			return m, m.listenCmd()
		}
		return m, nil

	case tea.KeyMsg:
		return m.handleKey(msg)
	}

	// 非按键消息转发给 textinput (光标闪烁等)
	if m.phase == 0 {
		var cmd tea.Cmd
		if m.focus == 0 {
			m.nameIn, cmd = m.nameIn.Update(msg)
		} else {
			m.addrIn, cmd = m.addrIn.Update(msg)
		}
		return m, cmd
	}
	return m, nil
}

func (m model) handleKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
	if msg.String() == "ctrl+c" {
		return m, tea.Quit
	}

	if m.phase == 0 {
		return m.handleInputKey(msg)
	}
	return m.handleMonitorKey(msg)
}

func (m model) handleInputKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
	switch msg.String() {
	case "enter":
		return m.handleEnter()
	case "tab", "down":
		m.focus = 1
		m.nameIn.Blur()
		m.addrIn.Focus()
		return m, nil
	case "up", "shift+tab":
		m.focus = 0
		m.nameIn.Focus()
		m.addrIn.Blur()
		return m, nil
	}
	// 其余按键转发给当前聚焦的输入框
	var cmd tea.Cmd
	if m.focus == 0 {
		m.nameIn, cmd = m.nameIn.Update(msg)
	} else {
		m.addrIn, cmd = m.addrIn.Update(msg)
	}
	return m, cmd
}

func (m model) handleEnter() (tea.Model, tea.Cmd) {
	name := strings.TrimSpace(m.nameIn.Value())
	addr := strings.TrimSpace(m.addrIn.Value())
	if name == "" {
		m.errMsg = "设备名称不能为空"
		return m, nil
	}
	if addr == "" {
		m.errMsg = "服务端地址不能为空"
		return m, nil
	}
	if !strings.Contains(addr, ":") {
		addr += ":8080"
	}

	cfg := defaultConfig()
	cfg.MachineName = name
	cfg.Server = addr
	m.cfg = cfg
	saveConfig(m.cfg)

	// 切换到监控阶段
	m.phase = 1
	m.errMsg = ""
	m.dataCh = make(chan MachineData, 4)
	m.statCh = make(chan bool, 2)
	m.wsOnline = false

	return m, tea.Batch(m.startCollectorCmd(), m.listenCmd())
}

func (m model) handleMonitorKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
	switch msg.String() {
	case "q":
		return m, tea.Quit
	case "r":
		// 停止采集 goroutine
		close(m.doneCh)
		m.doneCh = make(chan struct{})
		// 回到输入阶段
		m.phase = 0
		m.wsOnline = false
		m.nameIn.SetValue(m.cfg.MachineName)
		m.addrIn.SetValue(m.cfg.Server)
		m.focus = 0
		m.nameIn.Focus()
		m.addrIn.Blur()
		return m, textinput.Blink
	}
	return m, nil
}

// ═══════════════════════════════════════════════
//  历史数据
// ═══════════════════════════════════════════════

func (m *model) pushHistory() {
	m.cpuH = appendHist(m.cpuH, m.cpu.UsageTotal)
	m.memH = appendHist(m.memH, m.mem.Percent)
	if len(m.gpus) > 0 {
		m.gpuLH = appendHist(m.gpuLH, m.gpus[0].LoadPercent)
	}
}

func appendHist(h []float64, v float64) []float64 {
	h = append(h, v)
	if len(h) > histLen {
		h = h[len(h)-histLen:]
	}
	return h
}

// ═══════════════════════════════════════════════
//  View
// ═══════════════════════════════════════════════

func (m model) View() string {
	if m.phase == 0 {
		return m.viewInput()
	}
	return m.viewMonitor()
}

// ── 输入界面 ──

func (m model) viewInput() string {
	title := stTitle.Render("  HARDWARE  MONITOR  CLIENT  ")
	sub := stDim.Render("输入设备信息以连接服务端")
	div := stDim.Render(strings.Repeat("─", 46))

	content := lipgloss.JoinVertical(lipgloss.Left,
		title, sub, div, "",
		stLabel.Render("  设备名称"),
		m.nameIn.View(), "",
		stLabel.Render("  服务端地址"),
		m.addrIn.View(),
	)

	if m.errMsg != "" {
		content += "\n" + lipgloss.NewStyle().Foreground(sDanger).Render("  ✗ "+m.errMsg)
	}
	content += "\n" + stDim.Render("  Tab 切换 · Enter 确认 · Ctrl+C 退出")

	box := stBox.Render(content)
	return lipgloss.Place(m.w, m.h, lipgloss.Center, lipgloss.Center, box)
}

// ── 监控主界面 ──

func (m model) viewMonitor() string {
	tw := m.w
	if tw < 60 {
		tw = 60
	}
	gap := 2
	halfW := (tw - gap) / 2

	// ── 顶栏 ──
	wsDot := "○"
	wsTxt := "未连接"
	wsC := lipgloss.NewStyle().Foreground(sDanger)
	if m.wsOnline {
		wsDot = "●"
		wsTxt = "已连接"
		wsC = lipgloss.NewStyle().Foreground(sAccent)
	}
	header := lipgloss.JoinHorizontal(lipgloss.Left,
		stTitle.Render(" SYSTEM MONITOR "),
		"  ",
		wsC.Render(wsDot+" "+wsTxt),
		stDim.Render("  │  "+m.cfg.MachineName+"  │  "),
		stDim.Render(time.Now().Format("15:04:05")),
	)
	sep := stDim.Render(strings.Repeat("─", tw))

	// ── 第一行: CPU + Memory ──
	cpuBox := m.viewCPUBox(halfW - 4)
	memBox := m.viewMemBox(halfW - 4)
	row1 := lipgloss.JoinHorizontal(lipgloss.Top,
		cpuBox, strings.Repeat(" ", gap), memBox,
	)

	// ── 第二行: GPU + History ──
	gpuBox := m.viewGPUBox(halfW - 4)
	histBox := m.viewHistBox(halfW - 4)
	row2 := lipgloss.JoinHorizontal(lipgloss.Top,
		gpuBox, strings.Repeat(" ", gap), histBox,
	)

	full := lipgloss.JoinVertical(lipgloss.Left,
		header, sep, "",
		row1, "",
		row2, "",
		sep,
		stDim.Render(" q 退出 · r 重新配置 · 连接: "+m.cfg.Server),
	)

	lines := strings.Split(full, "\n")
	if len(lines) > m.h {
		lines = lines[:m.h]
	}
	return strings.Join(lines, "\n")
}

// ── CPU 盒子 ──

func (m model) viewCPUBox(innerW int) string {
	c := m.cpu
	pct := c.UsageTotal

	modelName := c.Model
	maxNameW := innerW - 8
	if len(modelName) > maxNameW && maxNameW > 3 {
		modelName = modelName[:maxNameW-1] + "…"
	}

	// 标题 + 核心/频率/温度 一行
	coresStr := fmt.Sprintf("%dC/%dT", c.CoresPhysical, c.CoresLogical)
	freqStr := fmt.Sprintf("%.0fMHz", c.FreqMHz)
	tempStr := tempText(c.Temperature)
	titleLine := lipgloss.JoinHorizontal(lipgloss.Left,
		stTitle.Render("CPU"),
		" ", stFg.Render(modelName),
		"  ", stLabel.Render(coresStr),
		" ", stVal.Render(freqStr),
		" ", tempStyle(c.Temperature).Render(tempStr),
	)

	// 进度条 + 百分比 一行
	barW := innerW - 8
	if barW < 10 {
		barW = 10
	}
	bar := renderBar(pct, barW)
	pctStr := pctStyle(pct).Bold(true).Render(fmt.Sprintf("%.1f%%", pct))
	barLine := lipgloss.JoinHorizontal(lipgloss.Center, bar, " ", pctStr)

	// 核心热力图
	coreLine := m.viewCoreHeatmap(innerW)

	body := lipgloss.JoinVertical(lipgloss.Left,
		titleLine, barLine, coreLine,
	)
	return stBox.Width(innerW + 4).Render(body)
}

func (m model) viewCoreHeatmap(innerW int) string {
	cores := m.cpu.UsagePerCore
	if len(cores) == 0 {
		return stDim.Render("  核心占用  (无数据)")
	}
	lbl := stDim.Render("  核心 ")
	graphW := innerW - lipgloss.Width(lbl)
	if graphW < 1 {
		graphW = 1
	}

	var sb strings.Builder
	sb.WriteString(lbl)
	for i, p := range cores {
		if i >= graphW {
			break
		}
		idx := int(p / 100 * float64(len(sparkChars)-1))
		idx = clamp(idx, 0, len(sparkChars)-1)
		sb.WriteString(pctStyle(p).Render(string(sparkChars[idx])))
	}
	// 补点
	if len(cores) < graphW {
		dim := lipgloss.NewStyle().Foreground(sDimBar)
		sb.WriteString(dim.Render(strings.Repeat("·", graphW-len(cores))))
	}
	return sb.String()
}

// ── Memory 盒子 ──

func (m model) viewMemBox(innerW int) string {
	pct := m.mem.Percent

	usedGB := fmtBytes(m.mem.UsedBytes)
	totalGB := fmtBytes(m.mem.TotalBytes)

	// 标题 + 详情 一行
	titleLine := lipgloss.JoinHorizontal(lipgloss.Left,
		stTitle.Render("MEMORY"),
		"  ", stLabel.Render("已用 "), stVal.Render(usedGB),
		" / ", stVal.Render(totalGB),
		"  ", pctStyle(pct).Bold(true).Render(fmt.Sprintf("%.1f%%", pct)),
	)

	// 进度条
	barW := innerW - 8
	if barW < 10 {
		barW = 10
	}
	bar := renderBar(pct, barW)
	barLine := lipgloss.JoinHorizontal(lipgloss.Center, bar)

	body := lipgloss.JoinVertical(lipgloss.Left,
		titleLine, barLine,
	)
	return stBox.Width(innerW + 4).Render(body)
}

// ── GPU 盒子 ──

func (m model) viewGPUBox(innerW int) string {
	titleLine := stTitle.Render("GPU") + stDim.Render(fmt.Sprintf("  (%d张)", len(m.gpus)))

	if len(m.gpus) == 0 {
		body := lipgloss.JoinVertical(lipgloss.Left,
			titleLine, "", stDim.Render("  未检测到 GPU"),
		)
		return stBox.Width(innerW + 4).Render(body)
	}

	// 总功耗汇总
	totalP := 0.0
	totalFan := 0.0
	fanCnt := 0
	for _, g := range m.gpus {
		totalP += g.Power
		if g.FanSpeed > 0 {
			totalFan += g.FanSpeed
			fanCnt++
		}
	}
	avgFan := 0.0
	if fanCnt > 0 {
		avgFan = totalFan / float64(fanCnt)
	}
	summary := stDim.Render("  ") + stVal.Render(fmt.Sprintf("总功耗: %.0fW", totalP)) +
		stDim.Render("  │  ") + stVal.Render(fmt.Sprintf("均温: %.0f°C", m.avgTemp())) +
		stDim.Render("  │  ") + stVal.Render(fmt.Sprintf("风扇: %.0f%%", avgFan))

	var blocks []string
	blocks = append(blocks, titleLine, summary, "")

	// 表头
	hdr := lipgloss.JoinHorizontal(lipgloss.Left,
		stDim.Render(fmt.Sprintf("  %-4s", "#")),
		stDim.Render(fmt.Sprintf("%-6s", "Temp")),
		stDim.Render(fmt.Sprintf("%-6s", "Load")),
		stDim.Render(fmt.Sprintf("%-8s", "Power")),
		stDim.Render(fmt.Sprintf("%-10s", "Clock")),
		stDim.Render(fmt.Sprintf("%-10s", "MemClk")),
		stDim.Render(fmt.Sprintf("%-10s", "VRAM")),
		stDim.Render(fmt.Sprintf("%-5s", "Fan")),
	)
	blocks = append(blocks, hdr, stDim.Render("  "+strings.Repeat("─", innerW-4)))

	for i, g := range m.gpus {
		tmpC := tempStyle(&g.Temperature)
		loadC := pctStyle(g.LoadPercent)

		vramStr := "—"
		if g.VRAMTotalMB > 0 {
			vramStr = fmt.Sprintf("%.0f/%.0fM", g.VRAMUsedMB, g.VRAMTotalMB)
		}

		fanStr := "—"
		if g.FanSpeed > 0 {
			fanStr = fmt.Sprintf("%.0f%%", g.FanSpeed)
		}

		line := lipgloss.JoinHorizontal(lipgloss.Left,
			stVal.Render(fmt.Sprintf("  %-4d", i)),
			tmpC.Render(fmt.Sprintf("%-6.0f°C", g.Temperature)),
			loadC.Render(fmt.Sprintf("%-6.0f%%", g.LoadPercent)),
			stVal.Render(fmt.Sprintf("%-8.0fW", g.Power)),
			stVal.Render(fmt.Sprintf("%-10.0f", g.CoreClock)),
			stVal.Render(fmt.Sprintf("%-10.0f", g.MemClock)),
			stVal.Render(fmt.Sprintf("%-10s", vramStr)),
			stVal.Render(fmt.Sprintf("%-5s", fanStr)),
		)
		blocks = append(blocks, line)
	}

	// 总功耗
	totalP = 0.0
	for _, g := range m.gpus {
		totalP += g.Power
	}
	blocks = append(blocks, stDim.Render("  ")+stVal.Render(fmt.Sprintf("总功耗: %.0fW", totalP)), "")

	body := lipgloss.JoinVertical(lipgloss.Left, blocks...)
	return stBox.Width(innerW + 4).Render(body)
}

func (m model) avgTemp() float64 {
	if len(m.gpus) == 0 {
		return 0
	}
	total := 0.0
	for _, g := range m.gpus {
		total += g.Temperature
	}
	return total / float64(len(m.gpus))
}

// ── History 盒子 ──

func (m model) viewHistBox(innerW int) string {
	titleLine := stTitle.Render("HISTORY") + stDim.Render("  (最近 60 采样)")

	graphW := innerW - 8
	if graphW < 8 {
		graphW = 8
	}

	sparkCPU := renderSparkRow("CPU ", m.cpuH, graphW, lipgloss.NewStyle().Foreground(sAccent))
	sparkMEM := renderSparkRow("MEM ", m.memH, graphW, lipgloss.NewStyle().Foreground(sWarn))
	sparkGPU := renderSparkRow("GPU ", m.gpuLH, graphW, lipgloss.NewStyle().Foreground(sAccent))

	body := lipgloss.JoinVertical(lipgloss.Left,
		titleLine, "", sparkCPU, sparkMEM, sparkGPU,
	)
	return stBox.Width(innerW + 4).Render(body)
}

// ═══════════════════════════════════════════════
//  渲染工具函数
// ═══════════════════════════════════════════════

func renderBar(pct float64, width int) string {
	pct = clampF(pct, 0, 100)
	filled := int(math.Round(float64(width) * pct / 100))
	filled = clamp(filled, 0, width)
	style := pctStyle(pct)
	dimStyle := lipgloss.NewStyle().Foreground(sDimBar)
	return style.Render(strings.Repeat("█", filled)) +
		dimStyle.Render(strings.Repeat("░", width-filled))
}

func renderSparkRow(label string, data []float64, graphW int, style lipgloss.Style) string {
	lbl := stDim.Render("  " + label)
	gw := graphW - 2
	if gw < 4 {
		gw = 4
	}

	dimDot := lipgloss.NewStyle().Foreground(sDimBar)

	if len(data) == 0 {
		return lbl + dimDot.Render(strings.Repeat("·", gw))
	}
	d := data
	if len(d) > gw {
		d = d[len(d)-gw:]
	}

	var sb strings.Builder
	sb.WriteString(lbl)
	pad := gw - len(d)
	if pad > 0 {
		sb.WriteString(dimDot.Render(strings.Repeat("·", pad)))
	}
	for _, v := range d {
		idx := int(v / 100 * float64(len(sparkChars)-1))
		idx = clamp(idx, 0, len(sparkChars)-1)
		sb.WriteString(style.Render(string(sparkChars[idx])))
	}
	return sb.String()
}

func tempText(t *float64) string {
	if t == nil || *t <= 0 {
		return "N/A"
	}
	return fmt.Sprintf("%.1f°C", *t)
}

func fmtBytes(b uint64) string {
	if b == 0 {
		return "0 B"
	}
	units := []string{"B", "KB", "MB", "GB", "TB"}
	f := float64(b)
	for _, u := range units {
		if f < 1024 {
			return fmt.Sprintf("%.1f %s", f, u)
		}
		f /= 1024
	}
	return fmt.Sprintf("%.1f PB", f)
}

func clamp(v, lo, hi int) int {
	if v < lo {
		return lo
	}
	if v > hi {
		return hi
	}
	return v
}

func clampF(v, lo, hi float64) float64 {
	if v < lo {
		return lo
	}
	if v > hi {
		return hi
	}
	return v
}

// ═══════════════════════════════════════════════
//  数据采集 goroutine
// ═══════════════════════════════════════════════

func runCollector(done <-chan struct{}, cfg ClientConfig, dataCh chan<- MachineData, statCh chan<- bool) {
	// 预热
	cpu.Percent(500*time.Millisecond, true)

	interval := time.Duration(cfg.Interval) * time.Second
	if interval < time.Second {
		interval = 3 * time.Second
	}
	reconnect := time.Duration(cfg.ReconnectDelay) * time.Second
	if reconnect < time.Second {
		reconnect = 3 * time.Second
	}

	for {
		select {
		case <-done:
			return
		default:
		}

		wsURL := "ws://" + cfg.Server + "/ws/agent"
		err := collectLoop(done, wsURL, cfg.MachineName, interval, dataCh, statCh)
		if err != nil {
			select {
			case statCh <- false:
			default:
			}
		}

		// 断线重连等待
		select {
		case <-done:
			return
		case <-time.After(reconnect):
		}
	}
}

func collectLoop(done <-chan struct{}, wsURL, name string, interval time.Duration, dataCh chan<- MachineData, statCh chan<- bool) error {
	conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
	if err != nil {
		return err
	}
	defer conn.Close()

	select {
	case statCh <- true:
	default:
	}

	for {
		select {
		case <-done:
			return nil
		default:
		}

		// 采集 CPU 使用率
		perCore, _ := cpu.Percent(interval, true)

		data := collectAll(name, perCore)

		if err := conn.WriteJSON(data); err != nil {
			return err
		}

		select {
		case dataCh <- data:
		default: // 满了就丢弃
		}

		// 每 10 轮触发一次 GC，减少内存占用
		runtime.GC()
	}
}

func collectAll(name string, perCore []float64) MachineData {
	return MachineData{
		MachineName: name,
		Motherboard: collectMotherboard(),
		CPU:         collectCPU(perCore),
		Memory:      collectMemory(),
		GPUs:        collectGPUs(),
		Timestamp:   time.Now(),
	}
}

func collectCPU(perCore []float64) CPUInfo {
	pC, _ := cpu.Counts(false)
	lC, _ := cpu.Counts(true)

	var total float64
	for _, p := range perCore {
		total += p
	}
	if len(perCore) > 0 {
		total /= float64(len(perCore))
	}

	modelName := "Unknown CPU"
	freq := 0.0
	infos, err := cpu.Info()
	if err == nil && len(infos) > 0 {
		modelName = strings.TrimSpace(infos[0].ModelName)
		freq = infos[0].Mhz
	}

	return CPUInfo{
		Model:         modelName,
		CoresPhysical: pC,
		CoresLogical:  lC,
		FreqMHz:       freq,
		Temperature:   getCPUTemp(),
		UsageTotal:    math.Round(total*10) / 10,
		UsagePerCore:  perCore,
	}
}

func getCPUTemp() *float64 {
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	switch runtime.GOOS {
	case "windows":
		out, err := exec.CommandContext(ctx, "powershell", "-NoProfile", "-Command",
			"(Get-CimInstance MSAcpi_ThermalZoneTemperature -Namespace 'root/wmi' -EA SilentlyContinue | Select -First 1).CurrentTemperature",
		).Output()
		if err != nil {
			return nil
		}
		raw := strings.TrimSpace(string(out))
		val, err := strconv.ParseFloat(raw, 64)
		if err != nil || val < 1000 {
			return nil
		}
		c := (val - 2732) / 10.0
		if c < 0 || c > 150 {
			return nil
		}
		return &c
	case "linux":
		out, err := exec.CommandContext(ctx, "cat", "/sys/class/thermal/thermal_zone0/temp").Output()
		if err != nil {
			return nil
		}
		raw := strings.TrimSpace(string(out))
		val, err := strconv.ParseFloat(raw, 64)
		if err != nil {
			return nil
		}
		c := val / 1000.0
		if c < 0 || c > 150 {
			return nil
		}
		return &c
	case "darwin":
		out, err := exec.CommandContext(ctx, "sudo", "powermetrics", "--samplers", "smc", "-i", "1", "-n", "1", "--format", "plist").Output()
		if err != nil {
			return nil
		}
		s := string(out)
		idx := strings.Index(s, "<key>CPU die temperature</key>")
		if idx < 0 {
			return nil
		}
		s = s[idx:]
		idx = strings.Index(s, "<real>")
		if idx < 0 {
			return nil
		}
		s = s[idx+6:]
		end := strings.Index(s, "</real>")
		if end < 0 {
			return nil
		}
		val, err := strconv.ParseFloat(strings.TrimSpace(s[:end]), 64)
		if err != nil {
			return nil
		}
		if val < 0 || val > 150 {
			return nil
		}
		return &val
	}
	return nil
}

func collectMemory() MemInfo {
	vm, err := mem.VirtualMemory()
	if err != nil {
		return MemInfo{}
	}
	return MemInfo{
		TotalBytes: vm.Total,
		UsedBytes:  vm.Used,
		Percent:    math.Round(vm.UsedPercent*10) / 10,
	}
}

func collectMotherboard() BoardInfo {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	switch runtime.GOOS {
	case "windows":
		out, err := exec.CommandContext(ctx, "wmic", "baseboard", "get", "manufacturer,product", "/format:list").Output()
		if err != nil {
			return BoardInfo{}
		}
		var b BoardInfo
		for _, line := range strings.Split(string(out), "\n") {
			line = strings.TrimSpace(line)
			if strings.HasPrefix(line, "Manufacturer=") {
				b.Manufacturer = strings.TrimPrefix(line, "Manufacturer=")
			} else if strings.HasPrefix(line, "Product=") {
				b.Product = strings.TrimPrefix(line, "Product=")
			}
		}
		return b
	case "linux":
		man, _ := os.ReadFile("/sys/class/dmi/id/board_vendor")
		prod, _ := os.ReadFile("/sys/class/dmi/id/board_name")
		return BoardInfo{
			Manufacturer: strings.TrimSpace(string(man)),
			Product:      strings.TrimSpace(string(prod)),
		}
	case "darwin":
		out, err := exec.CommandContext(ctx, "system_profiler", "SPHardwareDataType").Output()
		if err != nil {
			return BoardInfo{}
		}
		var b BoardInfo
		for _, line := range strings.Split(string(out), "\n") {
			line = strings.TrimSpace(line)
			if strings.HasPrefix(line, "Model Name:") {
				b.Product = strings.TrimSpace(strings.TrimPrefix(line, "Model Name:"))
			} else if strings.HasPrefix(line, "Model Identifier:") {
				if b.Manufacturer == "" {
					b.Manufacturer = "Apple"
				}
			}
		}
		if b.Manufacturer == "" {
			b.Manufacturer = "Apple"
		}
		return b
	}
	return BoardInfo{}
}

func collectGPUs() []GPUInfo {
	switch runtime.GOOS {
	case "windows":
		gpus := tryNvidiaSMI()
		if len(gpus) > 0 {
			return gpus
		}
		wmi := tryWMIGPU()
		return filterPCIeGPUs(wmi)
	case "linux":
		gpus := tryNvidiaSMI()
		if len(gpus) > 0 {
			return gpus
		}
		lspci := tryLinuxGPU()
		return filterPCIeGPUs(lspci)
	case "darwin":
		gpus := tryNvidiaSMI()
		mac := tryMacGPU()
		return filterPCIeGPUs(append(gpus, mac...))
	}
	return tryNvidiaSMI()
}

func filterPCIeGPUs(gpus []GPUInfo) []GPUInfo {
	var result []GPUInfo
	for _, g := range gpus {
		if !isVirtualGPU(g.Name) {
			result = append(result, g)
		}
	}
	return result
}

func isVirtualGPU(name string) bool {
	name = strings.ToLower(name)
	blacklist := []string{
		"microsoft", "basic render", "vmware", "virtual", "hyper-v",
		"parallels", "virtualbox", "intel", "remote", "rdp", "citrix",
		"teamviewer", "anydesk", "parsec", "splashtop", "oray",
		"sunlogin", "todesk", "amdgpu-pro",
	}
	for _, v := range blacklist {
		if strings.Contains(name, v) {
			return true
		}
	}
	return false
}

func tryNvidiaSMI() []GPUInfo {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	out, err := exec.CommandContext(ctx, "nvidia-smi",
		"--query-gpu=index,name,uuid,pci.bus_id,driver_version,vbios_version,"+
			"temperature.gpu,temperature.memory,fan.speed,"+
			"power.draw,power.limit,power.default_limit,power.min_limit,power.max_limit,"+
			"clocks.current.graphics,clocks.current.sm,clocks.current.memory,"+
			"clocks.max.graphics,clocks.max.memory,"+
			"utilization.gpu,utilization.memory,utilization.encoder,utilization.decoder,"+
			"memory.total,memory.used,memory.free,"+
			"ecc.errors.corrected.volatile.total,ecc.errors.uncorrected.volatile.total,"+
			"compute_mode,pstate",
		"--format=csv,noheader,nounits",
	).Output()
	if err != nil {
		return nil
	}
	var gpus []GPUInfo
	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
		parts := strings.Split(line, ",")
		if len(parts) < 24 {
			continue
		}
		for i := range parts {
			parts[i] = strings.TrimSpace(parts[i])
			parts[i] = strings.Trim(parts[i], "[]")
		}

		// 0:index 1:name 2:uuid 3:bus_id 4:driver 5:vbios
		// 6:temp_gpu 7:temp_mem 8:fan 9:power 10:power_limit
		// 11:power_default 12:power_min 13:power_max
		// 14:clk_gfx 15:clk_sm 16:clk_mem 17:clk_max_gfx 18:clk_max_mem
		// 19:util_gpu 20:util_mem 21:util_enc 22:util_dec
		// 23:vram_total 24:vram_used 25:vram_free
		// 26:ecc_corr 27:ecc_uncorr 28:compute_mode 29:pstate
		gpus = append(gpus, GPUInfo{
			Name:          cleanStr(parts[1]),
			DriverVersion: cleanStr(parts[4]),
			Temperature:   parseFloat(parts[6]),
			FanSpeed:      parseFloat(parts[8]),
			Power:         parseFloat(parts[9]),
			PowerLimit:    parseFloat(parts[10]),
			PowerMax:      parseFloat(parts[13]),
			CoreClock:     parseFloat(parts[14]),
			MemClock:      parseFloat(parts[16]),
			ClocksMaxGfx:  parseFloat(parts[17]),
			ClocksMaxMem:  parseFloat(parts[18]),
			LoadPercent:   parseFloat(parts[19]),
			UtilMemory:    parseFloat(parts[20]),
			UtilEncoder:   parseFloat(parts[21]),
			UtilDecoder:   parseFloat(parts[22]),
			VRAMTotalMB:   parseFloat(parts[23]),
			VRAMUsedMB:    parseFloat(parts[24]),
			ComputeMode:   cleanStr(parts[28]),
			PState:        cleanStr(parts[29]),
		})
	}
	return gpus
}

func parseFloatSafe(s string) float64 {
	s = strings.Trim(s, "[] ")
	s = strings.TrimSuffix(s, "W")
	s = strings.TrimSpace(s)
	if s == "N/A" || s == "" {
		return 0
	}
	return parseFloat(s)
}

func cleanStr(s string) string {
	s = strings.Trim(s, "[] ")
	if s == "N/A" || s == "[N/A]" {
		return ""
	}
	return s
}

func tryWMIGPU() []GPUInfo {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	out, err := exec.CommandContext(ctx, "powershell", "-NoProfile", "-Command",
		"Get-CimInstance Win32_VideoController | Select Name,AdapterRAM | ConvertTo-Json -Compress",
	).Output()
	if err != nil {
		return nil
	}
	type wg struct {
		Name       string `json:"Name"`
		AdapterRAM int64  `json:"AdapterRAM"`
	}
	s := strings.TrimSpace(string(out))
	if !strings.HasPrefix(s, "[") {
		s = "[" + s + "]"
	}
	var items []wg
	if json.Unmarshal([]byte(s), &items) != nil {
		return nil
	}
	var gpus []GPUInfo
	for _, item := range items {
		var ram float64
		if item.AdapterRAM > 0 {
			ram = float64(item.AdapterRAM) / (1024 * 1024)
		}
		gpus = append(gpus, GPUInfo{Name: item.Name, VRAMTotalMB: ram})
	}
	return gpus
}

func tryLinuxGPU() []GPUInfo {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	out, err := exec.CommandContext(ctx, "lspci", "-vnn").Output()
	if err != nil {
		return nil
	}
	var gpus []GPUInfo
	lines := strings.Split(string(out), "\n")
	for i, line := range lines {
		if strings.Contains(line, "VGA") || strings.Contains(line, "3D") || strings.Contains(line, "Display") {
			name := line
			if idx := strings.Index(name, ": "); idx >= 0 {
				name = name[idx+2:]
			}
			if idx := strings.Index(name, " ["); idx >= 0 {
				name = name[:idx]
			}
			name = strings.TrimSpace(name)
			var vram float64
			for j := i + 1; j < len(lines) && j < i+10; j++ {
				if strings.Contains(lines[j], "prefetchable") && strings.Contains(lines[j], "Memory") {
					if idx := strings.Index(lines[j], "size="); idx >= 0 {
						sz := lines[j][idx+5:]
						if end := strings.Index(sz, "M"); end > 0 {
							vram, _ = strconv.ParseFloat(sz[:end], 64)
						} else if end := strings.Index(sz, "G"); end > 0 {
							v, _ := strconv.ParseFloat(sz[:end], 64)
							vram = v * 1024
						}
					}
				}
			}
			gpus = append(gpus, GPUInfo{Name: name, VRAMTotalMB: vram})
		}
	}
	return gpus
}

func tryMacGPU() []GPUInfo {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	out, err := exec.CommandContext(ctx, "system_profiler", "SPDisplaysDataType", "-json").Output()
	if err != nil {
		return nil
	}
	var data struct {
		SPDisplaysDataType []struct {
			sppci_model            string `json:"_name"`
			sppci_memory           string `json:"sppci_memory"`
			SPDisplaysVendorID     string `json:"spdisplays_vendor-id"`
		} `json:"SPDisplaysDataType"`
	}
	if json.Unmarshal(out, &data) != nil {
		return nil
	}
	var gpus []GPUInfo
	for _, d := range data.SPDisplaysDataType {
		g := GPUInfo{Name: d.sppci_model}
		if vram, err := strconv.ParseFloat(d.sppci_memory, 64); err == nil {
			g.VRAMTotalMB = vram / (1024 * 1024)
			if g.VRAMTotalMB > 1024*10 {
				g.VRAMTotalMB = vram / (1024 * 1024)
			}
		}
		gpus = append(gpus, g)
	}
	return gpus
}

func parseFloat(s string) float64 {
	v, _ := strconv.ParseFloat(strings.TrimSpace(s), 64)
	return v
}

// ═══════════════════════════════════════════════
//  main
// ═══════════════════════════════════════════════

func main() {
	runtime.GOMAXPROCS(4)

	showVersion := flag.Bool("version", false, "显示版本信息")
	flag.Parse()

	if *showVersion {
		fmt.Printf("Hardware Monitor Client %s\n", Version)
		fmt.Printf("Build: %s / %s\n", BuildTime, runtime.GOOS+"/"+runtime.GOARCH)
		return
	}

	hostname, _ := os.Hostname()
	cfg, loaded := loadConfig()

	if loaded {
		fmt.Printf("  [✓] 配置文件: %s\n", configPath())
		fmt.Printf("  [✓] 设备名称: %s\n", cfg.MachineName)
		fmt.Printf("  [✓] 服务端  : %s\n", cfg.Server)
		fmt.Printf("  [✓] 采集间隔: %ds\n", cfg.Interval)
		fmt.Println()
	}

	m := newModel(hostname, cfg, loaded)
	p := tea.NewProgram(m, tea.WithAltScreen())
	if _, err := p.Run(); err != nil {
		fmt.Fprintf(os.Stderr, "错误: %v\n", err)
		os.Exit(1)
	}
}