// Package gitrepo legt bare repositories op schijf en praat met de git-binary.
package gitrepo

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"sort"
	"strconv"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gitlab.com/Timfa/bluegit/internal/names"
)

// Dir is de bare repository op de datadisk.
func Dir(storage, owner, name string) string {
	return filepath.Join(storage, "repos", owner, name+".git")
}

// Init maakt een lege bare repository en zet de pre-receive-hook.
func Init(gitBin, dir, defaultBranch, hookBinary string) error {
	if err := os.MkdirAll(filepath.Dir(dir), 0o755); err != nil {
		return err
	}
	if _, err := run(context.Background(), gitBin, nil, "init", "--bare", "--initial-branch", defaultBranch, dir); err != nil {
		return err
	}
	for _, kv := range [][2]string{
		{"http.receivepack", "true"},
		{"http.uploadpack", "true"},
		{"receive.denyCurrentBranch", "ignore"},
	} {
		if _, err := run(context.Background(), gitBin, nil, "-C", dir, "config", kv[0], kv[1]); err != nil {
			return err
		}
	}
	return InstallHook(dir, hookBinary)
}

// InstallHook schrijft hooks/pre-receive. Die roept deze binary aan.
func InstallHook(dir, hookBinary string) error {
	if hookBinary == "" {
		return fmt.Errorf("hook-binary ontbreekt")
	}
	path := filepath.Join(dir, "hooks", "pre-receive")
	body := "#!/bin/sh\nset -eu\nexec " + shellQuote(hookBinary) + " hook pre-receive\n"
	if err := os.WriteFile(path, []byte(body), 0o755); err != nil {
		return err
	}
	return nil
}

func shellQuote(s string) string {
	return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
}

// PushEnv zijn de variabelen die de hook leest. Zonder deze variabelen
// weigert de hook, zodat een push buiten BlueGit om niet slaagt.
func PushEnv(role access.Role, patterns, tagPatterns []string) []string {
	return []string{
		"BLUEGIT_ROLE=" + string(role),
		"BLUEGIT_PROTECTED=" + strings.Join(patterns, "\n"),
		"BLUEGIT_PROTECTED_TAGS=" + strings.Join(tagPatterns, "\n"),
	}
}

// ReadUpdates leest de regels van een pre-receive-hook.
func ReadUpdates(r io.Reader) ([]access.RefUpdate, error) {
	sc := bufio.NewScanner(r)
	var out []access.RefUpdate
	for sc.Scan() {
		line := strings.TrimSpace(sc.Text())
		if line == "" {
			continue
		}
		parts := strings.Fields(line)
		if len(parts) != 3 {
			return nil, fmt.Errorf("onverwachte hookregel %q", line)
		}
		out = append(out, access.RefUpdate{Old: parts[0], New: parts[1], Ref: parts[2]})
	}
	return out, sc.Err()
}

// EvaluatePush is wat `bluegit hook pre-receive` doet.
func EvaluatePush(role access.Role, patterns, tagPatterns []string, r io.Reader) error {
	if role == "" {
		return fmt.Errorf("push geweigerd: geen BlueGit-rol")
	}
	ups, err := ReadUpdates(r)
	if err != nil {
		return err
	}
	return access.AuthorizeUpdates(role, patterns, tagPatterns, ups)
}

// Commit is één commit voor de webinterface.
type Commit struct {
	SHA     string
	Short   string
	Author  string
	Email   string
	Date    string
	Unix    int64
	Subject string
	Body    string
}

// Entry is een bestand of map in een tree.
type Entry struct {
	Mode string
	Type string
	SHA  string
	Name string
}

// Log geeft de nieuwste commits.
func Log(ctx context.Context, gitBin, dir, rev string, limit int) ([]Commit, error) {
	return LogPage(ctx, gitBin, dir, rev, 0, limit)
}

// LogPage slaat de nieuwste skip commits over en leest daarna hooguit limit commits.
func LogPage(ctx context.Context, gitBin, dir, rev string, skip, limit int) ([]Commit, error) {
	if rev == "" {
		rev = "HEAD"
	}
	if limit < 1 {
		limit = 1
	}
	if skip < 0 {
		skip = 0
	}
	args := []string{"-C", dir, "log", "--format=%H%x1f%an%x1f%ae%x1f%ad%x1f%at%x1f%s%x1f%b%x1e", "--date=short", fmt.Sprintf("-n%d", limit)}
	if skip > 0 {
		args = append(args, fmt.Sprintf("--skip=%d", skip))
	}
	args = append(args, rev)
	out, err := run(ctx, gitBin, nil, args...)
	if err != nil {
		if strings.Contains(err.Error(), "does not have any commits") || strings.Contains(err.Error(), "bad default revision") || strings.Contains(err.Error(), "ambiguous argument") {
			return nil, nil
		}
		return nil, err
	}
	return parseLog(out), nil
}

