package gitrepo

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

// DefaultMaintTimeout is de maximale duur van onderhoud op één repository.
const DefaultMaintTimeout = 30 * time.Minute

// MaintenanceArgs is het voorkeurscommando (modern git). Geen --prune=now.
func MaintenanceArgs() []string {
	return []string{"maintenance", "run", "--task=gc", "--task=loose-objects", "--task=incremental-repack"}
}

// GCAutoArgs is de veilige kern: git's eigen auto-drempels, standaard prune-termijn, locking.
func GCAutoArgs() []string {
	return []string{"gc", "--auto"}
}

// extraMaintTasks zijn optionele stappen na gc --auto. Een taak die niets
// te doen heeft (geen packfiles) is geen fout.
func extraMaintTasks() [][]string {
	return [][]string{
		{"maintenance", "run", "--task=loose-objects"},
		{"maintenance", "run", "--task=incremental-repack"},
	}
}

// MaintResult is de uitkomst van onderhoud op één bare repository.
type MaintResult struct {
	Dir      string
	OK       bool
	Output   string
	Err      string
	Duration time.Duration
}

// Maintain voert veilig git-onderhoud uit op één bare repository.
// Eerst `git gc --auto` (locking, geen --prune=now). Daarna optioneel
// loose-objects en incremental-repack; die mogen stil falen als er niets
// te doen is of als de git-binary maintenance niet kent. Een lock van
// een push of clone laat git falen; de aanroeper slaat de repo over.
func Maintain(ctx context.Context, gitBin, dir string) MaintResult {
	start := time.Now()
	res := MaintResult{Dir: dir}
	if gitBin == "" {
		gitBin = "git"
	}
	if dir == "" {
		res.Err = "leeg pad"
		res.Duration = time.Since(start)
		return res
	}

	var logs []string
	out, err := runNice(ctx, gitBin, append([]string{"-C", dir}, GCAutoArgs()...)...)
	if strings.TrimSpace(out) != "" {
		logs = append(logs, strings.TrimSpace(out))
	}
	if err != nil {
		res.Err = err.Error()
		res.Output = strings.Join(logs, "\n")
		res.Duration = time.Since(start)
		return res
	}
	for _, args := range extraMaintTasks() {
		if ctx.Err() != nil {
			break
		}
		out, err = runNice(ctx, gitBin, append([]string{"-C", dir}, args...)...)
		if strings.TrimSpace(out) != "" {
			logs = append(logs, strings.TrimSpace(out))
		}
		if err == nil || isSkippableMaint(err) {
			continue
		}
		// Een echte fout op een extra taak is geen reden de ronde te
		// laten mislukken: gc --auto is al gelukt. We loggen het wel.
		logs = append(logs, err.Error())
	}
	res.Output = strings.Join(logs, "\n")
	res.Duration = time.Since(start)
	res.OK = true
	return res
}

func isSkippableMaint(err error) bool {
	if err == nil {
		return true
	}
	msg := strings.ToLower(err.Error())
	return strings.Contains(msg, "is not a git command") ||
		strings.Contains(msg, "unknown subcommand") ||
		strings.Contains(msg, "unknown command") ||
		strings.Contains(msg, "no pack files") ||
		strings.Contains(msg, "nothing to repack") ||
		strings.Contains(msg, "nothing to do")
}

func runNice(ctx context.Context, bin string, args ...string) (string, error) {
	var cmd *exec.Cmd
	if nice, err := exec.LookPath("nice"); err == nil {
		cmd = exec.CommandContext(ctx, nice, append([]string{"-n", "19", bin}, args...)...)
	} else {
		cmd = exec.CommandContext(ctx, bin, args...)
	}
	var stdout, stderr strings.Builder
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	if err := cmd.Run(); err != nil {
		msg := strings.TrimSpace(stderr.String())
		if msg == "" {
			msg = err.Error()
		}
		return stdout.String(), fmt.Errorf("%s", msg)
	}
	return stdout.String(), nil
}
