//go:build integration

package buildstep

import (
	"context"
	sdkstep "git.novox.be/novox/mesh-delivery/sdk/buildstep"
	"reflect"
	"strings"
	"testing"

	"git.novox.be/novox/mesh-sdk/go/forgekey"
)

// On a real repository shaped like mesh-sdk (novox/hq ADR 0499 clauses 2 and 6), a commit touching only the Go package
// leaves the TypeScript package's named objects equal, and a commit touching its source changes them; the answer is raw
// (Tree is always the directory's git tree, the indexer computes the named one: ADR 0593 §2).
func TestAGoOnlyCommitLeavesTheNamedObjectsEqualOnRealGit(t *testing.T) {
	repo := t.TempDir()
	realGit(t, repo, "init", "-q", "-b", "main")
	writeFile(t, repo, "module.json", `{"module":"mesh-sdk","version":"1","build":{"artifacts":[`+
		`{"name":"lib","kind":"package","language":"typescript","paths":["src","test","package.json","package-lock.json","tsconfig.json"]}]}}`)
	writeFile(t, repo, "src/index.ts", "export const a = 1\n")
	writeFile(t, repo, "test/a.test.ts", "// a\n")
	writeFile(t, repo, "package.json", "{}\n")
	writeFile(t, repo, "package-lock.json", "{}\n")
	writeFile(t, repo, "tsconfig.json", "{}\n")
	writeFile(t, repo, "go/delivery/x.go", "package delivery\n")
	writeFile(t, repo, "other/module.json", `{"module":"other","version":"1"}`)
	writeFile(t, repo, "other/a.txt", "a\n")
	commit := func(msg string) string {
		realGit(t, repo, "add", "-A")
		realGit(t, repo, "commit", "-q", "-m", msg)
		return realGit(t, repo, "rev-parse", "HEAD")
	}
	trees := func(c string) map[string]sdkstep.ModuleTree {
		got, err := ModuleTrees(context.Background(), forgekey.ExecRunner, nil, repo, c)
		if err != nil {
			t.Fatal(err)
		}
		return got
	}
	first := trees(commit("first"))
	if want := realGit(t, repo, "rev-parse", "HEAD^{tree}"); first["."].Tree != want || strings.HasPrefix(first["."].Tree, "named:") || len(first["."].Paths) != 5 {
		t.Fatalf("the root module: %+v, want its git tree %s and five named objects", first["."], want)
	}
	if want := realGit(t, repo, "rev-parse", "HEAD:other"); first["other"].Tree != want || first["other"].Paths != nil {
		t.Fatalf("a module naming no path: %+v, want its directory's tree %s", first["other"], want)
	}

	writeFile(t, repo, "go/delivery/x.go", "package delivery\n\nconst B = 2\n")
	goOnly := trees(commit("go only"))
	if !reflect.DeepEqual(goOnly["."].Paths, first["."].Paths) {
		t.Fatalf("a Go-only commit changed the TypeScript package's objects: %v, were %v", goOnly["."].Paths, first["."].Paths)
	}

	writeFile(t, repo, "src/index.ts", "export const a = 2\n")
	src := trees(commit("src"))
	if reflect.DeepEqual(src["."].Paths, first["."].Paths) {
		t.Fatal("a commit to src/ left the TypeScript package's objects equal")
	}
	if src["."].Paths["src"] != realGit(t, repo, "rev-parse", "HEAD:src") {
		t.Fatalf("the object of src is %s, git says %s", src["."].Paths["src"], realGit(t, repo, "rev-parse", "HEAD:src"))
	}

	// A manifest naming a path and a path inside it (mesh-contracts' "go" and "go/seats/meshvault"; issue 1966): each
	// gets its own object, not git ls-tree's listing of the outer one's children.
	writeFile(t, repo, "nested/module.json", `{"module":"nested","version":"1","build":{"artifacts":[`+
		`{"name":"go","kind":"package","language":"go","paths":["go"]},`+
		`{"name":"go-seat","kind":"package","language":"go","paths":["go/seats/a"]}]}}`)
	writeFile(t, repo, "nested/go/go.mod", "module x\n")
	writeFile(t, repo, "nested/go/seats/a/a.go", "package a\n")
	nested := trees(commit("nested"))["nested"]
	if nested.Paths["go"] != realGit(t, repo, "rev-parse", "HEAD:nested/go") || nested.Paths["go/seats/a"] != realGit(t, repo, "rev-parse", "HEAD:nested/go/seats/a") {
		t.Fatalf("a path and a path inside it: %v", nested.Paths)
	}
}