func parseLog(out string) []Commit {
	var commits []Commit
	for _, rec := range strings.Split(out, "\x1e") {
		rec = strings.TrimSpace(rec)
		if rec == "" {
			continue
		}
		parts := strings.Split(rec, "\x1f")
		if len(parts) < 6 {
			continue
		}
		c := Commit{SHA: parts[0], Author: parts[1], Email: parts[2], Date: parts[3], Subject: parts[5]}
		c.Unix, _ = strconv.ParseInt(parts[4], 10, 64)
		if len(c.SHA) >= 10 {
			c.Short = c.SHA[:10]
		}
		if len(parts) > 6 {
			c.Body = strings.TrimSpace(parts[6])
		}
		commits = append(commits, c)
	}
	return commits
}

// Message is een commitbericht. Merge is waar bij twee of meer ouders.
type Message struct {
	Subject string
	Body    string
	Author  string
	Email   string
	Merge   bool
}

// Messages leest hooguit limit berichten, oudste eerst.
func Messages(ctx context.Context, gitBin, dir, rev string, limit int) ([]Message, error) {
	if rev == "" {
		rev = "HEAD"
	}
	if limit < 1 {
		limit = 1
	}
	if limit > 100 {
		limit = 100
	}
	out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--reverse", "--format=%an%x1f%ae%x1f%P%x1f%s%x1f%b%x1e", "--date=short", fmt.Sprintf("-n%d", limit), rev)
	if err != nil {
		if strings.Contains(err.Error(), "does not have any commits") || strings.Contains(err.Error(), "bad default revision") || strings.Contains(err.Error(), "ambiguous argument") {
			return nil, nil
		}
		return nil, err
	}
	return parseMessages(out), nil
}

func parseMessages(out string) []Message {
	var msgs []Message
	for _, rec := range strings.Split(out, "\x1e") {
		rec = strings.TrimSpace(rec)
		if rec == "" {
			continue
		}
		parts := strings.Split(rec, "\x1f")
		if len(parts) < 4 {
			continue
		}
		m := Message{Author: parts[0], Email: parts[1], Subject: parts[3]}
		m.Merge = len(strings.Fields(parts[2])) > 1
		if len(parts) > 4 {
			m.Body = strings.TrimSpace(parts[4])
		}
		msgs = append(msgs, m)
	}
	return msgs
}

// Show leest één commit.
func Show(ctx context.Context, gitBin, dir, sha string) (Commit, error) {
	list, err := Log(ctx, gitBin, dir, sha, 1)
	if err != nil {
		return Commit{}, err
	}
	if len(list) == 0 {
		return Commit{}, fmt.Errorf("commit niet gevonden")
	}
	return list[0], nil
}

// Tree leest een map. path is relatief en mag leeg zijn.
func Tree(ctx context.Context, gitBin, dir, rev, rel string) ([]Entry, error) {
	spec := rev
	if rel != "" {
		spec = rev + ":" + rel
	}
	out, err := run(ctx, gitBin, nil, "-C", dir, "ls-tree", spec)
	if err != nil {
		return nil, err
	}
	var entries []Entry
	for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
		if line == "" {
			continue
		}
		// mode type sha\tname
		tab := strings.SplitN(line, "\t", 2)
		if len(tab) != 2 {
			continue
		}
		head := strings.Fields(tab[0])
		if len(head) != 3 {
			continue
		}
		entries = append(entries, Entry{Mode: head[0], Type: head[1], SHA: head[2], Name: tab[1]})
	}
	return entries, nil
}

// Blob leest een tekstbestand, afgekapt op max bytes. binary is waar als
// het bestand een NUL bevat.
func Blob(ctx context.Context, gitBin, dir, rev, rel string, max int) (text string, binary bool, err error) {
	out, err := run(ctx, gitBin, nil, "-C", dir, "show", rev+":"+rel)
	if err != nil {
		return "", false, err
	}
	if strings.Contains(out, "\x00") {
		return "", true, nil
	}
	if len(out) > max {
		out = out[:max] + "\n… afgekapt"
	}
	return out, false, nil
}

