package gitgraph

import (
	"strings"
	"testing"
)

func commits(pairs ...string) []Commit {
	// pairs: "sha:parent,parent" or "sha:" for root. Order is newest first.
	var out []Commit
	for _, p := range pairs {
		sha, rest, _ := strings.Cut(p, ":")
		var parents []string
		if rest != "" {
			parents = strings.Split(rest, ",")
		}
		out = append(out, Commit{SHA: sha, Short: sha, Subject: "msg-" + sha, Parents: parents})
	}
	return out
}

func TestLayoutLinear(t *testing.T) {
	g := Layout(commits("c:b", "b:a", "a:"), nil, "master")
	if g.Lanes != 1 {
		t.Fatalf("lanes=%d, wil 1", g.Lanes)
	}
	for i, want := range []string{"c", "b", "a"} {
		if g.Rows[i].SHA != want || g.Rows[i].Lane != 0 {
			t.Fatalf("rij %d: %+v", i, g.Rows[i])
		}
	}
}

func TestLayoutFork(t *testing.T) {
	// feature (d) en master (c) splitsen vanaf b.
	refs := []Ref{
		{Name: "master", SHA: "c", Kind: "branch"},
		{Name: "feature", SHA: "d", Kind: "branch"},
	}
	g := Layout(commits("d:b", "c:b", "b:a", "a:"), refs, "master")
	if g.Lanes < 2 {
		t.Fatalf("verwacht minstens 2 lanes, kreeg %d", g.Lanes)
	}
	laneOf := map[string]int{}
	for _, r := range g.Rows {
		laneOf[r.SHA] = r.Lane
	}
	if laneOf["d"] == laneOf["c"] {
		t.Fatalf("forks moeten andere lanes hebben: %v", laneOf)
	}
	if laneOf["b"] != laneOf["a"] {
		t.Fatalf("stam blijft op één lane: %v", laneOf)
	}
	// master is blauw
	for _, r := range g.Rows {
		if r.SHA == "c" && r.Color != "var(--blue)" {
			t.Fatalf("master-tip kleur %s", r.Color)
		}
	}
	// merge/fork-lijn van d of c naar b
	if !hasEdgeTo(g, "b") {
		t.Fatalf("geen lijn naar b: %+v", g.Edges)
	}
}

func TestLayoutMerge(t *testing.T) {
	// m merget feature (f) in master (c).
	refs := []Ref{
		{Name: "master", SHA: "m", Kind: "branch"},
		{Name: "feature", SHA: "f", Kind: "branch"},
	}
	g := Layout(commits("m:c,f", "f:b", "c:b", "b:a", "a:"), refs, "master")
	if g.Lanes < 2 {
		t.Fatalf("merge heeft een tweede lane nodig, kreeg %d", g.Lanes)
	}
	laneOf := map[string]int{}
	colorOf := map[string]string{}
	for _, r := range g.Rows {
		laneOf[r.SHA] = r.Lane
		colorOf[r.SHA] = r.Color
	}
	if laneOf["f"] == laneOf["c"] {
		t.Fatalf("feature en master voor de merge op dezelfde lane: %v", laneOf)
	}
	if colorOf["m"] != "var(--blue)" {
		t.Fatalf("merge-commit op master moet blauw zijn, kreeg %s", colorOf["m"])
	}
	if !hasEdgeBetween(g, "m", "f") && !hasEdgeBetween(g, "m", "c") {
		t.Fatalf("verwacht lijnen van de merge naar beide ouders: %+v", g.Edges)
	}
}

func TestLayoutMergeAndForkTogether(t *testing.T) {
	// master: a-b-c-m, feature: b-d-e, m merget e.
	refs := []Ref{
		{Name: "master", SHA: "m", Kind: "branch"},
		{Name: "feature", SHA: "e", Kind: "branch"},
		{Name: "v1", SHA: "c", Kind: "tag"},
	}
	g := Layout(commits("m:c,e", "e:d", "d:b", "c:b", "b:a", "a:"), refs, "master")
	if len(g.Rows) != 6 {
		t.Fatalf("rijen=%d", len(g.Rows))
	}
	var hasTag, hasMaster, hasFeature bool
	for _, r := range g.Rows {
		for _, lb := range r.Labels {
			switch {
			case lb.Kind == "tag" && lb.Name == "v1":
				hasTag = true
			case lb.Default && lb.Name == "master":
				hasMaster = true
			case lb.Name == "feature":
				hasFeature = true
			}
		}
	}
	if !hasTag || !hasMaster || !hasFeature {
		t.Fatalf("labels ontbreken: tag=%v master=%v feature=%v", hasTag, hasMaster, hasFeature)
	}
}

