package authenticator

import (
	"testing"
)

// TestRestoreCodeRoundTrip verifies that restoreCharToByte exactly
// inverts restoreByteToChar across every 5-bit value the encoding
// produces. A regression here would silently corrupt the HMAC key the
// Restore flow sends to Blizzard, so the round-trip is the cheapest
// possible safety net.
func TestRestoreCodeRoundTrip(t *testing.T) {
	for v := 0; v < 32; v++ {
		c := restoreByteToChar(byte(v))
		got, ok := restoreCharToByte(c)
		if !ok {
			t.Fatalf("v=%d encoded as %q but failed to decode", v, c)
		}
		if int(got) != v {
			t.Fatalf("v=%d → %q → %d (want %d)", v, c, got, v)
		}
	}
}

// TestRestoreCharToByteRejectsAmbiguous confirms that the four letters
// deliberately omitted from the Battle.Net restore alphabet (I, L, O,
// S) are rejected on decode. A user typing "1" instead of "I" should
// land on the "1" branch; "I" should be a hard error rather than a
// silent misdecode.
func TestRestoreCharToByteRejectsAmbiguous(t *testing.T) {
	for _, c := range []byte{'I', 'L', 'O', 'S'} {
		if _, ok := restoreCharToByte(c); ok {
			t.Errorf("char %q must not decode", c)
		}
	}
}

// TestDecodeRestoreCodeLength sanity-checks the length validator.
func TestDecodeRestoreCodeLength(t *testing.T) {
	if _, err := decodeRestoreCode("ABCDEFGHI"); err == nil {
		t.Error("expected error for 9-char input")
	}
	if _, err := decodeRestoreCode("ABCDEFGHIJK"); err == nil {
		t.Error("expected error for 11-char input")
	}
	// 10 valid characters
	if _, err := decodeRestoreCode("ABCDEFGHJK"); err != nil {
		t.Errorf("unexpected error for 10-char input: %v", err)
	}
}

// TestNormalizeBnetSerial verifies the user-friendly formats (dashes
// and spaces, mixed case) all collapse to the protocol-required form.
func TestNormalizeBnetSerial(t *testing.T) {
	cases := map[string]string{
		"us-1234-5678-9012":   "US123456789012",
		"US-1234-5678-9012":   "US123456789012",
		"  US 1234 5678 9012": "US123456789012",
		"us123456789012":      "US123456789012",
	}
	for in, want := range cases {
		if got := normalizeBnetSerial(in); got != want {
			t.Errorf("normalizeBnetSerial(%q) = %q, want %q", in, got, want)
		}
	}
}