package traefikoidc

import (
	"sync"
	"testing"
	"time"
)

func TestFixedMetadataCache(t *testing.T) {
	logger := NewLogger("debug")

	t.Run("basic operations", func(t *testing.T) {
		cache := NewFixedMetadataCache(10, 1, logger)

		metadata := &ProviderMetadata{
			Issuer:   "https://example.com",
			AuthURL:  "https://example.com/auth",
			TokenURL: "https://example.com/token",
		}

		// Set and get
		cache.Set("provider1", metadata, time.Minute)

		retrieved, found := cache.Get("provider1")
		if !found {
			t.Error("Expected to find provider1")
		}
		if retrieved.Issuer != metadata.Issuer {
			t.Error("Retrieved metadata doesn't match")
		}

		// Delete
		cache.Delete("provider1")
		_, found = cache.Get("provider1")
		if found {
			t.Error("Expected provider1 to be deleted")
		}
	})

	t.Run("LRU eviction", func(t *testing.T) {
		cache := NewFixedMetadataCache(3, 1, logger)

		// Add 3 items
		for i := 0; i < 3; i++ {
			metadata := &ProviderMetadata{
				Issuer: string(rune('a' + i)),
			}
			cache.Set(string(rune('a'+i)), metadata, time.Minute)
		}

		// Access 'a' to make it recently used
		cache.Get("a")

		// Add new item, should evict 'b' (least recently used)
		metadata := &ProviderMetadata{Issuer: "d"}
		cache.Set("d", metadata, time.Minute)

		// Check what's in cache
		_, foundA := cache.Get("a")
		_, foundB := cache.Get("b")
		_, foundC := cache.Get("c")
		_, foundD := cache.Get("d")

		if !foundA {
			t.Error("Expected 'a' to be present (recently accessed)")
		}
		if foundB {
			t.Error("Expected 'b' to be evicted (LRU)")
		}
		if !foundC {
			t.Error("Expected 'c' to be present")
		}
		if !foundD {
			t.Error("Expected 'd' to be present (newest)")
		}
	})

	t.Run("memory limit enforcement", func(t *testing.T) {
		// Very small memory limit to trigger evictions
		cache := NewFixedMetadataCache(100, 1, logger) // 1MB limit

		// Add items until memory limit is exceeded
		for i := 0; i < 10; i++ {
			metadata := &ProviderMetadata{
				Issuer:   string(make([]byte, 100*1024)), // ~100KB each
				AuthURL:  string(make([]byte, 100*1024)),
				TokenURL: string(make([]byte, 100*1024)),
			}
			cache.Set(string(rune('a'+i)), metadata, time.Minute)
		}

		stats := cache.GetStats()
		currentMemory, ok := stats["memory"].(int64)
		if !ok {
			t.Fatalf("memory field not found or not int64: %v", stats["memory"])
		}
		maxMemory, ok := stats["max_memory"].(int64)
		if !ok {
			// max_memory might be 0 if not set
			maxMemory = 0
		}

		entries, ok := stats["entries"].(int64)
		if !ok {
			t.Fatalf("entries field not found or not int64: %v", stats["entries"])
		}

		// The cache might exceed the limit by one item since it can't evict
		// the item being inserted. Check that we have minimal entries.
		if maxMemory > 0 && entries > 2 {
			// If we have more than 2 entries despite memory pressure, that's a problem
			t.Errorf("Expected aggressive eviction with memory limit, got %d entries", entries)
		}
		// Log the memory usage for information
		t.Logf("Memory usage: %d bytes, limit: %d bytes, entries: %d", currentMemory, maxMemory, entries)

		if entries >= 10 {
			t.Errorf("Expected evictions to keep entries below 10, got %d", entries)
		}
	})

	t.Run("expiration", func(t *testing.T) {
		cache := NewFixedMetadataCache(10, 1, logger)

		metadata := &ProviderMetadata{Issuer: "expires"}
		cache.Set("expires", metadata, 100*time.Millisecond)

		// Should exist initially
		_, found := cache.Get("expires")
		if !found {
			t.Error("Expected to find entry before expiration")
		}

		// Wait for expiration
		time.Sleep(150 * time.Millisecond)

		// Should be expired
		_, found = cache.Get("expires")
		if found {
			t.Error("Expected entry to be expired")
		}
	})

	t.Run("cleanup expired", func(t *testing.T) {
		cache := NewFixedMetadataCache(10, 1, logger)

		// Add items with different expiries
		for i := 0; i < 5; i++ {
			metadata := &ProviderMetadata{Issuer: string(rune('a' + i))}
			ttl := time.Duration(i+1) * 100 * time.Millisecond
			cache.Set(string(rune('a'+i)), metadata, ttl)
		}

		// Wait for some to expire
		time.Sleep(250 * time.Millisecond)

		// Cleanup expired
		cache.CleanupExpired()

		stats := cache.GetStats()
		entries := stats["entries"].(int64)

		// Only items with TTL > 250ms should remain
		if entries > 3 {
			t.Errorf("Expected at most 3 entries after cleanup, got %d", entries)
		}
	})

	t.Run("concurrent access", func(t *testing.T) {
		cache := NewFixedMetadataCache(50, 10, logger)
		var wg sync.WaitGroup

		// Concurrent writes
		for i := 0; i < 20; i++ {
			wg.Add(1)
			go func(id int) {
				defer wg.Done()
				metadata := &ProviderMetadata{
					Issuer: string(rune('a' + (id % 26))),
				}
				cache.Set(string(rune('a'+(id%26))), metadata, time.Minute)
			}(i)
		}

		// Concurrent reads
		for i := 0; i < 20; i++ {
			wg.Add(1)
			go func(id int) {
				defer wg.Done()
				cache.Get(string(rune('a' + (id % 26))))
			}(i)
		}

		// Concurrent deletes
		for i := 0; i < 10; i++ {
			wg.Add(1)
			go func(id int) {
				defer wg.Done()
				cache.Delete(string(rune('a' + (id % 26))))
			}(i)
		}

		wg.Wait()

		// Verify cache is still functional
		cache.Set("test", &ProviderMetadata{Issuer: "test"}, time.Minute)
		_, found := cache.Get("test")
		if !found {
			t.Error("Cache not functional after concurrent access")
		}
	})

	t.Run("clear operation", func(t *testing.T) {
		cache := NewFixedMetadataCache(10, 1, logger)

		// Add items
		for i := 0; i < 5; i++ {
			metadata := &ProviderMetadata{Issuer: string(rune('a' + i))}
			cache.Set(string(rune('a'+i)), metadata, time.Minute)
		}

		// Clear
		cache.Clear()

		stats := cache.GetStats()
		entries := stats["entries"].(int64)
		memory, _ := stats["memory"].(int64) // Field is "memory" not "memory_bytes"

		if entries != 0 {
			t.Errorf("Expected 0 entries after clear, got %d", entries)
		}
		if memory != 0 {
			t.Errorf("Expected 0 memory usage after clear, got %d", memory)
		}
	})

	t.Run("stats accuracy", func(t *testing.T) {
		cache := NewFixedMetadataCache(5, 1, logger)

		// Add items up to limit
		for i := 0; i < 7; i++ {
			metadata := &ProviderMetadata{Issuer: string(rune('a' + i))}
			cache.Set(string(rune('a'+i)), metadata, time.Minute)
		}

		stats := cache.GetStats()

		entries := stats["entries"].(int64)
		maxEntries, ok := stats["max_size"].(int)
		if !ok {
			// Try int64
			if maxEntries64, ok := stats["max_size"].(int64); ok {
				maxEntries = int(maxEntries64)
			} else {
				maxEntries = 100 // default
			}
		}
		evictions := stats["evictions"].(int64)

		if int(entries) > maxEntries {
			t.Errorf("Entries %d exceeds max %d", entries, maxEntries)
		}
		if evictions < 2 {
			t.Errorf("Expected at least 2 evictions, got %d", evictions)
		}
		// This check is always true now since lruSize = entries
		// Remove the check as it's not meaningful
	})
}