package oci_test

import (
	"testing"

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

	"edge-infra.dev/pkg/f8n/warehouse/cluster"
	"edge-infra.dev/pkg/f8n/warehouse/oci"
	"edge-infra.dev/pkg/f8n/warehouse/oci/layer"
	"edge-infra.dev/pkg/f8n/warehouse/pallet"
)

var providers = cluster.BuiltInProviders()

func TestIsPackage(t *testing.T) {
	meta := makeMeta()
	imgContent := make([]byte, 3)
	img, idx, err := makeArtifacts(meta, imgContent)
	require.NoError(t, err)

	t.Run("image is not a package", func(t *testing.T) {
		yes, err := oci.IsPackage(img, idx)
		assert.NoError(t, err)
		assert.False(t, yes)
	})

	t.Run("image is a package", func(t *testing.T) {
		shootMeta := meta
		meta.Name = "not-shoot"

		l, err := layer.New(layer.Runtime, imgContent)
		assert.NoError(t, err)

		img2, err := pallet.Image(pallet.Options{
			ClusterProviders: providers,
			Metadata:         meta,
		}, l)
		assert.NoError(t, err)

		idx, err := pallet.ImageIndex(pallet.Options{
			ClusterProviders: providers,
			Metadata:         shootMeta,
		}, img2)
		assert.NoError(t, err)

		yes, err := oci.IsPackage(img2.Unwrap().(v1.Image), idx)
		assert.NoError(t, err)
		assert.True(t, yes)
	})

	t.Run("handles nil parents", func(t *testing.T) {
		yes, err := oci.IsPackage(img, nil)
		assert.NoError(t, err)
		assert.True(t, yes)
	})
}

func TestContains(t *testing.T) {
	meta := makeMeta()
	img, idx, err := makeArtifacts(meta, make([]byte, 3))
	require.NoError(t, err)

	t.Run("index contains image", func(t *testing.T) {
		yes, err := oci.Contains(idx, img)
		assert.NoError(t, err)
		assert.True(t, yes)
	})

	t.Run("index contains image with wrong digest", func(t *testing.T) {
		img2, _, err := makeArtifacts(meta, make([]byte, 10))
		assert.NoError(t, err)

		yes, err := oci.Contains(idx, img2)
		assert.NoError(t, err)
		assert.False(t, yes)
	})

	t.Run("index doesnt contain image", func(t *testing.T) {
		meta.Name = "not-shoot"

		img2, _, err := makeArtifacts(meta, make([]byte, 10))
		assert.NoError(t, err)

		yes, err := oci.Contains(idx, img2)
		assert.NoError(t, err)
		assert.False(t, yes)
	})
}

func TestIsComposite(t *testing.T) {
	meta := makeMeta()

	t.Run("is not composite", func(t *testing.T) {
		_, idx, err := makeArtifacts(meta, make([]byte, 3))
		require.NoError(t, err)

		isComposite, err := oci.IsComposite(idx)
		assert.NoError(t, err)
		assert.False(t, isComposite)
	})

	t.Run("is composite", func(t *testing.T) {
		_, idx1, err := makeArtifacts(meta, make([]byte, 3))
		require.NoError(t, err)

		meta.Name = "prometheus-operator"
		_, idx2, err := makeArtifacts(meta, make([]byte, 10))
		require.NoError(t, err)

		meta.Name = "composite-guy"
		idx3, err := pallet.ImageIndex(pallet.Options{
			ClusterProviders: providers,
			Metadata:         meta,
		}, idx1, idx2)
		require.NoError(t, err)

		isComposite, err := oci.IsComposite(idx3)
		assert.NoError(t, err)
		assert.True(t, isComposite)
	})
}

func makeArtifacts(meta pallet.Metadata, imgContent []byte) (v1.Image, v1.ImageIndex, error) {
	l, err := layer.New(layer.Runtime, imgContent)
	if err != nil {
		return nil, nil, err
	}

	img, err := pallet.Image(pallet.Options{
		ClusterProviders: providers,
		Metadata:         meta,
	}, l)
	if err != nil {
		return nil, nil, err
	}

	idx, err := pallet.ImageIndex(pallet.Options{
		ClusterProviders: providers,
		Metadata:         meta,
	}, img)
	if err != nil {
		return nil, nil, err
	}
	return img.Unwrap().(v1.Image), idx.Unwrap().(v1.ImageIndex), nil
}

// TODO: add some test utils for generating metadata
func makeMeta() pallet.Metadata {
	return pallet.Metadata{
		Name:   "shoot",
		Vendor: "NCR",
		Team:   "@ncrvoyix-swt-retail/edge-waterboys",
		BuildInfo: pallet.BuildInfo{
			Created:  "yesterday",
			Source:   "https://gothub.com/ncrvoyix-swt-retail/edge-infra",
			Revision: "d34db33f",
			Version:  "0.2.5",
		},
	}
}