package integration

import (
	"context"
	"fmt"
	"io"
	"log"
	"os"
	"slices"
	"strings"
	"testing"

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

	"edge-infra.dev/pkg/f8n/warehouse/packagelock"
	"edge-infra.dev/pkg/f8n/warehouse/pallet"
	"edge-infra.dev/pkg/f8n/warehouse/release"
	"edge-infra.dev/test/f2"
	"edge-infra.dev/test/f2/x/warehouse"
)

var f f2.Framework
var err error
var (
	reg      *warehouse.Registry
	host     string
	hostRepo string
	ver01911 = "0.19.11"
	ver02019 = "0.20.19"
	ver0214  = "0.21.4"
	// ver01911Minor = "0.19"
	// ver02019Minor = "0.20"
	ver0214Minor = "0.21"

	edgeInfraRepo = release.Repository{
		Repo: release.GCPRepository{
			Location: "us-east1",
			Project:  "ret-edge-pltf-infra",
			RepoName: "warehouse",
		},
	}
	localWarehouseRepo release.Repository

	releaser01911    release.Releaser
	releaser02019    release.Releaser
	releaser0214     release.Releaser
	smallEnvironment release.Environment
	badEnvironment   release.Environment

	release0214ExpectedTags = []string{ver0214, ver0214Minor, "latest"}
	smallEnvironmentLock    = packagelock.PackageLock{
		Packages: []packagelock.LockPackage{
			{
				Name: "descheduler",
				Versions: []packagelock.Version{
					{
						Tags: []string{ver0214, ver0214Minor, "latest"},
					},
				},
			},
			{
				Name: "store",
				Versions: []packagelock.Version{
					{
						Tags: []string{ver0214, ver0214Minor, "latest"},
					},
				},
			},
			{
				Name: "data-sync",
				Versions: []packagelock.Version{
					{
						Tags: []string{ver0214, ver0214Minor, "latest"},
					},
				},
			},
		},
	}

	release01911 release.EdgeRelease
	release02019 release.EdgeRelease
	release0214  release.EdgeRelease
)

func TestMain(m *testing.M) {
	l := log.New(io.Discard, "", 0)
	f = f2.New(context.Background(), f2.WithExtensions(
		warehouse.New(registry.Logger(l)),
	)).Component("registry").
		Setup(func(ctx f2.Context) (f2.Context, error) {
			reg, err = warehouse.FromContext(ctx)
			if err != nil {
				return ctx, err
			}
			urlPts := strings.Split(reg.URL, "/")
			host = urlPts[0]
			hostRepo = urlPts[1]
			localWarehouseRepo = release.Repository{
				Repo: release.RawRepository{
					RawRegistry: host,
					RepoName:    hostRepo,
				},
			}
			return ctx, nil
		}).
		Component("releasers and environment").
		Setup(func(ctx f2.Context) (f2.Context, error) {
			releaser01911 = release.Releaser{
				CurrentVersion:        ver01911,
				SourceRepository:      edgeInfraRepo,
				DestinationRepository: localWarehouseRepo,
				PalletNames: []string{
					"descheduler",
					"store",
				},
			}

			releaser02019 = release.Releaser{
				CurrentVersion:        ver02019,
				SourceRepository:      edgeInfraRepo,
				DestinationRepository: localWarehouseRepo,
				PalletNames: []string{
					"descheduler",
					"store",
					"data-sync",
				},
			}

			releaser0214 = release.Releaser{
				CurrentVersion:        ver0214,
				SourceRepository:      edgeInfraRepo,
				DestinationRepository: localWarehouseRepo,
				PalletNames: []string{
					"descheduler",
					"store",
					"data-sync",
				},
			}

			smallEnvironment = release.Environment{
				SourceRepository: localWarehouseRepo,
				CurrentVersion:   ver0214,
			}

			badEnvironment = release.Environment{
				SourceRepository: localWarehouseRepo,
				CurrentVersion:   "0.0.0",
			}
			return ctx, nil
		})

	os.Exit(f.Run(m))
}

