package spec

import (
	"testing"

	"vetting/internal/model"
)

func TestDiffEmptySpec(t *testing.T) {
	if d := Diff(&Spec{}, &Inventory{}); len(d) != 0 {
		t.Fatalf("empty spec → empty diff, got %v", d)
	}
}

func TestDiffCPUMismatch(t *testing.T) {
	exp := &Spec{CPU: &CPUSpec{Model: "E5-2680 v4", LogicalCores: 28}}
	act := &Inventory{CPU: CPUSpec{Model: "Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GHz", LogicalCores: 16}}
	d := Diff(exp, act)
	if len(d) != 1 || d[0].Field != "cpu.logical_cores" || d[0].Severity != "critical" {
		t.Fatalf("expected logical_cores critical, got %+v", d)
	}
}

func TestDiffCPUModelSubstringMatch(t *testing.T) {
	exp := &Spec{CPU: &CPUSpec{Model: "E5-2680 v4"}}
	act := &Inventory{CPU: CPUSpec{Model: "Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GHz"}}
	if d := Diff(exp, act); len(d) != 0 {
		t.Fatalf("substring should match, got %+v", d)
	}
}

func TestDiffMemoryTolerance(t *testing.T) {
	exp := &Spec{Memory: &MemorySpec{TotalGiB: 128}}
	act := &Inventory{Memory: MemorySpec{TotalGiB: 127}}
	if d := Diff(exp, act); len(d) != 0 {
		t.Fatalf("1 GiB variance should be tolerated, got %+v", d)
	}
	act2 := &Inventory{Memory: MemorySpec{TotalGiB: 112}} // missing stick
	d := Diff(exp, act2)
	if len(d) != 1 || d[0].Field != "memory.total_gib" {
		t.Fatalf("16 GiB drop should be critical, got %+v", d)
	}
}

func TestDiffDisksMissingAndUnexpected(t *testing.T) {
	exp := &Spec{Disks: []DiskSpec{{Serial: "A", SizeGB: 1000}, {Serial: "B", SizeGB: 500}}}
	act := &Inventory{Disks: []DiskSpec{{Serial: "A", SizeGB: 1000}, {Serial: "C", SizeGB: 32}}}
	d := Diff(exp, act)
	// Expect: disk B missing, disk C unexpected.
	got := map[string]bool{}
	for _, row := range d {
		got[row.Field] = true
	}
	if !got["disks[B].present"] {
		t.Fatalf("expected disks[B].present critical; got %+v", d)
	}
	if !got["disks[unexpected C]"] {
		t.Fatalf("expected disks[unexpected C] critical; got %+v", d)
	}
}

func TestDiffDisksSerialCaseInsensitive(t *testing.T) {
	exp := &Spec{Disks: []DiskSpec{{Serial: "wd-abc123", SizeGB: 1000}}}
	act := &Inventory{Disks: []DiskSpec{{Serial: "WD-ABC123", SizeGB: 1000}}}
	if d := Diff(exp, act); len(d) != 0 {
		t.Fatalf("serial compare must be case-insensitive, got %+v", d)
	}
}

func TestDiffNICMAC(t *testing.T) {
	exp := &Spec{NICs: []NICSpec{{MAC: "aa:bb:cc:dd:ee:ff", SpeedGbps: 10}}}
	act := &Inventory{NICs: []NICSpec{{MAC: "aa:bb:cc:dd:ee:ff", SpeedGbps: 1}}}
	d := Diff(exp, act)
	if len(d) != 1 || d[0].Field != "nics[aa:bb:cc:dd:ee:ff].speed_gbps" {
		t.Fatalf("expected speed mismatch, got %+v", d)
	}
}

func TestDiffGPUCount(t *testing.T) {
	exp := &Spec{GPUs: []GPUSpec{{Model: "NVIDIA RTX 3090"}, {Model: "NVIDIA RTX 3090"}}}
	act := &Inventory{GPUs: []GPUSpec{{Model: "nvidia rtx 3090"}}}
	d := Diff(exp, act)
	if len(d) != 1 || d[0].Field != "gpus[nvidia rtx 3090].count" {
		t.Fatalf("expected GPU count critical, got %+v", d)
	}
}

