package kmp

import (
	"bytes"
	_ "embed"
	"testing"

	"gotest.tools/v3/assert"

	"edge-infra.dev/pkg/k8s/object"
	"edge-infra.dev/pkg/k8s/runtime/inventory"
	"edge-infra.dev/pkg/k8s/unstructured"
)

// Object data used to create inventories for tests
var (
	//go:embed testdata/deployment.yaml
	deployBytes []byte
	//go:embed testdata/deployment2.yaml
	deploy2Bytes []byte
	//go:embed testdata/serviceaccount.yaml
	svcActBytes []byte
	//go:embed testdata/namespace.yaml
	nsBytes []byte
)

func TestInventory(t *testing.T) {
	t.Parallel()

	// Objects
	var (
		deploy, deploy2, svcAct, ns *unstructured.Unstructured
	)

	// Load objects
	var err error
	deploy, err = object.ReadObject(bytes.NewReader(deployBytes))
	assert.NilError(t, err)
	deploy2, err = object.ReadObject(bytes.NewReader(deploy2Bytes))
	assert.NilError(t, err)
	svcAct, err = object.ReadObject(bytes.NewReader(svcActBytes))
	assert.NilError(t, err)
	ns, err = object.ReadObject(bytes.NewReader(nsBytes))
	assert.NilError(t, err)

	invFrom := func(objs ...*unstructured.Unstructured) *inventory.ResourceInventory {
		return inventory.New(inventory.FromUnstructured(objs...))
	}

	tcs := map[string]map[string]testCase{
		"SameInventory": {
			"same": {
				SameInventory(invFrom(deploy2, svcAct, ns), invFrom(deploy2, svcAct, ns)),
				true,
			},
			"empty is same": {
				SameInventory(inventory.New(), inventory.New()),
				true,
			},
			"nil isn't comparable same": {
				SameInventory(nil, inventory.New()),
				false,
			},
			"nil is not the same": {
				SameInventory(nil, nil),
				false,
			},
			"not": {
				SameInventory(invFrom(deploy2, svcAct, ns), invFrom(deploy2, svcAct, deploy)),
				false,
			},
			"not with different lengths": {
				SameInventory(invFrom(deploy2, svcAct, ns), invFrom(deploy2, svcAct)),
				false,
			},
		},
	}

	for fn, fnTestCases := range tcs {
		fnTestCases := fnTestCases
		// Run tests so they are structured like:
		// TestConditions/EqualCondition/equal_is_same
		t.Run(fn, func(t *testing.T) {
			t.Parallel()
			for name, tc := range fnTestCases {
				t.Run(name, func(t *testing.T) {
					run(t, tc)
				})
			}
		})
	}
}