// Branches geeft lokale branchnamen.
func Branches(ctx context.Context, gitBin, dir string) ([]string, error) {
	out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/heads")
	if err != nil {
		return nil, err
	}
	var names []string
	for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
		if line != "" {
			names = append(names, line)
		}
	}
	return names, nil
}

// SetHEAD zet de symbolische HEAD van een bare repository naar een bestaande branch.
// Het verwijdert geen refs of objecten.
func SetHEAD(ctx context.Context, gitBin, dir, branch string) error {
	if branch == "" {
		return fmt.Errorf("leeg branch")
	}
	_, err := run(ctx, gitBin, nil, "-C", dir, "symbolic-ref", "HEAD", "refs/heads/"+branch)
	return err
}

// HasBranch meldt of de named branch bestaat.
func HasBranch(ctx context.Context, gitBin, dir, branch string) bool {
	if branch == "" {
		return false
	}
	_, err := run(ctx, gitBin, nil, "-C", dir, "show-ref", "--verify", "--quiet", "refs/heads/"+branch)
	return err == nil
}

// HasCommit meldt of sha een commit in deze repository is.
func HasCommit(ctx context.Context, gitBin, dir, sha string) bool {
	out, err := run(ctx, gitBin, nil, "-C", dir, "cat-file", "-t", sha)
	return err == nil && strings.TrimSpace(out) == "commit"
}

// Refs geeft refnaam → sha.
func Refs(ctx context.Context, gitBin, dir string) (map[string]string, error) {
	out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(objectname) %(refname)")
	if err != nil {
		return nil, err
	}
	m := map[string]string{}
	for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
		if line == "" {
			continue
		}
		parts := strings.SplitN(line, " ", 2)
		if len(parts) == 2 {
			m[parts[1]] = parts[0]
		}
	}
	return m, nil
}

// Touch geeft per pad de nieuwste commit uit de recente geschiedenis.
// Mappen erven de nieuwste commit van een bestand erin.
func Touch(ctx context.Context, gitBin, dir, rev string) (map[string]Commit, error) {
	if rev == "" {
		rev = "HEAD"
	}
	out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--format=%H%x1f%an%x1f%at%x1f%s", "--name-only", "-n", "400", rev)
	if err != nil {
		if emptyHistory(err) {
			return map[string]Commit{}, nil
		}
		return nil, err
	}
	m := map[string]Commit{}
	var cur Commit
	have := false
	for _, line := range strings.Split(out, "\n") {
		if strings.Contains(line, "\x1f") {
			parts := strings.Split(line, "\x1f")
			if len(parts) < 4 {
				continue
			}
			cur = Commit{SHA: parts[0], Author: parts[1], Subject: parts[3]}
			cur.Unix, _ = strconv.ParseInt(parts[2], 10, 64)
			if len(cur.SHA) >= 10 {
				cur.Short = cur.SHA[:10]
			}
			have = true
			continue
		}
		line = strings.TrimSpace(line)
		if line == "" || !have {
			continue
		}
		notePath(m, line, cur)
	}
	return m, nil
}

func notePath(m map[string]Commit, path string, c Commit) {
	for path != "" && path != "." {
		if _, ok := m[path]; !ok {
			m[path] = c
		}
		i := strings.LastIndex(path, "/")
		if i < 0 {
			return
		}
		path = path[:i]
	}
}

func emptyHistory(err error) bool {
	msg := err.Error()
	return strings.Contains(msg, "does not have any commits") || strings.Contains(msg, "bad default revision") || strings.Contains(msg, "ambiguous argument")
}

// Stats telt commits op rev, lokale branches en tags.
func Stats(ctx context.Context, gitBin, dir, rev string) (commits, branches, tags int, err error) {
	if rev == "" {
		rev = "HEAD"
	}
	out, err := run(ctx, gitBin, nil, "-C", dir, "rev-list", "--count", rev)
	if err != nil {
		if emptyHistory(err) {
			return 0, 0, 0, nil
		}
		return 0, 0, 0, err
	}
	commits, _ = strconv.Atoi(strings.TrimSpace(out))
	names, err := Branches(ctx, gitBin, dir)
	if err != nil {
		return commits, 0, 0, err
	}
	branches = len(names)
	out, err = run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/tags")
	if err != nil {
		return commits, branches, 0, err
	}
	for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
		if line != "" {
			tags++
		}
	}
	return commits, branches, tags, nil
}

