package mapper

import (
	"fmt"

	v1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime"

	"edge-infra.dev/pkg/edge/api/graph/model"
)

func DeploymentToLivenessReadinessResponse(pods *corev1.PodList, deployment *v1.Deployment) *model.LivenessReadinessResponse {
	resp := model.LivenessReadinessResponse{}
	resp.PodStatus = PodListToModel(pods)
	for _, container := range deployment.Spec.Template.Spec.Containers {
		if container.LivenessProbe != nil {
			resp.LivenessProbe = ProbeToProbeModel(container.LivenessProbe)
		}
		if container.ReadinessProbe != nil {
			resp.ReadinessProbe = ProbeToProbeModel(container.ReadinessProbe)
		}
	}
	return &resp
}

func StatefulSetToLivenessReadinessResponse(pods *corev1.PodList, ss *v1.StatefulSet) *model.LivenessReadinessResponse {
	resp := model.LivenessReadinessResponse{}
	resp.PodStatus = PodListToModel(pods)
	for _, container := range ss.Spec.Template.Spec.Containers {
		if container.LivenessProbe != nil {
			resp.LivenessProbe = ProbeToProbeModel(container.LivenessProbe)
		}
		if container.ReadinessProbe != nil {
			resp.ReadinessProbe = ProbeToProbeModel(container.ReadinessProbe)
		}
	}
	return &resp
}

func DaemonSetToLivenessReadinessResponse(pods *corev1.PodList, ds *v1.DaemonSet) *model.LivenessReadinessResponse {
	resp := model.LivenessReadinessResponse{}
	resp.PodStatus = PodListToModel(pods)
	for _, container := range ds.Spec.Template.Spec.Containers {
		if container.LivenessProbe != nil {
			resp.LivenessProbe = ProbeToProbeModel(container.LivenessProbe)
		}
		if container.ReadinessProbe != nil {
			resp.ReadinessProbe = ProbeToProbeModel(container.ReadinessProbe)
		}
	}
	return &resp
}

func UnstructuredToPodsList(resources *unstructured.UnstructuredList) (*corev1.PodList, error) {
	resp := make([]corev1.Pod, 0)
	for _, item := range resources.Items {
		converted := &corev1.Pod{}
		err := runtime.DefaultUnstructuredConverter.
			FromUnstructured(item.UnstructuredContent(), &converted)
		if err != nil {
			return nil, err
		}
		resp = append(resp, *converted)
	}
	return &corev1.PodList{Items: resp}, nil
}

func UnstructuredToObject(resources *unstructured.UnstructuredList, object interface{}) error {
	for _, item := range resources.Items {
		err := runtime.DefaultUnstructuredConverter.
			FromUnstructured(item.UnstructuredContent(), object)
		if err != nil {
			return err
		}
		return nil //nolint on purpose just want first item if it exists
	}
	return nil
}

func UnstructuredToDeploymentList(resources *unstructured.UnstructuredList) (*v1.DeploymentList, error) {
	resp := make([]v1.Deployment, 0)
	for _, item := range resources.Items {
		converted := &v1.Deployment{}
		err := runtime.DefaultUnstructuredConverter.
			FromUnstructured(item.UnstructuredContent(), &converted)
		if err != nil {
			return nil, err
		}
		resp = append(resp, *converted)
	}
	return &v1.DeploymentList{Items: resp}, nil
}

func UnstructuredToStatefulSetList(resources *unstructured.UnstructuredList) (*v1.StatefulSetList, error) {
	resp := make([]v1.StatefulSet, 0)
	for _, item := range resources.Items {
		converted := &v1.StatefulSet{}
		err := runtime.DefaultUnstructuredConverter.
			FromUnstructured(item.UnstructuredContent(), &converted)
		if err != nil {
			return nil, err
		}
		resp = append(resp, *converted)
	}
	return &v1.StatefulSetList{Items: resp}, nil
}

func UnstructuredToDaemonSetList(resources *unstructured.UnstructuredList) (*v1.DaemonSetList, error) {
	resp := make([]v1.DaemonSet, 0)
	for _, item := range resources.Items {
		converted := &v1.DaemonSet{}
		err := runtime.DefaultUnstructuredConverter.
			FromUnstructured(item.UnstructuredContent(), &converted)
		if err != nil {
			return nil, err
		}
		resp = append(resp, *converted)
	}
	return &v1.DaemonSetList{Items: resp}, nil
}

func PodListToModel(pods *corev1.PodList) []*model.PodStatus {
	var models []*model.PodStatus
	for _, pod := range pods.Items {
		models = append(models, PodToStatusModel(pod))
	}
	return models
}

func PodToStatusModel(pod corev1.Pod) *model.PodStatus {
	modelPod := model.PodStatus{}
	modelPod.Name = pod.Name
	for _, container := range pod.Status.ContainerStatuses {
		modelPod.RestartCount = int(container.RestartCount)
		modelPod.Started = *container.Started
		modelPod.Ready = container.Ready
	}
	modelPod.Conditions = PodConditionsToModel(pod.Status.Conditions)
	return &modelPod
}

func PodConditionsToModel(conditions []corev1.PodCondition) []*model.PodCondition {
	var modelConditions []*model.PodCondition
	for _, condition := range conditions {
		modelConditions = append(modelConditions, PodConditionToModel(condition))
	}
	return modelConditions
}

func PodConditionToModel(condition corev1.PodCondition) *model.PodCondition {
	var lastProbeTime *string
	if !condition.LastProbeTime.IsZero() {
		probeTime := condition.LastProbeTime.Time.Format(TimeFormat)
		lastProbeTime = &probeTime
	}
	return &model.PodCondition{
		LastProbeTime:      lastProbeTime,
		LastTransitionTime: condition.LastTransitionTime.Time.Format(TimeFormat),
		Status:             string(condition.Status),
		Type:               string(condition.Type),
	}
}

func ProbeToProbeModel(probe *corev1.Probe) *model.Probe {
	return &model.Probe{
		FailureThreshold: fmt.Sprint(probe.FailureThreshold),
		HTTPGet:          HTTPGetToModel(probe.HTTPGet),
		PeriodSeconds:    int(probe.PeriodSeconds),
		SuccessThreshold: int(probe.SuccessThreshold),
		TimeoutSeconds:   int(probe.TimeoutSeconds),
	}
}

func HTTPGetToModel(httpGet *corev1.HTTPGetAction) *model.HTTPGet {
	if httpGet != nil {
		return &model.HTTPGet{
			Path:   httpGet.Path,
			Port:   int(httpGet.Port.IntVal),
			Scheme: string(httpGet.Scheme),
		}
	}
	return nil
}