package gitutil

import (
	"bytes"
	"context"
	"fmt"
	"os"
	"os/exec"
	"strings"
	"syscall"
	"time"
)

// git runs network work in child processes, so killing only git leaves them running

// WaitDelay stops waits on output held open by git's children
const WaitDelay = 10 * time.Second

// LC_ALL=C keeps git's messages in english, callers match on its stderr
func Command(ctx context.Context, args ...string) *exec.Cmd {
	cmd := exec.CommandContext(ctx, "git", args...)
	cmd.Env = append(os.Environ(), "LC_ALL=C")
	return Contain(cmd)
}

// Contain is for sandbox-rebuilt commands and direct git binaries
func Contain(cmd *exec.Cmd) *exec.Cmd {
	if cmd.SysProcAttr == nil {
		cmd.SysProcAttr = &syscall.SysProcAttr{}
	}
	cmd.SysProcAttr.Setpgid = true
	cmd.WaitDelay = WaitDelay
	// exec rejects Cancel on commands not created with CommandContext
	if cmd.Cancel != nil {
		cmd.Cancel = func() error {
			if cmd.Process == nil {
				return nil
			}
			err := syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
			if err == syscall.ESRCH {
				return nil
			}
			return err
		}
	}
	return cmd
}

func Run(ctx context.Context, args ...string) error {
	var stderr bytes.Buffer
	cmd := Command(ctx, args...)
	cmd.Stderr = &stderr
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("%w: %s", err, strings.TrimSpace(stderr.String()))
	}
	return nil
}

func Output(ctx context.Context, args ...string) ([]byte, error) {
	return output(Command(ctx, args...))
}

func OutputOffline(ctx context.Context, args ...string) ([]byte, error) {
	cmd := Command(ctx, args...)
	cmd.Env = append(cmd.Env, "GIT_NO_LAZY_FETCH=1")
	return output(cmd)
}

func output(cmd *exec.Cmd) ([]byte, error) {
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	if err := cmd.Run(); err != nil {
		return nil, fmt.Errorf("%w: %s", err, strings.TrimSpace(stderr.String()))
	}
	return stdout.Bytes(), nil
}