package main

import (
	"encoding/json"
	"fmt"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/cri-o/ocicni/pkg/ocicni"
	"github.com/docker/go-units"
	specs "github.com/opencontainers/runtime-spec/specs-go"
	"github.com/pkg/errors"
	"github.com/projectatomic/libpod/cmd/podman/batchcontainer"
	"github.com/projectatomic/libpod/cmd/podman/formats"
	"github.com/projectatomic/libpod/cmd/podman/libpodruntime"
	"github.com/projectatomic/libpod/libpod"
	cc "github.com/projectatomic/libpod/pkg/spec"
	"github.com/projectatomic/libpod/pkg/util"
	"github.com/sirupsen/logrus"
	"github.com/urfave/cli"
	"k8s.io/apimachinery/pkg/fields"
)

const mountTruncLength = 12

type psTemplateParams struct {
	ID            string
	Image         string
	Command       string
	CreatedAtTime time.Time
	Created       string
	RunningFor    string
	Status        string
	Ports         string
	Size          string
	Names         string
	Labels        string
	Mounts        string
	PID           int
	Cgroup        string
	IPC           string
	MNT           string
	NET           string
	PIDNS         string
	User          string
	UTS           string
}

// psJSONParams is only used when the JSON format is specified,
// and is better for data processing from JSON.
// psJSONParams will be populated by data from libpod.Container,
// the members of the struct are the sama data types as their sources.
type psJSONParams struct {
	ID               string                    `json:"id"`
	Image            string                    `json:"image"`
	ImageID          string                    `json:"image_id"`
	Command          []string                  `json:"command"`
	CreatedAt        time.Time                 `json:"createdAt"`
	RunningFor       time.Duration             `json:"runningFor"`
	Status           string                    `json:"status"`
	Ports            []ocicni.PortMapping      `json:"ports"`
	RootFsSize       int64                     `json:"rootFsSize"`
	RWSize           int64                     `json:"rwSize"`
	Names            string                    `json:"names"`
	Labels           fields.Set                `json:"labels"`
	Mounts           []specs.Mount             `json:"mounts"`
	ContainerRunning bool                      `json:"ctrRunning"`
	Namespaces       *batchcontainer.Namespace `json:"namespace,omitempty"`
}

// Type declaration and functions for sorting the PS output by time
type psSorted []psTemplateParams

func (a psSorted) Len() int           { return len(a) }
func (a psSorted) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a psSorted) Less(i, j int) bool { return a[i].CreatedAtTime.After(a[j].CreatedAtTime) }

var (
	psFlags = []cli.Flag{
		cli.BoolFlag{
			Name:  "all, a",
			Usage: "Show all the containers, default is only running containers",
		},
		cli.StringFlag{
			Name:  "filter, f",
			Usage: "Filter output based on conditions given",
		},
		cli.StringFlag{
			Name:  "format",
			Usage: "Pretty-print containers to JSON or using a Go template",
		},
		cli.IntFlag{
			Name:  "last, n",
			Usage: "Print the n last created containers (all states)",
			Value: -1,
		},
		cli.BoolFlag{
			Name:  "latest, l",
			Usage: "Show the latest container created (all states)",
		},
		cli.BoolFlag{
			Name:  "no-trunc",
			Usage: "Display the extended information",
		},
		cli.BoolFlag{
			Name:  "quiet, q",
			Usage: "Print the numeric IDs of the containers only",
		},
		cli.BoolFlag{
			Name:  "size, s",
			Usage: "Display the total file sizes",
		},
		cli.BoolFlag{
			Name:  "namespace, ns",
			Usage: "Display namespace information",
		},
	}
	psDescription = "Prints out information about the containers"
	psCommand     = cli.Command{
		Name:                   "ps",
		Usage:                  "List containers",
		Description:            psDescription,
		Flags:                  psFlags,
		Action:                 psCmd,
		ArgsUsage:              "",
		UseShortOptionHandling: true,
	}
)

