package layout

import (
	"fmt"
	"os"
	"testing"

	"github.com/google/go-containerregistry/pkg/name"
	"github.com/stretchr/testify/assert"

	"edge-infra.dev/pkg/f8n/warehouse/cluster"
	"edge-infra.dev/pkg/f8n/warehouse/lift"
	"edge-infra.dev/pkg/f8n/warehouse/oci"
	"edge-infra.dev/pkg/f8n/warehouse/oci/layer"
	"edge-infra.dev/pkg/f8n/warehouse/pallet"
	"edge-infra.dev/pkg/lib/build/bazel"
	"edge-infra.dev/pkg/lib/uuid"
	"edge-infra.dev/test/snapshot"
)

var (
	tempDir string
)

func TestMain(m *testing.M) {
	path, err := os.MkdirTemp("", "LayoutTest")
	if err != nil {
		os.Exit(1)
	}
	tempDir = path
	defer os.RemoveAll(path)
	os.Exit(m.Run())
}

func TestNew(t *testing.T) {
	layout, err := New(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, layout)
}

func TestSort(t *testing.T) {
	layout, err := New(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, layout)

	// Add 3 static pallets with different digests to the layout
	lmperLyer, err := createLayer(layer.Infra, []byte("hi"))
	assert.NoError(t, err)
	lmperPllet, err := tempPallet("clusterctl", lmperLyer)
	assert.NoError(t, err)
	tagRef, err := name.NewTag(fmt.Sprintf("%s/%s:%s", lift.LocalRegistryAlias, "clusterctl", "test"))
	assert.NoError(t, err)
	assert.NoError(t, layout.Append(tagRef, lmperPllet))

	lmperPllet, err = tempPallet("bannerctl", lmperLyer)
	assert.NoError(t, err)
	tagRef, err = name.NewTag(fmt.Sprintf("%s/%s:%s", lift.LocalRegistryAlias, "bannerctl", "test"))
	assert.NoError(t, err)
	assert.NoError(t, layout.Append(tagRef, lmperPllet))

	lmperPllet, err = tempPallet("lumperctl", lmperLyer)
	assert.NoError(t, err)
	tagRef, err = name.NewTag(fmt.Sprintf("%s/%s:%s", lift.LocalRegistryAlias, "lumperctl", "test"))
	assert.NoError(t, err)
	assert.NoError(t, layout.Append(tagRef, lmperPllet))

	// Sort the layout & snap the sorted index
	assert.NoError(t, layout.Sort())
	layoutIndex, err := layout.ImageIndex()
	assert.NoError(t, err)
	idx, err := layoutIndex.IndexManifest()
	assert.NoError(t, err)
	snapshot.Snap(t, idx)
}

func TestAppendTag(t *testing.T) {
	layout, err := New(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, layout)
	tag := uuid.New().Hash()
	lmperLyer, err := createLayer(layer.Infra, []byte("hi"))
	assert.NoError(t, err)
	lmperPllet, err := tempPallet("clusterctl", lmperLyer)
	assert.NoError(t, err)
	tagRef, err := name.NewTag(fmt.Sprintf("%s/%s:%s", lift.LocalRegistryAlias, "lumper", tag))
	assert.NoError(t, err)
	assert.NoError(t, layout.Append(tagRef, lmperPllet))
}

func TestAppendDigest(t *testing.T) {
	layout, err := New(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, layout)
	lmperLyer, err := createLayer(layer.Infra, []byte("hi"))
	assert.NoError(t, err)
	lmperPllet, err := tempPallet("bannerctl", lmperLyer)
	assert.NoError(t, err)
	digest, err := name.NewDigest(fmt.Sprintf("%s/%s@sha256:%s", lift.LocalRegistryAlias, "lumper", "3a97b8b8a414dc3e030550ffcb05d54a93a06bbed23925914ba59b8e6fc05545"))
	assert.NoError(t, err)
	assert.NoError(t, layout.Append(digest, lmperPllet))
}

func TestGetTag(t *testing.T) {
	layout, err := New(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, layout)
	lmperLyer, err := createLayer(layer.Infra, []byte("hi"))
	assert.NoError(t, err)
	lmperPllet, err := tempPallet("lumper", lmperLyer)
	assert.NoError(t, err)
	tag := uuid.New().Hash()
	tagRef, err := name.NewTag(fmt.Sprintf("%s/%s:%s", lift.LocalRegistryAlias, "lumper", tag))
	assert.NoError(t, err)
	assert.NoError(t, layout.Append(tagRef, lmperPllet))
	a, err := layout.Get(tagRef)
	assert.NoError(t, err)
	assert.NotEmpty(t, a)
}

func TestAppendTagMultipleTimes(t *testing.T) {
	layout, err := New(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, layout)
	lmperLyer, err := createLayer(layer.Infra, []byte("hi"))
	assert.NoError(t, err)
	lmperPllet, err := tempPallet("lumper", lmperLyer)
	assert.NoError(t, err)
	tag := uuid.New().Hash()
	tagRef, err := name.NewTag(fmt.Sprintf("%s/%s:%s", lift.LocalRegistryAlias, "lumper", tag))
	assert.NoError(t, err)
	for i := 0; i <= 8; i++ {
		assert.NoError(t, err)
		assert.NoError(t, layout.Append(tagRef, lmperPllet))
	}
}

