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

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

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

// 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 []string) []string {
	return []string{
		"BLUEGIT_ROLE=" + string(role),
		"BLUEGIT_PROTECTED=" + strings.Join(patterns, "\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 []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, ups)
}

// Commit is één commit voor de webinterface.
type Commit struct {
	SHA     string
	Short   string
	Author  string
	Date    string
	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) {
	if rev == "" {
		rev = "HEAD"
	}
	out, err := run(ctx, gitBin, nil, "-C", dir, "log", "--format=%H%x1f%an%x1f%ad%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 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) < 4 {
			continue
		}
		c := Commit{SHA: parts[0], Author: parts[1], Date: parts[2], Subject: parts[3]}
		if len(c.SHA) >= 10 {
			c.Short = c.SHA[:10]
		}
		if len(parts) > 4 {
			c.Body = strings.TrimSpace(parts[4])
		}
		commits = append(commits, c)
	}
	return commits
}

// 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
}

// 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
}

// 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.
// 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, role access.Role, patterns []string) error {
	if err := os.RemoveAll(work); err != nil {
		return err
	}
	if err := os.MkdirAll(filepath.Dir(work), 0o755); err != nil {
		return err
	}
	if _, err := run(ctx, gitBin, nil, "clone", bare, work); err != nil {
		return err
	}
	env := append(os.Environ(),
		"GIT_AUTHOR_NAME="+author,
		"GIT_AUTHOR_EMAIL="+email,
		"GIT_COMMITTER_NAME="+author,
		"GIT_COMMITTER_EMAIL="+email,
	)
	if _, err := run(ctx, gitBin, env, "-C", work, "checkout", target); err != nil {
		return fmt.Errorf("doelbranch %s: %w", target, err)
	}
	if _, err := run(ctx, gitBin, env, "-C", work, "merge", "--no-ff", "--no-edit", "-m", message, source); err != nil {
		return fmt.Errorf("samenvoegen lukt niet, er is een conflict of de branch ontbreekt")
	}
	pushEnv := append(env, PushEnv(role, patterns)...)
	if _, err := run(ctx, gitBin, pushEnv, "-C", work, "push", "origin", target); err != nil {
		return err
	}
	return nil
}

// Tag zet een annotated tag op sha.
func Tag(ctx context.Context, gitBin, dir, tag, sha, message string) error {
	_, err := run(ctx, gitBin, nil, "-C", dir, "tag", "-a", tag, sha, "-m", message)
	return err
}

// 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
}
