package info

import (
	"context"
	"encoding/json"
	"fmt"
	"strings"

	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"sigs.k8s.io/controller-runtime/pkg/client"

	"edge-infra.dev/pkg/edge/constants/api/fleet"
)

type EdgeInfo struct {
	BannerName       string
	ProjectID        string
	Store            string
	Fleet            string
	ClusterType      string
	Location         string
	ForemanProjectID string
	BannerEdgeID     string
	ClusterEdgeID    string
	EdgeAPIEndpoint  string
}

// FromConfigMap retrieves data from ConfigMap to EdgeInfo
func (i *EdgeInfo) FromConfigMap(cfg *v1.ConfigMap) *EdgeInfo {
	i.BannerName = cfg.Data[Banner]
	i.ProjectID = cfg.Data[ProjectID]
	i.Store = cfg.Data[StoreName]
	i.ClusterEdgeID = cfg.Data[ClusterEdgeID]
	i.ClusterType = cfg.Data[ClusterType]
	i.Fleet = cfg.Data[FleetType]
	i.Location = cfg.Data[K8sClusterLocation]
	i.ForemanProjectID = cfg.Data[ForemanProjectID]
	i.BannerEdgeID = cfg.Data[BannerID]
	i.EdgeAPIEndpoint = cfg.Data[EdgeAPIEndpoint]
	return i
}

// ToConfigMap create edge-info ConfigMap
func (i EdgeInfo) ToConfigMap() *v1.ConfigMap {
	return &v1.ConfigMap{
		TypeMeta: metav1.TypeMeta{
			Kind:       "ConfigMap",
			APIVersion: v1.SchemeGroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      EdgeConfigMapName,
			Namespace: EdgeConfigMapNS,
		},
		Data: map[string]string{
			Banner:             i.BannerName,
			ProjectID:          i.ProjectID,
			StoreName:          i.Store,
			ClusterEdgeID:      i.ClusterEdgeID,
			ClusterType:        i.ClusterType,
			K8sClusterLocation: i.Location,
			FleetType:          i.Fleet,
			ForemanProjectID:   i.ForemanProjectID,
			BannerID:           i.BannerEdgeID,
			EdgeAPIEndpoint:    i.EdgeAPIEndpoint,
		},
	}
}

// ValidateConfigMap validates edge-info ConfigMap
func ValidateConfigMap(cfg *v1.ConfigMap) error {
	f := cfg.Data[FleetType]
	notTopLevelCluster := f != fleet.Banner && f != fleet.TopLevel

	var missing []string
	if notTopLevelCluster && cfg.Data[Banner] == "" {
		missing = append(missing, Banner)
	}
	if cfg.Data[ProjectID] == "" {
		missing = append(missing, ProjectID)
	}
	if cfg.Data[StoreName] == "" {
		missing = append(missing, StoreName)
	}
	if cfg.Data[ClusterEdgeID] == "" {
		missing = append(missing, ClusterEdgeID)
	}
	if cfg.Data[ClusterType] == "" {
		missing = append(missing, ClusterType)
	}
	if notTopLevelCluster && cfg.Data[K8sClusterLocation] == "" {
		missing = append(missing, K8sClusterLocation)
	}
	if len(missing) > 0 {
		// TODO add name namespace
		return fmt.Errorf("edge-info configmap invalid, value(s) not provided: %s", strings.Join(missing, ","))
	}
	return nil
}

// New creates a valid EdgeInfo ref
func New(cfg *v1.ConfigMap) (*EdgeInfo, error) {
	if err := ValidateConfigMap(cfg); err != nil {
		return nil, err
	}
	return FromConfigMap(cfg), nil
}

// FromConfigMap util function to create EdgeInfo from config map
func FromConfigMap(cfg *v1.ConfigMap) *EdgeInfo {
	return (&EdgeInfo{}).FromConfigMap(cfg)
}

// IsEdgeInfoConfigMap util function to check if object is edge info config map
func IsEdgeInfoConfigMap(name, namespace string) bool {
	hasRequiredName := name == EdgeConfigMapName
	inRequiredNamespace := namespace == EdgeConfigMapNS
	return hasRequiredName && inRequiredNamespace
}

// FromClient grabs the configmap from the cluster
func FromClient(ctx context.Context, cl client.Client) (*EdgeInfo, error) {
	cfg := &v1.ConfigMap{}
	key := client.ObjectKey{Namespace: EdgeConfigMapNS, Name: EdgeConfigMapName}
	if err := cl.Get(ctx, key, cfg); err != nil {
		return nil, err
	}
	return New(cfg)
}

// BuildConfigMap creates an edge-info configmap
func BuildConfigMap(projectID, store, storeType, location, banner, fleet, foremanProjectID, bannerID, clusterEdgeID, edgeAPIEndpoint string) *v1.ConfigMap {
	i := &EdgeInfo{
		BannerName:       banner,
		ProjectID:        projectID,
		ClusterEdgeID:    clusterEdgeID,
		Store:            store,
		ClusterType:      storeType,
		Location:         location,
		Fleet:            fleet,
		ForemanProjectID: foremanProjectID,
		BannerEdgeID:     bannerID,
		EdgeAPIEndpoint:  edgeAPIEndpoint,
	}
	return i.ToConfigMap()
}

// ConfigMapToString converts the provided configmap to a string.
func ConfigMapToString(configMap *v1.ConfigMap) ([]byte, error) {
	return json.Marshal(configMap)
}