func psCmd(c *cli.Context) error {
	if err := validateFlags(c, psFlags); err != nil {
		return err
	}

	if err := checkFlagsPassed(c); err != nil {
		return errors.Wrapf(err, "error with flags passed")
	}

	runtime, err := libpodruntime.GetRuntime(c)
	if err != nil {
		return errors.Wrapf(err, "error creating libpod runtime")
	}

	defer runtime.Shutdown(false)

	if len(c.Args()) > 0 {
		return errors.Errorf("too many arguments, ps takes no arguments")
	}

	format := genPsFormat(c.String("format"), c.Bool("quiet"), c.Bool("size"), c.Bool("namespace"))

	opts := batchcontainer.PsOptions{
		All:       c.Bool("all"),
		Filter:    c.String("filter"),
		Format:    format,
		Last:      c.Int("last"),
		Latest:    c.Bool("latest"),
		NoTrunc:   c.Bool("no-trunc"),
		Quiet:     c.Bool("quiet"),
		Size:      c.Bool("size"),
		Namespace: c.Bool("namespace"),
	}

	var filterFuncs []libpod.ContainerFilter
	// When we are dealing with latest or last=n, we need to
	// get all containers.
	if !opts.All && !opts.Latest && opts.Last < 1 {
		// only get running containers
		filterFuncs = append(filterFuncs, func(c *libpod.Container) bool {
			state, _ := c.State()
			return state == libpod.ContainerStateRunning
		})
	}

	if opts.Filter != "" {
		filters := strings.Split(opts.Filter, ",")
		for _, f := range filters {
			filterSplit := strings.Split(f, "=")
			if len(filterSplit) < 2 {
				return errors.Errorf("filter input must be in the form of filter=value: %s is invalid", f)
			}
			generatedFunc, err := generateContainerFilterFuncs(filterSplit[0], filterSplit[1], runtime)
			if err != nil {
				return errors.Wrapf(err, "invalid filter")
			}
			filterFuncs = append(filterFuncs, generatedFunc)
		}
	}

	containers, err := runtime.GetContainers(filterFuncs...)
	var outputContainers []*libpod.Container
	if opts.Latest && len(containers) > 0 {
		outputContainers = append(outputContainers, containers[0])
	} else if opts.Last > 0 && opts.Last <= len(containers) {
		outputContainers = append(outputContainers, containers[:opts.Last]...)
	} else {
		outputContainers = containers
	}

	return generatePsOutput(outputContainers, opts)
}

// checkFlagsPassed checks if mutually exclusive flags are passed together
func checkFlagsPassed(c *cli.Context) error {
	// latest, and last are mutually exclusive.
	if c.Int("last") >= 0 && c.Bool("latest") {
		return errors.Errorf("last and latest are mutually exclusive")
	}
	// quiet, size, namespace, and format with Go template are mutually exclusive
	flags := 0
	if c.Bool("quiet") {
		flags++
	}
	if c.Bool("size") {
		flags++
	}
	if c.Bool("namespace") {
		flags++
	}
	if c.IsSet("format") && c.String("format") != formats.JSONString {
		flags++
	}
	if flags > 1 {
		return errors.Errorf("quiet, size, namespace, and format with Go template are mutually exclusive")
	}
	return nil
}

