package handlers

import (
	"testing"
	"time"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestGeneratePairingCodeShape(t *testing.T) {
	for i := 0; i < 50; i++ {
		code, err := generatePairingCode()
		require.NoError(t, err)
		assert.Len(t, code, pairingCodeDigits)
		assert.Regexp(t, `^\d{6}$`, code, "codes are 6 digits")
	}
}

func TestGeneratePairingCodeAvoidsLiveCollisions(t *testing.T) {
	reg := &PendingRegistration{RegistrationID: uuid.NewString(), PairingCode: "000000"}
	pendingMu.Lock()
	pendingRegistrations[reg.RegistrationID] = reg
	pendingMu.Unlock()
	t.Cleanup(func() {
		pendingMu.Lock()
		delete(pendingRegistrations, reg.RegistrationID)
		pendingMu.Unlock()
	})

	for i := 0; i < 200; i++ {
		code, err := generatePairingCode()
		require.NoError(t, err)
		assert.NotEqual(t, "000000", code, "mint must not collide with a live registration's code")
	}
}

func TestNormalizePairingCode(t *testing.T) {
	assert.Equal(t, "583912", normalizePairingCode("583 912"), "device shows spaced digits")
	assert.Equal(t, "583912", normalizePairingCode("583-912"))
	assert.Equal(t, "583912", normalizePairingCode("583912"))
	assert.Equal(t, "583912", normalizePairingCode(" 58 39 12 "), "stray whitespace tolerated")
	assert.Equal(t, "", normalizePairingCode("no digits here"))
}

func TestRegistrationByPairingCodeScopes(t *testing.T) {
	live := &PendingRegistration{
		RegistrationID: uuid.NewString(),
		PairingCode:    "111111",
		DeviceName:     "Live Device",
		ExpiresAt:      time.Now().Add(time.Minute),
	}
	expired := &PendingRegistration{
		RegistrationID: uuid.NewString(),
		PairingCode:    "222222",
		ExpiresAt:      time.Now().Add(-time.Minute),
	}
	claimed := &PendingRegistration{
		RegistrationID: uuid.NewString(),
		PairingCode:    "333333",
		ExpiresAt:      time.Now().Add(time.Minute),
		Approved:       true,
	}
	pendingMu.Lock()
	for _, reg := range []*PendingRegistration{live, expired, claimed} {
		pendingRegistrations[reg.RegistrationID] = reg
	}
	pendingMu.Unlock()
	t.Cleanup(func() {
		pendingMu.Lock()
		for _, reg := range []*PendingRegistration{live, expired, claimed} {
			delete(pendingRegistrations, reg.RegistrationID)
		}
		pendingMu.Unlock()
	})

	// Live code resolves.
	got, err := registrationByPairingCode("111111")
	require.NoError(t, err)
	assert.Equal(t, "Live Device", got.DeviceName)

	// Expired code is reaped on sight.
	_, err = registrationByPairingCode("222222")
	assert.ErrorIs(t, err, errPairingExpired)
	pendingMu.Lock()
	_, stillThere := pendingRegistrations[expired.RegistrationID]
	pendingMu.Unlock()
	assert.False(t, stillThere, "expired registration must be reaped")

	// Claimed code is refused.
	_, err = registrationByPairingCode("333333")
	assert.ErrorIs(t, err, errPairingClaimed)

	// Unknown code is the generic miss.
	_, err = registrationByPairingCode("999999")
	assert.ErrorIs(t, err, errPairingInvalid)
}