package mapper

import (
	"fmt"
	"regexp"
	"strings"

	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime"

	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/api/utils"
	metastatus "edge-infra.dev/pkg/k8s/meta/status"
)

func ToClusterKubeConfig(secret *corev1.Secret, endpoint string) *model.ClusterKubeconfig {
	if len(secret.Data["kubeconfig.yaml"]) > 0 {
		return ToClusterKubeConfigString(string(secret.Data["kubeconfig.yaml"]), endpoint)
	}
	return &model.ClusterKubeconfig{
		ClusterKubeConfig:         "",
		RedactedClusterKubeConfig: "",
	}
}

func ToClusterKubeConfigString(kubeConfig string, endpoint string) *model.ClusterKubeconfig {
	var redactedClusterKubeConfigBytes []byte
	if endpoint != "" {
		kubeConfig = strings.ReplaceAll(kubeConfig, "localhost", endpoint)
		kubeConfig = strings.ReplaceAll(kubeConfig, "127.0.0.1", endpoint)
	}

	// replace certificate data with *****
	certRegex := regexp.MustCompile(`data: ([\s\S]*?[\r?\n])`)
	redactedClusterKubeConfigBytes = certRegex.ReplaceAll([]byte(kubeConfig), []byte(`data: **********
`))

	// replace password with *****
	passwordRegex := regexp.MustCompile(`password: ([\s\S]*?) username`)
	redactedClusterKubeConfigBytes = passwordRegex.ReplaceAll(redactedClusterKubeConfigBytes, []byte(`password: **********
    username`))
	return &model.ClusterKubeconfig{
		ClusterKubeConfig:         kubeConfig,
		RedactedClusterKubeConfig: string(redactedClusterKubeConfigBytes),
	}
}

func ToStoreStatusModel(name, bannerEdgeID string, kubeVersion *string, status *model.ClusterStatus) *model.StoreStatusInfo {
	storeStatus := &model.StoreStatusInfo{
		Name:         name,
		BannerEdgeID: bannerEdgeID,
		Status:       status,
		KubeVersion:  kubeVersion,
	}
	return storeStatus
}

func ToConvertUnstructuredToConfigMap(resource *unstructured.Unstructured) (*corev1.ConfigMap, error) {
	converted := &corev1.ConfigMap{}
	err := runtime.DefaultUnstructuredConverter.
		FromUnstructured(resource.UnstructuredContent(), &converted)
	if err != nil {
		fmt.Print(err)
		return &corev1.ConfigMap{}, err
	}
	return converted, nil
}

func ToConvertUnstructuredToNode(resources *unstructured.UnstructuredList) ([]corev1.Node, error) {
	resp := make([]corev1.Node, 0)
	for _, item := range resources.Items {
		converted := &corev1.Node{}
		err := runtime.DefaultUnstructuredConverter.
			FromUnstructured(item.UnstructuredContent(), &converted)
		if err != nil {
			return nil, err
		}
		resp = append(resp, *converted)
	}

	return resp, nil
}

func ToStoreClusterStatus(conditions []metav1.Condition, successCondition string, progressingReasons []string) (bool, *model.ClusterStatus) {
	if ready, reason, message := isResourceReady(conditions, successCondition); !ready {
		if utils.Contains(progressingReasons, reason) {
			return false, &model.ClusterStatus{Status: Provisioning, Message: message}
		}
		return false, &model.ClusterStatus{Status: ProvisioningError, Message: message}
	}
	return true, &model.ClusterStatus{Status: metastatus.ReadyCondition, Message: "the cluster is ready"}
}