package command

import (
	"context"
	"errors"
	"fmt"
	"io"
	"os"
	"os/exec"
	"strings"

	"alin.ovh/erl/output"
)

type Command interface {
	Start() error
	Wait() error
	Stop(context.Context) error
}

type Cmd struct {
	*exec.Cmd

	name string
	args []string

	out output.Output

	opts Options
}

type Options struct {
	Output io.Writer
	Stdout io.Writer
	Stderr io.Writer
}

func New(name string, args []string, options Options) *Cmd {
	if options.Stdout == nil {
		options.Stdout = os.Stdout
	}
	if options.Stderr == nil {
		options.Stderr = os.Stderr
	}
	if options.Output == nil {
		options.Output = os.Stderr
	}

	return &Cmd{
		name: name,
		args: args,
		opts: options,

		out: output.New(options.Output),
	}
}

func (cmd *Cmd) Stop(ctx context.Context) error {
	if cmd.Cmd == nil || cmd.Process == nil || cmd.ProcessState != nil {
		return nil
	}

	err := cmd.Process.Signal(os.Interrupt)
	if err != nil {
		return fmt.Errorf("error killing command: %v", err)
	}

	exited := make(chan struct{})
	go func() {
		cmd.Wait()
		exited <- struct{}{}
		close(exited)
	}()

	for {
		select {
		case <-ctx.Done():
			err := ctx.Err()
			if !errors.Is(err, context.DeadlineExceeded) {
				return err
			}

			cmd.out.Fail("[command not stopped, killing]\n")
			err = cmd.Process.Kill()
			if err != nil && !errors.Is(err, os.ErrProcessDone) {
				return fmt.Errorf("error killing command: %v", err)
			}

			return nil
		case <-exited:
			return nil
		}
	}
}

func (cmd *Cmd) Exited() bool {
	return cmd.Cmd != nil && cmd.ProcessState != nil && cmd.ProcessState.Exited()
}

func (cmd *Cmd) Wait() error {
	err := cmd.Cmd.Wait()
	var exitErr *exec.ExitError
	if err != nil && !errors.As(err, &exitErr) {
		return err
	}

	switch {
	case !cmd.Exited():
		cmd.out.Info("[command stopped]\n")
	case cmd.ProcessState.Success():
		cmd.out.Success("[command finished]\n")
	default:
		cmd.out.Fail("[command exited with code %d]\n", cmd.ProcessState.ExitCode())
	}

	return nil
}

func (cmd *Cmd) Start() error {
	cmd.makeCommand()
	cmd.out.Success("[running: %s]\n", strings.Join(append([]string{cmd.name}, cmd.args...), " "))
	err := cmd.Cmd.Start()
	if err != nil {
		return fmt.Errorf("error starting command: %v", err)
	}

	return err
}

func (cmd *Cmd) makeCommand() {
	cmd.Cmd = exec.Command(cmd.name, cmd.args...)
	cmd.Stdout = cmd.opts.Stdout
	cmd.Stderr = cmd.opts.Stderr
}