func TestBuildReleases(t *testing.T) {
	ft := f2.NewFeature("build 0.20.19 release subset").
		Setup("build releases from edge-infra", func(ctx f2.Context, t *testing.T) f2.Context {
			release01911, err = releaser01911.BuildRelease(ctx.Context, pallet.BuildInfo{})
			if err != nil {
				t.Fatal(err)
			}
			release02019, err = releaser02019.BuildRelease(ctx.Context, pallet.BuildInfo{})
			if err != nil {
				t.Fatal(err)
			}
			release0214, err = releaser0214.BuildRelease(ctx.Context, pallet.BuildInfo{})
			if err != nil {
				t.Fatal(err)
			}
			return ctx
		}).
		Test("test expected pallets in releases", func(ctx f2.Context, t *testing.T) f2.Context {
			for _, pall := range release01911.Pallets {
				foundName := slices.Contains(releaser01911.PalletNames, pall.Name())
				assert.True(t, foundName)
			}
			for _, pall := range release02019.Pallets {
				foundName := slices.Contains(releaser02019.PalletNames, pall.Name())
				assert.True(t, foundName)
			}
			for _, pall := range release0214.Pallets {
				foundName := slices.Contains(releaser0214.PalletNames, pall.Name())
				assert.True(t, foundName)
			}
			return ctx
		}).
		Test("test release metadata version is accurate", func(ctx f2.Context, t *testing.T) f2.Context {
			assert.Equal(t, releaser01911.CurrentVersion, release01911.Metadata.Version)
			assert.Equal(t, releaser02019.CurrentVersion, release02019.Metadata.Version)
			assert.Equal(t, releaser0214.CurrentVersion, release0214.Metadata.Version)
			return ctx
		}).
		Feature()
	f.Test(t, ft)
}

func TestPushRelease(t *testing.T) {
	ft := f2.NewFeature("test push release functionality").
		Setup("push release to integration repo", func(ctx f2.Context, _ *testing.T) f2.Context {
			err = releaser01911.Push(ctx, release01911)
			assert.NoError(t, err)
			err = releaser02019.Push(ctx, release02019)
			assert.NoError(t, err)
			err = releaser0214.Push(ctx, release0214)
			assert.NoError(t, err)
			return ctx
		}).
		Feature()
	f.Test(t, ft)
}

func TestPullReleases(t *testing.T) {
	ft := f2.NewFeature("pull releases from live repositories").
		Setup("pull releases", func(ctx f2.Context, t *testing.T) f2.Context {
			releases, err := smallEnvironment.PullReleases()
			if err != nil {
				t.Fatal(err)
			}
			assert.Len(t, releases, 1)
			release0214 = releases[0]
			return ctx
		}).
		Test("ensure release is present", func(ctx f2.Context, t *testing.T) f2.Context {
			assert.Equal(t, release0214.Metadata.Version, ver0214)
			return ctx
		}).
		Feature()
	f.Test(t, ft)
}

func TestErrorOnMissingRelease(t *testing.T) {
	ft := f2.NewFeature("attempt to pull a release that does not exist").
		Test("ensure missing release errors", func(ctx f2.Context, t *testing.T) f2.Context {
			releases, err := badEnvironment.PullReleases()
			assert.Nil(t, releases)
			assert.Error(t, err)
			return ctx
		}).
		Feature()
	f.Test(t, ft)
}

