package delivery

import (
	"encoding/json"
	"reflect"
	"strings"
	"testing"
	"time"
)

// The packages state, the build end's imports and the kept imports (ADR 0593 §2) round-trip, and a reader refuses what it
// could not take, naming it.
func TestPublishedPackagesAndImportsRoundTripAndRefuse(t *testing.T) {
	commit := strings.Repeat("a", 40)
	sdk := "git.novox.be/novox/mesh-sdk/go"
	good := PublishedPackages{Module: sdk, Repository: "novox/mesh-sdk", Dir: "go", Commit: commit, Requires: "sha256:01",
		Packages: []PackageDigest{{Package: sdk, Digest: "d0"}, {Package: sdk + "/announce", Digest: "d1"}, {Package: sdk + "/internal/token", Digest: "d2"}},
		At:       time.Date(2026, 11, 2, 18, 0, 0, 0, time.UTC)}
	raw, err := EncodePublishedPackages(good)
	if err != nil {
		t.Fatal(err)
	}
	back, err := DecodePublishedPackages(raw)
	good.V = Version
	if err != nil || !reflect.DeepEqual(back, good) {
		t.Fatalf("round trip: %v, %+v", err, back)
	}
	if d, ok := back.DigestOf(sdk + "/announce"); !ok || d != "d1" {
		t.Fatalf("DigestOf announce = %q, %v", d, ok)
	}
	if _, ok := back.DigestOf(sdk + "/buildstep"); ok {
		t.Fatal("DigestOf finds a package the value does not hold")
	}
	if key, err := PackagesKey(sdk); err != nil || key != "git=2enovox=2ebe/novox/mesh-sdk/go" {
		t.Fatalf("PackagesKey = %q, %v", key, err)
	}
	if _, err := PackagesKey("github.com/x/y"); err == nil {
		t.Fatal("PackagesKey takes a path that is no mesh Go module's")
	}
	for name, mutate := range map[string]func(p *PublishedPackages){
		"no mesh module":   func(p *PublishedPackages) { p.Module = "github.com/x/y" },
		"other repository": func(p *PublishedPackages) { p.Repository = "novox/mesh-host" },
		"short commit":     func(p *PublishedPackages) { p.Commit = "abc" },
		"no requires":      func(p *PublishedPackages) { p.Requires = "" },
		"package elsewhere": func(p *PublishedPackages) {
			p.Packages = []PackageDigest{{Package: "git.novox.be/novox/mesh-host/x", Digest: "d"}}
		},
		"unsorted":  func(p *PublishedPackages) { p.Packages = []PackageDigest{p.Packages[1], p.Packages[0]} },
		"no digest": func(p *PublishedPackages) { p.Packages = []PackageDigest{{Package: sdk}} },
	} {
		p := good
		p.Packages = slicesClone(good.Packages)
		mutate(&p)
		if _, err := EncodePublishedPackages(p); err == nil {
			t.Errorf("%s: encoded", name)
		}
	}

	imports := []string{sdk, sdk + "/announce"}
	end := BuildLogEntry{Event: BuildEndedEvent, Module: "netcheck", FP: "src2:x", Repository: "novox/mesh-catalog", Commit: commit,
		Node: "ace", At: good.At, Outcome: "done", Imports: imports}
	raw, err = EncodeBuildLogEntry(end)
	if err != nil {
		t.Fatal(err)
	}
	if e, err := DecodeBuildLogEntry(raw); err != nil || !reflect.DeepEqual(e.Imports, imports) {
		t.Fatalf("build end round trip: %v, %v", err, e.Imports)
	}
	start := end
	start.Event, start.Outcome = BuildStartedEvent, ""
	if _, err := EncodeBuildLogEntry(start); err == nil {
		t.Error("a build's start with imports encoded")
	}
	end.Imports = []string{sdk + "/announce", sdk}
	if _, err := EncodeBuildLogEntry(end); err == nil {
		t.Error("unsorted imports encoded")
	}
	var answer BuildAnswer
	if err := json.Unmarshal([]byte(`{"artifacts":[],"imports":["`+sdk+`"]}`), &answer); err != nil || len(answer.Imports) != 1 {
		t.Fatalf("build answer imports: %v, %v", err, answer.Imports)
	}
	if err := CheckImports([]string{"fmt"}); err == nil {
		t.Error("CheckImports takes a standard package")
	}
}

func slicesClone(d []PackageDigest) []PackageDigest { return append([]PackageDigest(nil), d...) }