func generateContainerFilterFuncs(filter, filterValue string, runtime *libpod.Runtime) (func(container *libpod.Container) bool, error) {
	switch filter {
	case "id":
		return func(c *libpod.Container) bool {
			return strings.Contains(c.ID(), filterValue)
		}, nil
	case "label":
		return func(c *libpod.Container) bool {
			for _, label := range c.Labels() {
				if label == filterValue {
					return true
				}
			}
			return false
		}, nil
	case "name":
		return func(c *libpod.Container) bool {
			return strings.Contains(c.Name(), filterValue)
		}, nil
	case "exited":
		exitCode, err := strconv.ParseInt(filterValue, 10, 32)
		if err != nil {
			return nil, errors.Wrapf(err, "exited code out of range %q", filterValue)
		}
		return func(c *libpod.Container) bool {
			ec, err := c.ExitCode()
			if ec == int32(exitCode) && err == nil {
				return true
			}
			return false
		}, nil
	case "status":
		if !util.StringInSlice(filterValue, []string{"created", "restarting", "running", "paused", "exited", "unknown"}) {
			return nil, errors.Errorf("%s is not a valid status", filterValue)
		}
		return func(c *libpod.Container) bool {
			status, err := c.State()
			if err != nil {
				return false
			}
			state := status.String()
			if status == libpod.ContainerStateConfigured {
				state = "created"
			}
			return state == filterValue
		}, nil
	case "ancestor":
		// This needs to refine to match docker
		// - ancestor=(<image-name>[:tag]|<image-id>| ⟨image@digest⟩) - containers created from an image or a descendant.
		return func(c *libpod.Container) bool {
			containerConfig := c.Config()
			if strings.Contains(containerConfig.RootfsImageID, filterValue) || strings.Contains(containerConfig.RootfsImageName, filterValue) {
				return true
			}
			return false
		}, nil
	case "before":
		ctr, err := runtime.LookupContainer(filterValue)
		if err != nil {
			return nil, errors.Errorf("unable to find container by name or id of %s", filterValue)
		}
		containerConfig := ctr.Config()
		createTime := containerConfig.CreatedTime
		return func(c *libpod.Container) bool {
			cc := c.Config()
			return createTime.After(cc.CreatedTime)
		}, nil
	case "since":
		ctr, err := runtime.LookupContainer(filterValue)
		if err != nil {
			return nil, errors.Errorf("unable to find container by name or id of %s", filterValue)
		}
		containerConfig := ctr.Config()
		createTime := containerConfig.CreatedTime
		return func(c *libpod.Container) bool {
			cc := c.Config()
			return createTime.Before(cc.CreatedTime)
		}, nil
	case "volume":
		//- volume=(<volume-name>|<mount-point-destination>)
		return func(c *libpod.Container) bool {
			containerConfig := c.Config()
			var dest string
			arr := strings.Split(filterValue, ":")
			source := arr[0]
			if len(arr) == 2 {
				dest = arr[1]
			}
			for _, mount := range containerConfig.Spec.Mounts {
				if dest != "" && (mount.Source == source && mount.Destination == dest) {
					return true
				}
				if dest == "" && mount.Source == source {
					return true
				}
			}
			return false
		}, nil
	}
	return nil, errors.Errorf("%s is an invalid filter", filter)
}

// generate the template based on conditions given
func genPsFormat(format string, quiet, size, namespace bool) string {
	if format != "" {
		// "\t" from the command line is not being recognized as a tab
		// replacing the string "\t" to a tab character if the user passes in "\t"
		return strings.Replace(format, `\t`, "\t", -1)
	}
	if quiet {
		return formats.IDString
	}
	if namespace {
		return "table {{.ID}}\t{{.Names}}\t{{.PID}}\t{{.Cgroup}}\t{{.IPC}}\t{{.MNT}}\t{{.NET}}\t{{.PIDNS}}\t{{.User}}\t{{.UTS}}\t"
	}
	format = "table {{.ID}}\t{{.Image}}\t{{.Command}}\t{{.Created}}\t{{.Status}}\t{{.Ports}}\t{{.Names}}\t"
	if size {
		format += "{{.Size}}\t"
	}
	return format
}

func psToGeneric(templParams []psTemplateParams, JSONParams []psJSONParams) (genericParams []interface{}) {
	if len(templParams) > 0 {
		for _, v := range templParams {
			genericParams = append(genericParams, interface{}(v))
		}
		return
	}
	for _, v := range JSONParams {
		genericParams = append(genericParams, interface{}(v))
	}
	return
}

// generate the accurate header based on template given
func (p *psTemplateParams) headerMap() map[string]string {
	v := reflect.Indirect(reflect.ValueOf(p))
	values := make(map[string]string)

	for i := 0; i < v.NumField(); i++ {
		key := v.Type().Field(i).Name
		value := key
		if value == "ID" {
			value = "Container" + value
		}
		values[key] = strings.ToUpper(splitCamelCase(value))
	}
	return values
}

