cache

func newRedisCache[T any](t *testing.T) (*RedisCache[T], context.Context)

{
	t.Helper()
	mr, err := miniredis.Run()
	if err != nil {
		t.Fatalf("miniredis run: %v", err)
	}

	client := redis.NewClient(&redis.Options{Addr: mr.Addr()})
	ctx := context.Background()

	t.Cleanup(func() {
		_ = client.FlushDB(ctx).Err()
		_ = client.Close()
		mr.Close()
	})

	return NewRedis[T](client, nil), ctx
}

func TestRedisCacheGetSetInvalidate(t *testing.T)

{
	c, ctx := newRedisCache[string](t)

	if err := c.Set(ctx, "foo", "bar", time.Minute); err != nil {
		t.Fatalf("Set: %v", err)
	}

	if v, ok, err := c.Get(ctx, "foo"); err != nil || !ok || v != "bar" {
		t.Fatalf("Get: expected bar, got %v err %v", v, err)
	}

	if err := c.Invalidate(ctx, "foo"); err != nil {
		t.Fatalf("Invalidate: %v", err)
	}

	if _, ok, err := c.Get(ctx, "foo"); ok || err != nil {
		t.Fatalf("expected miss after invalidate")
	}
}

func TestRedisCacheComplexStruct(t *testing.T)

{
	type complex struct {
		Name string
		Age  int
		Tags []string
	}

	c, ctx := newRedisCache[complex](t)

	expected := complex{Name: "Alice", Age: 30, Tags: []string{"go", "redis"}}
	if err := c.Set(ctx, "user:1", expected, time.Minute); err != nil {
		t.Fatalf("Set: %v", err)
	}

	got, ok, err := c.Get(ctx, "user:1")
	if err != nil || !ok {
		t.Fatalf("expected value, got miss err %v", err)
	}
	if !reflect.DeepEqual(got, expected) {
		t.Fatalf("expected %+v, got %+v", expected, got)
	}
}

func TestRedisCacheGetErrors(t *testing.T)

{
	t.Run("client error", func(t *testing.T) {
		c, ctx := newRedisCache[string](t)
		_ = c.client.Close()
		if _, _, err := c.Get(ctx, "foo"); !errors.Is(err, warperrors.ErrConnectionClosed) {
			t.Fatalf("expected connection closed error, got %v", err)
		}
	})

	t.Run("unmarshal error", func(t *testing.T) {
		c, ctx := newRedisCache[string](t)
		// store invalid JSON to trigger unmarshal error
		if err := c.client.Set(ctx, "foo", "{invalid", 0).Err(); err != nil {
			t.Fatalf("setup: %v", err)
		}
		if _, _, err := c.Get(ctx, "foo"); err == nil {
			t.Fatalf("expected unmarshal error")
		}
	})

	t.Run("timeout", func(t *testing.T) {
		c, ctx := newRedisCache[string](t)
		tCtx, cancel := context.WithTimeout(ctx, time.Nanosecond)
		defer cancel()
		time.Sleep(time.Millisecond)
		if _, _, err := c.Get(tCtx, "foo"); !errors.Is(err, warperrors.ErrTimeout) {
			t.Fatalf("expected timeout error, got %v", err)
		}
	})
}

func TestByteCodec(t *testing.T)

{
	codec := ByteCodec{}

	t.Run("Marshal []byte", func(t *testing.T) {
		input := []byte("hello")
		data, err := codec.Marshal(input)
		if err != nil {
			t.Fatalf("Marshal failed: %v", err)
		}
		if !bytes.Equal(data, input) {
			t.Fatalf("Marshal returned unexpected data: got %s, want %s", data, input)
		}
	})

	t.Run("Marshal Invalid Type", func(t *testing.T) {
		input := "string"
		_, err := codec.Marshal(input)
		if err == nil {
			t.Fatal("Marshal expected error for non-[]byte input")
		}
	})

	t.Run("Unmarshal *[]byte", func(t *testing.T) {
		input := []byte("world")
		var output []byte
		if err := codec.Unmarshal(input, &output); err != nil {
			t.Fatalf("Unmarshal failed: %v", err)
		}
		if !bytes.Equal(output, input) {
			t.Fatalf("Unmarshal returned unexpected data: got %s, want %s", output, input)
		}
	})

	t.Run("Unmarshal Invalid Type", func(t *testing.T) {
		input := []byte("world")
		var output string
		if err := codec.Unmarshal(input, &output); err == nil {
			t.Fatal("Unmarshal expected error for non-*[]byte target")
		}
	})
}

func TestAdaptiveCacheInvalidate(t *testing.T)

