package environment

import (
	"encoding/json"
	"fmt"
	"github.com/openHPI/poseidon/internal/runner"
	"github.com/openHPI/poseidon/pkg/dto"
	"k8s.io/client-go/kubernetes"
)

type KubernetesEnvironment struct {
	id              dto.EnvironmentID
	image           string
	cpuLimit        uint
	memoryLimit     uint
	networkEnabled  bool
	mappedPorts     []uint16
	prewarmingPool  uint
	onDestroyRunner runner.DestroyRunnerHandler
	clientset       *kubernetes.Clientset
}

func NewKubernetesEnvironment(onDestroyRunner runner.DestroyRunnerHandler, clientset *kubernetes.Clientset) *KubernetesEnvironment {
	return &KubernetesEnvironment{
		onDestroyRunner: onDestroyRunner,
		clientset:       clientset,
		cpuLimit:        500, // Default CPU limit (in millicores)
		memoryLimit:     512, // Default memory limit (in MB)
		networkEnabled:  false,
		prewarmingPool:  1,
	}
}

func (k *KubernetesEnvironment) MarshalJSON() ([]byte, error) {
	res, err := json.Marshal(dto.ExecutionEnvironmentData{
		ID:                          int(k.ID()),
		ExecutionEnvironmentRequest: dto.ExecutionEnvironmentRequest{Image: k.Image()},
	})
	if err != nil {
		return res, fmt.Errorf("couldn't marshal kubernetes execution environment: %w", err)
	}
	return res, nil
}

func (k *KubernetesEnvironment) ID() dto.EnvironmentID {
	return k.id
}

func (k *KubernetesEnvironment) SetID(id dto.EnvironmentID) {
	k.id = id
}

func (k *KubernetesEnvironment) Image() string {
	return k.image
}

func (k *KubernetesEnvironment) SetImage(image string) {
	k.image = image
}

func (k *KubernetesEnvironment) Delete(_ runner.DestroyReason) error {
	// Implement Kubernetes-specific deletion logic here
	return nil
}

func (k *KubernetesEnvironment) Sample() (r runner.Runner, ok bool) {
	workload, err := runner.NewKubernetesPodWorkload(k, k.onDestroyRunner, k.clientset)
	if err != nil {
		return nil, false
	}
	return workload, true
}

func (k *KubernetesEnvironment) IdleRunnerCount() uint {
	// Implement logic to count idle runners in Kubernetes
	return 0
}

func (k *KubernetesEnvironment) PrewarmingPoolSize() uint {
	return k.prewarmingPool
}

func (k *KubernetesEnvironment) SetPrewarmingPoolSize(size uint) {
	k.prewarmingPool = size
}

func (k *KubernetesEnvironment) ApplyPrewarmingPoolSize() error {
	// Implement logic to apply prewarming pool size in Kubernetes
	return nil
}

func (k *KubernetesEnvironment) CPULimit() uint {
	return k.cpuLimit
}

func (k *KubernetesEnvironment) SetCPULimit(limit uint) {
	k.cpuLimit = limit
}

func (k *KubernetesEnvironment) MemoryLimit() uint {
	return k.memoryLimit
}

func (k *KubernetesEnvironment) SetMemoryLimit(limit uint) {
	k.memoryLimit = limit
}

func (k *KubernetesEnvironment) NetworkAccess() (enabled bool, mappedPorts []uint16) {
	return k.networkEnabled, k.mappedPorts
}

func (k *KubernetesEnvironment) SetNetworkAccess(enabled bool, ports []uint16) {
	k.networkEnabled = enabled
	k.mappedPorts = ports
}

func (k *KubernetesEnvironment) SetConfigFrom(env runner.ExecutionEnvironment) {
	if kEnv, ok := env.(*KubernetesEnvironment); ok {
		k.cpuLimit = kEnv.cpuLimit
		k.memoryLimit = kEnv.memoryLimit
		k.networkEnabled = kEnv.networkEnabled
		k.mappedPorts = kEnv.mappedPorts
		k.prewarmingPool = kEnv.prewarmingPool
	}
}

func (k *KubernetesEnvironment) Register() error {
	// Implement Kubernetes-specific registration logic here
	return nil
}

func (k *KubernetesEnvironment) AddRunner(runner runner.Runner) {
	// Implement logic to add a runner to the Kubernetes environment
}

func (k *KubernetesEnvironment) DeleteRunner(id string) (r runner.Runner, ok bool) {
	// Implement logic to delete a runner from the Kubernetes environment
	return nil, false
}