package stress

import (
	"strings"
	"testing"
)

// TestEvalBench 验证基准评估逻辑
func TestEvalBench(t *testing.T) {
	tests := []struct {
		name string
		bench MetricBench
		val   float64
		want  Level
	}{
		// CPU 跑分（越高越好）：4 档
		{"CPU-远低于", benchCPU, 5000, LevelPoor},
		{"CPU-正常", benchCPU, 15000, LevelNormal},
		{"CPU-超过", benchCPU, 30000, LevelGood},
		{"CPU-远超过", benchCPU, 50000, LevelExcellent},
		{"CPU-边界-正常下限", benchCPU, 8000, LevelNormal},
		{"CPU-边界-超过下限", benchCPU, 20000, LevelGood},
		{"CPU-边界-远超过下限", benchCPU, 40000, LevelExcellent},

		// 温度（越低越好）
		{"Temp-远超过(危险)", benchTemp, 95, LevelPoor},
		{"Temp-偏高", benchTemp, 80, LevelNormal},
		{"Temp-正常", benchTemp, 70, LevelGood},
		{"Temp-优秀", benchTemp, 50, LevelExcellent},
		{"Temp-边界-正常", benchTemp, 90, LevelNormal},
		{"Temp-边界-良好", benchTemp, 75, LevelGood},
		{"Temp-边界-优秀", benchTemp, 60, LevelExcellent},

		// 磁盘 IOPS
		{"IOPS-远低于(HDD)", benchDiskIOPS, 500, LevelPoor},
		{"IOPS-正常(低端SSD)", benchDiskIOPS, 5000, LevelNormal},
		{"IOPS-超过(SATA)", benchDiskIOPS, 30000, LevelGood},
		{"IOPS-远超过(NVMe)", benchDiskIOPS, 80000, LevelExcellent},

		// 磁盘吞吐
		{"BW-远低于(HDD)", benchDiskBW, 50, LevelPoor},
		{"BW-正常", benchDiskBW, 300, LevelNormal},
		{"BW-超过", benchDiskBW, 1000, LevelGood},
		{"BW-远超过", benchDiskBW, 3000, LevelExcellent},
	}
	for _, tc := range tests {
		got := EvalBench(tc.bench, tc.val)
		if got != tc.want {
			t.Errorf("%s: val=%.0f got=%s want=%s", tc.name, tc.val, got, tc.want)
		}
	}
}

// TestEvaluateResult 验证 Result 评估
func TestEvaluateResult(t *testing.T) {
	// 模拟一次 CPU 压测结果：跑分 25000（超过正常），最高温度 70°C（良好）
	r := Result{
		Type:  TestCPU,
		Score: 25000,
		Metrics: map[string]float64{
			"max_temp": 70,
		},
	}
	// 使用 N100 库：CPU 跑分阈值 10000/22000/38000 → 25000 介于 22k-38k，应为 LevelGood
	items := EvaluateResult(r, "Intel N100")
	if len(items) != 2 {
		t.Fatalf("期望 2 个评估项（跑分+温度），实际 %d", len(items))
	}
	// 第一项是 CPU 跑分
	if items[0].Level != LevelGood {
		t.Errorf("CPU 跑分评级错误: got=%s want=%s", items[0].Level, LevelGood)
	}
	// 第二项是温度（70°C 在 60-75 之间，应为 LevelGood）
	if items[1].Level != LevelGood {
		t.Errorf("温度评级错误: got=%s want=%s", items[1].Level, LevelGood)
	}
	// 综合评级应取最差
	if OverallLevel(items) != LevelGood {
		t.Errorf("综合评级错误: got=%s", OverallLevel(items))
	}
}

// TestEvaluateResultDisk 验证磁盘测试评估
func TestEvaluateResultDisk(t *testing.T) {
	// 模拟一次磁盘压测：吞吐 1500MB/s（良好），IOPS 80000（远超过）
	r := Result{
		Type:  TestDiskIO,
		Score: 1500, // score 是 bw_total
		Metrics: map[string]float64{
			"iops_total": 80000,
			"bw_total":   1500,
		},
	}
	// 磁盘阈值与 CPU 型号无关，传任意库内型号都能正常评估
	items := EvaluateResult(r, "Intel N100")
	if len(items) != 2 {
		t.Fatalf("期望 2 个评估项，实际 %d", len(items))
	}
	// 找 IOPS 项
	var iops, bw BenchItem
	for _, it := range items {
		switch it.Key {
		case "iops_total":
			iops = it
		case "bw_total":
			bw = it
		}
	}
	if iops.Level != LevelExcellent {
		t.Errorf("IOPS 80000 应评为远超过正常: got=%s", iops.Level)
	}
	if bw.Level != LevelGood {
		t.Errorf("吞吐 1500 应评为超过正常: got=%s", bw.Level)
	}
}

