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_watts"`
	FanSpeed    float64 `json:"fan_speed"`
}

// ═══════════════════════════════════════════════
//  样式 (全部使用 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
	}

	// ── 顶栏 ──
	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))

	// ── 列宽计算 ──
	gap := 2
	var leftW, rightW int
	if tw >= 100 {
		leftW = (tw - gap) / 2
		rightW = tw - gap - leftW
	} else {
		leftW = tw
		rightW = tw
		gap = 0
	}
	innerL := leftW - 4
	innerR := rightW - 4

	// ── 左列: CPU + History ──
	cpuBox := m.viewCPUBox(innerL)
	histBox := m.viewHistBox(innerL)
	leftCol := lipgloss.JoinVertical(lipgloss.Left, cpuBox, "", histBox)

	// ── 右列: Memory + GPU ──
	memBox := m.viewMemBox(innerR)
	gpuBox := m.viewGPUBox(innerR)
	rightCol := lipgloss.JoinVertical(lipgloss.Left, memBox, "", gpuBox)

	// ── 合并列 ──
	var mainContent string
	if gap > 0 {
		mainContent = lipgloss.JoinHorizontal(lipgloss.Top,
			leftCol, strings.Repeat(" ", gap), rightCol,
		)
	} else {
		mainContent = lipgloss.JoinVertical(lipgloss.Left, leftCol, "", rightCol)
	}

	// ── 底栏 ──
	footer := stDim.Render(" q 退出 · r 重新配置 · 连接: " + m.cfg.Server)

	full := lipgloss.JoinVertical(lipgloss.Left,
		header, sep, "", mainContent, "", sep, footer,
	)
	return full
}

// ── CPU 盒子 ──

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

	// 标题
	modelName := c.Model
	maxNameW := innerW - 10
	if len(modelName) > maxNameW && maxNameW > 3 {
		modelName = modelName[:maxNameW-1] + "…"
	}
	titleLine := stTitle.Render("CPU") + "  " + stFg.Render(modelName)

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

	// 信息行
	coresStr := fmt.Sprintf("%dC/%dT", c.CoresPhysical, c.CoresLogical)
	freqStr := fmt.Sprintf("%.0f MHz", c.FreqMHz)
	tempStr := tempText(c.Temperature)
	infoLine := lipgloss.JoinHorizontal(lipgloss.Left,
		stLabel.Render("核心 "), stVal.Render(coresStr),
		"   ",
		stLabel.Render("频率 "), stVal.Render(freqStr),
		"   ",
		stLabel.Render("温度 "), tempStyle(c.Temperature).Render(tempStr),
	)

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

	body := lipgloss.JoinVertical(lipgloss.Left,
		titleLine, "", barLine, infoLine, "", 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

	titleLine := stTitle.Render("MEMORY")

	// 百分比
	pctStr := 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, " ", pctStr)

	// 详情
	usedGB := fmtBytes(m.mem.UsedBytes)
	totalGB := fmtBytes(m.mem.TotalBytes)
	detailLine := lipgloss.JoinHorizontal(lipgloss.Left,
		stLabel.Render("已用 "), stVal.Render(usedGB),
		"     ",
		stLabel.Render("总计 "), stVal.Render(totalGB),
	)

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

// ── GPU 盒子 ──

func (m model) viewGPUBox(innerW int) string {
	titleLine := stTitle.Render("GPU")

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

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

	for i, g := range m.gpus {
		if i > 0 {
			blocks = append(blocks, stDim.Render("  "+strings.Repeat("·", innerW-4)))
		}
		blocks = append(blocks, m.viewSingleGPU(g, innerW))
	}

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

func (m model) viewSingleGPU(g GPUInfo, w int) string {
	// 名称
	nm := g.Name
	if len(nm) > w-2 && w > 5 {
		nm = nm[:w-5] + "…"
	}
	nameLine := stBold.Render("  " + nm)

	// 统计行
	loadC := pctStyle(g.LoadPercent)
	tmpC := tempStyle(&g.Temperature)
	statsLine := lipgloss.JoinHorizontal(lipgloss.Left,
		stLabel.Render("  负载 "), loadC.Render(fmt.Sprintf("%.0f%%", g.LoadPercent)),
		"  ",
		stLabel.Render("温度 "), tmpC.Render(fmt.Sprintf("%.0f°C", g.Temperature)),
		"  ",
		stLabel.Render("功耗 "), stVal.Render(fmt.Sprintf("%.0fW", g.Power)),
	)

	// 频率行
	clockLine := lipgloss.JoinHorizontal(lipgloss.Left,
		stLabel.Render("  核心 "), stVal.Render(fmt.Sprintf("%.0f MHz", g.CoreClock)),
		"  ",
		stLabel.Render("显存 "), stVal.Render(fmt.Sprintf("%.0f MHz", g.MemClock)),
	)

	// VRAM
	vramLine := ""
	if g.VRAMTotalMB > 0 {
		vpct := g.VRAMUsedMB / g.VRAMTotalMB * 100
		barW := w - 20
		if barW < 6 {
			barW = 6
		}
		vbar := renderBar(vpct, barW)
		usedGB := fmt.Sprintf("%.1f", g.VRAMUsedMB/1024)
		totalGB := fmt.Sprintf("%.1f", g.VRAMTotalMB/1024)
		vramLine = lipgloss.JoinHorizontal(lipgloss.Left,
			stLabel.Render("  显存 "),
			pctStyle(vpct).Render(usedGB),
			stVal.Render("/"+totalGB+" GB "),
			vbar,
		)
	}

	return lipgloss.JoinVertical(lipgloss.Left,
		nameLine, statsLine, clockLine, vramLine,
	)
}

// ── 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: // 满了就丢弃
		}
	}
}

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 {
	if runtime.GOOS != "windows" {
		return nil
	}
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	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
}

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 {
	if runtime.GOOS != "windows" {
		return BoardInfo{}
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	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
}

func collectGPUs() []GPUInfo {
	if runtime.GOOS == "windows" {
		gpus := tryNvidiaSMI()
		if len(gpus) > 0 {
			return gpus
		}
		return tryWMIGPU()
	}
	return tryNvidiaSMI()
}

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,memory.total,memory.used,memory.free,temperature.gpu,utilization.gpu,clocks.current.graphics,clocks.current.memory,power.draw,fan.speed",
		"--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) < 11 {
			continue
		}
		for i := range parts {
			parts[i] = strings.TrimSpace(parts[i])
		}
		fan := parseFloat(parts[10])
		if parts[10] == "[N/A]" || parts[10] == "N/A" || strings.Contains(parts[10], "[") {
			fan = 0
		}
		gpus = append(gpus, GPUInfo{
			Name:        parts[1],
			VRAMTotalMB: parseFloat(parts[2]),
			VRAMUsedMB:  parseFloat(parts[3]),
			Temperature: parseFloat(parts[5]),
			LoadPercent: parseFloat(parts[6]),
			CoreClock:   parseFloat(parts[7]),
			MemClock:    parseFloat(parts[8]),
			Power:       parseFloat(parts[9]),
			FanSpeed:    fan,
		})
	}
	return gpus
}

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 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)
	}
}