package firewallctl

import (
	"time"

	"github.com/fluxcd/pkg/ssa"
	corev1 "k8s.io/api/core/v1"
	kruntime "k8s.io/apimachinery/pkg/runtime"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
	"k8s.io/client-go/rest"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"
	ctrlmgr "sigs.k8s.io/controller-runtime/pkg/manager"

	"edge-infra.dev/pkg/k8s/runtime/controller"
	"edge-infra.dev/pkg/k8s/runtime/controller/metrics"
	"edge-infra.dev/pkg/k8s/runtime/controller/reconcile"
	v1ien "edge-infra.dev/pkg/sds/ien/k8s/apis/v1"
)

var (
	scheme             = kruntime.NewScheme()
	requeueTime        = time.Second * 60
	MetricsBindAddress = ":9000"
	HealthBindAddress  = ":9001"
)

type Controller struct {
	name            string
	conditions      reconcile.Conditions
	client          client.Client
	metrics         metrics.Metrics
	resourceManager *ssa.ResourceManager
	requeueTime     time.Duration
}

func init() {
	utilruntime.Must(clientgoscheme.AddToScheme(scheme))
	utilruntime.Must(v1ien.AddToScheme(scheme))
}

func Run(opts ...controller.Option) error {
	log := ctrl.Log.WithName("setup")

	// setup the controller manager
	mgr, err := SetupManager(opts...)
	if err != nil {
		return err
	}

	// start controllers registered to the manager
	if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
		log.Error(err, "could not start controller")
		return err
	}

	return nil
}

func SetupManager(ctrlOpts ...controller.Option) (ctrl.Manager, error) {
	log := ctrl.Log.WithName("setup")

	mgrRestConfig, mgrOpts := getManagerOptions(ctrlOpts...)
	mgrOpts.Metrics.BindAddress = MetricsBindAddress
	mgrOpts.Scheme = createScheme()
	mgrOpts.HealthProbeBindAddress = HealthBindAddress
	mgr, err := ctrl.NewManager(mgrRestConfig, mgrOpts)
	if err != nil {
		log.Error(err, "unable to create controller manager")
		return nil, err
	}

	client := mgr.GetClient()

	clusterFirewallReconciler := NewClusterFirewallController(client, mgr)

	if err = clusterFirewallReconciler.SetUpWithManager(mgr); err != nil {
		log.Error(err, "failed to setup ClusterFirewall controller with manager")
		return nil, err
	}

	return mgr, nil
}

func getManagerOptions(opts ...controller.Option) (*rest.Config, ctrlmgr.Options) {
	mgrConfig, mgrOpts := controller.ProcessOptions(opts...)
	mgrOpts.Scheme = scheme
	return mgrConfig, mgrOpts
}

func createScheme() *kruntime.Scheme {
	scheme := kruntime.NewScheme()
	utilruntime.Must(corev1.AddToScheme(scheme))
	utilruntime.Must(v1ien.AddToScheme(scheme))
	return scheme
}