package abi

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"strings"

	"github.com/containers/podman/v4/libpod"
	"github.com/containers/podman/v4/libpod/define"
	"github.com/containers/podman/v4/pkg/domain/entities"
	k8sAPI "github.com/containers/podman/v4/pkg/k8s.io/api/core/v1"
	"github.com/containers/podman/v4/pkg/specgen"
	generateUtils "github.com/containers/podman/v4/pkg/specgen/generate"
	"github.com/containers/podman/v4/pkg/systemd/generate"
	"sigs.k8s.io/yaml"
)

func (ic *ContainerEngine) GenerateSystemd(ctx context.Context, nameOrID string, options entities.GenerateSystemdOptions) (*entities.GenerateSystemdReport, error) {
	// First assume it's a container.
	ctr, ctrErr := ic.Libpod.LookupContainer(nameOrID)
	if ctrErr == nil {
		// Generate the unit for the container.
		name, content, err := generate.ContainerUnit(ctr, options)
		if err != nil {
			return nil, err
		}
		return &entities.GenerateSystemdReport{Units: map[string]string{name: content}}, nil
	}

	// If it's not a container, we either have a pod or garbage.
	pod, err := ic.Libpod.LookupPod(nameOrID)
	if err != nil {
		err = fmt.Errorf("%v: %w", err.Error(), ctrErr)
		return nil, fmt.Errorf("%s does not refer to a container or pod: %w", nameOrID, err)
	}

	// Generate the units for the pod and all its containers.
	units, err := generate.PodUnits(pod, options)
	if err != nil {
		return nil, err
	}
	return &entities.GenerateSystemdReport{Units: units}, nil
}

func (ic *ContainerEngine) GenerateSpec(ctx context.Context, opts *entities.GenerateSpecOptions) (*entities.GenerateSpecReport, error) {
	var spec *specgen.SpecGenerator
	var pspec *specgen.PodSpecGenerator
	var err error
	if _, err := ic.Libpod.LookupContainer(opts.ID); err == nil {
		spec = &specgen.SpecGenerator{}
		_, _, err = generateUtils.ConfigToSpec(ic.Libpod, spec, opts.ID)
		if err != nil {
			return nil, err
		}
	} else if p, err := ic.Libpod.LookupPod(opts.ID); err == nil {
		pspec = &specgen.PodSpecGenerator{}
		pspec.Name = p.Name()
		_, err := generateUtils.PodConfigToSpec(ic.Libpod, pspec, &entities.ContainerCreateOptions{}, opts.ID)
		if err != nil {
			return nil, err
		}
	}

	if pspec == nil && spec == nil {
		return nil, fmt.Errorf("could not find a pod or container with the id %s", opts.ID)
	}

	// rename if we are looking to consume the output and make a new entity
	if opts.Name {
		if spec != nil {
			spec.Name = generateUtils.CheckName(ic.Libpod, spec.Name, true)
		} else {
			pspec.Name = generateUtils.CheckName(ic.Libpod, pspec.Name, false)
		}
	}

	j := []byte{}
	if spec != nil {
		j, err = json.MarshalIndent(spec, "", " ")
		if err != nil {
			return nil, err
		}
	} else if pspec != nil {
		j, err = json.MarshalIndent(pspec, "", " ")
		if err != nil {
			return nil, err
		}
	}

	// compact output
	if opts.Compact {
		compacted := &bytes.Buffer{}
		err := json.Compact(compacted, j)
		if err != nil {
			return nil, err
		}
		return &entities.GenerateSpecReport{Data: compacted.Bytes()}, nil
	}
	return &entities.GenerateSpecReport{Data: j}, nil // regular output
}

