package resolver

import (
	"context"
	"errors"

	"google.golang.org/grpc/codes"

	gcperror "edge-infra.dev/pkg/edge/api/apierror/gcp"
	"edge-infra.dev/pkg/edge/api/graph/mapper"
	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/api/utils"
	edgeCapabilities "edge-infra.dev/pkg/edge/capabilities"
	chariotClientApi "edge-infra.dev/pkg/edge/chariot/client"
	"edge-infra.dev/pkg/edge/constants"
	"edge-infra.dev/pkg/edge/k8objectsutils"
	"edge-infra.dev/pkg/sds/clustersecrets/breakglass"
	"edge-infra.dev/pkg/sds/clustersecrets/grub"
)

func (r *Resolver) UpdateBootOptionsViaChariot(ctx context.Context, clusterEdgeID string, clusterConfig *model.ClusterConfig, operation chariotClientApi.Operation) error {
	cluster, err := r.StoreClusterService.GetCluster(ctx, clusterEdgeID)
	if err != nil {
		return err
	}

	bootOptionsConfigMap := mapper.CreateBootOptionsConfigMap(clusterConfig)
	bootOptionsBase64, err := utils.ConvertStructToBase64(bootOptionsConfigMap)
	if err != nil {
		return err
	}

	return r.sendChariotMessage(ctx, cluster.ProjectID, cluster.ClusterEdgeID, operation, bootOptionsBase64)
}

func (r *Resolver) UpdateTopologyInfoCMViaChariot(ctx context.Context, clusterEdgeID string, clusterConfig *model.ClusterConfig, operation chariotClientApi.Operation) error {
	cluster, err := r.StoreClusterService.GetCluster(ctx, clusterEdgeID)
	if err != nil {
		return err
	}
	topologyConfigMap := mapper.CreateTopologyInfoConfigMap(*clusterConfig)
	topologyConfigMapBase64, err := utils.ConvertStructToBase64(topologyConfigMap)
	if err != nil {
		return err
	}

	return r.sendChariotMessage(ctx, cluster.ProjectID, cluster.ClusterEdgeID, operation, topologyConfigMapBase64)
}

func (r *Resolver) DeleteClustersInfraAndGCPResources(ctx context.Context, cluster *model.Cluster) error {
	errors := utils.NewErrorWrapper()

	if err := r.deleteClusterSecretManagerSecrets(ctx, cluster); err != nil {
		errors.AddError(err, "error deleting cluster secrets")
	}

	if err := r.ActivationCodeService.CleanupStore(ctx, cluster); err != nil {
		errors.AddError(err, "error deleting clusters activation codes")
	}
	return errors.Errors
}

func (r *Resolver) UpdateClusterDefaultOptionalPallets(ctx context.Context, cluster *model.Cluster, fleetVersion, previousStoreVersion string) error {
	// add default optional pallets to clusters for the updated fleet version
	existingLabels, err := r.LabelService.GetLabels(ctx, &cluster.BannerEdgeID)
	if err != nil {
		return err
	}

	// get existing labels of type edge-capabilities
	edgeCapabilityLabels := edgeCapabilities.GetCapabilityLabels(existingLabels, edgeCapabilities.DefaultStoreEdgeCapabilities...)

	supportedEdgeCapabilityLabels, err := edgeCapabilities.GetCapabilityLabelsForSupportedVersion(edgeCapabilityLabels, fleetVersion, &previousStoreVersion)
	if err != nil {
		return err
	}

	for _, label := range supportedEdgeCapabilityLabels {
		if err := r.LabelService.CreateClusterLabel(ctx, cluster.ClusterEdgeID, label.LabelEdgeID); err != nil {
			return err
		}
	}
	return nil
}

func isNotFound(err error) bool {
	var gcpErr *gcperror.Error
	return errors.As(err, &gcpErr) && gcpErr.Code == int(codes.NotFound)
}

func (r *Resolver) deleteClusterSecretManagerSecrets(ctx context.Context, cluster *model.Cluster) error {
	allErrors := utils.NewErrorWrapper()

	breakGlassPlainName := k8objectsutils.NameWithPrefix(breakglass.PlainSecretName, cluster.ClusterEdgeID)
	if _, err := r.GCPService.DeleteSecret(ctx, breakGlassPlainName, cluster.ProjectID); err != nil && !isNotFound(err) {
		allErrors.AddError(err, "could not delete plain breakglass secret manager secret")
	}

	breakGlassHashedName := k8objectsutils.NameWithPrefix(breakglass.HashedSecretName, cluster.ClusterEdgeID)
	if _, err := r.GCPService.DeleteSecret(ctx, breakGlassHashedName, cluster.ProjectID); err != nil && !isNotFound(err) {
		allErrors.AddError(err, "could not delete hashed breakglass secret manager secret")
	}

	grubPlainName := k8objectsutils.NameWithPrefix(grub.PlainSecretName, cluster.ClusterEdgeID)
	if _, err := r.GCPService.DeleteSecret(ctx, grubPlainName, cluster.ProjectID); err != nil && !isNotFound(err) {
		allErrors.AddError(err, "could not delete plain grub secret manager secret")
	}

	grubHashedName := k8objectsutils.NameWithPrefix(grub.HashedSecretName, cluster.ClusterEdgeID)
	if _, err := r.GCPService.DeleteSecret(ctx, grubHashedName, cluster.ProjectID); err != nil && !isNotFound(err) {
		allErrors.AddError(err, "could not delete hashed grub secret manager secret")
	}

	return allErrors.GetErrors()
}

func (r *Resolver) registerK8sDefaultSubnets(ctx context.Context, clusterEdgeID string) error {
	k8sDefaultSubnets := []*model.CreateNetworkServiceInfo{
		{
			ServiceType: constants.ServiceTypePodNetworkCIDR,
			IP:          constants.ClusterNetworkServiceDefaults[constants.ServiceTypePodNetworkCIDR],
			Family:      "inet",
		},
		{
			ServiceType: constants.ServiceTypeServiceNetworkCIDR,
			IP:          constants.ClusterNetworkServiceDefaults[constants.ServiceTypeServiceNetworkCIDR],
			Family:      "inet",
		},
		{
			ServiceType: constants.ServiceTypeClusterDNS,
			IP:          constants.ClusterNetworkServiceDefaults[constants.ServiceTypeClusterDNS],
			Family:      "inet",
		},
		{
			ServiceType: constants.ServiceTypeEgressTunnelsCIDR,
			IP:          constants.ClusterNetworkServiceDefaults[constants.ServiceTypeEgressTunnelsCIDR],
			Family:      "inet",
		},
	}
	_, err := r.StoreClusterService.CreateClusterNetworkServices(ctx, clusterEdgeID, k8sDefaultSubnets)
	return err
}