package mapper

import (
	"time"

	helmApi "github.com/fluxcd/helm-controller/api/v2beta1"
	"google.golang.org/api/compute/v1"
	corev1 "k8s.io/api/core/v1"
	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/constants"
)

func getTestHelmRelease() *helmApi.HelmRelease {
	return &helmApi.HelmRelease{
		TypeMeta: metav1.TypeMeta{
			APIVersion: helmApi.GroupVersion.Group + "/" + helmApi.GroupVersion.Version,
			Kind:       "HelmRelease",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:              "test-helm-release",
			Namespace:         "test-ns",
			CreationTimestamp: metav1.Now(),
		},
		Spec: helmApi.HelmReleaseSpec{
			Chart: &helmApi.HelmChartTemplate{
				Spec: helmApi.HelmChartTemplateSpec{
					Chart:   "test-helm-chart",
					Version: "2.0.x",
					SourceRef: helmApi.CrossNamespaceObjectReference{
						Name: "test-helm-release",
					},
				},
			},
			Values: &apiextensionsv1.JSON{
				Raw: []byte(configValues),
			},
			TargetNamespace: "test-target-ns",
			Timeout: &metav1.Duration{
				Duration: time.Duration(HelmReleaseTimeout) * time.Minute,
			},
		},
		Status: helmApi.HelmReleaseStatus{
			ObservedGeneration: 0,
			Conditions: []metav1.Condition{{
				Type:               "Ready",
				Status:             "True",
				LastTransitionTime: metav1.Now(),
				Reason:             "test reason",
				Message:            "reconciliation successful",
			}, {
				Type:               helmApi.ReleasedCondition,
				Status:             "False",
				LastTransitionTime: metav1.Now(),
				Reason:             "test failure",
				Message:            "install failed",
			}},
			//History: helmApi.Snapshots{
			//	&helmApi.Snapshot{
			//		ChartVersion: "2.0.1",
			//	},
			//},
		},
	}
}

func GetTestHelmRepositorySecret() *model.SecretManagerResponse {
	n := time.Now().String()
	w := "edge-tenant"
	return &model.SecretManagerResponse{
		Name:     "secret-name",
		Created:  &n,
		Workload: &w,
		Values:   []*model.KeyValuesOutput{{Key: constants.HelmURL, Value: "https://test.ncr.com"}, {Key: constants.HelmRepoName, Value: "test-helm-release"}},
	}
}

func getTestHelmReleaseData(helmReleases []helmApi.HelmRelease) map[string][]*string {
	helmReleasesData := make(map[string][]*string)
	helmVersion := make([]*string, 0)
	versions := []string{"0.3.0", "0.2.0", "0.1.4", "0.1.3", "0.1.2", "0.1.1"}
	for index := range versions {
		helmVersion = append(helmVersion, &versions[index])
	}
	for _, helmData := range helmReleases {
		helmReleasesData[helmData.Spec.Chart.Spec.SourceRef.Name] = getHelmChartVersions(helmData.Spec.Chart.Spec.Chart, helmVersion).Versions
	}
	return helmReleasesData
}

func getHelmChartVersions(name string, versions []*string) *model.HelmChartResponse {
	return &model.HelmChartResponse{
		Name:     name,
		Versions: versions,
	}
}

func getCreateHelmReleaseCreate(actionNs, targetNamespace string) *helmApi.HelmRelease {
	labels := map[string]string{
		"parent-cluster":         Region,
		SecretManagerSecretLabel: "",
	}
	helmRelease := &helmApi.HelmRelease{
		TypeMeta: metav1.TypeMeta{
			APIVersion: helmApi.GroupVersion.String(),
			Kind:       "HelmRelease",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: actionNs,
			Labels:    labels,
		},
		Spec: helmApi.HelmReleaseSpec{
			Interval: metav1.Duration{
				Duration: time.Duration(2) * time.Minute,
			},
			ReleaseName:     name,
			TargetNamespace: targetNamespace,
			Chart: &helmApi.HelmChartTemplate{
				Spec: helmApi.HelmChartTemplateSpec{
					Chart:   helmChart,
					Version: version,
					SourceRef: helmApi.CrossNamespaceObjectReference{
						Kind: "HelmRepository",
						Name: helmRepository,
					},
				},
			},
			Timeout: &metav1.Duration{
				Duration: time.Duration(HelmReleaseTimeout) * time.Minute,
			},
		},
	}
	return helmRelease
}

func getTestServiceAccountSecret(name string, data []byte) *corev1.Secret {
	labels := map[string]string{
		"edge-type": "service_account",
	}
	return &corev1.Secret{
		TypeMeta: metav1.TypeMeta{
			APIVersion: "v1",
			Kind:       "ServiceAccount",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:              name,
			Namespace:         "test",
			Labels:            labels,
			CreationTimestamp: metav1.Now(),
		},
		Data: map[string][]byte{
			"key.json": data,
		},
	}
}

func getTestServiceAccount() *model.ServiceAccount {
	return &model.ServiceAccount{
		ProjectID:    &projectID,
		PrivateKeyID: &privateKeyID,
		PrivateKey:   &privateKey,
		ClientEmail:  &clientEmail,
		TokenURI:     &tokenURI,
	}
}

func getTestZoneList() *compute.ZoneList {
	return &compute.ZoneList{
		Items: []*compute.Zone{getTestZone("us-east1-a"), getTestZone("us-central2-b")},
	}
}

func getTestZone(name string) *compute.Zone {
	return &compute.Zone{
		Name: name,
	}
}

func getTestMachineList() *compute.MachineTypeList {
	return &compute.MachineTypeList{
		Items: []*compute.MachineType{getTestMachineType("n1-standard-2", 4, 61440)},
	}
}

func getTestMachineType(name string, numCPUs int64, memoryMb int64) *compute.MachineType {
	return &compute.MachineType{
		Name:      name,
		GuestCpus: numCPUs,
		MemoryMb:  memoryMb,
	}
}

func getTestGkeVersions() []string {
	return []string{"1.4-gke-test", "1.4.5-gke-test"}
}

func getTestStringArr(str1, str2 string) []*string {
	return []*string{&str1, &str2}
}

func getTestMachineInfo(name string, numCPUs int, memoryGB int) *model.MachineTypeInfo {
	return &model.MachineTypeInfo{
		Name:      name,
		GuestCPUs: numCPUs,
		MemoryGb:  memoryGB,
	}
}

func getTestSecret(org, secretType, name string) *corev1.Secret {
	labels := map[string]string{
		"edge-type": secretType,
	}
	return &corev1.Secret{
		TypeMeta: metav1.TypeMeta{
			APIVersion: "v1",
			Kind:       "Secret",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:              name,
			Namespace:         org,
			Labels:            labels,
			CreationTimestamp: metav1.Now(),
		},
	}
}

func getSecret(namespace, name, kubeconfig string) *corev1.Secret { //nolint might be used in the future and test
	return &corev1.Secret{
		TypeMeta: metav1.TypeMeta{
			APIVersion: "v1",
			Kind:       "Secret",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: namespace,
		},
		Data: map[string][]byte{
			"kubeconfig.yaml": []byte(kubeconfig),
		},
	}
}