func TestParseValidYAML(t *testing.T) {
	src := `
cpu:
  model: "E5-2680 v4"
  logical_cores: 28
memory:
  total_gib: 128
disks:
  - serial: A
    size_gb: 1000
`
	s, err := Parse(src)
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if s.CPU == nil || s.CPU.LogicalCores != 28 {
		t.Fatalf("cpu not parsed: %+v", s)
	}
	if len(s.Disks) != 1 || s.Disks[0].Serial != "A" {
		t.Fatalf("disks not parsed: %+v", s)
	}
}

func TestDiffSeverityAlwaysCritical(t *testing.T) {
	exp := &Spec{CPU: &CPUSpec{LogicalCores: 8}}
	act := &Inventory{CPU: CPUSpec{LogicalCores: 4}}
	d := Diff(exp, act)
	var got []model.SpecDiff = d
	for _, row := range got {
		if row.Severity != "critical" {
			t.Fatalf("phase-3 rule: every diff is critical; got %q for %s", row.Severity, row.Field)
		}
	}
}

func TestDiffFirmwareIdentifierMatch(t *testing.T) {
	exp := []FirmwareSpec{{Component: "bios", Version: "3.2"}}
	obs := []FirmwareObserved{{Component: "bios", Identifier: "system", Version: "3.2"}}
	if d := DiffFirmware(exp, obs); len(d) != 0 {
		t.Fatalf("matching bios version should produce no diff, got %+v", d)
	}
}

func TestDiffFirmwareVersionMismatch(t *testing.T) {
	exp := []FirmwareSpec{{Component: "bios", Version: "3.3"}}
	obs := []FirmwareObserved{{Component: "bios", Identifier: "system", Version: "3.2"}}
	d := DiffFirmware(exp, obs)
	if len(d) != 1 {
		t.Fatalf("want 1 diff, got %d: %+v", len(d), d)
	}
	if d[0].Expected != "3.3" || d[0].Actual != "3.2" {
		t.Fatalf("diff expected/actual = %q/%q, want 3.3/3.2", d[0].Expected, d[0].Actual)
	}
	if d[0].Severity != "critical" {
		t.Errorf("severity = %q, want critical", d[0].Severity)
	}
}

func TestDiffFirmwareMissingComponentPresent(t *testing.T) {
	// Expected rule with no identifier + zero observed snapshots →
	// single "present=false" diff, not N.
	exp := []FirmwareSpec{{Component: "bmc", Version: "1.74"}}
	d := DiffFirmware(exp, nil)
	if len(d) != 1 {
		t.Fatalf("want 1 diff for missing BMC, got %d: %+v", len(d), d)
	}
	if d[0].Field != "firmware[bmc].present" || d[0].Expected != "true" || d[0].Actual != "false" {
		t.Fatalf("missing-BMC diff = %+v", d[0])
	}
}

func TestDiffFirmwareWildcardFanOut(t *testing.T) {
	// Expected rule with empty identifier fans across every observed
	// snapshot of the component — one port matches, one doesn't → one diff.
	exp := []FirmwareSpec{{Component: "nic", Version: "16.32.1010"}}
	obs := []FirmwareObserved{
		{Component: "nic", Identifier: "eth0", Version: "16.32.1010"},
		{Component: "nic", Identifier: "eth1", Version: "14.28.0000"},
	}
	d := DiffFirmware(exp, obs)
	if len(d) != 1 {
		t.Fatalf("want 1 diff (mismatched eth1 only), got %d: %+v", len(d), d)
	}
	if d[0].Field != "firmware[nic/eth1].version" {
		t.Errorf("field = %q, want firmware[nic/eth1].version", d[0].Field)
	}
}

func TestDiffFirmwareIdentifierPin(t *testing.T) {
	// Identifier set: pins the rule to a specific port. Other ports
	// with mismatched firmware are not evaluated by this rule.
	exp := []FirmwareSpec{{Component: "nic", Identifier: "eth0", Version: "1.0"}}
	obs := []FirmwareObserved{
		{Component: "nic", Identifier: "eth0", Version: "1.0"},
		{Component: "nic", Identifier: "eth1", Version: "9.9"},
	}
	if d := DiffFirmware(exp, obs); len(d) != 0 {
		t.Fatalf("pinned rule should ignore other ports, got %+v", d)
	}
}