func TestColorDeterministicAndMainIsBlue(t *testing.T) {
	if Color("master", "master") != "var(--blue)" {
		t.Fatal("hoofdbranch moet --blue zijn")
	}
	if Color("main", "main") != "var(--blue)" {
		t.Fatal("hoofdbranch main moet --blue zijn")
	}
	if Color("feature", "master") == "var(--blue)" {
		t.Fatal("andere branch mag niet de hoofd-blauw zijn")
	}
	if Color("feature", "master") != Color("feature", "master") {
		t.Fatal("kleur moet deterministisch zijn")
	}
	if Color("feature", "master") != Color("FEATURE", "master") {
		t.Fatal("kleur is case-insensitive")
	}
	if Color("feature", "master") == Color("other", "master") {
		t.Fatal("verschillende namen moeten meestal een andere kleur krijgen")
	}
	seen := map[string]bool{}
	for _, n := range []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"} {
		seen[Color(n, "master")] = true
	}
	if len(seen) < 2 {
		t.Fatalf("palet wordt niet gebruikt: %v", seen)
	}
	for c := range seen {
		if !strings.HasPrefix(c, "var(--graph-") {
			t.Fatalf("onverwachte kleur %s", c)
		}
	}
}

func TestKeyChangesWithTips(t *testing.T) {
	a := Key(1, map[string]string{"refs/heads/master": "aaa"}, "master", 40)
	b := Key(1, map[string]string{"refs/heads/master": "bbb"}, "master", 40)
	c := Key(1, map[string]string{"refs/heads/master": "aaa"}, "master", 40)
	if a == b {
		t.Fatal("andere tip moet andere sleutel geven")
	}
	if a != c {
		t.Fatal("zelfde stand moet dezelfde sleutel geven")
	}
	if Key(2, map[string]string{"refs/heads/master": "aaa"}, "master", 40) == a {
		t.Fatal("andere repo moet andere sleutel geven")
	}
}

func hasEdgeTo(g *Graph, sha string) bool {
	idx := -1
	for i, r := range g.Rows {
		if r.SHA == sha {
			idx = i
			break
		}
	}
	if idx < 0 {
		return false
	}
	for _, e := range g.Edges {
		if e.ToRow == idx {
			return true
		}
	}
	return false
}

func hasEdgeBetween(g *Graph, from, to string) bool {
	fi, ti := -1, -1
	for i, r := range g.Rows {
		if r.SHA == from {
			fi = i
		}
		if r.SHA == to {
			ti = i
		}
	}
	if fi < 0 || ti < 0 {
		return false
	}
	for _, e := range g.Edges {
		if e.FromRow == fi && e.ToRow == ti {
			return true
		}
	}
	// via een tussenliggende lane (merge-boog plus verticaal)
	for _, e := range g.Edges {
		if e.FromRow == fi && e.ToLane == g.Rows[ti].Lane {
			return true
		}
	}
	return false
}

func TestMainlineStaysBlueOnLaneZero(t *testing.T) {
	// Nieuwere zijtak docs bovenop master-merge mag lane 0 en blauw niet inpikken.
	refs := []Ref{
		{Name: "master", SHA: "m", Kind: "branch"},
		{Name: "docs", SHA: "d", Kind: "branch"},
	}
	g := Layout(commits("d:m", "m:c,f", "f:b", "c:b", "b:"), refs, "master")
	for _, r := range g.Rows {
		switch r.SHA {
		case "m", "c", "b":
			if r.Color != "var(--blue)" {
				t.Fatalf("%s moet blauw zijn, kreeg %s (class %s)", r.SHA, r.Color, r.Class)
			}
			if r.Lane != 0 {
				t.Fatalf("%s moet op lane 0, kreeg %d", r.SHA, r.Lane)
			}
			if r.Class != "is-main" {
				t.Fatalf("%s class=%s", r.SHA, r.Class)
			}
		case "d":
			if r.Lane == 0 {
				t.Fatalf("zijtak docs mag lane 0 niet stelen")
			}
			if r.Color == "var(--blue)" {
				t.Fatalf("zijtak mag niet de hoofd-blauw zijn")
			}
		}
	}
}

