package couchctl

import (
	"fmt"
	"reflect"
	"testing"

	"edge-infra.dev/pkg/edge/constants/api/cluster"
	"edge-infra.dev/pkg/edge/constants/api/fleet"
	dsapi "edge-infra.dev/pkg/edge/datasync/apis/v1alpha1"
	"edge-infra.dev/test/f2"
	"edge-infra.dev/test/f2/x/ktest"

	"github.com/go-kivik/kivik/v4"
	"github.com/stretchr/testify/require"
	"gotest.tools/v3/assert"

	"sigs.k8s.io/controller-runtime/pkg/client"
)

func TestDesignDocReconciler(t *testing.T) { //nolint:dupl
	fin := f2.NewFeature("CouchDesignDocReconciler").
		WithLabel(_fleetType, fleet.Store, fleet.CouchDB).
		WithLabel(_clusterType, cluster.Generic, cluster.DSDS).
		Setup("CouchDBDesignDoc Created", func(ctx f2.Context, t *testing.T) f2.Context {
			k := ktest.FromContextT(ctx, t)
			k.WaitOn(t, k.ObjExists(couchDBDatabase))
			assert.NilError(t, client.IgnoreAlreadyExists(k.Client.Create(ctx, couchDBDesignDoc)))
			return ctx
		}).
		Test("CouchDBDatabase Ready", testReady(couchDBDatabase)).
		Test("CouchDBDesignDoc Ready", testReady(couchDBDesignDoc)).
		Test("CouchDBDesignDoc Exist", func(ctx f2.Context, t *testing.T) f2.Context {
			k := ktest.FromContextT(ctx, t)
			cc, err := couchdbServerClient(ctx, k.Client, couchDBServer)
			require.NoError(t, err)

			row := cc.Client.DB(couchDBDatabase.Name).
				Get(ctx, fmt.Sprintf("_design/%s", couchDBDesignDoc.Spec.ID))
			require.NoError(t, err)
			require.True(t, viewExists(row, couchDBDesignDoc, t))
			return ctx
		}).
		Feature()

	f.Test(t, fin)
}

func viewExists(row *kivik.Document, ddoc *dsapi.CouchDBDesignDoc, t *testing.T) bool {
	data := map[string]interface{}{}
	err := row.ScanDoc(&data)
	if err != nil || len(data) == 0 {
		t.Error("Scan View Error", err)
		return false
	}

	if data["_id"] != fmt.Sprintf("_design/%s", ddoc.Spec.ID) {
		return false
	}

	expectedViews := ddoc.Spec.DesignDoc.Views
	actualViews := data["views"].(map[string]interface{})

	if len(expectedViews) != len(actualViews) {
		t.Log("Expected views length not equal to actual views length")
		return false
	}

	for expectedKey, expectedValue := range expectedViews {
		actualValue, ok := actualViews[expectedKey]
		if !ok {
			t.Error("Expected key not found in actual views", expectedKey)
			return false
		}
		actualKeyValues, ok := actualValue.(map[string]interface{})
		if !ok {
			t.Error("cannot convert actual value to map[string]interface{}", actualValue)
			return false
		}
		for expectedInnerKey, expectedInnerValue := range expectedValue {
			actualInnerValue, ok := actualKeyValues[expectedInnerKey]
			if !ok {
				t.Error("Expected key not found in actual views", expectedInnerKey)
				return false
			}
			if !reflect.DeepEqual(expectedInnerValue, actualInnerValue) {
				t.Error("Expected value not equal to actual value", expectedInnerValue, actualInnerValue)
				return false
			}
		}
	}
	return true
}