package gitrepo

import (
	"context"
	"fmt"
	"strconv"
	"strings"
)

// Change is één bestand in een diff, zonder de difftekst zelf.
// Status is added, modified, removed of renamed.
type Change struct {
	Path    string
	OldPath string
	Status  string
	Added   int
	Deleted int
	Binary  bool
}

// CommitFileChanges geeft de bestanden die sha tegen zijn eerste parent wijzigt.
// Een root-commit wordt met de lege boom vergeleken.
func CommitFileChanges(ctx context.Context, gitBin, dir, sha string) ([]Change, error) {
	base, err := diffBase(ctx, gitBin, dir, sha)
	if err != nil {
		return nil, err
	}
	return diffChanges(ctx, gitBin, dir, base, sha)
}

// CompareChanges is de three-dot diff van from...to, zonder de difftekst.
func CompareChanges(ctx context.Context, gitBin, dir, from, to string) ([]Change, error) {
	if from == "" || to == "" {
		return nil, fmt.Errorf("lege vergelijking")
	}
	return diffChanges(ctx, gitBin, dir, from+"..."+to)
}

// CommitDiff is de unified diff van sha tegen zijn eerste parent.
func CommitDiff(ctx context.Context, gitBin, dir, sha string) (string, error) {
	base, err := diffBase(ctx, gitBin, dir, sha)
	if err != nil {
		return "", err
	}
	return unifiedDiff(ctx, gitBin, dir, base, sha)
}

// CompareDiff is de unified three-dot diff van from...to.
func CompareDiff(ctx context.Context, gitBin, dir, from, to string) (string, error) {
	if from == "" || to == "" {
		return "", fmt.Errorf("lege vergelijking")
	}
	return unifiedDiff(ctx, gitBin, dir, from+"..."+to)
}

func diffBase(ctx context.Context, gitBin, dir, sha string) (string, error) {
	out, err := run(ctx, gitBin, nil, "-C", dir, "rev-list", "--parents", "-n", "1", sha)
	if err != nil {
		return "", err
	}
	fields := strings.Fields(out)
	if len(fields) == 0 {
		return "", fmt.Errorf("commit niet gevonden")
	}
	if len(fields) > 1 {
		return fields[1], nil
	}
	empty, err := run(ctx, gitBin, nil, "hash-object", "-t", "tree", "--stdin")
	if err != nil {
		return "", err
	}
	return strings.TrimSpace(empty), nil
}

func diffChanges(ctx context.Context, gitBin, dir string, revs ...string) ([]Change, error) {
	nameRaw, err := gitDiff(ctx, gitBin, dir, append([]string{"--name-status", "--find-renames", "-z"}, revs...)...)
	if err != nil {
		return nil, err
	}
	numRaw, err := gitDiff(ctx, gitBin, dir, append([]string{"--numstat", "--find-renames", "-z"}, revs...)...)
	if err != nil {
		return nil, err
	}
	files := parseNameStatus(nameRaw)
	counts, binary := parseNumstat(numRaw)
	for i := range files {
		key := files[i].Path
		if n, ok := counts[key]; ok {
			files[i].Added, files[i].Deleted = n[0], n[1]
		}
		if binary[key] {
			files[i].Binary = true
			files[i].Added, files[i].Deleted = 0, 0
		}
	}
	if files == nil {
		files = []Change{}
	}
	return files, nil
}

func unifiedDiff(ctx context.Context, gitBin, dir string, revs ...string) (string, error) {
	return gitDiff(ctx, gitBin, dir, append([]string{"--no-color", "--find-renames", "--unified=3"}, revs...)...)
}

func gitDiff(ctx context.Context, gitBin, dir string, flags ...string) (string, error) {
	args := []string{"-c", "core.quotepath=false", "-C", dir, "diff"}
	args = append(args, flags...)
	return runAllow(ctx, gitBin, nil, 1, args...)
}

func parseNameStatus(raw string) []Change {
	parts := strings.Split(raw, "\x00")
	var out []Change
	for i := 0; i < len(parts); {
		status := parts[i]
		if status == "" {
			i++
			continue
		}
		i++
		if i >= len(parts) {
			break
		}
		if strings.HasPrefix(status, "R") || strings.HasPrefix(status, "C") {
			old := parts[i]
			i++
			if i >= len(parts) {
				break
			}
			path := parts[i]
			i++
			st := "renamed"
			if strings.HasPrefix(status, "C") {
				st = "modified"
			}
			out = append(out, Change{Path: path, OldPath: old, Status: st})
			continue
		}
		out = append(out, Change{Path: parts[i], Status: changeStatus(status)})
		i++
	}
	return out
}

func changeStatus(status string) string {
	switch status {
	case "A":
		return "added"
	case "D":
		return "removed"
	default:
		return "modified"
	}
}

func parseNumstat(raw string) (map[string][2]int, map[string]bool) {
	counts := map[string][2]int{}
	binary := map[string]bool{}
	for _, rec := range strings.Split(raw, "\x00") {
		rec = strings.TrimRight(rec, "\n")
		if rec == "" {
			continue
		}
		added, deleted, path, ok := splitNumstat(rec)
		if !ok || path == "" {
			continue
		}
		path = numstatPath(path)
		if added == "-" || deleted == "-" {
			binary[path] = true
			continue
		}
		a, aErr := strconv.Atoi(added)
		d, dErr := strconv.Atoi(deleted)
		if aErr != nil || dErr != nil {
			continue
		}
		counts[path] = [2]int{a, d}
	}
	return counts, binary
}

func splitNumstat(rec string) (added, deleted, path string, ok bool) {
	tab := strings.IndexByte(rec, '\t')
	if tab < 0 {
		return "", "", "", false
	}
	tab2 := strings.IndexByte(rec[tab+1:], '\t')
	if tab2 < 0 {
		return "", "", "", false
	}
	tab2 += tab + 1
	return rec[:tab], rec[tab+1 : tab2], rec[tab2+1:], true
}

func numstatPath(path string) string {
	brace := strings.Index(path, "{")
	arrow := strings.Index(path, " => ")
	end := strings.Index(path, "}")
	if brace >= 0 && arrow > brace && end > arrow {
		return path[:brace] + path[arrow+4:end] + path[end+1:]
	}
	if arrow >= 0 {
		return path[arrow+4:]
	}
	return path
}
