package gitread

import (

"context"

"strconv"

"strings"

"github.com/barerepo/server/internal/gitx"

)

// Comparison takes free text both sides, because a dropdown cannot say refs/proposals/47.

type Comparison struct {

A, B string

Commits int

Files []FileDiff

Add int

Del int

Conflict bool

// Missing names the side that did not resolve, so the page says which one was wrong.

Missing string

}

// Compare uses three dots, from the merge base, which is what a person means by a comparison.

func Compare(ctx context.Context, dir, a, b string) (*Comparison, error) {

c := &Comparison{A: a, B: b}

for _, side := range []struct{ name, rev string }{{"a", a}, {"b", b}} {

if !gitx.ValidRev(side.rev) {

c.Missing = side.rev

return c, nil

}

if _, err := gitx.Run(ctx, dir, "rev-parse", "--verify", "--quiet", side.rev+"^{commit}"); err != nil {

c.Missing = side.rev

return c, nil

}

}

if out, err := gitx.Run(ctx, dir, "rev-list", "--count", a+".."+b); err == nil {

c.Commits, _ = strconv.Atoi(strings.TrimSpace(out))

}

patch, err := gitx.Run(ctx, dir, "diff", "--unified=3", "--no-color", "--find-renames", a+"..."+b, "--")

if err != nil {

return nil, err

}

c.Files = parsePatch(patch)

for _, f := range c.Files {

c.Add += f.Add

c.Del += f.Del

}

// Answered without merging or a working tree, because rule 1 says the server only reports.

if _, err := gitx.Run(ctx, dir, "merge-tree", "--write-tree", "--name-only", a, b); err != nil {

c.Conflict = true

}

return c, nil

}

// DiffStat is the mockup's +81 -12 in one process, where a full Compare costs five.

func DiffStat(ctx context.Context, dir, a, b string) (add, del int) {

add, del, _ = diffStat(ctx, dir, a, b)

return add, del

}

// diffStat reports whether git answered, because a failed run counts +0 -0 and so does an empty one, and only one is worth keeping.

func diffStat(ctx context.Context, dir, a, b string) (add, del int, ok bool) {

if !gitx.ValidRev(a) || !gitx.ValidRev(b) {

return 0, 0, false

}

out, err := gitx.Run(ctx, dir, "diff", "--numstat", "--no-color", a+"..."+b, "--")

if err != nil {

return 0, 0, false

}

for _, line := range strings.Split(strings.TrimSpace(out), "\n") {

fields := strings.Fields(line)

if len(fields) < 3 {

continue

}

// A binary file is reported as "-", which counts as no lines either way.

if n, err := strconv.Atoi(fields[0]); err == nil {

add += n

}

if n, err := strconv.Atoi(fields[1]); err == nil {

del += n

}

}

return add, del, true

}

// DiffStatBetween is DiffStat keyed by two object hashes, which cannot change, so it never invalidates.

func DiffStatBetween(ctx context.Context, dir, aSHA, bSHA string) (add, del int) {

if aSHA == "" || bSHA == "" {

return 0, 0

}

if aSHA == bSHA {

return 0, 0

}

key := aSHA + "-" + bSHA

if body, ok := Cache.Get("diffstat", key); ok {

if a, d, ok := parseStat(string(body)); ok {

return a, d

}

}

add, del, ok := diffStat(ctx, dir, aSHA, bSHA)

if !ok {

// This key never expires, so a reader who left mid-render must not pin +0 -0 on it forever.

return 0, 0

}

Cache.Put("diffstat", key, []byte(strconv.Itoa(add)+" "+strconv.Itoa(del)))

return add, del

}

// parseStat reads back what DiffStatBetween wrote.

func parseStat(body string) (add, del int, ok bool) {

a, d, found := strings.Cut(strings.TrimSpace(body), " ")

if !found {

return 0, 0, false

}

add, err := strconv.Atoi(a)

if err != nil {

return 0, 0, false

}

del, err = strconv.Atoi(d)

if err != nil {

return 0, 0, false

}

return add, del, true

}