cache_memory.go

// Copyright 2017-2026 Allow2 Pty Ltd. All rights reserved.
// Use of this source code is governed by the Allow2 API and SDK Licence.

package allow2service

import (
	"sync"
	"time"
)

// MemoryCache is an in-memory cache with TTL support.
// Thread-safe via sync.RWMutex. Suitable for testing and
// single-process deployments.
type MemoryCache struct {
	mu    sync.RWMutex
	store map[string]memoryCacheEntry
}

// memoryCacheEntry is a cached value with an expiry timestamp.
type memoryCacheEntry struct {
	value     string
	expiresAt int64
}

// NewMemoryCache creates a new MemoryCache.
func NewMemoryCache() *MemoryCache {
	return &MemoryCache{
		store: make(map[string]memoryCacheEntry),
	}
}

// Get retrieves a cached value by key.
func (c *MemoryCache) Get(key string) (string, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()

	entry, ok := c.store[key]
	if !ok {
		return "", false
	}

	if time.Now().Unix() >= entry.expiresAt {
		// Don't delete under RLock; just report miss.
		// Cleanup happens on next Set or can be done lazily.
		return "", false
	}

	return entry.value, true
}

// Set stores a value in cache with the given TTL in seconds.
func (c *MemoryCache) Set(key, value string, ttlSeconds int) {
	c.mu.Lock()
	defer c.mu.Unlock()

	c.store[key] = memoryCacheEntry{
		value:     value,
		expiresAt: time.Now().Unix() + int64(ttlSeconds),
	}
}

// Delete removes a cached value.
func (c *MemoryCache) Delete(key string) {
	c.mu.Lock()
	defer c.mu.Unlock()

	delete(c.store, key)
}