package dbreads

import (
	"bytes"
	"errors"
	"testing"
	"time"
)

const sealID = "dbr_aaaaaaaaaaaaaaaaaaaaaaaaaa"

func TestChunkSealRoundTripsAndBindsEverything(t *testing.T) {
	t.Parallel()
	priv, err := NewReplyKey()
	if err != nil {
		t.Fatal(err)
	}
	plain := bytes.Repeat([]byte("row\n"), 1000)
	sealed, err := SealChunk(priv.PublicKey(), sealID, 3, StreamRows, false, plain)
	if err != nil {
		t.Fatal(err)
	}
	if len(sealed)-len(plain) >= 100 || len(sealed)-len(plain) != SealOverhead {
		t.Fatalf("overhead %d, spec §5.7 says under 100 bytes", len(sealed)-len(plain))
	}
	got, err := OpenChunk(priv, sealID, 3, StreamRows, false, sealed)
	if err != nil || !bytes.Equal(got, plain) {
		t.Fatalf("OpenChunk = %v", err)
	}
	other, _ := NewReplyKey()
	for name, open := range map[string]func() ([]byte, error){
		"moved to another read": func() ([]byte, error) {
			return OpenChunk(priv, "dbr_bbbbbbbbbbbbbbbbbbbbbbbbbb", 3, StreamRows, false, sealed)
		},
		"reordered":          func() ([]byte, error) { return OpenChunk(priv, sealID, 4, StreamRows, false, sealed) },
		"relabelled as last": func() ([]byte, error) { return OpenChunk(priv, sealID, 3, StreamRows, true, sealed) },
		"another stream":     func() ([]byte, error) { return OpenChunk(priv, sealID, 3, StreamLTX, false, sealed) },
		"another key":        func() ([]byte, error) { return OpenChunk(other, sealID, 3, StreamRows, false, sealed) },
		"truncated":          func() ([]byte, error) { return OpenChunk(priv, sealID, 3, StreamRows, false, sealed[:len(sealed)-1]) },
	} {
		if _, err := open(); !errors.Is(err, ErrSeal) {
			t.Errorf("%s: %v", name, err)
		}
	}
}

func TestSummarySealRoundTrips(t *testing.T) {
	t.Parallel()
	priv, _ := NewReplyKey()
	want := Summary{TXID: 42, At: time.Date(2026, 10, 7, 14, 0, 0, 0, time.UTC), Bytes: 10, SHA256: "ab"}
	sealed, err := SealSummary(priv.PublicKey(), sealID, want)
	if err != nil {
		t.Fatal(err)
	}
	got, err := OpenSummary(priv, sealID, sealed)
	if err != nil || got.TXID != want.TXID || !got.At.Equal(want.At) || got.SHA256 != want.SHA256 {
		t.Fatalf("OpenSummary = %+v, %v", got, err)
	}
	if _, err := OpenSummary(priv, "dbr_bbbbbbbbbbbbbbbbbbbbbbbbbb", sealed); !errors.Is(err, ErrSeal) {
		t.Fatalf("a summary moved to another read opened: %v", err)
	}
}

func TestReplyKeyRefusesWhatIsNotAnUncompressedPoint(t *testing.T) {
	t.Parallel()
	for _, bad := range []string{"", "AAAA", "!!!!"} {
		if _, err := ParseReplyKey(bad); err == nil {
			t.Errorf("ParseReplyKey(%q) accepted", bad)
		}
	}
}

func TestResultValidKnowsTheVocabulary(t *testing.T) {
	t.Parallel()
	ok := []Result{
		{State: StateDone, LastSeq: 1},
		{State: StateDone, Code: CodeOutputCap, LastSeq: 3},
		{State: StateFailed, Code: CodeSQLError},
		{State: StateRefused, Code: CodeRecordChanged},
		{State: StateCancelled},
	}
	for _, r := range ok {
		if err := r.Valid(); err != nil {
			t.Errorf("%+v: %v", r, err)
		}
	}
	bad := []Result{
		{State: StateDone, LastSeq: 0},
		{State: "maybe"},
		{State: StateFailed, Code: "nope"},
		{State: StateDone, LastSeq: -1},
	}
	for _, r := range bad {
		if err := r.Valid(); err == nil {
			t.Errorf("%+v accepted", r)
		}
	}
}