func (ic *ContainerEngine) GenerateKube(ctx context.Context, nameOrIDs []string, options entities.GenerateKubeOptions) (*entities.GenerateKubeReport, error) {
	var (
		pods        []*libpod.Pod
		ctrs        []*libpod.Container
		vols        []*libpod.Volume
		typeContent [][]byte
		content     [][]byte
	)

	if options.Replicas > 1 && options.Type != define.K8sKindDeployment {
		return nil, fmt.Errorf("--replicas can only be set when --type is set to deployment")
	}
	if options.Replicas < 1 {
		return nil, fmt.Errorf("--replicas has to be greater than or equal to 1. By default, --replicas is set to 1")
	}

	defaultKubeNS := true
	// Lookup for podman objects.
	for _, nameOrID := range nameOrIDs {
		// Let's assume it's a container, so get the container.
		ctr, err := ic.Libpod.LookupContainer(nameOrID)
		if err != nil {
			if !strings.Contains(err.Error(), "no such container") {
				return nil, err
			}
		} else {
			//  now that infra holds NS data, we need to support dependencies.
			// we cannot deal with ctrs already in a pod.
			if len(ctr.PodID()) > 0 {
				return nil, fmt.Errorf("container %s is associated with pod %s: use generate on the pod itself", ctr.ID(), ctr.PodID())
			}
			ctrs = append(ctrs, ctr)
			continue
		}

		// Maybe it's a pod.
		pod, err := ic.Libpod.LookupPod(nameOrID)
		if err != nil {
			if !strings.Contains(err.Error(), "no such pod") {
				return nil, err
			}
		} else {
			// Get the pod config to see if the user has modified the default
			// namespace sharing values as this might affect the pods when run
			// in a k8s cluster
			podConfig, err := pod.Config()
			if err != nil {
				return nil, err
			}
			if !(podConfig.UsePodIPC && podConfig.UsePodNet && podConfig.UsePodUTS) {
				defaultKubeNS = false
			}

			pods = append(pods, pod)
			continue
		}

		// Or volume.
		vol, err := ic.Libpod.LookupVolume(nameOrID)
		if err != nil {
			if !strings.Contains(err.Error(), "no such volume") {
				return nil, err
			}
		} else {
			vols = append(vols, vol)
			continue
		}

		// If it reaches here is because the name or id did not exist.
		return nil, fmt.Errorf("name or ID %q not found", nameOrID)
	}

	if !defaultKubeNS {
		warning := `
# NOTE: The namespace sharing for a pod has been modified by the user and is not the same as the
# default settings for kubernetes. This can lead to unexpected behavior when running the generated
# kube yaml in a kubernetes cluster.
`
		content = append(content, []byte(warning))
	}

	// Generate kube persistent volume claims from volumes.
	if len(vols) >= 1 {
		pvs, err := getKubePVCs(vols)
		if err != nil {
			return nil, err
		}

		content = append(content, pvs...)
	}

	// Generate kube pods and services from pods.
	if len(pods) >= 1 {
		out, svcs, err := getKubePods(ctx, pods, options)
		if err != nil {
			return nil, err
		}

		typeContent = append(typeContent, out...)
		if options.Service {
			content = append(content, svcs...)
		}
	}

	// Generate the kube pods from containers.
	if len(ctrs) >= 1 {
		po, err := libpod.GenerateForKube(ctx, ctrs, options.Service, options.UseLongAnnotations, options.PodmanOnly)
		if err != nil {
			return nil, err
		}
		if len(po.Spec.Volumes) != 0 {
			warning := `
# NOTE: If you generated this yaml from an unprivileged and rootless podman container on an SELinux
# enabled system, check the podman generate kube man page for steps to follow to ensure that your pod/container
# has the right permissions to access the volumes added.
`
			content = append(content, []byte(warning))
		}

		// Create a pod or deployment kind depending on what Type was requested by the user
		switch options.Type {
		case define.K8sKindDeployment:
			dep, err := libpod.GenerateForKubeDeployment(ctx, libpod.ConvertV1PodToYAMLPod(po), options)
			if err != nil {
				return nil, err
			}
			b, err := generateKubeYAML(dep)
			if err != nil {
				return nil, err
			}
			typeContent = append(typeContent, b)
		case define.K8sKindDaemonSet:
			dep, err := libpod.GenerateForKubeDaemonSet(ctx, libpod.ConvertV1PodToYAMLPod(po), options)
			if err != nil {
				return nil, err
			}
			b, err := generateKubeYAML(dep)
			if err != nil {
				return nil, err
			}
			typeContent = append(typeContent, b)
		case define.K8sKindPod:
			b, err := generateKubeYAML(libpod.ConvertV1PodToYAMLPod(po))
			if err != nil {
				return nil, err
			}
			typeContent = append(typeContent, b)
		default:
			return nil, fmt.Errorf("invalid generation type - only pods, deployments and daemonsets are currently supported: %+v", options.Type)
		}

		if options.Service {
			svc, err := libpod.GenerateKubeServiceFromV1Pod(po, []k8sAPI.ServicePort{})
			if err != nil {
				return nil, err
			}
			b, err := generateKubeYAML(svc)
			if err != nil {
				return nil, err
			}
			content = append(content, b)
		}
	}

	// Content order is based on helm install order (secret, persistentVolumeClaim, service, pod/deployment).
	content = append(content, typeContent...)

	// Generate kube YAML file from all kube kinds.
	k, err := generateKubeOutput(content)
	if err != nil {
		return nil, err
	}

	return &entities.GenerateKubeReport{Reader: bytes.NewReader(k)}, nil
}

