package object

import (
	"fmt"
	"strings"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"
	"k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"sigs.k8s.io/controller-runtime/pkg/client"

	"edge-infra.dev/pkg/k8s/object/fobject"
)

func TestCmpMaskData(t *testing.T) {
	testCases := []struct {
		name     string
		current  map[string]interface{}
		future   map[string]interface{}
		expected string
	}{
		{
			name:     "empty",
			current:  map[string]interface{}{},
			future:   map[string]interface{}{},
			expected: "",
		},
		{
			name: "no change",
			current: map[string]interface{}{
				"foo": "bar",
			},
			future: map[string]interface{}{
				"foo": "bar",
			},
			expected: "",
		},
		{
			name: "simple value changed",
			current: map[string]interface{}{
				"foo": "bar",
			},
			future: map[string]interface{}{
				"foo": "baz",
			},
			expected: fmt.Sprintf("foo\": string(\"%s\")", DefaultMask),
		},
		{
			name: "simple value changed with different casing",
			current: map[string]interface{}{
				"foo": "bar",
			},
			future: map[string]interface{}{
				"FOO": "baz",
			},
			expected: fmt.Sprintf("foo\": string(\"%s\")", DefaultMask),
		},
		{
			name: "value changed with different casing and different values",
			current: map[string]interface{}{
				"foo": "bar",
				"baz": "qux",
			},
			future: map[string]interface{}{
				"foo": "baz",
				"baz": "qux",
			},
			expected: fmt.Sprintf("baz\": string(\"%s\")", DefaultMask),
		},
	}

	t.Parallel()
	for _, tc := range testCases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			c, ft := CmpMaskData(tc.current, tc.future)
			if diff := cmp.Diff(c, ft); !strings.Contains(diff, tc.expected) {
				t.Errorf("Unexpected value in Diff")
			}
		})
	}
}

func TestReadObjects_DropsInvalid(t *testing.T) {
	testCases := []struct {
		name      string
		resources string
		expected  int
	}{
		{
			name: "valid resources",
			resources: `
---
apiVersion: v1
kind: Secret
metadata:
  name: test
  namespace: default
immutable: true
stringData:
  key: "private-key"
---
apiVersion: pkg.crossplane.io/v1
kind: Provider
metadata:
  name: crossplane-provider-aws2
spec:
  package: crossplane/provider-aws:v0.23.0
  controllerConfigRef:
    name: provider-aws
`,
			expected: 2,
		},
		{
			name: "some invalid resources",
			resources: `
---
piVersion: pkg.crossplane.io/v1
kind: Provider
metadata:
  name: crossplane-provider-aws1
spec:
  package: crossplane/provider-aws:v0.23.0
  controllerConfigRef:
    name: provider-aws
---
apiVersion: v1
kind: Secret
metadata:
  name: test
  namespace: default
immutable: true
stringData:
  key: "private-key"
`,
			expected: 1,
		},
	}

	t.Parallel()
	for _, tc := range testCases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			objects, err := ReadObjects(strings.NewReader(tc.resources))
			if err != nil {
				t.Errorf("unexpected error: %v", err)
			}

			if len(objects) != tc.expected {
				t.Errorf("unexpected number of objects in %v", objects)
			}
		})
	}
}

func TestIsDeleted(t *testing.T) {
	tcs := map[string]struct {
		obj      client.Object
		err      error
		expected bool
	}{
		"Marked for deletion no error": {
			&fobject.Fake{ObjectMeta: metav1.ObjectMeta{DeletionTimestamp: &metav1.Time{Time: time.Now()}}},
			nil,
			true,
		},
		"Marked for deletion error IsGone": {
			&fobject.Fake{ObjectMeta: metav1.ObjectMeta{DeletionTimestamp: &metav1.Time{Time: time.Now()}}},
			errors.NewGone(""),
			true,
		},
		"Marked for deletion error IsNotFound": {
			&fobject.Fake{ObjectMeta: metav1.ObjectMeta{DeletionTimestamp: &metav1.Time{Time: time.Now()}}},
			errors.NewNotFound(fobject.FakeGroupResource, ""),
			true,
		},
		"Error IsGone": {
			&fobject.Fake{},
			errors.NewGone(""),
			true,
		},
		"Error IsNotFound": {
			&fobject.Fake{},
			errors.NewNotFound(fobject.FakeGroupResource, ""),
			true,
		},
		"Not deleted": {
			&fobject.Fake{},
			nil,
			false,
		},
	}

	t.Parallel()
	for name, tc := range tcs {
		tc := tc
		t.Run(name, func(t *testing.T) {
			t.Parallel()
			actual := IsDeleted(tc.obj, tc.err)
			if tc.expected != actual {
				t.Error("expected", tc.expected, "got", actual,
					"error", tc.err, "object", tc.obj)
			}
		})
	}
}

func TestFmtObject(t *testing.T) {
	tcs := map[string]struct {
		obj      client.Object
		expected string
	}{
		"Namespaced": {
			&fobject.Fake{
				TypeMeta:   metav1.TypeMeta{Kind: "Fake"},
				ObjectMeta: metav1.ObjectMeta{Name: "special-boy", Namespace: "special-home"},
			},
			"Fake/special-home/special-boy",
		},
		"Cluster": {
			&fobject.Fake{
				TypeMeta:   metav1.TypeMeta{Kind: "Fake"},
				ObjectMeta: metav1.ObjectMeta{Name: "special-girl"},
			},
			"Fake/special-girl",
		},
	}

	t.Parallel()
	for name, tc := range tcs {
		tc := tc
		t.Run(name, func(t *testing.T) {
			t.Parallel()
			actual := FmtObject(tc.obj)
			if tc.expected != actual {
				t.Error("expected", tc.expected, "got", actual)
			}
		})
	}
}