func TestLockSmallEnvironment(t *testing.T) {
	var pl packagelock.PackageLock
	ft := f2.NewFeature("lock a small environment's releases").
		Setup("lock pulled releases", func(ctx f2.Context, _ *testing.T) f2.Context {
			pl, err = smallEnvironment.LockReleases([]release.EdgeRelease{release0214})
			fmt.Println("integration pl", pl)
			return ctx
		}).
		Test("check pl tags match expected", func(ctx f2.Context, _ *testing.T) f2.Context {
			packageCount := len(smallEnvironmentLock.Packages)
			assert.Len(t, pl.Packages, len(smallEnvironmentLock.Packages))
			for _, lp := range pl.Packages {
				assert.Len(t, lp.Versions, 1)
				for _, exLp := range smallEnvironmentLock.Packages {
					assert.Len(t, lp.Versions, len(exLp.Versions))
					assert.Equal(t, lp.Versions[0].Tags, release0214ExpectedTags)
				}
				packageCount--
			}
			assert.Equal(t, packageCount, 0)
			return ctx
		}).
		Feature()
	f.Test(t, ft)
}

// func TestContainedReleaseE2E(t *testing.T) {
// 	// var reg *warehouse.Registry
// 	// var host string
// 	// var projectID string
// 	// Pallets
// 	var (
// 		storePalletName = "store"
// 		// storePallet          pallet.Pallet
// 		storeDigest          v1.Hash
// 		cloudInfraPalletName = "cloud-infra"
// 		// cloudInfraPallet     pallet.Pallet
// 		cloudInfraDigest v1.Hash
// 	)

// 	// Release
// 	var (
// 		testRelease  release.EdgeRelease
// 		testManifest *v1.IndexManifest
// 	)

// 	sourceRepoName := "f2repo"

// 	releasePallets := []string{storePalletName, cloudInfraPalletName}

// 	ft := f2.NewFeature("push").
// 		Setup("add store pallet", func(ctx f2.Context, t *testing.T) f2.Context {
// 			// create and push an artifact to the test registry
// 			l, err := layer.New(layer.Runtime, []byte("hello"))
// 			if err != nil {
// 				t.Fatal(err)
// 			}
// 			layers := []layer.Layer{l}
// 			storePallet, err := pallet.Image(pallet.Options{
// 				Metadata: pallet.Metadata{
// 					Name: storePalletName,
// 					Team: "f8n",
// 					BuildInfo: pallet.BuildInfo{
// 						Created:  "yesterday",
// 						Source:   "https://gothub.com/ncrvoyix-swt-retail/edge-infra",
// 						Revision: "d34db33f",
// 						Version:  ver02019,
// 					},
// 				},
// 				ClusterProviders: cluster.BuiltInProviders(),
// 			}, layers...)
// 			if err != nil {
// 				t.Fatal("failed to create test pallet", storePalletName, err)
// 			}
// 			storeDigest, err = storePallet.Digest()
// 			if err != nil {
// 				t.Fatal(err)
// 			}

// 			tag := ver02019
// 			pushPath := fmt.Sprintf("%s/%s", sourceRepoName, storePalletName)
// 			if err := reg.Push(storePallet, pushPath, tag, remote.WithoutAuth()); err != nil {
// 				t.Fatal("failed to push test pallet", err)
// 			}

// 			fmt.Println("pushed store pallet")
// 			return ctx
// 		}).
// 		Setup("add cloud-infra pallet", func(ctx f2.Context, t *testing.T) f2.Context {
// 			// create and push an artifact to the test registry
// 			l, err := layer.New(layer.Runtime, []byte("its infra time"))
// 			if err != nil {
// 				t.Fatal(err)
// 			}
// 			layers := []layer.Layer{l}
// 			cloudInfraPallet, err := pallet.Image(pallet.Options{
// 				Metadata: pallet.Metadata{
// 					Name: cloudInfraPalletName,
// 					Team: "f8n",
// 					BuildInfo: pallet.BuildInfo{
// 						Created:  "yesterday",
// 						Source:   "https://gothub.com/ncrvoyix-swt-retail/edge-infra",
// 						Revision: "d34db33f",
// 						Version:  ver02019,
// 					},
// 				},
// 				ClusterProviders: cluster.BuiltInProviders(),
// 			}, layers...)
// 			if err != nil {
// 				t.Fatal("failed to create test pallet", cloudInfraPalletName, err)
// 			}
// 			cloudInfraDigest, err = cloudInfraPallet.Digest()
// 			if err != nil {
// 				t.Fatal(err)
// 			}

