go-eve-pi/esi/cached.go

package esi

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"os"
	"time"

	"go-eve-pi/options"
	"go-eve-pi/types"

	logger "git.site.quack-lab.dev/dave/cylogger"
)

type CacheDB interface {
	GetCacheEntry(urlHash string) (*types.CacheEntry, error)
	SaveCacheEntry(entry *types.CacheEntry) error
}

// CachedESI implements ESIInterface with caching
type CachedESI struct {
	direct ESIInterface
	db     CacheDB
	cacheValidity time.Duration
}

// NewCachedESI creates a new CachedESI instance
func NewCachedESI(direct ESIInterface, db CacheDB) *CachedESI {
	// Parse cache validity ONCE at initialization
	cacheValidity, err := time.ParseDuration(options.GlobalOptions.CacheValidity)
	if err != nil {
		logger.Error("Invalid cache validity duration %s: %v", options.GlobalOptions.CacheValidity, err)
		os.Exit(1)
	}

	logger.Info("Initializing CachedESI with cache validity: %v", cacheValidity)
	return &CachedESI{
		direct:        direct,
		db:            db,
		cacheValidity: cacheValidity,
	}
}

// GetPlanetPI retrieves detailed information about a specific planet with caching
func (c *CachedESI) GetPlanetPI(ctx context.Context, characterID int, planetID int64, accessToken string) (*PlanetPI, error) {
	funclog := logger.Default.WithPrefix("CachedESI.GetPlanetPI").WithPrefix(fmt.Sprintf("characterID=%d", characterID)).WithPrefix(fmt.Sprintf("planetID=%d", planetID))

	url := fmt.Sprintf("/v3/characters/%d/planets/%d/", characterID, planetID)
	funclog.Info("Starting")

	fetchFunc := func() (*PlanetPI, error) {
		funclog.Info("Calling direct ESI")
		result, err := c.direct.GetPlanetPI(ctx, characterID, planetID, accessToken)
		if err != nil {
			funclog.Error("Direct ESI call failed: %v", err)
			return nil, err
		}
		if result != nil {
			funclog.Info("Direct ESI returned planet details with %d pins", len(result.Pins))
		} else {
			funclog.Info("Direct ESI returned nil planet details")
		}
		return result, nil
	}

	result, err := getCachedResponse(c, url, fetchFunc)
	if err != nil {
		funclog.Error("Failed to get planet details: %v", err)
		return nil, err
	}

	if result != nil {
		funclog.Info("Successfully retrieved planet details with %d pins", len(result.Pins))
	} else {
		funclog.Info("Successfully retrieved nil planet details")
	}
	return result, nil
}

// getCachedResponse handles caching logic with generics
func getCachedResponse[T any](c *CachedESI, url string, fetchFunc func() (T, error)) (T, error) {
	funclog := logger.Default.WithPrefix("getCachedResponse").WithPrefix(fmt.Sprintf("url=%s", url))
	// Generate cache key
	hash := sha256.Sum256([]byte(url))
	urlHash := hex.EncodeToString(hash[:])
	funclog.Debug("Generated cache key %s for URL: %s", urlHash[:8], url)

	// Check cache using the interface
	funclog.Debug("Checking cache for URL: %s", url)
	cacheEntry, err := c.db.GetCacheEntry(urlHash)
	if err == nil {
		// Check if cache is still valid
		age := time.Since(cacheEntry.CachedAt)
		if age < c.cacheValidity {
			funclog.Info("Cache HIT for URL: %s (cached %v ago, valid for %v more)", url, age, c.cacheValidity-age)
			// Parse cached response
			var result T
			if err := json.Unmarshal([]byte(cacheEntry.Response), &result); err == nil {
				funclog.Debug("Successfully unmarshaled cached response for URL: %s", url)
				return result, nil
			}
			funclog.Warning("Failed to unmarshal cached response for URL: %s: %v", url, err)
		} else {
			logger.Info("Cache EXPIRED for URL: %s (cached %v ago, validity: %v)", url, age, c.cacheValidity)
		}
	} else {
		funclog.Info("Cache MISS for URL: %s (no cache entry found): %v", url, err)
	}

	// Cache miss or invalid, fetch from API
	funclog.Info("Fetching from API for URL: %s", url)
	result, err := fetchFunc()
	if err != nil {
		funclog.Error("API fetch failed for URL: %s: %v", url, err)
		var zero T
		return zero, err
	}
	funclog.Debug("API fetch successful for URL: %s", url)

	// Store in cache
	funclog.Debug("Marshaling response for caching URL: %s", url)
	responseBytes, err := json.Marshal(result)
	if err != nil {
		funclog.Warning("Failed to marshal response for caching URL: %s: %v", url, err)
		return result, nil
	}
	funclog.Debug("Response marshaled successfully for URL: %s (%d bytes)", url, len(responseBytes))

	cacheEntry = &types.CacheEntry{
		URLHash:  urlHash,
		Response: string(responseBytes),
		CachedAt: time.Now(),
	}

	funclog.Debug("Saving cache entry for URL: %s", url)
	if err := c.db.SaveCacheEntry(cacheEntry); err != nil {
		funclog.Warning("Failed to cache response for URL: %s: %v", url, err)
	} else {
		funclog.Info("Cached response for URL: %s (valid for %v, %d bytes)", url, c.cacheValidity, len(responseBytes))
	}

	return result, nil
}

// GetPlanetName retrieves planet name with caching
func (c *CachedESI) GetPlanetName(ctx context.Context, planetID int64) (*PlanetName, error) {
	funclog := logger.Default.WithPrefix("CachedESI.GetPlanetName").WithPrefix(fmt.Sprintf("planetID=%d", planetID))
	url := fmt.Sprintf("/v1/universe/planets/%d/", planetID)
	funclog.Info("Starting")

	fetchFunc := func() (*PlanetName, error) {
		funclog.Info("Calling direct ESI for planet %d name", planetID)
		result, err := c.direct.GetPlanetName(ctx, planetID)
		if err != nil {
			funclog.Error("Direct ESI call failed for planet %d: %v", planetID, err)
			return nil, err
		}
		if result != nil {
			funclog.Info("Direct ESI returned planet name '%s' for planet %d", result.Name, planetID)
		} else {
			funclog.Info("Direct ESI returned nil planet name for planet %d", planetID)
		}
		return result, nil
	}

	result, err := getCachedResponse(c, url, fetchFunc)
	if err != nil {
		funclog.Error("Failed to get planet name for planet %d: %v", planetID, err)
		return nil, err
	}

	if result != nil {
		funclog.Info("Successfully retrieved planet name '%s' for planet %d", result.Name, planetID)
	} else {
		funclog.Info("Successfully retrieved nil planet name for planet %d", planetID)
	}
	return result, nil
}