{
	ctx := context.Background()
	ac := NewAdaptive[string]()
	defer ac.Close()

	if err := ac.Set(ctx, "foo", "bar", time.Minute); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if err := ac.Invalidate(ctx, "foo"); err != nil {
		t.Fatalf("invalidate: %v", err)
	}
	if _, ok, _ := ac.lru.Get(ctx, "foo"); ok {
		t.Fatalf("expected lru cache to remove key")
	}
	if _, ok, _ := ac.lfu.Get(ctx, "foo"); ok {
		t.Fatalf("expected lfu cache to remove key")
	}
}

func TestAdaptiveCacheClose(t *testing.T)

{
	ctx := context.Background()
	ac := NewAdaptive[string]()
	if err := ac.Set(ctx, "foo", "bar", time.Minute); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	ac.Close()
	if c, ok := ac.lru.(*InMemoryCache[string]); ok {
		c.mu.RLock()
		size := len(c.items)
		c.mu.RUnlock()
		if size != 0 {
			t.Fatalf("expected lru cache to be empty after close")
		}
	}
	if _, ok, _ := ac.lfu.Get(ctx, "foo"); ok {
		t.Fatalf("expected lfu cache to be empty after close")
	}
}

func New[T any](opts ...Option[T]) Cache[T]

{
	cfg := factoryConfig[T]{strategy: LRUStrategy}
	for _, opt := range opts {
		opt(&cfg)
	}
	switch cfg.strategy {
	case LFUStrategy:
		return NewLFU[T]()
	case AdaptiveStrategy:
		return NewAdaptive[T]()
	default:
		return NewLRU[T]()
	}
}

func NewRistretto[T any](opts ...RistrettoOption) *RistrettoCache[T]

{
	cfg := &ristretto.Config{
		NumCounters: 1e4,     // number of keys to track frequency of (10k).
		MaxCost:     1 << 20, // maximum cost of cache (1MB by default).
		BufferItems: 64,      // number of keys per Get buffer.
	}
	for _, opt := range opts {
		opt(cfg)
	}
	rc, err := ristretto.NewCache(cfg)
	if err != nil {
		panic(err)
	}
	return &RistrettoCache[T]{c: rc}
}

func TestRistrettoCacheGetSetInvalidate(t *testing.T)

{
	c, ctx := newRistrettoCache[string](t)

	if err := c.Set(ctx, "foo", "bar", time.Minute); err != nil {
		t.Fatalf("Set: %v", err)
	}
	if v, ok, err := c.Get(ctx, "foo"); err != nil || !ok || v != "bar" {
		t.Fatalf("Get: expected bar, got %v err %v", v, err)
	}
	if err := c.Invalidate(ctx, "foo"); err != nil {
		t.Fatalf("Invalidate: %v", err)
	}
	if _, ok, err := c.Get(ctx, "foo"); ok || err != nil {
		t.Fatalf("expected miss after invalidate")
	}
}

func TestRistrettoCacheExpiration(t *testing.T)

{
	c, ctx := newRistrettoCache[string](t)

	if err := c.Set(ctx, "foo", "bar", 10*time.Millisecond); err != nil {
		t.Fatalf("Set: %v", err)
	}
	time.Sleep(20 * time.Millisecond)
	if _, ok, err := c.Get(ctx, "foo"); ok || err != nil {
		t.Fatalf("expected key to expire")
	}
}

func TestRistrettoCacheContext(t *testing.T)

{
	c, _ := newRistrettoCache[string](t)
	defer c.Close()

	ctxSet, cancelSet := context.WithCancel(context.Background())
	cancelSet()
	if err := c.Set(ctxSet, "a", "b", time.Minute); !errors.Is(err, context.Canceled) {
		t.Fatalf("expected context canceled error, got %v", err)
	}
	if _, ok, err := c.Get(context.Background(), "a"); ok || err != nil {
		t.Fatalf("item should not be stored when context is canceled")
	}

	if err := c.Set(context.Background(), "foo", "bar", time.Minute); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	ctxGet, cancelGet := context.WithCancel(context.Background())
	cancelGet()
	if v, ok, err := c.Get(ctxGet, "foo"); !errors.Is(err, context.Canceled) || ok || v != "" {
		t.Fatalf("expected canceled context to prevent retrieval")
	}

	ctxInv, cancelInv := context.WithCancel(context.Background())
	cancelInv()
	if err := c.Invalidate(ctxInv, "foo"); !errors.Is(err, context.Canceled) {
		t.Fatalf("expected context canceled error, got %v", err)
	}
	if v, ok, err := c.Get(context.Background(), "foo"); err != nil || !ok || v != "bar" {
		t.Fatalf("item should remain after canceled invalidate")
	}
}