// Tags geeft tagnamen.
func Tags(ctx context.Context, gitBin, dir string) ([]string, error) {
	out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(refname:short)", "refs/tags")
	if err != nil {
		return nil, err
	}
	var names []string
	for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
		if line != "" {
			names = append(names, line)
		}
	}
	return names, nil
}

// TagInfo is één git-tag voor de webinterface.
type TagInfo struct {
	Name          string
	Annotated     bool
	Message       string
	CommitSHA     string
	CommitSubject string
	Unix          int64
}

// ListTags geeft alle tags, nieuwste eerst.
func ListTags(ctx context.Context, gitBin, dir string) ([]TagInfo, error) {
	const format = "%(refname:short)\n%(objecttype)\n%(objectname)\n%(*objectname)\n%(creatordate:unix)\n%(subject)\n%(*subject)\nBLUEGIT-END"
	out, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--sort=-creatordate", "--format="+format, "refs/tags")
	if err != nil {
		return nil, err
	}
	lines := strings.Split(out, "\n")
	if len(lines) > 0 && lines[len(lines)-1] == "" {
		lines = lines[:len(lines)-1]
	}
	var tags []TagInfo
	for i := 0; i+7 < len(lines); i += 8 {
		if lines[i+7] != "BLUEGIT-END" {
			continue
		}
		unix, _ := strconv.ParseInt(strings.TrimSpace(lines[i+4]), 10, 64)
		tag := TagInfo{Name: lines[i], Unix: unix}
		if lines[i+1] == "tag" {
			tag.Annotated = true
			tag.CommitSHA = lines[i+3]
			tag.CommitSubject = lines[i+6]
			if tag.CommitSHA == "" {
				tag.CommitSHA = lines[i+2]
			}
			if tag.CommitSubject == "" {
				tag.CommitSubject = lines[i+5]
			}
			msg, err := run(ctx, gitBin, nil, "-C", dir, "for-each-ref", "--format=%(contents)", "refs/tags/"+tag.Name)
			if err != nil {
				return nil, err
			}
			tag.Message = strings.TrimSpace(msg)
		} else {
			tag.CommitSHA = lines[i+2]
			tag.CommitSubject = lines[i+5]
		}
		if tag.Name != "" {
			tags = append(tags, tag)
		}
	}
	sort.SliceStable(tags, func(i, j int) bool {
		if tags[i].Unix != tags[j].Unix {
			return tags[i].Unix > tags[j].Unix
		}
		return tags[i].Name < tags[j].Name
	})
	return tags, nil
}

// CreateTag zet een tag op een branch of commit. Een leeg bericht blijft licht.
func CreateTag(ctx context.Context, gitBin, dir, name, rev, message, author, email string) error {
	if err := names.ValidTag(name); err != nil {
		return err
	}
	sha, err := resolveCommit(ctx, gitBin, dir, rev)
	if err != nil {
		return err
	}
	if HasTag(ctx, gitBin, dir, name) {
		return i18n.E("err.tagExists", name)
	}
	message = strings.TrimSpace(message)
	if len(message) > 5000 {
		return i18n.E("err.tagLong")
	}
	home, err := os.MkdirTemp(dir, "home-")
	if err != nil {
		return classifyGit(err)
	}
	defer os.RemoveAll(home)
	env := CommandEnv(author, email, home, home)
	if message == "" {
		_, err = run(ctx, gitBin, env, "-C", dir, "tag", name, sha)
		return err
	}
	_, err = run(ctx, gitBin, env, "-C", dir, "tag", "-a", name, sha, "-m", message)
	return err
}

// DeleteTag verwijdert een bestaande tag.
func DeleteTag(ctx context.Context, gitBin, dir, name string) error {
	if err := usableTag(name); err != nil {
		return err
	}
	if !HasTag(ctx, gitBin, dir, name) {
		return i18n.E("err.tagMissing", name)
	}
	_, err := run(ctx, gitBin, nil, "-C", dir, "tag", "-d", "--", name)
	return err
}

// HasTag meldt of refs/tags/name bestaat.
func HasTag(ctx context.Context, gitBin, dir, name string) bool {
	if err := usableTag(name); err != nil {
		return false
	}
	_, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "-q", "--verify", "--end-of-options", "refs/tags/"+name)
	return err == nil
}

