package mapper

import (
	"encoding/json"
	"reflect"

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

	v1vpnconfig "edge-infra.dev/pkg/sds/remoteaccess/k8s/apis/vpnconfigs/v1"

	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/sds/ien/bootoptions"
	"edge-infra.dev/pkg/sds/ien/topology"
)

func CreateBootOptionsConfigMap(clusterConfig *model.ClusterConfig) *corev1.ConfigMap {
	return bootoptions.FromClusterConfig(clusterConfig)
}

func CreateTopologyInfoConfigMap(clusterConfig model.ClusterConfig) *corev1.ConfigMap {
	tpInfo := &topology.Info{}
	tpInfo = tpInfo.FromGraphQLModel(clusterConfig)
	return tpInfo.ToConfigMap()
}

func CreateVPNConfig(cluster *model.Cluster, clusterConfig *model.ClusterConfig) *v1vpnconfig.VPNConfig {
	return &v1vpnconfig.VPNConfig{
		TypeMeta: metav1.TypeMeta{
			Kind:       reflect.TypeOf(v1vpnconfig.VPNConfig{}).Name(),
			APIVersion: v1vpnconfig.GroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      cluster.ClusterEdgeID,
			Namespace: "vpn",
		},
		Spec: v1vpnconfig.VPNConfigSpec{
			Enabled: clusterConfig.VpnEnabled,
		},
	}
}

// NamespaceLogLevelPayload to NamespaceLogLevel
func NLLPToNLL(NLLP []*model.NamespaceLogLevelPayload) []*model.NamespaceLogLevel {
	NLL := make([]*model.NamespaceLogLevel, len(NLLP))

	if len(NLL) == 0 {
		return NLL
	}

	for index, entry := range NLLP {
		conversion := model.NamespaceLogLevel{
			Namespace: *entry.Namespace,
			Level:     *entry.Level,
		}
		NLL = append(NLL[:index+1], NLL[index:]...)
		NLL[index] = &conversion
	}

	return NLL[:(len(NLL) / 2)]
}

// NamespaceLogLevelPayload to Json
func NLLPToJSON(NLLP []*model.NamespaceLogLevelPayload) (string, error) {
	// Edge case if no value is passed into the payload
	if len(NLLP) == 0 {
		return "[]", nil
	}

	namespaceLogLevelsJSON, err := json.Marshal(NLLP)

	if err != nil {
		return "", err
	}

	return string(namespaceLogLevelsJSON), nil
}

// JSON to NamespaceLogLevelPayload
func JSONtoNLLP(jsonPayload string) ([]*model.NamespaceLogLevelPayload, error) {
	var NLLP []*model.NamespaceLogLevelPayload
	err := json.Unmarshal([]byte(jsonPayload), &NLLP)

	if err != nil {
		return nil, err
	}

	return NLLP, nil
}

// JSON to NamespaceLogLevel
func JSONtoNLL(jsonPayload string) ([]*model.NamespaceLogLevel, error) {
	var NLL []*model.NamespaceLogLevel
	err := json.Unmarshal([]byte(jsonPayload), &NLL)

	if err != nil {
		return nil, err
	}

	return NLL, nil
}