// D-I4 (ADR 0634 §8) on a real repository shaped like mesh-contracts: a root module naming the paths of each of its
// artifacts has the folders of the modules nested in it left out of its source, and a module in a folder is narrowed
// like a root one, its paths read from its own directory. A commit to a folder changes that folder's objects and
// none of the root's; a commit to the root's own package changes none of the folder's.
func TestARootModulesSourceLeavesOutItsNestedModuleFolders(t *testing.T) {
	repo := t.TempDir()
	realGit(t, repo, "init", "-q", "-b", "main")
	writeFile(t, repo, "module.json", `{"module":"root","version":"1","build":{"artifacts":[{"name":"go-core","kind":"package","language":"go","paths":["go/seats/core"]}]}}`)
	writeFile(t, repo, "go/seats/core/go.mod", "module example.org/c/go/seats/core\n")
	writeFile(t, repo, "domain/module.json", `{"module":"domain","version":"1","build":{"artifacts":[{"name":"go-one","kind":"package","language":"go","paths":["go/seats/one"]},{"name":"go-oneclient","kind":"package","language":"go","paths":["go/clients/oneclient"]}]}}`)
	writeFile(t, repo, "domain/seats/one/seat.json", "{}\n")
	writeFile(t, repo, "domain/go/seats/one/go.mod", "module example.org/c/domain/go/seats/one\n")
	writeFile(t, repo, "domain/go/clients/oneclient/go.mod", "module example.org/c/domain/go/clients/oneclient\n")
	commit := func(msg string) map[string]sdkstep.ModuleTree {
		realGit(t, repo, "add", "-A")
		realGit(t, repo, "commit", "-q", "-m", msg)
		got, err := ModuleTrees(context.Background(), forgekey.ExecRunner, nil, repo, realGit(t, repo, "rev-parse", "HEAD"))
		if err != nil {
			t.Fatal(err)
		}
		return got
	}
	first := commit("first")
	if got := len(first["."].Paths); got != 1 {
		t.Fatalf("the root names %v: only its own package, never a nested module's folder", first["."].Paths)
	}
	if got := first["domain"].Paths; len(got) != 2 || got["go/seats/one"] == "" || got["go/clients/oneclient"] == "" {
		t.Fatalf("the folder module's named objects %v, want its two packages read from its own directory", got)
	}
	writeFile(t, repo, "domain/go/seats/one/one.go", "package one\n")
	folder := commit("folder")
	if !reflect.DeepEqual(folder["."].Paths, first["."].Paths) || reflect.DeepEqual(folder["domain"].Paths, first["domain"].Paths) {
		t.Fatalf("a commit to the folder: root %v (was %v), folder %v (was %v)", folder["."].Paths, first["."].Paths, folder["domain"].Paths, first["domain"].Paths)
	}
	writeFile(t, repo, "go/seats/core/core.go", "package core\n")
	root := commit("root")
	if reflect.DeepEqual(root["."].Paths, folder["."].Paths) || !reflect.DeepEqual(root["domain"].Paths, folder["domain"].Paths) {
		t.Fatalf("a commit to the root's package: root %v (was %v), folder %v (was %v)", root["."].Paths, folder["."].Paths, root["domain"].Paths, folder["domain"].Paths)
	}
}