func TestOneCommitPerRow(t *testing.T) {
	refs := []Ref{
		{Name: "master", SHA: "m", Kind: "branch"},
		{Name: "feature", SHA: "e", Kind: "branch"},
		{Name: "docs", SHA: "d", Kind: "branch"},
	}
	g := Layout(commits("d:m", "m:c,e", "e:b", "c:b", "b:a", "a:"), refs, "master")
	if len(g.Rows) != 6 {
		t.Fatalf("rijen=%d, wil één per commit", len(g.Rows))
	}
	seen := map[string]int{}
	for i, r := range g.Rows {
		if r.SHA == "" {
			t.Fatalf("lege commit op rij %d", i)
		}
		if j, ok := seen[r.SHA]; ok {
			t.Fatalf("commit %s staat op rij %d en %d", r.SHA, j, i)
		}
		seen[r.SHA] = i
	}
}

func TestTextXIsRightOfLanes(t *testing.T) {
	refs := []Ref{
		{Name: "master", SHA: "m", Kind: "branch"},
		{Name: "feature", SHA: "e", Kind: "branch"},
		{Name: "docs", SHA: "d", Kind: "branch"},
	}
	g := Layout(commits("d:m", "m:c,e", "e:b", "c:b", "b:a", "a:"), refs, "master")
	if g.Lanes < 2 {
		t.Fatalf("verwacht meerdere lanes, kreeg %d", g.Lanes)
	}
	maxLaneRight := 0.0
	for i := 0; i < g.Lanes; i++ {
		right := laneX(i) + float64(LaneW)/2
		if right > maxLaneRight {
			maxLaneRight = right
		}
	}
	if float64(g.TextX) < maxLaneRight {
		t.Fatalf("TextX=%d ligt niet rechts van de laatste lane (%.1f), lanes=%d", g.TextX, maxLaneRight, g.Lanes)
	}
	if g.PanelWidth < RefW+g.TextX {
		t.Fatalf("PanelWidth=%d is te smal voor refs+tekst (TextX=%d)", g.PanelWidth, g.TextX)
	}
}

func TestLaneAssignmentStable(t *testing.T) {
	refs := []Ref{
		{Name: "master", SHA: "m", Kind: "branch"},
		{Name: "feature", SHA: "f", Kind: "branch"},
	}
	g := Layout(commits("m:c,f", "f:b", "c:b", "b:"), refs, "master")
	laneOf := map[string]int{}
	for _, r := range g.Rows {
		laneOf[r.SHA] = r.Lane
	}
	if laneOf["m"] != 0 || laneOf["c"] != 0 || laneOf["b"] != 0 {
		t.Fatalf("master moet lane 0 blijven: %v", laneOf)
	}
	if laneOf["f"] == 0 {
		t.Fatalf("feature mag lane 0 niet gebruiken: %v", laneOf)
	}
	if g.Rows[0].Branch != "master" {
		t.Fatalf("merge-commit branch=%q", g.Rows[0].Branch)
	}
	for _, r := range g.Rows {
		if r.SHA == "f" && r.Branch != "feature" {
			t.Fatalf("feature-commit branch=%q", r.Branch)
		}
	}
}

func TestNodeLeftMatchesLane(t *testing.T) {
	refs := []Ref{
		{Name: "master", SHA: "m", Kind: "branch"},
		{Name: "feature", SHA: "f", Kind: "branch"},
	}
	g := Layout(commits("m:c,f", "f:b", "c:b", "b:"), refs, "master")
	if g.Lanes < 2 {
		t.Fatalf("verwacht meerdere lanes, kreeg %d", g.Lanes)
	}
	seenOffMain := false
	for _, r := range g.Rows {
		if r.NodeX != laneX(r.Lane) {
			t.Fatalf("commit %s NodeX=%.1f, wil laneX(%d)=%.1f", r.SHA, r.NodeX, r.Lane, laneX(r.Lane))
		}
		wantLeft := RefW + int(r.NodeX-DotR)
		if r.NodeLeft != wantLeft {
			t.Fatalf("commit %s NodeLeft=%d, wil %d (lane %d)", r.SHA, r.NodeLeft, wantLeft, r.Lane)
		}
		if r.Lane != 0 {
			seenOffMain = true
			mainLeft := RefW + int(laneX(0)-DotR)
			if r.NodeLeft <= mainLeft {
				t.Fatalf("zijtak %s staat niet rechts van de hoofdlane: left=%d main=%d", r.SHA, r.NodeLeft, mainLeft)
			}
		}
	}
	if !seenOffMain {
		t.Fatal("verwacht minstens één commit naast de hoofdlane")
	}
}