func benchmarkGet(b *testing.B, c Cache[string])

{
	ctx := context.Background()
	if err := c.Set(ctx, "key", "val", time.Minute); err != nil {
		b.Fatalf("setup failed: %v", err)
	}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		if _, ok, err := c.Get(ctx, "key"); err != nil || !ok {
			b.Fatalf("get failed: %v ok=%v", err, ok)
		}
	}
}

func WithMetrics[T any](reg prometheus.Registerer) InMemoryOption[T]

{
	return func(c *InMemoryCache[T]) {
		c.hitCounter = prometheus.NewCounter(prometheus.CounterOpts{
			Name: "warp_cache_hits_total",
			Help: "Total number of cache hits",
		})
		c.missCounter = prometheus.NewCounter(prometheus.CounterOpts{
			Name: "warp_cache_misses_total",
			Help: "Total number of cache misses",
		})
		c.evictionCounter = prometheus.NewCounter(prometheus.CounterOpts{
			Name: "warp_cache_evictions_total",
			Help: "Total number of cache evictions",
		})
		c.latencyHist = prometheus.NewHistogram(prometheus.HistogramOpts{
			Name:    "warp_cache_latency_seconds",
			Help:    "Latency of cache operations",
			Buckets: prometheus.DefBuckets,
		})
		reg.MustRegister(c.hitCounter, c.missCounter, c.evictionCounter, c.latencyHist)
	}
}

func NewInMemory[T any](opts ...InMemoryOption[T]) *InMemoryCache[T]

{
	ctx, cancel := context.WithCancel(context.Background())
	c := &InMemoryCache[T]{
		items:         make(map[string]item[T]),
		order:         list.New(),
		sweepInterval: defaultSweepInterval,
		ctx:           ctx,
		cancel:        cancel,
	}
	for _, opt := range opts {
		opt(c)
	}
	if c.sweepInterval > 0 {
		c.wg.Add(1)
		go c.sweeper()
	}
	return c
}

func EstimateSize[T any](v T) int64

{
	// 1. Check if it implements Sizer
	if s, ok := any(v).(Sizer); ok {
		return s.Size()
	}

	// 2. Common types
	switch val := any(v).(type) {
	case string:
		return int64(len(val))
	case []byte:
		return int64(len(val))
	case int, uint, int64, uint64, float64, complex128:
		return 8
	case int32, uint32, float32:
		return 4
	case int16, uint16:
		return 2
	case int8, uint8, bool:
		return 1
	}

	// 3. Last resort: unsafe.Sizeof (Shallow)
	return int64(unsafe.Sizeof(v))
}

func TestInMemoryCache(t *testing.T)

{
	ctx := context.Background()
	c := NewInMemory[string]()
	defer c.Close()
	if err := c.Set(ctx, "foo", "bar", time.Millisecond); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if v, ok, err := c.Get(ctx, "foo"); err != nil || !ok || v != "bar" {
		t.Fatalf("expected bar, got %v err %v", v, err)
	}

	time.Sleep(2 * time.Millisecond)
	if _, ok, err := c.Get(ctx, "foo"); ok || err != nil {
		t.Fatalf("expected key to expire")
	}

	m := c.Metrics()
	if m.Hits != 1 || m.Misses != 1 {
		t.Fatalf("unexpected metrics: %+v", m)
	}
}

func TestInMemoryCacheSweeper(t *testing.T)

{
	ctx := context.Background()
	c := NewInMemory[string](WithSweepInterval[string](5 * time.Millisecond))
	defer c.Close()
	if err := c.Set(ctx, "foo", "bar", 5*time.Millisecond); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	time.Sleep(20 * time.Millisecond)
	c.mu.RLock()
	_, ok := c.items["foo"]
	c.mu.RUnlock()
	if ok {
		t.Fatalf("expected key to be swept")
	}
}

func TestInMemoryCacheContext(t *testing.T)