// Archive schrijft een zip of tar.gz van de tag naar w.
func Archive(ctx context.Context, w io.Writer, gitBin, dir, prefix, name, format string) error {
	if err := usableTag(name); err != nil {
		return err
	}
	if !HasTag(ctx, gitBin, dir, name) {
		return i18n.E("err.tagMissing", name)
	}
	return ArchiveAt(ctx, w, gitBin, dir, prefix, name, format)
}

// ArchiveAt schrijft een zip of tar.gz van een bestaande revisie.
// rev is een tagnaam of refs/heads/….
func ArchiveAt(ctx context.Context, w io.Writer, gitBin, dir, prefix, rev, format string) error {
	if format != "zip" && format != "tar.gz" {
		return i18n.E("err.notFound")
	}
	if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") {
		return i18n.E("err.notFound")
	}
	if gitBin == "" {
		gitBin = "git"
	}
	if prefix != "" && !strings.HasSuffix(prefix, "/") {
		prefix += "/"
	}
	cmd := exec.CommandContext(ctx, gitBin, "-C", dir, "archive", "--format="+format, "--prefix="+prefix, rev)
	cmd.Stdout = w
	var stderr bytes.Buffer
	cmd.Stderr = &stderr
	if err := cmd.Run(); err != nil {
		msg := strings.TrimSpace(stderr.String())
		if msg == "" {
			msg = err.Error()
		}
		return fmt.Errorf("%s", msg)
	}
	return nil
}

func resolveCommit(ctx context.Context, gitBin, dir, rev string) (string, error) {
	rev = strings.TrimSpace(rev)
	if rev == "" || strings.HasPrefix(rev, "-") || strings.Contains(rev, "..") || strings.ContainsAny(rev, " \t\r\n\\") {
		return "", i18n.E("err.tagRef", rev)
	}
	out, err := run(ctx, gitBin, nil, "-C", dir, "rev-parse", "--verify", "--end-of-options", rev+"^{commit}")
	if err != nil {
		return "", i18n.E("err.tagRef", rev)
	}
	return strings.TrimSpace(out), nil
}

func usableTag(name string) error {
	if name == "" || len(name) > 200 || strings.HasPrefix(name, "-") || strings.HasPrefix(name, "/") || strings.HasSuffix(name, "/") || strings.Contains(name, "..") || strings.Contains(name, "//") || strings.Contains(name, "@{") || strings.ContainsAny(name, " \t\r\n\\~^:?*[") {
		return i18n.E("err.tag", name)
	}
	return nil
}

// TreeAll leest de hele boom. Name is het pad vanaf de root.
func TreeAll(ctx context.Context, gitBin, dir, rev string) ([]Entry, error) {
	if rev == "" {
		rev = "HEAD"
	}
	out, err := run(ctx, gitBin, nil, "-C", dir, "ls-tree", "-r", "-t", rev)
	if err != nil {
		if emptyHistory(err) {
			return nil, nil
		}
		return nil, err
	}
	return parseTree(out), nil
}

func parseTree(out string) []Entry {
	var entries []Entry
	for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
		if line == "" {
			continue
		}
		tab := strings.SplitN(line, "\t", 2)
		if len(tab) != 2 {
			continue
		}
		head := strings.Fields(tab[0])
		if len(head) != 3 {
			continue
		}
		entries = append(entries, Entry{Mode: head[0], Type: head[1], SHA: head[2], Name: tab[1]})
	}
	return entries
}

// LastCommit is de nieuwste commit die path heeft geraakt. Leeg pad is de tip.
func LastCommit(ctx context.Context, gitBin, dir, rev, path string) (Commit, error) {
	if rev == "" {
		rev = "HEAD"
	}
	args := []string{"-C", dir, "log", "-1", "--format=%H%x1f%an%x1f%ae%x1f%at%x1f%s", rev}
	if path != "" {
		args = append(args, "--", path)
	}
	out, err := run(ctx, gitBin, nil, args...)
	if err != nil {
		if emptyHistory(err) {
			return Commit{}, nil
		}
		return Commit{}, err
	}
	line := strings.TrimSpace(out)
	parts := strings.Split(line, "\x1f")
	if len(parts) < 5 {
		return Commit{}, nil
	}
	c := Commit{SHA: parts[0], Author: parts[1], Email: parts[2], Subject: parts[4]}
	c.Unix, _ = strconv.ParseInt(parts[3], 10, 64)
	if len(c.SHA) >= 10 {
		c.Short = c.SHA[:10]
	}
	return c, nil
}

