package applicationsets

import (
	"fmt"
	"reflect"
	"regexp"
	"slices"
	"strings"
	"testing"

	"github.com/argoproj/argo-cd/gitops-engine/pkg/diff"
	"github.com/argoproj/argo-cd/gitops-engine/pkg/health"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"github.com/argoproj/argo-cd/v3/pkg/apis/application/v1alpha1"
	"github.com/argoproj/argo-cd/v3/test/e2e/fixture/applicationsets/utils"
)

type state = string

const (
	failed    = "failed"
	pending   = "pending"
	succeeded = "succeeded"
)

// Expectation returns succeeded on succes condition, or pending/failed on failure, along with
// a message to describe the success/failure condition.
type Expectation func(c *Consequences) (state state, message string)

// Success asserts that the last command was successful
func Success(message string) Expectation {
	return func(c *Consequences) (state, string) {
		if c.actions.lastError != nil {
			return failed, fmt.Sprintf("error: %v", c.actions.lastError)
		}
		if !strings.Contains(c.actions.lastOutput, message) {
			return failed, fmt.Sprintf("output did not contain '%s'", message)
		}
		return succeeded, fmt.Sprintf("no error and output contained '%s'", message)
	}
}

// Error asserts that the last command was an error with substring match
func Error(message, err string) Expectation {
	return func(c *Consequences) (state, string) {
		if c.actions.lastError == nil {
			return failed, "no error"
		}
		if !strings.Contains(c.actions.lastOutput, message) {
			return failed, fmt.Sprintf("output does not contain '%s'", message)
		}
		if !strings.Contains(c.actions.lastError.Error(), err) {
			return failed, fmt.Sprintf("error does not contain '%s'", message)
		}
		return succeeded, fmt.Sprintf("error '%s'", message)
	}
}

// ApplicationsExist checks whether each of the 'expectedApps' exist in the namespace, and are
// equivalent to provided values.
func ApplicationsExist(expectedApps []v1alpha1.Application) Expectation {
	return func(c *Consequences) (state, string) {
		for _, expectedApp := range expectedApps {
			foundApp := c.app(expectedApp.Name)
			if foundApp == nil {
				return pending, fmt.Sprintf("missing app '%s'", expectedApp.QualifiedName())
			}

			if !appsAreEqual(expectedApp, *foundApp) {
				diff, err := getDiff(filterFields(expectedApp), filterFields(*foundApp))
				if err != nil {
					return failed, err.Error()
				}

				return pending, fmt.Sprintf("apps are not equal: '%s', diff: %s\n", expectedApp.QualifiedName(), diff)
			}
		}

		return succeeded, "all apps successfully found"
	}
}

// ApplicationSetHasHealthStatus checks whether the ApplicationSet has the expected health status.
func ApplicationSetHasHealthStatus(expectedHealthStatus health.HealthStatusCode) Expectation {
	return func(c *Consequences) (state, string) {
		// retrieve the application set
		foundApplicationSet := c.applicationSet(c.context.GetName())
		if foundApplicationSet == nil {
			return pending, fmt.Sprintf("application set '%s' not found", c.context.GetName())
		}

		if foundApplicationSet.Status.Health.Status != expectedHealthStatus {
			return pending, fmt.Sprintf("application set health status is '%s', expected '%s'",
				foundApplicationSet.Status.Health.Status, expectedHealthStatus)
		}
		return succeeded, fmt.Sprintf("application set has expected health status '%s'", expectedHealthStatus)
	}
}

// ApplicationSetHasConditions checks whether each of the 'expectedConditions' exist in the ApplicationSet status, and are
// equivalent to provided values.
func ApplicationSetHasConditions(expectedConditions []v1alpha1.ApplicationSetCondition) Expectation {
	return func(c *Consequences) (state, string) {
		// retrieve the application set
		foundApplicationSet := c.applicationSet(c.context.GetName())
		if foundApplicationSet == nil {
			return pending, fmt.Sprintf("application set '%s' not found", c.context.GetName())
		}

		if !conditionsAreEqual(&expectedConditions, &foundApplicationSet.Status.Conditions) {
			diff, err := getConditionDiff(expectedConditions, foundApplicationSet.Status.Conditions)
			if err != nil {
				return failed, err.Error()
			}
			return pending, fmt.Sprintf("application set conditions are not equal: '%s', diff: %s\n", expectedConditions, diff)
		}
		return succeeded, "application set successfully found"
	}
}