{
	c := NewInMemory[string]()
	defer c.Close()

	// Set with canceled context should fail and not store the item.
	ctxSet, cancelSet := context.WithCancel(context.Background())
	cancelSet()
	if err := c.Set(ctxSet, "a", "b", time.Minute); !errors.Is(err, context.Canceled) {
		t.Fatalf("expected context canceled error, got %v", err)
	}
	if _, ok, err := c.Get(context.Background(), "a"); ok || err != nil {
		t.Fatalf("item should not be stored when context is canceled")
	}

	// Prepare an item for further context tests.
	if err := c.Set(context.Background(), "foo", "bar", time.Minute); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Get with canceled context should not retrieve the item.
	ctxGet, cancelGet := context.WithCancel(context.Background())
	cancelGet()
	if v, ok, err := c.Get(ctxGet, "foo"); !errors.Is(err, context.Canceled) || ok || v != "" {
		t.Fatalf("expected canceled context to prevent retrieval")
	}

	// Invalidate with canceled context should fail and keep the item.
	ctxInv, cancelInv := context.WithCancel(context.Background())
	cancelInv()
	if err := c.Invalidate(ctxInv, "foo"); !errors.Is(err, context.Canceled) {
		t.Fatalf("expected context canceled error, got %v", err)
	}
	if v, ok, err := c.Get(context.Background(), "foo"); err != nil || !ok || v != "bar" {
		t.Fatalf("item should remain after canceled invalidate")
	}
}

func TestInMemoryCacheEviction(t *testing.T)

{
	ctx := context.Background()
	c := NewInMemory[string](WithMaxEntries[string](2))
	defer c.Close()

	if err := c.Set(ctx, "a", "1", time.Minute); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if err := c.Set(ctx, "b", "2", time.Minute); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Access "a" so that "b" becomes the least recently used.
	if _, ok, err := c.Get(ctx, "a"); err != nil || !ok {
		t.Fatalf("expected to retrieve a: %v", err)
	}

	if err := c.Set(ctx, "c", "3", time.Minute); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if _, ok, _ := c.Get(ctx, "b"); ok {
		t.Fatalf("expected b to be evicted")
	}
	if _, ok, _ := c.Get(ctx, "a"); !ok {
		t.Fatalf("expected a to remain in cache")
	}
	if _, ok, _ := c.Get(ctx, "c"); !ok {
		t.Fatalf("expected c to be present")
	}
}

func TestInMemoryCache_MaxMemory(t *testing.T)

{
	ctx := context.Background()
	c := NewInMemory[string](WithMaxMemory[string](20))
	defer c.Close()

	c.Set(ctx, "k1", "12345", time.Minute)
	c.Set(ctx, "k2", "12345", time.Minute)
	c.Set(ctx, "k3", "12345", time.Minute)

	if c.GetCurrentMemory() != 15 {
		t.Fatalf("expected 15 bytes, got %d", c.GetCurrentMemory())
	}

	c.Set(ctx, "k4", "1234567890", time.Minute)

	if _, ok, _ := c.Get(ctx, "k1"); ok {
		t.Fatalf("expected k1 to be evicted due to memory pressure")
	}
	if _, ok, _ := c.Get(ctx, "k4"); !ok {
		t.Fatalf("expected k4 to be present")
	}

	mem := c.GetCurrentMemory()
	if mem > 20 {
		t.Fatalf("memory usage %d exceeds limit 20", mem)
	}
}

func TestAdaptiveSwitch(t *testing.T)

{
	ctx := context.Background()
	c := New[int](WithStrategy[int](AdaptiveStrategy))
	ac, ok := c.(*AdaptiveCache[int])
	if !ok {
		t.Fatalf("expected AdaptiveCache")
	}
	defer ac.Close()
	for i := 0; i < 150; i++ {
		key := fmt.Sprintf("k%d", i)
		c.Get(ctx, key)
	}
	if !ac.useLFU.Load() {
		t.Fatalf("expected adaptive cache to switch to LFU")
	}
}

func TestTTLOptionsAdjust(t *testing.T)

{
	now := time.Now()
	opts := TTLOptions{
		FreqThreshold: 10 * time.Millisecond,
		Increment:     5 * time.Millisecond,
		Decrement:     3 * time.Millisecond,
		MinTTL:        4 * time.Millisecond,
		MaxTTL:        20 * time.Millisecond,
	}

	t.Run("increment", func(t *testing.T) {
		ttl := opts.Adjust(10*time.Millisecond, now.Add(-5*time.Millisecond), now)
		if ttl != 15*time.Millisecond {
			t.Fatalf("expected 15ms, got %v", ttl)
		}
	})

	t.Run("decrement", func(t *testing.T) {
		ttl := opts.Adjust(15*time.Millisecond, now.Add(-20*time.Millisecond), now)
		if ttl != 12*time.Millisecond {
			t.Fatalf("expected 12ms, got %v", ttl)
		}
	})

	t.Run("sliding", func(t *testing.T) {
		opts.Sliding = true
		ttl := opts.Adjust(12*time.Millisecond, now.Add(-5*time.Millisecond), now)
		if ttl != 17*time.Millisecond {
			t.Fatalf("expected 17ms, got %v", ttl)
		}
		if !opts.Sliding {
			t.Fatalf("expected sliding to remain enabled")
		}
	})
}