func TestTextXClearsAllGeometry(t *testing.T) {
	refs := []Ref{
		{Name: "master", SHA: "m", Kind: "branch"},
		{Name: "feature", SHA: "e", Kind: "branch"},
		{Name: "docs", SHA: "d", Kind: "branch"},
	}
	g := Layout(commits("d:m", "m:c,e", "e:b", "c:b", "b:a", "a:"), refs, "master")
	limit := float64(g.TextX - TextPad)
	for _, r := range g.Rows {
		if r.NodeX+DotR > limit {
			t.Fatalf("knoop %s reikt tot %.1f, TextX-pad=%.1f", r.SHA, r.NodeX+DotR, limit)
		}
	}
	for _, e := range g.Edges {
		for _, ln := range []int{e.FromLane, e.ToLane} {
			if laneX(ln)+1 > limit {
				t.Fatalf("lijn op lane %d reikt tot %.1f, TextX-pad=%.1f", ln, laneX(ln)+1, limit)
			}
		}
	}
	svg := g.SVG()
	for _, x := range svgPathXs(svg) {
		if x > limit {
			t.Fatalf("svg-pad heeft x=%.1f rechts van TextX-pad=%.1f: %s", x, limit, svg)
		}
	}
}

func TestLeafLabel(t *testing.T) {
	cases := map[string]string{
		"feature/commit-graph-v5":            "commit-graph-v5",
		"refs/heads/feature/commit-graph-v5": "commit-graph-v5",
		"a/b/c":                              "c",
		"master":                             "master",
		"refs/tags/v1.2":                     "v1.2",
		"feature/":                           "feature/",
		"":                                   "",
	}
	for in, want := range cases {
		if got := LeafLabel(in); got != want {
			t.Errorf("LeafLabel(%q)=%q, wil %q", in, got, want)
		}
	}
}

func TestCommitTipIncludesSubjectSHAAndAuthor(t *testing.T) {
	got := CommitTip(Row{Commit: Commit{Subject: "merge feature", Short: "e5d0eb4b", Author: "tim"}})
	if got != "merge feature · e5d0eb4b · tim" {
		t.Fatalf("tip=%q", got)
	}
	if CommitTip(Row{Commit: Commit{Subject: "only"}}) != "only" {
		t.Fatalf("korte tip is verkeerd")
	}
}

func TestLayoutSetsShortLabelAndTip(t *testing.T) {
	refs := []Ref{
		{Name: "master", SHA: "m", Kind: "branch"},
		{Name: "feature/commit-graph-v5", SHA: "f", Kind: "branch"},
	}
	g := Layout([]Commit{
		{SHA: "f", Short: "fffffff", Subject: "work", Author: "tim", Parents: []string{"b"}},
		{SHA: "m", Short: "mmmmmmm", Subject: "merge", Author: "tim", Parents: []string{"b"}},
		{SHA: "b", Short: "bbbbbbb", Subject: "base", Author: "tim"},
	}, refs, "master")
	var found bool
	for _, r := range g.Rows {
		if r.Tip == "" {
			t.Fatalf("commit %s mist tip", r.SHA)
		}
		for _, lb := range r.Labels {
			if lb.Ref == "feature/commit-graph-v5" || lb.Name == "feature/commit-graph-v5" || lb.Short == "commit-graph-v5" {
				found = true
				if lb.Short != "commit-graph-v5" {
					t.Fatalf("Short=%q, wil commit-graph-v5 (Name=%q Ref=%q)", lb.Short, lb.Name, lb.Ref)
				}
			}
		}
	}
	if !found {
		t.Fatal("feature/commit-graph-v5 label ontbreekt of Short is leeg")
	}
}