func ApplicationSetHasCondition(expType v1alpha1.ApplicationSetConditionType, expStatus v1alpha1.ApplicationSetConditionStatus, expMessage *regexp.Regexp, expReason string) Expectation {
	return func(c *Consequences) (state, string) {
		foundApplicationSet := c.applicationSet(c.context.GetName())
		if foundApplicationSet == nil {
			return pending, fmt.Sprintf("application set '%s' not found", c.context.GetName())
		}
		got := foundApplicationSet.Status.Conditions
		message := fmt.Sprintf("condition {%s %s %s %s} in %v", expType, expMessage, expStatus, expReason, got)
		for _, condition := range got {
			if expType == condition.Type && expStatus == condition.Status && expReason == condition.Reason && expMessage.MatchString(condition.Message) {
				return succeeded, message
			}
		}
		return pending, message
	}
}

// ApplicationsDoNotExist checks that each of the 'expectedApps' no longer exist in the namespace
func ApplicationsDoNotExist(expectedApps []v1alpha1.Application) Expectation {
	return func(c *Consequences) (state, string) {
		for _, expectedApp := range expectedApps {
			foundApp := c.app(expectedApp.Name)
			if foundApp != nil {
				return pending, fmt.Sprintf("app '%s' should no longer exist", expectedApp.QualifiedName())
			}
		}

		return succeeded, "all apps do not exist"
	}
}

// Pod checks whether a specified condition is true for any of the pods in the namespace
func Pod(t *testing.T, predicate func(p corev1.Pod) bool) Expectation {
	t.Helper()
	return func(_ *Consequences) (state, string) {
		pods, err := pods(t, utils.ApplicationsResourcesNamespace)
		if err != nil {
			return failed, err.Error()
		}
		for _, pod := range pods.Items {
			if predicate(pod) {
				return succeeded, fmt.Sprintf("pod predicate matched pod named '%s'", pod.GetName())
			}
		}
		return pending, "pod predicate does not match pods"
	}
}

func pods(t *testing.T, namespace string) (*corev1.PodList, error) {
	t.Helper()
	fixtureClient := utils.GetE2EFixtureK8sClient(t)

	pods, err := fixtureClient.KubeClientset.CoreV1().Pods(namespace).List(t.Context(), metav1.ListOptions{})
	return pods, err
}

// getDiff returns a string containing a comparison result of two applications (for test output/debug purposes)
func getDiff(orig, newApplication v1alpha1.Application) (string, error) {
	bytes, _, err := diff.CreateTwoWayMergePatch(orig, newApplication, orig)
	if err != nil {
		return "", err
	}

	return string(bytes), nil
}

// getConditionDiff returns a string containing a comparison result of two ApplicationSetCondition (for test output/debug purposes)
func getConditionDiff(orig, newApplicationSetCondition []v1alpha1.ApplicationSetCondition) (string, error) {
	if len(orig) != len(newApplicationSetCondition) {
		return fmt.Sprintf("mismatch between condition sizes: %v %v", len(orig), len(newApplicationSetCondition)), nil
	}

	var bytes []byte

	for index := range orig {
		b, _, err := diff.CreateTwoWayMergePatch(orig[index], newApplicationSetCondition[index], orig[index])
		if err != nil {
			return "", err
		}
		bytes = append(bytes, b...)
	}

	return string(bytes), nil
}

