package collector

import (
	"bee/audit/internal/schema"
	"fmt"
)

func finalizeSnapshot(snap *schema.HardwareSnapshot, collectedAt string) {
	snap.Memory = filterMemory(snap.Memory)
	snap.Storage = filterStorage(snap.Storage)
	snap.PowerSupplies = filterPSUs(snap.PowerSupplies)

	setComponentStatusMetadata(snap, collectedAt)
	deduplicateComponentSerials(snap)
}

func filterMemory(dimms []schema.HardwareMemory) []schema.HardwareMemory {
	out := make([]schema.HardwareMemory, 0, len(dimms))
	for _, dimm := range dimms {
		if dimm.Present != nil && !*dimm.Present {
			continue
		}
		if dimm.Status != nil && *dimm.Status == statusEmpty {
			continue
		}
		if dimm.SerialNumber == nil || *dimm.SerialNumber == "" {
			continue
		}
		out = append(out, dimm)
	}
	return out
}

func filterStorage(disks []schema.HardwareStorage) []schema.HardwareStorage {
	out := make([]schema.HardwareStorage, 0, len(disks))
	for _, disk := range disks {
		if disk.SerialNumber == nil || *disk.SerialNumber == "" {
			continue
		}
		out = append(out, disk)
	}
	return out
}

func filterPSUs(psus []schema.HardwarePowerSupply) []schema.HardwarePowerSupply {
	out := make([]schema.HardwarePowerSupply, 0, len(psus))
	for _, psu := range psus {
		if psu.SerialNumber == nil || *psu.SerialNumber == "" {
			continue
		}
		out = append(out, psu)
	}
	return out
}

func setComponentStatusMetadata(snap *schema.HardwareSnapshot, collectedAt string) {
	for i := range snap.CPUs {
		setStatusCheckedAt(&snap.CPUs[i].HardwareComponentStatus, collectedAt)
	}
	for i := range snap.Memory {
		setStatusCheckedAt(&snap.Memory[i].HardwareComponentStatus, collectedAt)
	}
	for i := range snap.Storage {
		setStatusCheckedAt(&snap.Storage[i].HardwareComponentStatus, collectedAt)
	}
	for i := range snap.PCIeDevices {
		setStatusCheckedAt(&snap.PCIeDevices[i].HardwareComponentStatus, collectedAt)
	}
	for i := range snap.PowerSupplies {
		setStatusCheckedAt(&snap.PowerSupplies[i].HardwareComponentStatus, collectedAt)
	}
}

func setStatusCheckedAt(status *schema.HardwareComponentStatus, collectedAt string) {
	if status == nil || status.Status == nil || *status.Status == "" {
		return
	}
	if status.StatusCheckedAt == nil {
		status.StatusCheckedAt = &collectedAt
	}
}

func deduplicateComponentSerials(snap *schema.HardwareSnapshot) {
	deduplicateCPUSerials(snap.CPUs)
	deduplicateMemorySerials(snap.Memory)
	deduplicateStorageSerials(snap.Storage)
	deduplicatePCIeSerials(snap.PCIeDevices)
	deduplicatePSUSerials(snap.PowerSupplies)
}

func deduplicateCPUSerials(items []schema.HardwareCPU) {
	seen := map[string]int{}
	seq := 1
	for i := range items {
		if items[i].SerialNumber == nil || *items[i].SerialNumber == "" {
			continue
		}
		model := derefString(items[i].Model)
		key := model + "\x00" + *items[i].SerialNumber
		seen[key]++
		if seen[key] > 1 {
			repl := fmt.Sprintf("NO_SN-%08d", seq)
			seq++
			items[i].SerialNumber = &repl
		}
	}
}

func deduplicateMemorySerials(items []schema.HardwareMemory) {
	seen := map[string]int{}
	seq := 1
	for i := range items {
		if items[i].SerialNumber == nil || *items[i].SerialNumber == "" {
			continue
		}
		model := derefString(items[i].PartNumber)
		key := model + "\x00" + *items[i].SerialNumber
		seen[key]++
		if seen[key] > 1 {
			repl := fmt.Sprintf("NO_SN-%08d", seq)
			seq++
			items[i].SerialNumber = &repl
		}
	}
}

func deduplicateStorageSerials(items []schema.HardwareStorage) {
	seen := map[string]int{}
	seq := 1
	for i := range items {
		if items[i].SerialNumber == nil || *items[i].SerialNumber == "" {
			continue
		}
		model := derefString(items[i].Model)
		key := model + "\x00" + *items[i].SerialNumber
		seen[key]++
		if seen[key] > 1 {
			repl := fmt.Sprintf("NO_SN-%08d", seq)
			seq++
			items[i].SerialNumber = &repl
		}
	}
}

func deduplicatePCIeSerials(items []schema.HardwarePCIeDevice) {
	seen := map[string]int{}
	seq := 1
	for i := range items {
		if items[i].SerialNumber == nil || *items[i].SerialNumber == "" {
			continue
		}
		model := derefString(items[i].Model)
		key := model + "\x00" + *items[i].SerialNumber
		seen[key]++
		if seen[key] > 1 {
			repl := fmt.Sprintf("NO_SN-%08d", seq)
			seq++
			items[i].SerialNumber = &repl
		}
	}
}

func deduplicatePSUSerials(items []schema.HardwarePowerSupply) {
	seen := map[string]int{}
	seq := 1
	for i := range items {
		if items[i].SerialNumber == nil || *items[i].SerialNumber == "" {
			continue
		}
		model := derefString(items[i].Model)
		key := model + "\x00" + *items[i].SerialNumber
		seen[key]++
		if seen[key] > 1 {
			repl := fmt.Sprintf("NO_SN-%08d", seq)
			seq++
			items[i].SerialNumber = &repl
		}
	}
}