// 			tag := ver02019
// 			pushPath := fmt.Sprintf("%s/%s", sourceRepoName, cloudInfraPalletName)
// 			if err := reg.Push(cloudInfraPallet, pushPath, tag, remote.WithoutAuth()); err != nil {
// 				t.Fatal("failed to push test pallet", err)
// 			}

// 			fmt.Println("pushed cloud-infra pallet")
// 			return ctx
// 		}).
// 		Test("build release", func(ctx f2.Context, t *testing.T) f2.Context {
// 			sourceRepo := release.Repository{
// 				Repo: release.RawRepository{
// 					RawRegistry: reg.URL,
// 					RepoName:    sourceRepoName,
// 				},
// 			}
// 			releaser := &release.Releaser{
// 				CurrentVersion:   ver02019,
// 				SourceRepository: sourceRepo,
// 				PalletNames:      releasePallets,
// 			}

// 			fmt.Println("build release")
// 			testRelease, err = releaser.BuildRelease(ctx.Context, pallet.BuildInfo{})
// 			if err != nil {
// 				t.Fatal(err)
// 			}

// 			testIdx, isIdx := testRelease.Artifact.(v1.ImageIndex)
// 			if !isIdx {
// 				t.Fatal("release is not index")
// 				return ctx
// 			}
// 			idxBytes, err := testIdx.RawManifest()
// 			if err != nil {
// 				t.Fatal("could not get raw manifest")
// 			}
// 			fmt.Println(string(idxBytes))

// 			testManifest, err = testIdx.IndexManifest()
// 			if err != nil {
// 				fmt.Println(err)
// 				t.Fatal(err)
// 				return ctx
// 			}

// 			return ctx
// 		}).
// 		Test("check store artifact", func(ctx f2.Context, t *testing.T) f2.Context {
// 			var storeDescr v1.Descriptor
// 			for _, descr := range testManifest.Manifests {
// 				fmt.Println(descr.Annotations)
// 				if annoName, found := descr.Annotations[wh.AnnotationName]; found && annoName == storePalletName {
// 					storeDescr = descr
// 					break
// 				}
// 			}

// 			if storeDescr.Size == 0 {
// 				t.Fatal("could not find store artifact in test release manifests")
// 				return ctx
// 			}

// 			if storeDigest.Hex != storeDescr.Digest.Hex {
// 				fmt.Println("store digest did not match")
// 				fmt.Println("got", storeDescr.Digest.Hex)
// 				fmt.Println("wanted", storeDigest.Hex)
// 				t.Fatal("store digest did not match")
// 			}

// 			fmt.Println("store artifact found successfully")
// 			return ctx
// 		}).
// 		Test("check cloud artifact", func(ctx f2.Context, t *testing.T) f2.Context {
// 			var cloudDescr v1.Descriptor
// 			for _, descr := range testManifest.Manifests {
// 				if annoName, found := descr.Annotations[wh.AnnotationName]; found && annoName == cloudInfraPalletName {
// 					cloudDescr = descr
// 					break
// 				}
// 			}

// 			if cloudDescr.Size == 0 {
// 				t.Fatal("could not find cloud infra artifact in test release manifests")
// 				return ctx
// 			}

// 			if cloudInfraDigest.Hex != cloudDescr.Digest.Hex {
// 				fmt.Println("cloud digest did not match")
// 				fmt.Println("got", cloudDescr.Digest.Hex)
// 				fmt.Println("wanted", cloudInfraDigest.Hex)
// 				t.Fatal("cloud digest did not match")
// 			}
// 			fmt.Println("cloud artifact found successfully")

// 			return ctx
// 		}).
// 		Feature()

// 	f.Test(t, ft)
// }