func TestDiffFirmwareIdentifierPinMissing(t *testing.T) {
	// Pinned rule with no matching observed snapshot → present=false diff.
	exp := []FirmwareSpec{{Component: "nic", Identifier: "eth0", Version: "1.0"}}
	if d := DiffFirmware(exp, nil); len(d) != 1 || d[0].Field != "firmware[nic/eth0].present" {
		t.Fatalf("want present=false for pinned rule, got %+v", d)
	}
}

func TestDiffFirmwareEmptyRuleSkipped(t *testing.T) {
	// Empty component or empty version silently skip rather than panic.
	exp := []FirmwareSpec{{Component: "", Version: "x"}, {Component: "bios", Version: ""}}
	obs := []FirmwareObserved{{Component: "bios", Identifier: "system", Version: "3.2"}}
	if d := DiffFirmware(exp, obs); len(d) != 0 {
		t.Fatalf("empty rules should skip, got %+v", d)
	}
}

func TestDiffFirmwareCaseInsensitive(t *testing.T) {
	// Version match is case-insensitive after trim; avoids spurious diff
	// from ethtool's "FW1234" vs expected YAML's "fw1234".
	exp := []FirmwareSpec{{Component: "nvme_fw", Identifier: "nvme0", Version: "fw1234"}}
	obs := []FirmwareObserved{{Component: "nvme_fw", Identifier: "nvme0", Version: "FW1234"}}
	if d := DiffFirmware(exp, obs); len(d) != 0 {
		t.Fatalf("case-insensitive match expected, got %+v", d)
	}
}

func TestDiffDIMMMissingSlot(t *testing.T) {
	exp := &Spec{Memory: &MemorySpec{Modules: []DIMMSpec{
		{Slot: "DIMM_A1", SizeGB: 16, PartNumber: "8ATF2G64AZ-3G2E1", Populated: true},
		{Slot: "DIMM_B1", SizeGB: 16, PartNumber: "8ATF2G64AZ-3G2E1", Populated: true},
	}}}
	act := &Inventory{Memory: MemorySpec{Modules: []DIMMSpec{
		{Slot: "DIMM_A1", SizeGB: 16, PartNumber: "8ATF2G64AZ-3G2E1", Populated: true},
	}}}
	d := Diff(exp, act)
	got := map[string]bool{}
	for _, row := range d {
		got[row.Field] = true
	}
	if !got["memory.modules[DIMM_B1].present"] {
		t.Fatalf("expected missing DIMM_B1; got %+v", d)
	}
}

func TestDiffDIMMPartNumberMismatch(t *testing.T) {
	exp := &Spec{Memory: &MemorySpec{Modules: []DIMMSpec{
		{Slot: "DIMM_A1", PartNumber: "8ATF2G64AZ-3G2E1", Populated: true},
	}}}
	act := &Inventory{Memory: MemorySpec{Modules: []DIMMSpec{
		{Slot: "DIMM_A1", PartNumber: "HMA82GR7AFR8N-UH", Populated: true},
	}}}
	d := Diff(exp, act)
	if len(d) != 1 || d[0].Field != "memory.modules[DIMM_A1].part_number" || d[0].Severity != "critical" {
		t.Fatalf("expected part_number critical, got %+v", d)
	}
}

func TestDiffDIMMUnexpectedPopulated(t *testing.T) {
	exp := &Spec{Memory: &MemorySpec{Modules: []DIMMSpec{
		{Slot: "DIMM_A1", Populated: true},
	}}}
	act := &Inventory{Memory: MemorySpec{Modules: []DIMMSpec{
		{Slot: "DIMM_A1", Populated: true},
		{Slot: "DIMM_B1", Populated: true, SizeGB: 8},
	}}}
	d := Diff(exp, act)
	got := map[string]bool{}
	for _, row := range d {
		got[row.Field] = true
	}
	if !got["memory.modules[unexpected DIMM_B1]"] {
		t.Fatalf("expected unexpected-DIMM_B1; got %+v", d)
	}
}

func TestDiffDIMMEmptySlotsIgnoredWhenNotExpected(t *testing.T) {
	// Actual has two empty slots; expected only lists the populated one.
	// Empty extras must not produce an unexpected-populated diff.
	exp := &Spec{Memory: &MemorySpec{Modules: []DIMMSpec{
		{Slot: "DIMM_A1", Populated: true, SizeGB: 16},
	}}}
	act := &Inventory{Memory: MemorySpec{Modules: []DIMMSpec{
		{Slot: "DIMM_A1", Populated: true, SizeGB: 16},
		{Slot: "DIMM_A2"},
		{Slot: "DIMM_B1"},
	}}}
	if d := Diff(exp, act); len(d) != 0 {
		t.Fatalf("empty extra slots must not diff; got %+v", d)
	}
}

