package main

import (
	"flag"
	"os"

	"k8s.io/client-go/rest"

	kruntime "k8s.io/apimachinery/pkg/runtime"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"

	"k8s.io/client-go/kubernetes/scheme"

	edgeagent "edge-infra.dev/pkg/edge/edgeagent"
	"edge-infra.dev/pkg/edge/info"
	"edge-infra.dev/pkg/lib/fog"
	"edge-infra.dev/pkg/lib/runtime"
	"edge-infra.dev/pkg/lib/runtime/manager"
	"edge-infra.dev/pkg/lib/runtime/subscriber"

	_ "github.com/GoogleCloudPlatform/cloudsql-proxy/proxy/dialers/postgres"
	"github.com/peterbourgon/ff/v3"

	helmApi "github.com/fluxcd/helm-controller/api/v2"
	kustomizeApi "github.com/fluxcd/kustomize-controller/api/v1"
	kubeVirtApi "kubevirt.io/api/core/v1"
)

var log = ctrl.Log.WithName("setup")

func init() {
	utilruntime.Must(scheme.AddToScheme(kruntime.NewScheme()))
	utilruntime.Must(helmApi.AddToScheme(scheme.Scheme))
	utilruntime.Must(kustomizeApi.AddToScheme(scheme.Scheme))
	utilruntime.Must(kubeVirtApi.AddToScheme(scheme.Scheme))
}

type Cfg struct {
	ProjectID      string
	SubscriptionID string
}

func (cfg *Cfg) BindFlags(flags *flag.FlagSet) {
	flags.StringVar(
		&cfg.ProjectID,
		"project-id",
		"",
		"GCP project ID",
	)
	flags.StringVar(
		&cfg.SubscriptionID,
		"subscription-id",
		"",
		"Subscription ID",
	)
}

func main() {
	ctrl.SetLogger(fog.New())
	flags := flag.NewFlagSet("edge-agent", flag.ExitOnError)
	cfg := &Cfg{}
	cfg.BindFlags(flags)
	if err := ff.Parse(flags, os.Args[1:], ff.WithEnvVarNoPrefix(), ff.WithIgnoreUndefined(false)); err != nil {
		log.Error(err, "failed to parse command line arguments or environment variables")
		os.Exit(1)
	}

	edgeOpts := manager.Options{
		Logger: &log,
	}

	edgeMgr, err := runtime.NewManager(edgeOpts)
	if err != nil {
		log.Error(err, "failed to create default manager")
		os.Exit(1)
	}

	ctx := runtime.SetupSignalHandler()
	ctx = fog.IntoContext(ctx, log)

	config, err := rest.InClusterConfig()
	if err != nil {
		log.Error(err, "failed to get in cluster config")
		os.Exit(1)
	}

	c, err := client.New(config, client.Options{Scheme: scheme.Scheme})
	if err != nil {
		log.Error(err, "failed to create runtime client")
		os.Exit(1)
	}

	edgeInfo, err := info.FromClient(ctx, c)
	if err != nil {
		log.Error(err, "failed to retrieve edge info")
		os.Exit(1)
	}

	subOpts := subscriber.Options{
		Logger:    &log,
		ProjectID: cfg.ProjectID,
		ID:        cfg.SubscriptionID,
		Handler: &edgeagent.EdgeAgent{
			ClusterEdgeID: edgeInfo.ClusterEdgeID,
			Client:        c,
		},
	}
	sub, err := runtime.NewSubscriber(subOpts)
	if err != nil {
		log.Error(err, "failed to create subscriber")
		os.Exit(1)
	}

	if err := edgeMgr.Add(sub); err != nil {
		log.Error(err, "failed to add subscription to manager")
		os.Exit(1)
	}

	if err := edgeMgr.Start(ctx); err != nil {
		log.Error(err, "failed to start edge default manager")
		os.Exit(1)
	}
}