package bundle

import (
	"errors"
	"strings"
	"testing"

	"github.com/novox/mesh-host/internal/declaration"
)

// declarationParse is the parser Load uses, named here so the test reads as the assertion it is.
func declarationParse(raw []byte) (any, error) { return declaration.Parse(raw) }

func TestADefaultBuildCarriesNothingAndSaysSo(t *testing.T) {
	// The important one. A host built without a bundle that applied nothing and reported
	// success would look exactly like a host that raised a first node — and the difference
	// would surface as a mesh that never came up, with nothing to point at.
	if !IsEmpty() {
		t.Fatal("the default build claims to carry a substrate")
	}
	_, err := Load()
	if !errors.Is(err, ErrEmpty) {
		t.Fatalf("an empty bundle did not refuse: %v", err)
	}
	if !strings.Contains(err.Error(), "would look exactly like applying something") {
		t.Errorf("the refusal does not say why it matters: %v", err)
	}
}

func TestCommentsAreNotContent(t *testing.T) {
	// The placeholder is a comment. If comments counted as content, every default build would
	// claim to carry a substrate and then fail to parse it — the right outcome for the wrong
	// reason, and a confusing error at the worst moment.
	if got := stripComments([]byte("// a\n{\"a\":1}\n  // b\n")); strings.Contains(string(got), "//") {
		t.Errorf("comments survived stripping: %q", got)
	}
}

func TestOnlyWholeLineCommentsAreStripped(t *testing.T) {
	// Anything cleverer would have to know where strings begin and end. A parser that
	// half-understands its input is worse than one that does not try — a path containing a
	// double slash is ordinary, and losing half of it would be silent.
	raw := []byte(`{"path":"https://example.invalid/a"}`)
	if got := string(stripComments(raw)); got != string(raw) {
		t.Errorf("a slash inside a string was treated as a comment: %q", got)
	}
}

func TestABundleWithContentIsParsedByTheSameParserTheLinkWillUse(t *testing.T) {
	// A bundle that reaches a machine and is then refused by the host carrying it would be a
	// build-time mistake found at the worst possible moment.
	real := []byte(`// pinned
{"declaration":1,"resources":[{"id":"d","type":"directory","path":"/etc/mesh"}]}`)
	stripped := stripComments(real)
	if strings.Contains(string(stripped), "pinned") {
		t.Fatal("the comment survived")
	}
	if !strings.Contains(string(stripped), "declaration") {
		t.Fatal("the declaration did not survive")
	}
}

func TestWhatValidatesIsWhatIsApplied(t *testing.T) {
	// Found on a real machine. `mesh-host bundle` validated the carried bundle through Load,
	// which strips comments; `reconcile` handed the RAW bytes to the parser, which does not.
	// So the command whose whole job is to check the bundle said yes, and the command that
	// uses it said no — two paths to one artefact, disagreeing.
	//
	// There is now one path. This asserts the property that made the bug possible cannot
	// return: whatever Load accepts is what gets applied, byte for byte.
	annotated := []byte("// a comment\n" + `{"declaration":1,"resources":[{"id":"d","type":"directory","path":"/etc/mesh"}]}`)

	if _, err := parseFor(annotated); err != nil {
		t.Fatalf("an annotated bundle was refused: %v", err)
	}
}

// parseFor mirrors what Load does to arbitrary bytes, so the test can exercise the path
// without rebuilding the binary with a different embedded file.
func parseFor(raw []byte) (any, error) {
	return declarationParse(stripComments(raw))
}