package event

import (
	"bytes"
	"crypto/sha256"
	"testing"

	"git.smesh.lol/nostr/pkg/signer/p8k"
	"git.smesh.lol/nostr/pkg/tag"
	"git.smesh.lol/nostr/pkg/timestamp"
)

func TestSignVerifyEvent(t *testing.T) {
	kg := p8k.MustNew()
	if gerr := kg.Generate(); gerr != nil {
		t.Fatal(gerr)
	}

	evA := &E{
		CreatedAt: timestamp.Now().V,
		Kind:      1,
		Tags:      tag.NewS(tag.NewFromBytesSlice([]byte("p"), []byte("deadbeef"))),
		Content:   []byte("hello nostr from moxie"),
	}
	if serr := evA.Sign(kg); serr != nil {
		t.Fatal(serr)
	}

	// ID should be SHA256 of canonical form.
	canonA := evA.ToCanonical(nil)
	hA := sha256.Sum256(canonA)
	if !bytes.Equal(hA[:], evA.ID) {
		t.Fatal("event ID mismatch")
	}

	// Verify signature.
	validA, verrA := evA.Verify()
	if verrA != nil {
		t.Fatal(verrA)
	}
	if !validA {
		t.Fatal("signature verification failed")
	}
}

func TestMarshalUnmarshalRoundTrip(t *testing.T) {
	kg2 := p8k.MustNew()
	if gerr2 := kg2.Generate(); gerr2 != nil {
		t.Fatal(gerr2)
	}

	evB := &E{
		CreatedAt: 1234567890,
		Kind:      1,
		Tags:      tag.NewS(tag.NewFromBytesSlice([]byte("t"), []byte("test"))),
		Content:   []byte("test message with \"quotes\" and \\backslash"),
	}
	if serrB := evB.Sign(kg2); serrB != nil {
		t.Fatal(serrB)
	}

	// Marshal to JSON.
	rawB := evB.Marshal(nil)

	// Unmarshal back.
	evB2 := New()
	if _, uerrB := evB2.Unmarshal(rawB); uerrB != nil {
		t.Fatalf("unmarshal failed: %s", uerrB)
	}

	if !bytes.Equal(evB.ID, evB2.ID) {
		t.Fatal("ID mismatch after round-trip")
	}
	if !bytes.Equal(evB.Pubkey, evB2.Pubkey) {
		t.Fatal("Pubkey mismatch")
	}
	if evB.CreatedAt != evB2.CreatedAt {
		t.Fatal("CreatedAt mismatch")
	}
	if evB.Kind != evB2.Kind {
		t.Fatal("Kind mismatch")
	}
	if !bytes.Equal(evB.Content, evB2.Content) {
		t.Fatalf("Content mismatch: %s vs %s", evB.Content, evB2.Content)
	}
	if !bytes.Equal(evB.Sig, evB2.Sig) {
		t.Fatal("Sig mismatch")
	}

	// Verify the deserialized event.
	validB, verrB := evB2.Verify()
	if verrB != nil {
		t.Fatal(verrB)
	}
	if !validB {
		t.Fatal("deserialized event verification failed")
	}
}

func TestBinaryRoundTrip(t *testing.T) {
	kg3 := p8k.MustNew()
	if gerr3 := kg3.Generate(); gerr3 != nil {
		t.Fatal(gerr3)
	}

	evC := &E{
		CreatedAt: 1700000000,
		Kind:      30023,
		Tags: tag.NewS(
			tag.NewFromBytesSlice([]byte("d"), []byte("test-article")),
			tag.NewFromBytesSlice([]byte("title"), []byte("Test Article")),
		),
		Content: []byte("long form content here"),
	}
	if serrC := evC.Sign(kg3); serrC != nil {
		t.Fatal(serrC)
	}

	// Marshal to binary.
	binC := evC.MarshalBinaryToBytes(nil)

	// Unmarshal from binary.
	evC2 := New()
	if uerrC := evC2.UnmarshalBinary(bytes.NewReader(binC)); uerrC != nil {
		t.Fatalf("binary unmarshal failed: %s", uerrC)
	}

	if !bytes.Equal(evC.ID, evC2.ID) {
		t.Fatal("ID mismatch in binary round-trip")
	}
	if !bytes.Equal(evC.Sig, evC2.Sig) {
		t.Fatal("Sig mismatch in binary round-trip")
	}
	if !bytes.Equal(evC.Content, evC2.Content) {
		t.Fatal("Content mismatch in binary round-trip")
	}
}