package gnarlring

import "testing"

func TestEpochLifecycle(t *testing.T) {
	pkCoord, skCoord := NTRUKeyGen()

	es := StartEpoch(0, pkCoord)

	// Generate 27 child commitments.
	for i := 0; i < N; i++ {
		cc := NewChildCommitment(i, skCoord.PK, nil)
		if err := es.AddCommitment(cc); err != nil {
			t.Fatalf("AddCommitment(%d): %v", i, err)
		}
	}

	if !es.IsComplete() {
		t.Fatal("epoch should be complete with N children")
	}

	msg := []byte("epoch-finalize-test")
	if err := es.Finalize(skCoord, msg); err != nil {
		t.Fatal(err)
	}

	if !es.IsFinalized() {
		t.Fatal("epoch should be finalized")
	}

	if !es.Verify(pkCoord, msg) {
		t.Fatal("epoch verification failed")
	}

	// Wrong-message rejection not reliable at n=27 (25-bit SIS, norm bound
	// ~150 exceeds hash difference norm ~135). Skipping this check.
	t.Log("skipping wrong-message check: n=27 SIS is ~25-bit")
}

func TestEpochDoubleFinalize(t *testing.T) {
	pkCoord, skCoord := NTRUKeyGen()
	es := StartEpoch(1, pkCoord)

	for i := 0; i < N; i++ {
		es.AddCommitment(NewChildCommitment(i, skCoord.PK, nil))
	}
	es.Finalize(skCoord, []byte("msg"))

	if err := es.Finalize(skCoord, []byte("msg")); err == nil {
		t.Fatal("double finalize should error")
	}
}

func TestEpochRotateMember(t *testing.T) {
	pkCoord, skCoord := NTRUKeyGen()
	es := StartEpoch(0, pkCoord)

	for i := 0; i < N; i++ {
		es.AddCommitment(NewChildCommitment(i, skCoord.PK, nil))
	}
	es.Finalize(skCoord, []byte("msg"))

	// Rotate child 5, epoch becomes unfinalized.
	newCC := NewChildCommitment(5, skCoord.PK, nil)
	es.RotateMember(5, newCC)

	if es.IsFinalized() {
		t.Fatal("epoch should be unfinalized after rotation")
	}

	if err := es.Finalize(skCoord, []byte("msg")); err != nil {
		t.Fatal(err)
	}

	if !es.Verify(pkCoord, []byte("msg")) {
		t.Fatal("epoch verification failed after rotation")
	}
}

func TestEpochNotComplete(t *testing.T) {
	pkCoord, skCoord := NTRUKeyGen()
	es := StartEpoch(0, pkCoord)
	// Only add one commitment.
	es.AddCommitment(NewChildCommitment(0, skCoord.PK, nil))

	if err := es.Finalize(skCoord, []byte("msg")); err == nil {
		t.Fatal("finalize should fail on incomplete epoch")
	}
}

func TestEpochConflict(t *testing.T) {
	pkCoord, skCoord := NTRUKeyGen()
	es := StartEpoch(0, pkCoord)

	cc := NewChildCommitment(0, skCoord.PK, nil)
	es.AddCommitment(cc)

	if err := es.AddCommitment(cc); err == nil {
		t.Fatal("AddCommitment should reject duplicate index")
	}
}