// filterFields returns a copy of Application, but with unnecessary (for testing) fields removed
func filterFields(input v1alpha1.Application) v1alpha1.Application {
	spec := input.Spec

	metaCopy := input.ObjectMeta.DeepCopy()

	output := v1alpha1.Application{
		ObjectMeta: metav1.ObjectMeta{
			Labels:      metaCopy.Labels,
			Annotations: metaCopy.Annotations,
			Name:        metaCopy.Name,
			Namespace:   metaCopy.Namespace,
			Finalizers:  metaCopy.Finalizers,
		},
		Spec: v1alpha1.ApplicationSpec{
			Source: &v1alpha1.ApplicationSource{
				Path:           spec.GetSource().Path,
				RepoURL:        spec.GetSource().RepoURL,
				TargetRevision: spec.GetSource().TargetRevision,
			},
			Destination: v1alpha1.ApplicationDestination{
				Server:    spec.Destination.Server,
				Name:      spec.Destination.Name,
				Namespace: spec.Destination.Namespace,
			},
			Project: spec.Project,
		},
	}

	return output
}

// filterConditionFields returns a copy of ApplicationSetCondition, but with unnecessary (for testing) fields removed
func filterConditionFields(input *[]v1alpha1.ApplicationSetCondition) *[]v1alpha1.ApplicationSetCondition {
	var filteredConditions []v1alpha1.ApplicationSetCondition
	for _, condition := range *input {
		newCondition := &v1alpha1.ApplicationSetCondition{
			Type:    condition.Type,
			Status:  condition.Status,
			Message: condition.Message,
			Reason:  condition.Reason,
		}
		filteredConditions = append(filteredConditions, *newCondition)
	}

	return &filteredConditions
}

// appsAreEqual returns true if the apps are equal, comparing only fields of interest
func appsAreEqual(one v1alpha1.Application, two v1alpha1.Application) bool {
	return reflect.DeepEqual(filterFields(one), filterFields(two))
}

// conditionsAreEqual returns true if the appset status conditions are equal, comparing only fields of interest
func conditionsAreEqual(one, two *[]v1alpha1.ApplicationSetCondition) bool {
	return reflect.DeepEqual(filterConditionFields(one), filterConditionFields(two))
}

// CheckProgressiveSyncStatusCodeOfApplications checks whether the progressive sync status codes of applications in ApplicationSetApplicationStatus
// match the expected values.
func CheckProgressiveSyncStatusCodeOfApplications(expectedStatuses map[string]v1alpha1.ApplicationSetApplicationStatus) Expectation {
	return func(c *Consequences) (state, string) {
		appSet := c.applicationSet(c.context.GetName())
		if appSet == nil {
			return pending, fmt.Sprintf("no ApplicationSet found with name '%s'", c.context.GetName())
		}
		if appSet.Status.ApplicationStatus == nil {
			return pending, fmt.Sprintf("no application status found for ApplicationSet '%s'", c.context.GetName())
		}
		for _, appStatus := range appSet.Status.ApplicationStatus {
			expectedstatus, found := expectedStatuses[appStatus.Application]
			if !found {
				continue // Appset has more apps than expected - not ideal
			}
			if appStatus.Status != expectedstatus.Status {
				return pending, fmt.Sprintf("for application '%s': expected status '%s' but got '%s'", expectedstatus.Application, expectedstatus.Status, appStatus.Status)
			}
		}
		return succeeded, fmt.Sprintf("all applications in ApplicationSet's: '%s' Application Status have expected statuses ", c.context.GetName())
	}
}

// CheckApplicationInRightSteps checks that a step contains exactly the expected applications.
func CheckApplicationInRightSteps(step string, expectedApps []string) Expectation {
	return func(c *Consequences) (state, string) {
		appSet := c.applicationSet(c.context.GetName())
		if appSet == nil {
			return pending, fmt.Sprintf("no application set found with name '%s'", c.context.GetName())
		}
		if appSet.Status.ApplicationStatus == nil {
			return pending, fmt.Sprintf("no application status found for ApplicationSet '%s'", c.context.GetName())
		}
		var stepApps []string
		for _, appStatus := range appSet.Status.ApplicationStatus {
			if appStatus.Step == step {
				stepApps = append(stepApps, appStatus.Application)
			}
		}
		if len(stepApps) != len(expectedApps) {
			return pending, fmt.Sprintf("expected %d apps in step '%s' for appset '%s', but got %d", len(expectedApps), step, c.context.GetName(), len(stepApps))
		}
		// Sort before comparing to avoid flakiness
		slices.Sort(stepApps)
		slices.Sort(expectedApps)
		if !slices.Equal(stepApps, expectedApps) {
			return pending, fmt.Sprintf("In step '%s', expected apps: '%s', but got: '%s'", step, expectedApps, stepApps)
		}
		return succeeded, fmt.Sprintf("Step '%s' has expected apps: '%s'", step, expectedApps)
	}
}