// getTemplateOutput returns the modified container information
func getTemplateOutput(containers []*libpod.Container, opts batchcontainer.PsOptions) (psSorted, error) {
	var (
		psOutput     psSorted
		status, size string
		ns           *batchcontainer.Namespace
	)

	for _, ctr := range containers {
		batchInfo, err := batchcontainer.BatchContainerOp(ctr, opts)
		if err != nil {
			// If the error was ErrNoSuchCtr, it was probably
			// removed sometime after we got the initial list.
			// Just ignore it.
			if errors.Cause(err) == libpod.ErrNoSuchCtr {
				logrus.Debugf("Container %s removed before batch, ignoring in output", ctr.ID())
				continue
			}

			return nil, err
		}
		ctrID := ctr.ID()
		runningFor := ""
		// If the container has not be started, the "zero" value of time is 0001-01-01 00:00:00 +0000 UTC
		// which would make the time elapsed about a few hundred of years. So checking for the "zero" value of time.Time
		if !batchInfo.StartedTime.IsZero() {
			runningFor = units.HumanDuration(time.Since(batchInfo.StartedTime))
		}
		imageName := batchInfo.ConConfig.RootfsImageName

		var createArtifact cc.CreateConfig
		artifact, err := ctr.GetArtifact("create-config")
		if err == nil {
			if err := json.Unmarshal(artifact, &createArtifact); err != nil {
				return nil, err
			}
		} else {
			logrus.Errorf("couldn't get some ps information, error getting artifact %q: %v", ctr.ID(), err)
		}
		if opts.Namespace {
			ns = batchcontainer.GetNamespaces(batchInfo.Pid)
		}
		if opts.Size {

			size = units.HumanSizeWithPrecision(float64(batchInfo.RwSize), 3) + " (virtual " + units.HumanSizeWithPrecision(float64(batchInfo.RootFsSize), 3) + ")"
		}

		command := strings.Join(batchInfo.ConConfig.Spec.Process.Args, " ")
		if !opts.NoTrunc {
			if len(command) > 20 {
				command = command[:19] + "..."
			}
		}
		ports := portsToString(batchInfo.ConConfig.PortMappings)
		mounts := getMounts(createArtifact.Volumes, opts.NoTrunc)
		labels := formatLabels(ctr.Labels())

		switch batchInfo.ConState {
		case libpod.ContainerStateStopped:
			status = fmt.Sprintf("Exited (%d) %s ago", batchInfo.ExitCode, runningFor)
		case libpod.ContainerStateRunning:
			status = "Up " + runningFor + " ago"
		case libpod.ContainerStatePaused:
			status = "Paused"
		case libpod.ContainerStateCreated, libpod.ContainerStateConfigured:
			status = "Created"
		default:
			status = "Dead"
		}

		if !opts.NoTrunc {
			ctrID = shortID(ctr.ID())
			imageName = batchInfo.ConConfig.RootfsImageName
		}
		params := psTemplateParams{
			ID:            ctrID,
			Image:         imageName,
			Command:       command,
			CreatedAtTime: batchInfo.ConConfig.CreatedTime,
			Created:       units.HumanDuration(time.Since(batchInfo.ConConfig.CreatedTime)) + " ago",
			RunningFor:    runningFor,
			Status:        status,
			Ports:         ports,
			Size:          size,
			Names:         ctr.Name(),
			Labels:        labels,
			Mounts:        mounts,
			PID:           batchInfo.Pid,
		}

		if opts.Namespace {
			params.Cgroup = ns.Cgroup
			params.IPC = ns.IPC
			params.MNT = ns.MNT
			params.NET = ns.NET
			params.PIDNS = ns.PIDNS
			params.User = ns.User
			params.UTS = ns.UTS
		}
		psOutput = append(psOutput, params)
	}
	// Sort the ps entries by created time
	sort.Sort(psSorted(psOutput))

	return psOutput, nil
}

