/*
Package dennis provides a simple K8s controller for automatically creating
DNSRecordSets in response to ComputeAddress resources, based on annotation
values.

DNS records are created according to annotations on a ComputeAddress object.
Example:

	apiVersion: compute.cnrm.cloud.google.com/v1beta1
	kind: ComputeAddress
	metadata:
		name: dev0-ip
		labels:
			platform.edge.ncr.com/component: dev0
		annotations:
			cnrm.cloud.google.com/deletion-policy: abandon
			dns.edge.ncr.com/name: "dev0.edge-preprod.dev."
			dns.edge.ncr.com/managed-zone: "infra/edge-preprod-dns-managed-zone"
			dns.edge.ncr.com/dns-project-id: "ret-edge-pltf-preprod-infra"
			dns.edge.ncr.com/external: "true"

dns.edge.ncr.com/name:

	A FQDN. Creates a Type A DNS record mapping the ComputeAddress to the value of
	this annotation. Represented as a DNSRecordSet.

dns.edge.ncr.com/managed-zone:

	The namespace/name formatted reference to the DNSManagedZone object that this record
	will be in.

dns.edge.ncr.com/dns-project-id:

	The GCP project where the DNS Managed Zone exists, and where the DNS Record will be created

dns.edge.ncr.com/external:

	If external is false, it is assumed that the names refer to DNSManagedZone resouces on the cluster.
	If true, the dns-project-id will be used as a reference to a non-k8s-resource DNS Managed Zone in GCP.

dns.edge.ncr.com/record-configs:

	Record config is a JSON string containing structured configuration. Supports the same options as individual
	annotations but allows for outputting multiple DNSRecordSets for a single ComputeAddress

	'[
		{
			"name": string,
			"managed-zone": string,
			"dns-project-id": string,
			"external": string
		}
	]'
*/
package dennis

import (
	"k8s.io/apimachinery/pkg/runtime"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"

	compute "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/clients/generated/apis/compute/v1beta1"
	dns "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/clients/generated/apis/dns/v1beta1"
	"github.com/go-logr/logr"
	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
	ctrl "sigs.k8s.io/controller-runtime"

	"edge-infra.dev/pkg/k8s/runtime/controller"
	"edge-infra.dev/pkg/lib/logging"
)

// Run creates the manager, sets up the controller, and then starts
// everything.  It returns the created manager for testing purposes
func Run(o ...controller.Option) error {
	mgr, log, err := create(o...)
	if err != nil {
		return err
	}

	log.Info("starting manager")
	if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
		log.Error(err, "problem running manager")
		return err
	}

	return nil
}

// create wires up the reconciler(s) with a created manager and returns the
// manager + setup logger
func create(o ...controller.Option) (ctrl.Manager, logr.Logger, error) {
	ctrl.SetLogger(logging.NewLogger().Logger)
	log := ctrl.Log.WithName("setup")

	cfg, opts := controller.ProcessOptions(o...)
	opts.LeaderElectionID = "183sas2df.recordboi.com"
	opts.Scheme = createScheme()

	mgr, err := ctrl.NewManager(cfg, opts)
	if err != nil {
		log.Error(err, "failed to create manager")
		return nil, logr.Logger{}, err
	}

	if err = (&ComputeAddressReconciler{
		Client: mgr.GetClient(),
		Log:    ctrl.Log.WithName("dennis-controller"),
		Name:   "dennis-controller",
	}).SetupWithManager(mgr); err != nil {
		log.Error(err, "failed to create controller and set up with manager")
		return nil, logr.Logger{}, err
	}

	return mgr, log, nil
}

func createScheme() *runtime.Scheme {
	scheme := runtime.NewScheme()

	utilruntime.Must(clientgoscheme.AddToScheme(scheme))
	utilruntime.Must(compute.AddToScheme(scheme))
	utilruntime.Must(dns.AddToScheme(scheme))

	return scheme
}