// TestMatchHardware 验证硬件库匹配
func TestMatchHardware(t *testing.T) {
	tests := []struct {
		cpu      string
		wantNil  bool
		wantNote string // 仅检查 Note 包含的子串
	}{
		// 飞牛常用低功耗
		{"Intel(R) Celeron(R) N100 CPU @ 0.80GHz", false, "N100"},
		{"Intel N305", false, "N305"},
		{"12th Gen Intel(R) Core(TM) i3-12100", false, "12代 i3"},
		{"13th Gen Intel(R) Core(TM) i5-13500", false, "13代 i5"},
		{"11th Gen Intel(R) Core(TM) i7-11700K", false, "11代 i7"},
		{"Intel(R) Core(TM) i9-12900K CPU", false, "12代 i9"},
		{"Intel(R) Celeron(R) J4125 CPU @ 2.00GHz", false, "J4125"},
		{"Intel(R) Celeron(R) N5095 @ 2.00GHz", false, "N5095"},

		// AMD
		{"AMD Ryzen 5 5600 6-Core Processor", false, "Ryzen 5"},
		{"AMD Ryzen 7 5800X 8-Core", false, "Ryzen 7"},
		{"AMD Ryzen 9 5900X", false, "Ryzen 9"},

		// 大小写不敏感
		{"INTEL N100", false, "N100"},
		{"intel celeron n100", false, "N100"},

		// 不在库中
		{"", true, ""},
		{"Some Unknown CPU XYZ", true, ""},
		{"Apple M1", true, ""},
		{"Loongson 3A5000", true, ""},
	}
	for _, tc := range tests {
		got := MatchHardware(tc.cpu)
		if tc.wantNil {
			if got != nil {
				t.Errorf("cpu=%q 应返回 nil，得到 %v (Note=%s)", tc.cpu, got, got.Note)
			}
			continue
		}
		if got == nil {
			t.Errorf("cpu=%q 应匹配到硬件，得到 nil", tc.cpu)
			continue
		}
		if !strings.Contains(got.Note, tc.wantNote) {
			t.Errorf("cpu=%q 匹配到 %q，但 Note 应包含 %q", tc.cpu, got.Note, tc.wantNote)
		}
	}
}

// TestMatchHardware_Priority 验证匹配顺序优先级（i5-12xxx 必须优先于 i5 通用）
func TestMatchHardware_Priority(t *testing.T) {
	hb := MatchHardware("Intel Core i5-12400")
	if hb == nil {
		t.Fatal("i5-12400 应匹配到硬件")
	}
	if !strings.Contains(hb.Note, "12代 i5") {
		t.Errorf("i5-12400 应优先匹配 12代 i5，实际 Note=%s", hb.Note)
	}

	// 不带代号的 i5 应匹配通用条目
	hb = MatchHardware("Intel Core i5-4400") // 老 4 代
	if hb == nil {
		t.Fatal("i5-4400 应匹配到硬件")
	}
	if !strings.Contains(hb.Note, "i5") {
		t.Errorf("i5-4400 应匹配 i5 系列，实际 Note=%s", hb.Note)
	}
}

// TestEvaluateResult_HardwareAware 验证同一分数在不同硬件下的评级不同
func TestEvaluateResult_HardwareAware(t *testing.T) {
	r := Result{Type: TestCPU, Score: 25000}
	mr := map[string]float64{"max_temp": 70}

	// N100：阈值 10000/22000/38000 → 25000 介于 22k-38k → Good
	rN100 := r
	rN100.Metrics = mr
	itemsN100 := EvaluateResult(rN100, "Intel N100")
	if itemsN100[0].Level != LevelGood {
		t.Errorf("N100 跑分 25k 应为 Good，实际 %s", itemsN100[0].Level)
	}

	// i3-12100：阈值 18000/38000/62000 → 25000 介于 18k-38k → Normal
	itemsI3 := EvaluateResult(r, "Intel Core i3-12100")
	if itemsI3[0].Level != LevelNormal {
		t.Errorf("i3-12100 跑分 25k 应为 Normal，实际 %s", itemsI3[0].Level)
	}

	// i7-12700：阈值 32000/70000/115000 → 25000 < 32k → Poor
	itemsI7 := EvaluateResult(r, "Intel Core i7-12700")
	if itemsI7[0].Level != LevelPoor {
		t.Errorf("i7-12700 跑分 25k 应为 Poor（明显低于 i7 水平），实际 %s", itemsI7[0].Level)
	}
}

// TestEvaluateResult_UnknownHardware 验证未在库中的硬件全部返回 normal
func TestEvaluateResult_UnknownHardware(t *testing.T) {
	r := Result{
		Type:  TestCPU,
		Score: 25000,
		Metrics: map[string]float64{
			"max_temp":   70,
			"iops_total": 80000,
			"bw_total":   1500,
		},
	}

	// 1) 空字符串
	items := EvaluateResult(r, "")
	if len(items) != 4 {
		t.Fatalf("空 cpuModel 应返回 4 项，实际 %d", len(items))
	}
	for _, it := range items {
		if it.Level != LevelNormal {
			t.Errorf("空 cpuModel 时 %s 应为 Normal，实际 %s", it.Label, it.Level)
		}
	}

	// 2) 未知型号
	items = EvaluateResult(r, "SomeUnknownCPU XYZ")
	if len(items) != 4 {
		t.Fatalf("未知 cpuModel 应返回 4 项，实际 %d", len(items))
	}
	for _, it := range items {
		if it.Level != LevelNormal {
			t.Errorf("未知 cpuModel 时 %s 应为 Normal，实际 %s", it.Label, it.Level)
		}
	}
}