func TestDiffDiskTransport(t *testing.T) {
	exp := &Spec{Disks: []DiskSpec{
		{Serial: "A", SizeGB: 1000, Transport: "nvme", Model: "SN850X"},
	}}
	act := &Inventory{Disks: []DiskSpec{
		{Serial: "A", SizeGB: 1000, Transport: "sata", Model: "860 EVO"},
	}}
	d := Diff(exp, act)
	got := map[string]bool{}
	for _, r := range d {
		got[r.Field] = true
	}
	if !got["disks[A].transport"] || !got["disks[A].model"] {
		t.Fatalf("expected transport + model diffs; got %+v", d)
	}
}

func TestDiffSystem(t *testing.T) {
	exp := &Spec{System: &SystemSpec{Manufacturer: "Beelink", ProductName: "Mini S12 Pro"}}
	act := &Inventory{System: SystemSpec{Manufacturer: "Beelink", ProductName: "Mini S11"}}
	d := Diff(exp, act)
	if len(d) != 1 || d[0].Field != "system.product_name" {
		t.Fatalf("expected system.product_name; got %+v", d)
	}
}

func TestDiffBaseboard(t *testing.T) {
	exp := &Spec{Baseboard: &BaseboardSpec{SerialNumber: "BB-0001"}}
	act := &Inventory{Baseboard: BaseboardSpec{SerialNumber: "BB-9999"}}
	d := Diff(exp, act)
	if len(d) != 1 || d[0].Field != "baseboard.serial_number" {
		t.Fatalf("expected baseboard.serial_number; got %+v", d)
	}
}

func TestDiffPSUMissing(t *testing.T) {
	exp := &Spec{PSU: []PowerSupplySpec{{Slot: "PSU1", MaxWatts: 760}, {Slot: "PSU2", MaxWatts: 760}}}
	act := &Inventory{PSU: []PowerSupplySpec{{Slot: "PSU1", MaxWatts: 760}}}
	d := Diff(exp, act)
	got := map[string]bool{}
	for _, r := range d {
		got[r.Field] = true
	}
	if !got["psu[PSU2].present"] {
		t.Fatalf("expected PSU2 missing; got %+v", d)
	}
}

func TestDiffOSKernel(t *testing.T) {
	exp := &Spec{OS: &OSSpec{Kernel: "6.1.0-17-amd64"}}
	act := &Inventory{OS: OSSpec{Kernel: "6.1.0-22-amd64"}}
	d := Diff(exp, act)
	if len(d) != 1 || d[0].Field != "os.kernel" {
		t.Fatalf("expected os.kernel; got %+v", d)
	}
}

func TestDiffCPUExtendedFields(t *testing.T) {
	exp := &Spec{CPU: &CPUSpec{
		PhysicalCores: 8,
		Vendor:        "GenuineIntel",
		Flags:         []string{"vmx", "aes"},
	}}
	act := &Inventory{CPU: CPUSpec{
		PhysicalCores: 4,
		Vendor:        "AuthenticAMD",
		Flags:         []string{"aes"}, // missing vmx
	}}
	d := Diff(exp, act)
	got := map[string]bool{}
	for _, r := range d {
		got[r.Field] = true
	}
	for _, want := range []string{"cpu.physical_cores", "cpu.vendor", "cpu.flags[vmx]"} {
		if !got[want] {
			t.Fatalf("expected %s diff; got %+v", want, d)
		}
	}
}

func TestDiffGPUByPCIAddr(t *testing.T) {
	exp := &Spec{GPUs: []GPUSpec{{PCIAddr: "0000:01:00.0", VRAMGiB: 8, Driver: "nvidia"}}}
	act := &Inventory{GPUs: []GPUSpec{{PCIAddr: "0000:01:00.0", VRAMGiB: 4, Driver: "nouveau"}}}
	d := Diff(exp, act)
	got := map[string]bool{}
	for _, r := range d {
		got[r.Field] = true
	}
	for _, want := range []string{"gpus[0000:01:00.0].vram_gib", "gpus[0000:01:00.0].driver"} {
		if !got[want] {
			t.Fatalf("expected %s; got %+v", want, d)
		}
	}
}