func TestAppendDigestMultipleTimes(t *testing.T) {
	layout, err := New(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, layout)
	lmperLyer, err := createLayer(layer.Infra, []byte("hi"))
	assert.NoError(t, err)
	lmperPllet, err := tempPallet("lumper", lmperLyer)
	assert.NoError(t, err)
	for i := 0; i <= 8; i++ {
		digest, err := name.NewDigest(fmt.Sprintf("%s/%s@sha256:%s", lift.LocalRegistryAlias, "lumper", "3a97b8b8a414dc3e030550ffcb05d54a93a06bbed23925914ba59b8e6fc05545"))
		assert.NoError(t, err)
		assert.NoError(t, layout.Append(digest, lmperPllet))
	}
}

func TestGetTagMultipleTimes(t *testing.T) {
	layout, err := New(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, layout)
	lmperLyer, err := createLayer(layer.Infra, []byte("hi"))
	assert.NoError(t, err)
	lmperPllet, err := tempPallet("lumper", lmperLyer)
	assert.NoError(t, err)
	tag := uuid.New().Hash()
	tagRef, err := name.NewTag(fmt.Sprintf("%s/%s:%s", lift.LocalRegistryAlias, "lumper", tag))
	assert.NoError(t, err)
	for i := 0; i <= 8; i++ {
		assert.NoError(t, layout.Append(tagRef, lmperPllet))
	}
	a, err := layout.Get(tagRef)
	assert.NoError(t, err)
	assert.NotEmpty(t, a)
}

func TestClear(t *testing.T) {
	layout, err := New(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, layout)
	idx, err := layout.ImageIndex()
	assert.NoError(t, err)
	manifest, err := idx.IndexManifest()
	assert.NoError(t, err)
	assert.NotEmpty(t, manifest.Manifests)
	l, err := Clear(tempDir)
	assert.NoError(t, err)
	assert.NotNil(t, l)
	i, err := l.ImageIndex()
	assert.NoError(t, err)
	m, err := i.IndexManifest()
	assert.NoError(t, err)
	assert.Empty(t, m.Manifests)
}
func TestPruneNone(t *testing.T) {
	path, err := bazel.NewTestTmpDir("LayoutTest")
	if err != nil {
		t.Fatal()
	}
	defer os.RemoveAll(path)
	l, err := New(path)
	assert.NoError(t, err)
	assert.NotNil(t, l)

	lmperLyer, err := createLayer(layer.Infra, []byte("hi"))
	assert.NoError(t, err)
	lmperPllet, err := tempPallet("clusterctl", lmperLyer)
	assert.NoError(t, err)
	tagRef, err := name.NewTag(fmt.Sprintf("%s/%s:%s", lift.LocalRegistryAlias, "clusterctl", "test"))
	assert.NoError(t, err)
	assert.NoError(t, l.Append(tagRef, lmperPllet))
	hashes, err := l.Prune()
	assert.NoError(t, err)
	assert.Empty(t, hashes)
}

func TestPrune(t *testing.T) {
	path, err := bazel.NewTestTmpDir("LayoutTest")
	if err != nil {
		t.Fatal()
	}
	defer os.RemoveAll(path)
	l, err := New(path)
	assert.NoError(t, err)
	assert.NotNil(t, l)
	lmperLyer, err := createLayer(layer.Infra, []byte("hi"))
	assert.NoError(t, err)
	lmperPllet, err := tempPallet("clusterctl", lmperLyer)
	assert.NoError(t, err)
	tagRef, err := name.NewTag(fmt.Sprintf("%s/%s:%s", lift.LocalRegistryAlias, "clusterctl", "test"))
	assert.NoError(t, err)
	assert.NoError(t, l.Append(tagRef, lmperPllet))
	grbLayer, err := createLayer(layer.Infra, []byte("test"))
	assert.NoError(t, err)
	digest, err := grbLayer.Digest()
	assert.NoError(t, err)
	uncmp, err := grbLayer.Uncompressed()
	assert.NoError(t, err)
	err = l.WriteBlob(digest, uncmp)
	assert.NoError(t, err)
	hashes, err := l.Prune()
	assert.NoError(t, err)
	assert.Equal(t, digest.Hex, hashes[0])
}

func tempPallet(name string, layers ...layer.Layer) (oci.Artifact, error) {
	a, err := pallet.Image(pallet.Options{
		Metadata: pallet.Metadata{
			Name: name,
			Team: "@ncrvoyix-swt-retail/wg-manifest-destiny",
			BuildInfo: pallet.BuildInfo{
				Created:  "yesterday",
				Source:   "https://gothub.com/ncrvoyix-swt-retail/edge-infra",
				Revision: "d34db33f",
				Version:  "0.2.5",
			},
		},
		ClusterProviders: cluster.BuiltInProviders(),
	}, layers...)
	if err != nil {
		return nil, err
	}
	return a, nil
}

func createLayer(lt layer.Type, yaml []byte) (layer.Layer, error) { //nolint:unparam
	l, err := layer.New(lt, yaml)
	if err != nil {
		return nil, err
	}
	return l, nil
}