package auth

import (
	"testing"
	"time"
)

func TestMemoryStateStore(t *testing.T) {
	store := NewMemoryStateStore()

	t.Run("set and validate state", func(t *testing.T) {
		state := "test-state-123"
		expiry := time.Now().Add(10 * time.Minute)

		err := store.Set(state, expiry)
		if err != nil {
			t.Fatalf("Failed to set state: %v", err)
		}

		valid, err := store.Validate(state)
		if err != nil {
			t.Fatalf("Failed to validate state: %v", err)
		}

		if !valid {
			t.Error("Expected state to be valid")
		}
	})

	t.Run("validate non-existent state", func(t *testing.T) {
		valid, err := store.Validate("non-existent")
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}

		if valid {
			t.Error("Expected non-existent state to be invalid")
		}
	})

	t.Run("validate expired state", func(t *testing.T) {
		state := "expired-state"
		expiry := time.Now().Add(-1 * time.Minute) // Already expired

		err := store.Set(state, expiry)
		if err != nil {
			t.Fatalf("Failed to set state: %v", err)
		}

		valid, err := store.Validate(state)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}

		if valid {
			t.Error("Expected expired state to be invalid")
		}
	})

	t.Run("delete state", func(t *testing.T) {
		state := "delete-test"
		expiry := time.Now().Add(10 * time.Minute)

		err := store.Set(state, expiry)
		if err != nil {
			t.Fatalf("Failed to set state: %v", err)
		}

		err = store.Delete(state)
		if err != nil {
			t.Fatalf("Failed to delete state: %v", err)
		}

		valid, err := store.Validate(state)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}

		if valid {
			t.Error("Expected deleted state to be invalid")
		}
	})

	t.Run("multiple states", func(t *testing.T) {
		state1 := "state-1"
		state2 := "state-2"
		expiry := time.Now().Add(10 * time.Minute)

		store.Set(state1, expiry)
		store.Set(state2, expiry)

		valid1, _ := store.Validate(state1)
		valid2, _ := store.Validate(state2)

		if !valid1 || !valid2 {
			t.Error("Expected both states to be valid")
		}

		store.Delete(state1)

		valid1, _ = store.Validate(state1)
		valid2, _ = store.Validate(state2)

		if valid1 {
			t.Error("Expected state1 to be invalid after deletion")
		}

		if !valid2 {
			t.Error("Expected state2 to still be valid")
		}
	})
}