// getKubePods returns kube pod or deployment and service YAML files from podman pods.
func getKubePods(ctx context.Context, pods []*libpod.Pod, options entities.GenerateKubeOptions) ([][]byte, [][]byte, error) {
	out := [][]byte{}
	svcs := [][]byte{}

	for _, p := range pods {
		po, sp, err := p.GenerateForKube(ctx, options.Service, options.UseLongAnnotations, options.PodmanOnly)
		if err != nil {
			return nil, nil, err
		}

		switch options.Type {
		case define.K8sKindDeployment:
			dep, err := libpod.GenerateForKubeDeployment(ctx, libpod.ConvertV1PodToYAMLPod(po), options)
			if err != nil {
				return nil, nil, err
			}
			b, err := generateKubeYAML(dep)
			if err != nil {
				return nil, nil, err
			}
			out = append(out, b)
		case define.K8sKindDaemonSet:
			dep, err := libpod.GenerateForKubeDaemonSet(ctx, libpod.ConvertV1PodToYAMLPod(po), options)
			if err != nil {
				return nil, nil, err
			}
			b, err := generateKubeYAML(dep)
			if err != nil {
				return nil, nil, err
			}
			out = append(out, b)
		case define.K8sKindPod:
			b, err := generateKubeYAML(libpod.ConvertV1PodToYAMLPod(po))
			if err != nil {
				return nil, nil, err
			}
			out = append(out, b)
		default:
			return nil, nil, fmt.Errorf("invalid generation type - only pods, deployments and daemonsets are currently supported")
		}

		if options.Service {
			svc, err := libpod.GenerateKubeServiceFromV1Pod(po, sp)
			if err != nil {
				return nil, nil, err
			}
			b, err := generateKubeYAML(svc)
			if err != nil {
				return nil, nil, err
			}
			svcs = append(svcs, b)
		}
	}

	return out, svcs, nil
}

// getKubePVCs returns kube persistent volume claim YAML files from podman volumes.
func getKubePVCs(volumes []*libpod.Volume) ([][]byte, error) {
	pvs := [][]byte{}

	for _, v := range volumes {
		b, err := generateKubeYAML(v.GenerateForKube())
		if err != nil {
			return nil, err
		}
		pvs = append(pvs, b)
	}

	return pvs, nil
}

// generateKubeYAML marshalls a kube kind into a YAML file.
func generateKubeYAML(kubeKind interface{}) ([]byte, error) {
	b, err := yaml.Marshal(kubeKind)
	if err != nil {
		return nil, err
	}

	return b, nil
}

// generateKubeOutput generates kube YAML file containing multiple kube kinds.
func generateKubeOutput(content [][]byte) ([]byte, error) {
	output := make([]byte, 0)

	header := `# Save the output of this file and use kubectl create -f to import
# it into Kubernetes.
#
# Created with podman-%s
`
	podmanVersion, err := define.GetVersion()
	if err != nil {
		return nil, err
	}

	// Add header to kube YAML file.
	output = append(output, []byte(fmt.Sprintf(header, podmanVersion.Version))...)

	// kube generate order is based on helm install order (secret, persistentVolume, service, pod...).
	// Add kube kinds.
	for i, b := range content {
		if i != 0 {
			output = append(output, []byte("---\n")...)
		}

		output = append(output, b...)
	}

	return output, nil
}