// getJSONOutput returns the container info in its raw form
func getJSONOutput(containers []*libpod.Container, opts batchcontainer.PsOptions) ([]psJSONParams, error) {
	var (
		psOutput []psJSONParams
		ns       *batchcontainer.Namespace
	)
	for _, ctr := range containers {
		batchInfo, err := batchcontainer.BatchContainerOp(ctr, opts)
		if err != nil {
			return nil, err
		}
		if opts.Namespace {
			ns = batchcontainer.GetNamespaces(batchInfo.Pid)
		}
		params := psJSONParams{
			ID:               ctr.ID(),
			Image:            batchInfo.ConConfig.RootfsImageName,
			ImageID:          batchInfo.ConConfig.RootfsImageID,
			Command:          batchInfo.ConConfig.Spec.Process.Args,
			CreatedAt:        batchInfo.ConConfig.CreatedTime,
			Status:           batchInfo.ConState.String(),
			Ports:            batchInfo.ConConfig.PortMappings,
			RootFsSize:       batchInfo.RootFsSize,
			RWSize:           batchInfo.RwSize,
			Names:            batchInfo.ConConfig.Name,
			Labels:           batchInfo.ConConfig.Labels,
			Mounts:           batchInfo.ConConfig.Spec.Mounts,
			ContainerRunning: batchInfo.ConState == libpod.ContainerStateRunning,
			Namespaces:       ns,
		}

		if !batchInfo.StartedTime.IsZero() {
			params.RunningFor = time.Since(batchInfo.StartedTime)
		}

		psOutput = append(psOutput, params)
	}
	return psOutput, nil
}

func generatePsOutput(containers []*libpod.Container, opts batchcontainer.PsOptions) error {
	if len(containers) == 0 && opts.Format != formats.JSONString {
		return nil
	}
	var out formats.Writer

	switch opts.Format {
	case formats.JSONString:
		psOutput, err := getJSONOutput(containers, opts)
		if err != nil {
			return errors.Wrapf(err, "unable to create JSON for output")
		}
		out = formats.JSONStructArray{Output: psToGeneric([]psTemplateParams{}, psOutput)}
	default:
		psOutput, err := getTemplateOutput(containers, opts)
		if err != nil {
			return errors.Wrapf(err, "unable to create output")
		}
		out = formats.StdoutTemplateArray{Output: psToGeneric(psOutput, []psJSONParams{}), Template: opts.Format, Fields: psOutput[0].headerMap()}
	}

	return formats.Writer(out).Out()
}

// getLabels converts the labels to a string of the form "key=value, key2=value2"
func formatLabels(labels map[string]string) string {
	var arr []string
	if len(labels) > 0 {
		for key, val := range labels {
			temp := key + "=" + val
			arr = append(arr, temp)
		}
		return strings.Join(arr, ",")
	}
	return ""
}

// getMounts converts the volumes mounted to a string of the form "mount1, mount2"
// it truncates it if noTrunc is false
func getMounts(mounts []string, noTrunc bool) string {
	var arr []string
	if len(mounts) == 0 {
		return ""
	}
	for _, mount := range mounts {
		splitArr := strings.Split(mount, ":")
		if len(splitArr[0]) > mountTruncLength && !noTrunc {
			arr = append(arr, splitArr[0][:mountTruncLength]+"...")
			continue
		}
		arr = append(arr, splitArr[0])
	}
	return strings.Join(arr, ",")
}

// portsToString converts the ports used to a string of the from "port1, port2"
func portsToString(ports []ocicni.PortMapping) string {
	var portDisplay []string
	if len(ports) == 0 {
		return ""
	}
	for _, v := range ports {
		hostIP := v.HostIP
		if hostIP == "" {
			hostIP = "0.0.0.0"
		}
		portDisplay = append(portDisplay, fmt.Sprintf("%s:%d->%d/%s", hostIP, v.HostPort, v.ContainerPort, v.Protocol))
	}
	return strings.Join(portDisplay, ", ")
}