// BlobSize is de grootte in bytes.
func BlobSize(ctx context.Context, gitBin, dir, rev, rel string) (int64, error) {
	out, err := run(ctx, gitBin, nil, "-C", dir, "cat-file", "-s", rev+":"+rel)
	if err != nil {
		return 0, err
	}
	return strconv.ParseInt(strings.TrimSpace(out), 10, 64)
}

// PushedCommit is een commit die met een push nieuw bereikbaar werd.
type PushedCommit struct {
	SHA   string
	Email string
	Name  string
	Unix  int64
}

// CommitsSince geeft commits die newSHA bereikt en old niet.
// Een lege of nul-old is de hele geschiedenis van newSHA.
func CommitsSince(ctx context.Context, gitBin, dir, old, newSHA string) ([]PushedCommit, error) {
	if newSHA == "" || allZero(newSHA) {
		return nil, nil
	}
	args := []string{"-C", dir, "log", "--format=%H%x1f%ae%x1f%an%x1f%at", newSHA}
	if old != "" && !allZero(old) {
		args = append(args, "--not", old)
	}
	out, err := run(ctx, gitBin, nil, args...)
	if err != nil {
		if emptyHistory(err) {
			return nil, nil
		}
		return nil, err
	}
	var commits []PushedCommit
	for _, line := range strings.Split(out, "\n") {
		line = strings.TrimSpace(line)
		if line == "" || !strings.Contains(line, "\x1f") {
			continue
		}
		parts := strings.Split(line, "\x1f")
		if len(parts) < 4 {
			continue
		}
		c := PushedCommit{SHA: parts[0], Email: parts[1], Name: parts[2]}
		c.Unix, _ = strconv.ParseInt(parts[3], 10, 64)
		commits = append(commits, c)
	}
	return commits, nil
}

func allZero(sha string) bool {
	return strings.Trim(sha, "0") == ""
}

// RangeLog geeft de commits die newSHA bereikt en old niet, nieuwste eerst.
// Een lege of nul-old is de geschiedenis van newSHA.
func RangeLog(ctx context.Context, gitBin, dir, old, newSHA string) ([]Commit, error) {
	if newSHA == "" || allZero(newSHA) {
		return nil, nil
	}
	args := []string{"-C", dir, "log", "--format=%H%x1f%an%x1f%ae%x1f%ad%x1f%at%x1f%s%x1f%b%x1e", "--date=short", newSHA}
	if old != "" && !allZero(old) {
		args = append(args, "--not", old)
	}
	out, err := run(ctx, gitBin, nil, args...)
	if err != nil {
		if emptyHistory(err) {
			return nil, nil
		}
		return nil, err
	}
	return parseLog(out), nil
}

// BranchOfRef haalt de branch uit refs/heads/… .
func BranchOfRef(ref string) (string, bool) {
	const p = "refs/heads/"
	if strings.HasPrefix(ref, p) && len(ref) > len(p) {
		return ref[len(p):], true
	}
	return "", false
}

// Merge voegt source samen in target en pusht het resultaat.
// squash maakt één gewone commit met message in plaats van een merge-commit.
// De push gaat door de hook, dus role en patterns moeten kloppen.
func Merge(ctx context.Context, gitBin, bare, work, source, target, author, email, message string, squash bool, role access.Role, patterns []string) error {
	repo, env, err := prepareWork(work, author, email)
	if err != nil {
		return classifyGit(err)
	}
	if _, err := run(ctx, gitBin, env, "clone", bare, repo); err != nil {
		return classifyGit(err)
	}
	if _, err := run(ctx, gitBin, env, "-C", repo, "checkout", target); err != nil {
		return classifyGit(fmt.Errorf("doelbranch %s: %w", target, err))
	}
	// De kloon heeft de bron alleen als origin/<branch>, niet als lokale branch.
	if squash {
		if _, err := run(ctx, gitBin, env, "-C", repo, "merge", "--squash", "origin/"+source); err != nil {
			return i18n.E("err.mergeConflict")
		}
		if _, err := run(ctx, gitBin, env, "-C", repo, "commit", "-m", message); err != nil {
			return classifyGit(err)
		}
	} else if _, err := run(ctx, gitBin, env, "-C", repo, "merge", "--no-ff", "--no-edit", "-m", message, "origin/"+source); err != nil {
		return i18n.E("err.mergeConflict")
	}
	pushEnv := append(append([]string{}, env...), PushEnv(role, patterns, nil)...)
	if _, err := run(ctx, gitBin, pushEnv, "-C", repo, "push", "origin", target); err != nil {
		return classifyGit(err)
	}
	return nil
}

