package indicator

import (
	"hash"
	"testing"

	"github.com/cespare/xxhash"
	"github.com/stackrox/rox/generated/storage"
	"github.com/stackrox/rox/pkg/networkgraph"
)

// Old implementations (before optimization) for comparison

func hashPortAndProtocolOld(h hash.Hash64, port uint16, protocol storage.L4Protocol) {
	// OLD: Two separate allocations
	portBytes := [2]byte{byte(port >> 8), byte(port)}
	_, _ = h.Write(portBytes[:])

	protocolBytes := [4]byte{
		byte(protocol >> 24), byte(protocol >> 16),
		byte(protocol >> 8), byte(protocol),
	}
	_, _ = h.Write(protocolBytes[:])
}

func hashStringsOld(h hash.Hash64, strs ...string) {
	// OLD: Allocates []byte for delimiter and for each string conversion
	for i, s := range strs {
		if i > 0 {
			_, _ = h.Write([]byte{0}) // Allocation per iteration
		}
		_, _ = h.Write([]byte(s)) // Allocation per string
	}
}

func keyHashOld(srcID, dstID string, port uint16, protocol storage.L4Protocol) string {
	h := xxhash.New()
	hashStringsOld(h, srcID, dstID)
	hashPortAndProtocolOld(h, port, protocol)
	return hashToHexString(h.Sum64())
}

// New implementations (current optimized versions) - using the actual functions

func keyHashNew(srcID, dstID string, port uint16, protocol storage.L4Protocol) string {
	h := xxhash.New()
	hashStrings(h, srcID, dstID)
	hashPortAndProtocol(h, port, protocol)
	return hashToHexString(h.Sum64())
}

// Benchmark NetworkConn key generation

func BenchmarkNetworkConn_KeyGeneration_Old(b *testing.B) {
	entity1 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-1-with-a-long-name"}
	entity2 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-2-with-another-long-name"}
	port := uint16(8080)
	protocol := storage.L4Protocol_L4_PROTOCOL_TCP

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = keyHashOld(entity1.ID, entity2.ID, port, protocol)
	}
}

func BenchmarkNetworkConn_KeyGeneration_New(b *testing.B) {
	entity1 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-1-with-a-long-name"}
	entity2 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-2-with-another-long-name"}
	port := uint16(8080)
	protocol := storage.L4Protocol_L4_PROTOCOL_TCP

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = keyHashNew(entity1.ID, entity2.ID, port, protocol)
	}
}

// Benchmark with real NetworkConn objects

func BenchmarkNetworkConn_Key_Old(b *testing.B) {
	entity1 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-1-with-a-long-name"}
	entity2 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-2-with-another-long-name"}

	conn := NetworkConn{
		SrcEntity: entity1,
		DstEntity: entity2,
		DstPort:   8080,
		Protocol:  storage.L4Protocol_L4_PROTOCOL_TCP,
	}

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = keyHashOld(conn.SrcEntity.ID, conn.DstEntity.ID, conn.DstPort, conn.Protocol)
	}
}

func BenchmarkNetworkConn_Key_New(b *testing.B) {
	entity1 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-1-with-a-long-name"}
	entity2 := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-2-with-another-long-name"}

	conn := NetworkConn{
		SrcEntity: entity1,
		DstEntity: entity2,
		DstPort:   8080,
		Protocol:  storage.L4Protocol_L4_PROTOCOL_TCP,
	}

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = conn.Key()
	}
}

// Benchmark ContainerEndpoint key generation

func BenchmarkContainerEndpoint_Old(b *testing.B) {
	entity := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-with-a-very-long-identifier"}
	port := uint16(443)
	protocol := storage.L4Protocol_L4_PROTOCOL_TCP

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = keyHashOld(entity.ID, "", port, protocol)
	}
}

func BenchmarkContainerEndpoint_New(b *testing.B) {
	entity := networkgraph.Entity{Type: storage.NetworkEntityInfo_DEPLOYMENT, ID: "deployment-with-a-very-long-identifier"}

	endpoint := ContainerEndpoint{
		Entity:   entity,
		Port:     443,
		Protocol: storage.L4Protocol_L4_PROTOCOL_TCP,
	}

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = endpoint.BinaryKey()
	}
}

// Benchmark ProcessListening key generation

func BenchmarkProcessListening_Old(b *testing.B) {
	podID := "nginx-pod-12345678-abcd"
	containerName := "nginx-container-with-long-name"
	processName := "nginx"
	processExec := "/usr/sbin/nginx"
	processArgs := "-g daemon off; -c /etc/nginx/nginx.conf"
	port := uint16(80)
	protocol := storage.L4Protocol_L4_PROTOCOL_TCP

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		h := xxhash.New()
		hashStringsOld(h, podID, containerName, processName, processExec, processArgs)
		hashPortAndProtocolOld(h, port, protocol)
		_ = BinaryHash(h.Sum64())
	}
}

func BenchmarkProcessListening_New(b *testing.B) {
	process := ProcessListening{
		Process: ProcessInfo{
			ProcessName: "nginx",
			ProcessArgs: "-g daemon off; -c /etc/nginx/nginx.conf",
			ProcessExec: "/usr/sbin/nginx",
		},
		PodID:         "nginx-pod-12345678-abcd",
		ContainerName: "nginx-container-with-long-name",
		DeploymentID:  "nginx-deployment",
		PodUID:        "pod-uid-456",
		Namespace:     "default",
		Port:          80,
		Protocol:      storage.L4Protocol_L4_PROTOCOL_TCP,
	}

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = process.BinaryKey()
	}
}

// Benchmark individual optimization components

func BenchmarkHashPortAndProtocol_Old(b *testing.B) {
	h := xxhash.New()
	port := uint16(8080)
	protocol := storage.L4Protocol_L4_PROTOCOL_TCP

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		hashPortAndProtocolOld(h, port, protocol)
		h.Reset()
	}
}

func BenchmarkHashPortAndProtocol_New(b *testing.B) {
	h := xxhash.New()
	port := uint16(8080)
	protocol := storage.L4Protocol_L4_PROTOCOL_TCP

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		hashPortAndProtocol(h, port, protocol)
		h.Reset()
	}
}

func BenchmarkHashStrings_Old(b *testing.B) {
	h := xxhash.New()
	str1 := "deployment-1-with-a-long-name"
	str2 := "deployment-2-with-another-long-name"

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		hashStringsOld(h, str1, str2)
		h.Reset()
	}
}

func BenchmarkHashStrings_New(b *testing.B) {
	h := xxhash.New()
	str1 := "deployment-1-with-a-long-name"
	str2 := "deployment-2-with-another-long-name"

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		hashStrings(h, str1, str2)
		h.Reset()
	}
}

// Benchmark with varying string counts
func BenchmarkHashStrings_Old_5Strings(b *testing.B) {
	h := xxhash.New()
	strs := []string{
		"nginx-pod-12345678-abcd",
		"nginx-container-with-long-name",
		"nginx",
		"/usr/sbin/nginx",
		"-g daemon off; -c /etc/nginx/nginx.conf",
	}

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		hashStringsOld(h, strs...)
		h.Reset()
	}
}

func BenchmarkHashStrings_New_5Strings(b *testing.B) {
	h := xxhash.New()
	strs := []string{
		"nginx-pod-12345678-abcd",
		"nginx-container-with-long-name",
		"nginx",
		"/usr/sbin/nginx",
		"-g daemon off; -c /etc/nginx/nginx.conf",
	}

	b.ResetTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		hashStrings(h, strs...)
		h.Reset()
	}
}