package kmp

import (
	"testing"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"edge-infra.dev/pkg/k8s/meta/status"
	"edge-infra.dev/pkg/k8s/runtime/conditions"
)

func TestConditions(t *testing.T) {
	t.Parallel()

	var (
		empty      = &metav1.Condition{}
		rdy        = conditions.TrueCondition(status.ReadyCondition, "", "")
		rdySuccess = conditions.TrueCondition(status.ReadyCondition, status.SucceededReason, "")
		rdyMsg     = conditions.TrueCondition(status.ReadyCondition, status.SucceededReason, "we done it")
		rdyMsg2    = conditions.TrueCondition(status.ReadyCondition, status.SucceededReason, "we done it again")
		recFalse   = conditions.FalseCondition(status.ReconcilingCondition, "Progressing", "")
		recFalse2  = conditions.FalseCondition(status.ReconcilingCondition, "", "")
		stalled    = conditions.TrueCondition(status.StalledCondition, status.DependencyInvalidReason, "")
	)

	tcs := map[string]map[string]testCase{
		"SameCondition": {
			"nil is same": {
				SameCondition(nil, nil),
				true,
			},
			"empty is same": {
				SameCondition(empty, empty),
				true,
			},
			"empty is not same": {
				SameCondition(empty, rdy),
				false,
			},
			"same": {
				SameCondition(rdy, rdy),
				true,
			},
			"same with reason": {
				SameCondition(rdySuccess, rdySuccess),
				true,
			},
			"same with message": {
				SameCondition(rdyMsg, rdyMsg),
				true,
			},
			"not same with substring message": {
				SameCondition(rdyMsg, rdyMsg2),
				false,
			},
			"not same with empty message": {
				SameCondition(rdy, rdyMsg),
				false,
			},
			"not same with different status": {
				SameCondition(recFalse, recFalse2),
				false,
			},
			"not same with different type": {
				SameCondition(rdy, stalled),
				false,
			},
		},
		"SameConditions": {
			"same": {
				SameConditions(
					[]metav1.Condition{*stalled, *recFalse},
					[]metav1.Condition{*stalled, *recFalse},
				),
				true,
			},
			"empty is same": {
				SameConditions(
					[]metav1.Condition{},
					[]metav1.Condition{},
				),
				true,
			},
			"not same": {
				SameConditions(
					[]metav1.Condition{*rdyMsg, *recFalse},
					[]metav1.Condition{*rdyMsg2, *recFalse},
				),
				false,
			},
			"not same with different lengths": {
				SameConditions(
					[]metav1.Condition{*rdy, *recFalse},
					[]metav1.Condition{*rdy},
				),
				false,
			},
		},
		"EqualCondition": {
			"nil is equal": {
				EqualCondition(nil, nil),
				true,
			},
			"empty is equal": {
				EqualCondition(empty, empty),
				true,
			},
			"equal": {
				EqualCondition(rdy, rdy),
				true,
			},
			"equal with reason": {
				EqualCondition(rdySuccess, rdySuccess),
				true,
			},
			"equal with same message": {
				EqualCondition(rdyMsg, rdyMsg),
				true,
			},
			"equal with substring message": {
				EqualCondition(rdyMsg2, rdyMsg),
				true,
			},
			"empty is not equal": {
				EqualCondition(empty, rdy),
				false,
			},
			"not equal with empty message": {
				EqualCondition(rdy, rdyMsg),
				false,
			},
			"not equal with different status": {
				EqualCondition(recFalse, recFalse2),
				false,
			},
			"not equal with different type": {
				EqualCondition(rdy, stalled),
				false,
			},
		},
		"EqualConditions": {
			"empty is equal": {
				EqualConditions(
					[]metav1.Condition{},
					[]metav1.Condition{},
				),
				true,
			},
			"equal": {
				EqualConditions(
					[]metav1.Condition{*stalled, *recFalse},
					[]metav1.Condition{*stalled, *recFalse},
				),
				true,
			},
			"equal with substring message": {
				EqualConditions(
					[]metav1.Condition{*rdyMsg, *recFalse},
					[]metav1.Condition{*rdyMsg2, *recFalse},
				),
				true,
			},
			"not equal": {
				EqualConditions(
					[]metav1.Condition{*rdyMsg, *recFalse},
					[]metav1.Condition{*rdy, *recFalse},
				),
				false,
			},
			"not equal with different lengths": {
				EqualConditions(
					[]metav1.Condition{*rdy, *recFalse},
					[]metav1.Condition{*rdy},
				),
				false,
			},
		},
	}

	for fn, fnTestCases := range tcs {
		fnTestCases := fnTestCases
		// Run tests so they are structured like:
		// TestConditions/EqualCondition/equal_is_same
		t.Run(fn, func(t *testing.T) {
			t.Parallel()
			for name, tc := range fnTestCases {
				t.Run(name, func(t *testing.T) {
					run(t, tc)
				})
			}
		})
	}
}