package cloudtoedge

import (
	"testing"

	dsapi "edge-infra.dev/pkg/edge/datasync/apis/v1alpha1"
	"edge-infra.dev/pkg/edge/datasync/couchdb"
	"edge-infra.dev/pkg/k8s/testing/kmp"
	"edge-infra.dev/test/f2"
	"edge-infra.dev/test/f2/x/ktest"

	"gotest.tools/v3/assert"
	"gotest.tools/v3/assert/cmp"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

// TestCouchDBAdditionalResource test resources not deployed as part of couchdb pallet
func TestCouchDBNewResources(t *testing.T) {
	var k *ktest.K8s
	var ref dsapi.ServerReference
	var objs []client.Object
	feature := f2.NewFeature("CouchDB New Resources Check").
		Setup("Initial setup", func(ctx f2.Context, t *testing.T) f2.Context {
			k = ktest.FromContextT(ctx, t)
			servers := dsapi.CouchDBServerList{}
			err := k.Client.List(ctx, &servers, client.MatchingLabels{
				couchdb.NodeLeaderLabel: "true",
			})
			assert.NilError(t, err, "fail to list couchdb servers")
			assert.Equal(t, len(servers.Items), 1, "number of couchdb servers not equal to 1")

			ref = dsapi.ServerReference{
				Name:      servers.Items[0].Name,
				Namespace: servers.Items[0].Namespace,
			}
			objs = couchResources(ref, ctx.RunID)
			for _, obj := range objs {
				assert.NilError(t, k.Client.Create(ctx, obj), "fail to create object")
			}
			return ctx
		}).
		Test("Verify CouchDBDatabase in ready state", func(ctx f2.Context, t *testing.T) f2.Context {
			databases := dsapi.CouchDBDatabaseList{}
			err := k.Client.List(ctx, &databases, client.InNamespace(couchNamespace))
			assert.NilError(t, err, "fail to list couchdb databases")
			assert.Check(t, cmp.Len(databases.Items, 1), "CouchDBDatabase should not be empty")

			for _, database := range databases.Items {
				db := database
				k.WaitOn(t, k.Check(&db, kmp.IsReady()))
			}
			return ctx
		}).
		Test("Verify CouchDBIndex in ready state", func(ctx f2.Context, t *testing.T) f2.Context {
			indices := dsapi.CouchDBIndexList{}
			err := k.Client.List(ctx, &indices, client.InNamespace(couchNamespace))
			assert.NilError(t, err, "fail to list couchdb indices")
			assert.Check(t, cmp.Len(indices.Items, 1), "CouchDBIndex should not be empty")

			for _, index := range indices.Items {
				index := index
				k.WaitOn(t, k.Check(&index, kmp.IsReady()))
			}
			return ctx
		}).
		Test("Verify CouchDBDesignDoc in ready state", func(ctx f2.Context, t *testing.T) f2.Context {
			ddocs := dsapi.CouchDBDesignDocList{}
			err := k.Client.List(ctx, &ddocs, client.InNamespace(couchNamespace))
			assert.NilError(t, err, "fail to list couchdb design docs")
			assert.Check(t, cmp.Len(ddocs.Items, 1), "CouchDBDesignDoc should not be empty")

			for _, ddoc := range ddocs.Items {
				ddoc := ddoc
				k.WaitOn(t, k.Check(&ddoc, kmp.IsReady()))
			}
			return ctx
		}).
		Teardown("Clean up", func(ctx f2.Context, t *testing.T) f2.Context {
			for _, obj := range objs {
				assert.NilError(t, k.Client.Delete(ctx, obj), "fail to delete object")
			}
			return ctx
		}).
		Feature()
	f.Test(t, feature)
}

func couchResources(ref dsapi.ServerReference, runID string) []client.Object {
	var resources []client.Object
	name := "test-" + runID
	resources = append(resources, &dsapi.CouchDBDatabase{
		TypeMeta: metav1.TypeMeta{
			APIVersion: dsapi.GroupVersion.String(),
			Kind:       "CouchDBDatabase",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: couchNamespace,
		},
		Spec: dsapi.CouchDBDatabaseSpec{
			Name:      name,
			ServerRef: ref,
			Security: dsapi.Security{
				Admins: dsapi.NameRole{
					Names: []string{"admin"},
					Roles: []string{"admin"},
				},
			},
		},
	}, &dsapi.CouchDBIndex{
		TypeMeta: metav1.TypeMeta{
			APIVersion: dsapi.GroupVersion.String(),
			Kind:       "CouchDBIndex",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: couchNamespace,
		},
		Spec: dsapi.CouchDBIndexSpec{
			DB:   name,
			DDoc: "referenceId-index",
			Index: dsapi.Index{
				Fields: []string{"referenceId"},
			},
		},
	}, &dsapi.CouchDBDesignDoc{
		TypeMeta: metav1.TypeMeta{
			APIVersion: dsapi.GroupVersion.String(),
			Kind:       "CouchDBDesignDoc",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: couchNamespace,
		},
		Spec: dsapi.CouchDBDesignDocSpec{
			DB: name,
			ID: "package-identifier",
			DesignDoc: dsapi.DesignDoc{
				Views: map[string]map[string]string{
					"by_package_value": {
						"map": "function(doc) { if(doc.packageIdentifiers) { doc.packageIdentifiers.forEach(function(item) { if(item.value) emit([item.value],doc)});}}",
					},
				},
			},
		},
	})
	return resources
}