package k8s_manager

import (
	"context"
	"fmt"
	"github.com/goccy/go-json"
	log "github.com/sirupsen/logrus"
	appv1 "k8s.io/api/apps/v1"
	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
)

type K8sClient struct {
	*kubernetes.Clientset
	Namespace string
}

func CreateClient() *K8sClient {
	var err error
	config, err := rest.InClusterConfig()
	if err != nil {
		log.WithError(err).Error("InClusterConfig")
		return nil
	}

	client, err := kubernetes.NewForConfig(config)
	if err != nil {
		log.WithError(err).Error("NewForConfig")
	}
	return &K8sClient{client, "apps"}
}

func (c *K8sClient) ListPods() {
	pods, err := c.CoreV1().Pods("").List(context.Background(), metav1.ListOptions{})
	if err != nil {
		log.WithError(err).Error("ListPods")
	} else {
		fmt.Printf("There are %d pods in the cluster\n", len(pods.Items))
	}
}

func (c *K8sClient) GetAppStatus(app *AppModel) (*appv1.DeploymentStatus, error) {
	get, err := c.AppsV1().Deployments(c.Namespace).Get(context.Background(), app.DeploymentName(), metav1.GetOptions{})
	// log.WithError(err).WithField("dep", get).WithField("name", app.DeploymentName()).Info("GetAppStatus")
	return &get.Status, err
}

func (c *K8sClient) CreateApp(app *AppModel) {
	var rep int32 = 1
	labelKey, labelValue := app.GetLabel()
	labels := map[string]string{labelKey: labelValue}
	deployment := &appv1.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Name:   app.DeploymentName(),
			Labels: labels,
		},
		Spec: appv1.DeploymentSpec{
			Replicas: &rep,
			Selector: &metav1.LabelSelector{
				MatchLabels: labels,
			},
			Template: v1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Labels: labels,
				},
				Spec: v1.PodSpec{
					Containers: []v1.Container{{
						Name:         app.ContainerName(),
						Image:        app.Image,
						Command:      app.GetCommandOrBlack(),
						Env:          app.GetEnv(),
						VolumeMounts: nil,
					}},
				},
			},
		},
	}
	deployment, err := c.AppsV1().Deployments(c.Namespace).Create(context.Background(), deployment, metav1.CreateOptions{})
	if err != nil {
		d, _ := json.Marshal(deployment)
		fmt.Println(string(d))
		log.WithError(err).Error("Create Deployment error.")
	}

	service := &v1.Service{
		ObjectMeta: metav1.ObjectMeta{
			Name: app.ServiceName(),
		},
		Spec: v1.ServiceSpec{
			Type:      v1.ServiceTypeClusterIP,
			ClusterIP: "None",
			Selector:  labels,
		},
	}

	service, err = c.CoreV1().Services(c.Namespace).Create(context.Background(), service, metav1.CreateOptions{})
	if err != nil {
		log.WithError(err).Error("Create Service ")
	}
}

func (c *K8sClient) DeleteApp(app *AppModel) {
	err := c.AppsV1().Deployments(c.Namespace).Delete(context.Background(), app.DeploymentName(), metav1.DeleteOptions{})
	if err != nil {
		log.WithError(err).Error("Delete error ", app.DeploymentName())
		return
	}
}