package composeplugin

import (
	"bytes"
	"context"
	"fmt"
	"os"
	"os/exec"
	"strings"

	"github.com/pkg/errors"
	"github.com/portainer/portainer/pkg/libstack"
	"github.com/portainer/portainer/pkg/libstack/compose/internal/utils"
	"github.com/rs/zerolog/log"
)

var (
	MissingDockerComposePluginErr = errors.New("docker-compose plugin is missing from config path")
)

// PluginWrapper provide a type for managing docker compose commands
type PluginWrapper struct {
	binaryPath string
	configPath string
}

// NewPluginWrapper initializes a new ComposeWrapper service with local docker-compose binary.
func NewPluginWrapper(binaryPath, configPath string) (libstack.Deployer, error) {
	if !utils.IsBinaryPresent(utils.ProgramPath(binaryPath, "docker-compose")) {
		return nil, MissingDockerComposePluginErr
	}

	return &PluginWrapper{binaryPath: binaryPath, configPath: configPath}, nil
}

// Up create and start containers
func (wrapper *PluginWrapper) Deploy(ctx context.Context, filePaths []string, options libstack.DeployOptions) error {
	output, err := wrapper.command(newUpCommand(filePaths, upOptions{
		forceRecreate:        options.ForceRecreate,
		abortOnContainerExit: options.AbortOnContainerExit,
	}), options.Options)

	if len(output) != 0 {
		if err != nil {
			return err
		}

		log.Info().Msg("Stack deployment successful")

		log.Debug().
			Str("output", string(output)).
			Msg("docker compose")
	}

	return err
}

// Down stop and remove containers
func (wrapper *PluginWrapper) Remove(ctx context.Context, projectName string, filePaths []string, options libstack.Options) error {
	output, err := wrapper.command(newDownCommand(projectName, filePaths), options)
	if len(output) != 0 {
		if err != nil {
			return err
		}

		log.Info().Msg("Stack removal successful")

		log.Debug().
			Str("output", string(output)).
			Msg("docker compose")

	}

	return err
}

// Pull images
func (wrapper *PluginWrapper) Pull(ctx context.Context, filePaths []string, options libstack.Options) error {
	output, err := wrapper.command(newPullCommand(filePaths), options)
	if len(output) != 0 {
		if err != nil {
			return err
		}

		log.Info().Msg("Stack pull successful")

		log.Debug().
			Str("output", string(output)).
			Msg("docker compose")
	}

	return err
}

// Validate stack file
func (wrapper *PluginWrapper) Validate(ctx context.Context, filePaths []string, options libstack.Options) error {
	output, err := wrapper.command(newValidateCommand(filePaths), options)
	if len(output) != 0 {
		if err != nil {
			return err
		}

		log.Info().Msg("Valid stack format")

		log.Debug().
			Str("output", string(output)).
			Msg("docker compose")
	}

	return err
}

// Command execute a docker-compose command
func (wrapper *PluginWrapper) command(command composeCommand, options libstack.Options) ([]byte, error) {
	program := utils.ProgramPath(wrapper.binaryPath, "docker-compose")

	if options.ProjectName != "" {
		command.WithProjectName(options.ProjectName)
	}

	if options.EnvFilePath != "" {
		command.WithEnvFilePath(options.EnvFilePath)
	}

	if options.Host != "" {
		command.WithHost(options.Host)
	}

	var stderr bytes.Buffer

	args := []string{}
	args = append(args, command.ToArgs()...)

	cmd := exec.Command(program, args...)
	cmd.Dir = options.WorkingDir

	if wrapper.configPath != "" || len(options.Env) > 0 {
		cmd.Env = os.Environ()
	}

	if wrapper.configPath != "" {
		cmd.Env = append(cmd.Env, "DOCKER_CONFIG="+wrapper.configPath)
	}

	cmd.Env = append(cmd.Env, options.Env...)

	log.Debug().
		Str("command", program).
		Strs("args", args).
		Interface("env", cmd.Env).
		Msg("run command")

	cmd.Stderr = &stderr

	output, err := cmd.Output()
	if err != nil {
		errOutput := stderr.String()
		log.Warn().
			Str("output", string(output)).
			Str("error_output", errOutput).
			Err(err).
			Msg("docker compose command failed")

		if errOutput != "" {
			return nil, errors.New(errOutput)
		}

		return nil, fmt.Errorf("docker compose command failed: %w", err)
	}

	return output, nil
}

type composeCommand struct {
	globalArgs        []string // docker-compose global arguments: --host host -f file.yaml
	subCommandAndArgs []string // docker-compose subcommand:  up, down folllowed by subcommand arguments
}

func newCommand(command []string, filePaths []string) composeCommand {
	args := []string{}
	for _, path := range filePaths {
		args = append(args, "-f")
		args = append(args, strings.TrimSpace(path))
	}
	return composeCommand{
		globalArgs:        args,
		subCommandAndArgs: command,
	}
}

type upOptions struct {
	forceRecreate        bool
	abortOnContainerExit bool
}

func newUpCommand(filePaths []string, options upOptions) composeCommand {
	args := []string{"up"}

	if options.abortOnContainerExit {
		args = append(args, "--abort-on-container-exit")
	} else { // detach by default, not working with --abort-on-container-exit
		args = append(args, "-d")
	}

	if options.forceRecreate {
		args = append(args, "--force-recreate")
	}
	return newCommand(args, filePaths)
}

func newDownCommand(projectName string, filePaths []string) composeCommand {
	cmd := newCommand([]string{"down", "--remove-orphans"}, filePaths)
	cmd.WithProjectName(projectName)

	return cmd
}

func newPullCommand(filePaths []string) composeCommand {
	return newCommand([]string{"pull"}, filePaths)
}

func newValidateCommand(filePaths []string) composeCommand {
	return newCommand([]string{"config", "--quiet"}, filePaths)
}

func (command *composeCommand) WithHost(host string) {
	// prepend compatibility flags such as this one as they must appear before the
	// regular global args otherwise docker-compose will throw an error
	command.globalArgs = append([]string{"--host", host}, command.globalArgs...)
}

func (command *composeCommand) WithProjectName(projectName string) {
	command.globalArgs = append(command.globalArgs, "--project-name", projectName)
}

func (command *composeCommand) WithEnvFilePath(envFilePath string) {
	command.globalArgs = append(command.globalArgs, "--env-file", envFilePath)
}

func (command *composeCommand) ToArgs() []string {
	return append(command.globalArgs, command.subCommandAndArgs...)
}