Cross-Game Transfers Overview

// Cache destination games data
public class TransferDestinationsCache : MonoBehaviour
{
    private const string CACHE_KEY = "transfer_destinations";
    private const string CACHE_TIME_KEY = "destinations_cached_at";
    private const int CACHE_DURATION_HOURS = 24;

    [System.Serializable]
    public class DestinationsData
    {
        public string status;
        public string source_game_name;
        public string universal_transfers;
        public GameDestination[] available_games;
        public int total_destinations;
    }

    public void CacheDestinations(DestinationsData data)
    {
        string json = JsonUtility.ToJson(data);
        PlayerPrefs.SetString(CACHE_KEY, json);
        PlayerPrefs.SetString(CACHE_TIME_KEY, System.DateTime.Now.ToBinary().ToString());
        PlayerPrefs.Save();
        Debug.Log(
quot;Cached {data.total_destinations} transfer destinations");
    }

    public DestinationsData GetCachedDestinations()
    {
        if (!PlayerPrefs.HasKey(CACHE_KEY)) return null;
        
        // Check if cache is expired
        if (IsCacheExpired())
        {
            Debug.Log("Destinations cache expired, refreshing...");
            RefreshDestinations();
            return null;
        }

        string json = PlayerPrefs.GetString(CACHE_KEY);
        return JsonUtility.FromJson<DestinationsData>(json);
    }

    private bool IsCacheExpired()
    {
        if (!PlayerPrefs.HasKey(CACHE_TIME_KEY)) return true;
        
        long cacheTicks = System.Convert.ToInt64(PlayerPrefs.GetString(CACHE_TIME_KEY));
        System.DateTime cacheTime = System.DateTime.FromBinary(cacheTicks);
        
        return (System.DateTime.Now - cacheTime).TotalHours > CACHE_DURATION_HOURS;
    }

    public void RefreshDestinations()
    {
        StartCoroutine(FetchDestinationsFromAPI());
    }

    private IEnumerator FetchDestinationsFromAPI()
    {
        // Call the available-destinations API here
        // Cache the result using CacheDestinations()
    }
}

class TransferDestinationsCache {
    constructor() {
        this.CACHE_KEY = 'invo_transfer_destinations';
        this.CACHE_TIME_KEY = 'invo_destinations_cached_at';
        this.CACHE_DURATION_HOURS = 24;
    }

    async getDestinations(gameId, secretKey) {
        // Try to get from cache first
        const cached = this.getCachedDestinations();
        if (cached) {
            console.log('Using cached transfer destinations');
            return cached;
        }

        // Cache miss or expired, fetch from API
        console.log('Fetching fresh transfer destinations...');
        return await this.fetchAndCacheDestinations(gameId, secretKey);
    }

    getCachedDestinations() {
        const cachedData = localStorage.getItem(this.CACHE_KEY);
        const cacheTime = localStorage.getItem(this.CACHE_TIME_KEY);
        
        if (!cachedData || !cacheTime) return null;

        // Check if expired
        const now = new Date().getTime();
        const cached = new Date(parseInt(cacheTime)).getTime();
        const hoursOld = (now - cached) / (1000 * 60 * 60);
        
        if (hoursOld > this.CACHE_DURATION_HOURS) {
            console.log('Cache expired, need fresh data');
            return null;
        }

        return JSON.parse(cachedData);
    }

    async fetchAndCacheDestinations(gameId, secretKey) {
        try {
            const response = await fetch('/api/transfers/available-destinations', {
                method: 'POST',
                headers: {
                    'X-Game-Secret-Key': secretKey,
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ source_game_id: gameId })
            });

            const data = await response.json();
            
            if (data.status === 'success') {
                // Cache the successful response
                localStorage.setItem(this.CACHE_KEY, JSON.stringify(data));
                localStorage.setItem(this.CACHE_TIME_KEY, new Date().getTime().toString());
                console.log(`Cached ${data.total_destinations} destinations`);
            }

            return data;
        } catch (error) {
            console.error('Failed to fetch destinations:', error);
            throw error;
        }
    }

    clearCache() {
        localStorage.removeItem(this.CACHE_KEY);
        localStorage.removeItem(this.CACHE_TIME_KEY);
    }
}

// Usage example
const cache = new TransferDestinationsCache();
const destinations = await cache.getDestinations('123456789012', 'your_secret_key');