package gitrepo

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

// PatchFile is één bestand in de diff van een commit tegen zijn eerste parent.
// Een root-commit wordt vergeleken met de lege boom.
type PatchFile struct {
	Status  string
	Path    string
	OldPath string
	Added   int
	Deleted int
	Binary  bool
	Lines   []DiffLine
}

// CommitPatch leest de parents en de diff van sha.
// Een mergecommit wordt tegen de eerste parent gezet.
func CommitPatch(ctx context.Context, gitBin, dir, sha string) (parents []string, files []PatchFile, err error) {
	out, err := run(ctx, gitBin, nil, "-C", dir, "rev-list", "--parents", "-n", "1", sha)
	if err != nil {
		return nil, nil, err
	}
	fields := strings.Fields(out)
	if len(fields) == 0 {
		return nil, nil, err
	}
	if len(fields) > 1 {
		parents = append([]string(nil), fields[1:]...)
	}
	base := ""
	if len(parents) > 0 {
		base = parents[0]
	} else {
		empty, err := run(ctx, gitBin, nil, "hash-object", "-t", "tree", "--stdin")
		if err != nil {
			return nil, nil, err
		}
		base = strings.TrimSpace(empty)
	}
	raw, err := runAllow(ctx, gitBin, nil, 1, "-c", "core.quotepath=false", "-C", dir, "diff", "--no-color", "--find-renames", "--unified=3", base, sha)
	if err != nil {
		return nil, nil, err
	}
	return parents, ParsePatch(raw), nil
}

// ParsePatch leest de tekst van git diff, inclusief hernoemen en binaire bestanden.
func ParsePatch(raw string) []PatchFile {
	var files []PatchFile
	var cur *PatchFile
	var oldGuess, newGuess string
	var oldLine, newLine int
	inHunk := false
	skipBinary := false
	for _, line := range strings.Split(raw, "\n") {
		switch {
		case strings.HasPrefix(line, "diff --git "):
			files = append(files, PatchFile{Status: "modified"})
			cur = &files[len(files)-1]
			oldGuess, newGuess = splitDiffPaths(line)
			cur.Path = newGuess
			oldLine, newLine = 0, 0
			inHunk = false
			skipBinary = false
		case cur == nil || skipBinary:
			continue
		case strings.HasPrefix(line, "new file mode "):
			cur.Status = "added"
		case strings.HasPrefix(line, "deleted file mode "):
			cur.Status = "deleted"
			if oldGuess != "" {
				cur.Path = oldGuess
			}
		case strings.HasPrefix(line, "rename from ") || strings.HasPrefix(line, "copy from "):
			cur.Status = "renamed"
			cur.OldPath = metaPath(line)
		case strings.HasPrefix(line, "rename to ") || strings.HasPrefix(line, "copy to "):
			cur.Status = "renamed"
			if p := metaPath(line); p != "" {
				cur.Path = p
			}
		case strings.HasPrefix(line, "Binary files ") || strings.HasPrefix(line, "GIT binary patch"):
			cur.Binary = true
			cur.Lines = nil
			cur.Added, cur.Deleted = 0, 0
			skipBinary = true
			inHunk = false
		case strings.HasPrefix(line, "@@"):
			oldLine, newLine = hunkStart(line)
			oldLine--
			newLine--
			inHunk = true
			cur.Lines = append(cur.Lines, DiffLine{Kind: "hunk", Text: line})
		case !inHunk:
			continue
		case strings.HasPrefix(line, `\`):
			continue
		case strings.HasPrefix(line, "+"):
			newLine++
			cur.Added++
			cur.Lines = append(cur.Lines, DiffLine{Kind: "add", New: newLine, Text: line[1:]})
		case strings.HasPrefix(line, "-"):
			oldLine++
			cur.Deleted++
			cur.Lines = append(cur.Lines, DiffLine{Kind: "del", Old: oldLine, Text: line[1:]})
		case strings.HasPrefix(line, " "):
			oldLine++
			newLine++
			cur.Lines = append(cur.Lines, DiffLine{Kind: "ctx", Old: oldLine, New: newLine, Text: line[1:]})
		}
	}
	var out []PatchFile
	for _, f := range files {
		if f.Path == "" {
			continue
		}
		if f.Status != "renamed" {
			f.OldPath = ""
		}
		out = append(out, f)
	}
	return out
}

func splitDiffPaths(line string) (oldPath, newPath string) {
	rest := strings.TrimSpace(strings.TrimPrefix(line, "diff --git "))
	a, b, ok := splitQuotedPair(rest)
	if !ok {
		return "", ""
	}
	return stripAB(a), stripAB(b)
}

func splitQuotedPair(s string) (string, string, bool) {
	s = strings.TrimSpace(s)
	if s == "" {
		return "", "", false
	}
	if strings.HasPrefix(s, `"`) {
		a, rest, ok := unquotePrefix(s)
		if !ok {
			return "", "", false
		}
		rest = strings.TrimSpace(rest)
		if strings.HasPrefix(rest, `"`) {
			b, _, ok := unquotePrefix(rest)
			return a, b, ok
		}
		return a, rest, rest != ""
	}
	i := strings.Index(s, " b/")
	if i < 0 {
		return "", "", false
	}
	return s[:i], s[i+1:], true
}

func unquotePrefix(s string) (string, string, bool) {
	if len(s) < 2 || s[0] != '"' {
		return "", "", false
	}
	for i := 1; i < len(s); i++ {
		if s[i] == '\\' {
			i++
			continue
		}
		if s[i] == '"' {
			u, err := strconv.Unquote(s[:i+1])
			if err != nil {
				return "", "", false
			}
			return u, s[i+1:], true
		}
	}
	return "", "", false
}

func metaPath(line string) string {
	if i := strings.IndexByte(line, ' '); i >= 0 {
		line = line[i+1:]
	}
	// "rename from pad" heeft twee spaties in het commando.
	if i := strings.IndexByte(line, ' '); i >= 0 && !strings.HasPrefix(line, `"`) && (strings.HasPrefix(line, "from ") || strings.HasPrefix(line, "to ")) {
		line = line[i+1:]
	}
	line = strings.TrimSpace(line)
	if strings.HasPrefix(line, `"`) {
		if u, err := strconv.Unquote(line); err == nil {
			return u
		}
	}
	return line
}
