package server

import (
	"context"

	"coopcloud.tech/abra/cli/internal"
	"coopcloud.tech/abra/pkg/autocomplete"
	"coopcloud.tech/abra/pkg/client"
	"coopcloud.tech/abra/pkg/formatter"
	"github.com/docker/docker/api/types/filters"
	"github.com/sirupsen/logrus"
	"github.com/urfave/cli"
)

var allFilter bool

var allFilterFlag = &cli.BoolFlag{
	Name:        "all, a",
	Usage:       "Remove all unused images not just dangling ones",
	Destination: &allFilter,
}

var volumesFilter bool

var volumesFilterFlag = &cli.BoolFlag{
	Name:        "volumes, v",
	Usage:       "Prune volumes. This will remove app data, Be Careful!",
	Destination: &volumesFilter,
}

var serverPruneCommand = cli.Command{
	Name:    "prune",
	Aliases: []string{"p"},
	Usage:   "Prune a managed server; Runs a docker system prune",
	Description: `
Prunes unused containers, networks, and dangling images.

If passing "-v/--volumes" then volumes not connected to a deployed app will
also be removed. This can result in unwanted data loss if not used carefully.
	`,
	ArgsUsage: "[<server>]",
	Flags: []cli.Flag{
		allFilterFlag,
		volumesFilterFlag,
		internal.DebugFlag,
		internal.OfflineFlag,
		internal.NoInputFlag,
	},
	Before:       internal.SubCommandBefore,
	BashComplete: autocomplete.ServerNameComplete,
	Action: func(c *cli.Context) error {
		serverName := internal.ValidateServer(c)

		cl, err := client.New(serverName)
		if err != nil {
			logrus.Fatal(err)
		}

		var args filters.Args

		ctx := context.Background()
		cr, err := cl.ContainersPrune(ctx, args)
		if err != nil {
			logrus.Fatal(err)
		}

		cntSpaceReclaimed := formatter.ByteCountSI(cr.SpaceReclaimed)
		logrus.Infof("containers pruned: %d; space reclaimed: %s", len(cr.ContainersDeleted), cntSpaceReclaimed)

		nr, err := cl.NetworksPrune(ctx, args)
		if err != nil {
			logrus.Fatal(err)
		}

		logrus.Infof("networks pruned: %d", len(nr.NetworksDeleted))

		pruneFilters := filters.NewArgs()
		if allFilter {
			logrus.Debugf("removing all images, not only dangling ones")
			pruneFilters.Add("dangling", "false")
		}

		ir, err := cl.ImagesPrune(ctx, pruneFilters)
		if err != nil {
			logrus.Fatal(err)
		}

		imgSpaceReclaimed := formatter.ByteCountSI(ir.SpaceReclaimed)
		logrus.Infof("images pruned: %d; space reclaimed: %s", len(ir.ImagesDeleted), imgSpaceReclaimed)

		if volumesFilter {
			vr, err := cl.VolumesPrune(ctx, args)
			if err != nil {
				logrus.Fatal(err)
			}

			volSpaceReclaimed := formatter.ByteCountSI(vr.SpaceReclaimed)
			logrus.Infof("volumes pruned: %d; space reclaimed: %s", len(vr.VolumesDeleted), volSpaceReclaimed)
		}

		return nil
	},
}