package projection

import (
	"path/filepath"
	"strings"
	"testing"
)

// TestKeyHashing_LongKeyRoundTrips — a key well over the 32-byte raw ceiling
// (a query string / page path) is accepted in hashed mode and Get finds it.
func TestKeyHashing_LongKeyRoundTrips(t *testing.T) {
	dir := t.TempDir()
	longKey := "/kategori/" + strings.Repeat("hem-hushall-tradgard/", 5) + "?q=" + strings.Repeat("x", 80)
	if len(longKey) <= maxSKULen {
		t.Fatalf("test bug: key is only %d bytes, not over the ceiling", len(longKey))
	}

	w := NewSnapshotWriter[tProj]().WithKeyHashing()
	// The value carries the original key — the id/sku stays the link even though
	// the index key is a digest.
	if err := w.Append(longKey, tProj{SKU: longKey, PriceIncVat: 42}); err != nil {
		t.Fatalf("Append long key in hashed mode: %v", err)
	}
	if _, err := w.Write(dir, "hashed.bin"); err != nil {
		t.Fatal(err)
	}

	r, err := ReadSnapshotFile[tProj](filepath.Join(dir, "hashed.bin"))
	if err != nil {
		t.Fatal(err)
	}
	defer r.Close()

	got, ok := r.Get(longKey)
	if !ok {
		t.Fatal("Get(longKey) miss — hashed lookup did not match the stored digest")
	}
	if got.PriceIncVat != 42 || got.SKU != longKey {
		t.Fatalf("got %+v, want price 42 and original key in value", got)
	}
	// Scan yields the digest, not the original — caller recovers it from the value.
	r.Scan(func(key string, v tProj) bool {
		if key == longKey {
			t.Error("Scan key should be the digest in hashed mode, got the original")
		}
		if len(key) != 32 {
			t.Errorf("digest key len = %d, want 32 hex chars", len(key))
		}
		if v.SKU != longKey {
			t.Errorf("value lost the original key: %q", v.SKU)
		}
		return true
	})
}

// TestKeyHashing_RawModeStillRejectsLongKeys — default (raw) mode is unchanged:
// an over-long key still errors, so catalog's contract is untouched.
func TestKeyHashing_RawModeStillRejectsLongKeys(t *testing.T) {
	w := NewSnapshotWriter[tProj]() // raw
	long := strings.Repeat("x", 33)
	if err := w.Append(long, tProj{SKU: long}); err == nil {
		t.Fatal("raw mode should still reject a 33-byte key")
	}
}

// TestKeyHashing_RawFileHeaderUnchanged — a raw-mode file sets keyEnc=0 at
// offset 12, i.e. byte-identical header to a pre-hashing v2 file. Guards the
// back-compat claim for catalog's existing .bin files.
func TestKeyHashing_RawFileHeaderUnchanged(t *testing.T) {
	dir := t.TempDir()
	w := NewSnapshotWriter[tProj]()
	if err := appendP(w, makeProjection("A", 1)); err != nil {
		t.Fatal(err)
	}
	if _, err := w.Write(dir, "raw.bin"); err != nil {
		t.Fatal(err)
	}
	r, err := ReadSnapshotFile[tProj](filepath.Join(dir, "raw.bin"))
	if err != nil {
		t.Fatal(err)
	}
	defer r.Close()
	if r.raw.keyEnc != keyEncRaw {
		t.Fatalf("raw file keyEnc = %d, want 0", r.raw.keyEnc)
	}
	if _, ok := r.Get("A"); !ok {
		t.Error("raw-mode Get still works")
	}
}

// TestKeyHashing_UnknownEncodingRejected — a header carrying an unknown key
// encoding is rejected rather than silently mis-looked-up.
func TestKeyHashing_UnknownEncodingRejected(t *testing.T) {
	dir := t.TempDir()
	w := NewSnapshotWriter[tProj]()
	if err := appendP(w, makeProjection("A", 1)); err != nil {
		t.Fatal(err)
	}
	path := filepath.Join(dir, "tamper.bin")
	if _, err := w.Write(dir, "tamper.bin"); err != nil {
		t.Fatal(err)
	}
	data, err := os2ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}
	data[12] = 0x09 // keyEnc = 9, unknown
	if err := os2WriteFile(path, data, 0o644); err != nil {
		t.Fatal(err)
	}
	if _, err := ReadSnapshotFile[tProj](path); err == nil {
		t.Fatal("unknown key encoding should be rejected")
	}
}