// Tag zet een annotated tag op sha.
// Tag maakt een geannoteerde tag. Een annotated tag heeft een tagger
// nodig; de serviceaccount heeft geen git-identiteit, dus die komt mee.
// Leeg valt terug op BlueGit <noreply@git.timfalken.com>.
func Tag(ctx context.Context, gitBin, dir, tag, sha, message, author, email string) error {
	if strings.TrimSpace(author) == "" || strings.TrimSpace(email) == "" {
		author, email = FallbackName, FallbackEmail
	}
	home, err := os.MkdirTemp("", "bluegit-tag-")
	if err != nil {
		return err
	}
	defer os.RemoveAll(home)
	_, err = run(ctx, gitBin, CommandEnv(author, email, home, home), "-C", dir, "tag", "-a", tag, sha, "-m", message)
	return err
}

// FallbackName en FallbackEmail zijn de identiteit van BlueGit zelf.
const (
	FallbackName  = "BlueGit"
	FallbackEmail = "noreply@git.timfalken.com"
)

// DiffStat is een korte vergelijking tussen twee branches.
func DiffStat(ctx context.Context, gitBin, dir, target, source string) (string, error) {
	out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--oneline", target+".."+source)
	if err != nil {
		return "", err
	}
	return strings.TrimSpace(out), nil
}

func run(ctx context.Context, bin string, env []string, args ...string) (string, error) {
	if bin == "" {
		bin = "git"
	}
	cmd := exec.CommandContext(ctx, bin, args...)
	if env != nil {
		cmd.Env = env
	}
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	if err := cmd.Run(); err != nil {
		msg := strings.TrimSpace(stderr.String())
		if msg == "" {
			msg = err.Error()
		}
		return "", fmt.Errorf("%s", msg)
	}
	return stdout.String(), nil
}

// Fork maakt dir als bare kloon van src met alle branches en tags. Objecten
// worden lokaal gehardlinkt (geen extra schijfruimte voor bestaande objecten).
// Daarna dezelfde instellingen en hook als Init; de remote naar src gaat weg.
func Fork(gitBin, src, dir, hookBinary string) error {
	if err := os.MkdirAll(filepath.Dir(dir), 0o755); err != nil {
		return err
	}
	if _, err := run(context.Background(), gitBin, nil, "clone", "--bare", "--quiet", src, dir); err != nil {
		return err
	}
	_, _ = run(context.Background(), gitBin, nil, "-C", dir, "remote", "remove", "origin")
	for _, kv := range [][2]string{
		{"http.receivepack", "true"},
		{"http.uploadpack", "true"},
		{"receive.denyCurrentBranch", "ignore"},
	} {
		if _, err := run(context.Background(), gitBin, nil, "-C", dir, "config", kv[0], kv[1]); err != nil {
			return err
		}
	}
	return InstallHook(dir, hookBinary)
}

// ErrNotFastForward: de branch in de fork is afgeweken van upstream.
var ErrNotFastForward = errors.New("not fast-forward")

// PushBranch zet branch uit src door naar dst, alleen fast-forward (geen
// force). De pre-receive-hook van dst controleert rechten en bescherming.
func PushBranch(ctx context.Context, gitBin, src, dst, branch string, env []string) error {
	out, err := run(ctx, gitBin, env, "-C", src, "push", dst, "refs/heads/"+branch+":refs/heads/"+branch)
	if err != nil {
		msg := out + " " + err.Error()
		if strings.Contains(msg, "non-fast-forward") || strings.Contains(msg, "fetch first") {
			return ErrNotFastForward
		}
		return classifyGit(err)
	}
	return nil
}

// FetchBranch haalt branch uit src op in dst als refs/heads/as (geforceerd:
// de spiegel volgt de bron). Een fetch draait geen hooks in dst.
func FetchBranch(ctx context.Context, gitBin, src, dst, branch, as string) error {
	_, err := run(ctx, gitBin, nil, "-C", dst, "fetch", "--quiet", "--no-tags", src, "+refs/heads/"+branch+":refs/heads/"+as)
	return err
}
