package terminalctl

import (
	"fmt"

	"github.com/go-logr/logr"
	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/runtime"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
	ctrl "sigs.k8s.io/controller-runtime"

	v1ien "edge-infra.dev/pkg/sds/ien/k8s/apis/v1"

	clusterApi "edge-infra.dev/pkg/edge/apis/cluster/v1alpha1"
	syncedobjectApi "edge-infra.dev/pkg/edge/apis/syncedobject/apis/v1alpha1"
	"edge-infra.dev/pkg/k8s/runtime/controller"
	"edge-infra.dev/pkg/k8s/runtime/controller/metrics"

	"edge-infra.dev/pkg/lib/fog"
	"edge-infra.dev/pkg/sds/k8s/controllers/terminalctl/pkg/plugins"
	"edge-infra.dev/pkg/sds/k8s/controllers/terminalctl/pkg/plugins/emergencyaccess"
)

// Run creates the manager, sets up the controller, and then starts
// everything.  It returns the created manager for testing purposes
func Run(config Config, o ...controller.Option) error {
	ctrl.SetLogger(fog.New())
	registerPlugins(config)
	mgr, log, err := create(config, 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(config Config, o ...controller.Option) (ctrl.Manager, logr.Logger, error) {
	log := ctrl.Log.WithName("setup")

	mgr, err := createMgr(o...)
	if err != nil {
		log.Error(err, "failed to create manager")
		return nil, logr.Logger{}, err
	}

	err = registerController(mgr, &config)
	if err != nil {
		log.Error(err, "failed to register controller", "controller", "terminal-reconciler")
		return nil, log, err
	}

	return mgr, log, nil
}

func createMgr(o ...controller.Option) (ctrl.Manager, error) {
	cfg, opts := controller.ProcessOptions(o...)
	opts.LeaderElectionID = "terminalctl.edge.ncr.com"
	opts.Scheme = createScheme()

	return ctrl.NewManager(cfg, opts)
}

func registerController(mgr ctrl.Manager, cfg *Config) error {
	if err := (&TerminalReconciler{
		Client:     mgr.GetClient(),
		Log:        ctrl.Log.WithName("terminal-reconciler"),
		Metrics:    metrics.New(mgr, "terminalctl"),
		Conditions: terminalConditions,
		Config:     cfg,
		Name:       "terminal-controller",
	}).SetupWithManager(mgr); err != nil {
		return fmt.Errorf("failed to set up terminal controller: %w", err)
	}

	return nil
}

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

	utilruntime.Must(corev1.AddToScheme(scheme))
	utilruntime.Must(v1ien.AddToScheme(scheme))
	utilruntime.Must(clusterApi.AddToScheme(scheme))
	utilruntime.Must(syncedobjectApi.AddToScheme(scheme))
	return scheme
}

// add new plugins here to be automatically executed by controller.
func registerPlugins(_ Config) {
	plugins.Register(emergencyaccess.Emergencyaccess{})
}