package resolve

import (
	"fmt"
	"os"
	"testing"

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

	"edge-infra.dev/pkg/f8n/warehouse/oci"
	"edge-infra.dev/pkg/f8n/warehouse/oci/mutate"
	"edge-infra.dev/pkg/f8n/warehouse/whtest/registry"
	"edge-infra.dev/test/fixtures"
	"edge-infra.dev/test/snapshot"
)

var path *fixtures.Path

func TestMain(m *testing.M) {
	var err error
	path, err = fixtures.Layout()
	if err != nil {
		panic(err)
	}

	os.Exit(m.Run())
}

func TestResolve(t *testing.T) {
	tcs := map[string]name.Reference{
		"shoot artifact":           name.MustParseReference("shoot:latest"),
		"redpanda-system artifact": name.MustParseReference("redpanda-system:latest"),
	}
	for test, tc := range tcs {
		t.Run(test, func(t *testing.T) {
			oart, err := path.Get(tc)
			if err != nil {
				t.Error(err)
			}

			result, err := Resolve(oart)
			if err != nil {
				t.Error(err)
			}

			snapshot.Snap(t, result)
		})
	}
}

func TestResolveRef(t *testing.T) {
	u, testRegistry, err := registry.New()
	if err != nil {
		t.Error(err)
	}

	tcs := map[string]string{
		"shoot artifact":           "shoot",
		"redpanda-system artifact": "redpanda-system",
	}

	for test, tc := range tcs {
		t.Run(test, func(t *testing.T) {
			ref, err := name.ParseReference(fmt.Sprintf("%s/test/%s:latest", u.Host, tc))
			if err != nil {
				t.Error(err)
			}
			t.Log(ref)

			if err := path.Push(ref, tc, "latest"); err != nil {
				t.Error(err)
			}

			result, err := Ref(ref)
			if err != nil {
				t.Error(err)
			}
			snapshots := make(map[string]v1.Hash, len(result))
			for k, v := range result {
				d, err := v.Digest()
				require.NoError(t, err)
				snapshots[k] = d
			}
			snapshot.Snap(t, snapshots)
		})
	}
	testRegistry.Close()
}

func TestAcceptFirst(t *testing.T) {
	oart, err := path.Get(name.MustParseReference("linkerdctl-test:latest"))
	if err != nil {
		require.NoError(t, err)
	}

	certMgr, err := path.Get(name.MustParseReference("cert-manager-test:resolve-conflict"))
	if err != nil {
		require.NoError(t, err)
	}

	newIdx, err := mutate.AppendManifests(oart.(v1.ImageIndex), certMgr)
	if err != nil {
		require.NoError(t, err)
	}

	_, err = Resolve(newIdx)
	var conflict *oci.ConflictError
	assert.ErrorAs(t, err, &conflict, "Failed TestAcceptFirst -> ConflictError expected")

	result, err := Resolve(newIdx, AcceptFirstDigest())
	assert.NoError(t, err, "Resolve should not error when AcceptFirst() is passed in.")
	d, err := result["cert-manager-test"].Digest()
	require.NoError(t, err)

	snapshot.Snap(t, d)
}