// ApplicationSetDoesNotHaveApplicationStatus checks that ApplicationSet.Status.ApplicationStatus is nil
func ApplicationSetDoesNotHaveApplicationStatus() Expectation {
	return func(c *Consequences) (state, string) {
		appSet := c.applicationSet(c.context.GetName())
		if appSet == nil {
			return pending, fmt.Sprintf("no application set found with name '%s'", c.context.GetName())
		}
		if appSet.Status.ApplicationStatus != nil {
			return failed, fmt.Sprintf("application set '%s' has ApplicationStatus when not expected", c.context.GetName())
		}
		return succeeded, fmt.Sprintf("Application '%s' does not have ApplicationStatus", c.context.GetName())
	}
}

// ApplicationSetHasApplicationStatus checks that ApplicationSet has expected number of applications in its status
// and all have progressive sync status Healthy.
func ApplicationSetHasApplicationStatus(expectedApplicationStatusLength int) Expectation {
	return func(c *Consequences) (state, string) {
		appSet := c.applicationSet(c.context.GetName())
		if appSet == nil {
			return pending, fmt.Sprintf("no application set found with name '%s'", c.context.GetName())
		}
		if appSet.Status.ApplicationStatus == nil {
			return pending, fmt.Sprintf("application set '%s' has no ApplicationStatus when '%d' expected", c.context.GetName(), expectedApplicationStatusLength)
		}

		if len(appSet.Status.ApplicationStatus) != expectedApplicationStatusLength {
			return failed, fmt.Sprintf("applicationset has '%d' applicationstatus, when '%d' are expected", len(appSet.Status.ApplicationStatus), expectedApplicationStatusLength)
		}

		for _, appStatus := range appSet.Status.ApplicationStatus {
			if appStatus.Status != v1alpha1.ProgressiveSyncHealthy {
				return pending, fmt.Sprintf("Application '%s' not Healthy", appStatus.Application)
			}
		}
		return succeeded, fmt.Sprintf("All Applications in ApplicationSet: '%s' are Healthy ", c.context.GetName())
	}
}

// ApplicationDeletionStarted verifies at least one application from provided list of appNames has DeletionTimestamp set,
// indicating deletion has begun for this step. Returns failed if any application doesn't exist, does not expect completion of deletion.
func ApplicationDeletionStarted(appNames []string) Expectation {
	return func(c *Consequences) (state, string) {
		anyapp := false
		for _, appName := range appNames {
			app := c.app(appName)
			if app == nil {
				// with test finalizer explicitly added, application should not be deleted
				return failed, fmt.Sprintf("no application found with name '%s'", c.context.GetName())
			}
			if app.DeletionTimestamp != nil {
				anyapp = true
			}
		}
		if !anyapp {
			return pending, "no app in this step is being deleted yet"
		}
		return succeeded, fmt.Sprintf("at least one app in %v is being deleted or gone", appNames)
	}
}

// ApplicationsExistAndNotBeingDeleted checks that specified apps exist and do NOT have DeletionTimestamp set
func ApplicationsExistAndNotBeingDeleted(appNames []string) Expectation {
	return func(c *Consequences) (state, string) {
		for _, appName := range appNames {
			app := c.app(appName)
			if app == nil {
				return failed, fmt.Sprintf("app '%s' does not exist but should", appName)
			}
			if app.DeletionTimestamp != nil {
				return failed, fmt.Sprintf("app '%s' is being deleted but should not be yet", appName)
			}
		}
		return succeeded, fmt.Sprintf("all apps %v exist and are not being deleted", appNames)
	}
}
