package com.infoloop.tianting.cache;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.Cache;

import java.util.concurrent.Callable;

/**
 * Spring Cache适配器
 * 将Spring Cache接口桥接到现有的MultiLevelCacheService
 */
@Slf4j
public class SpringCacheAdapter implements Cache {

    private final String name;
    private final CacheService cacheService;
    private final int defaultTtl;

    public SpringCacheAdapter(String name, CacheService cacheService, int defaultTtl) {
        this.name = name;
        this.cacheService = cacheService;
        this.defaultTtl = defaultTtl;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Object getNativeCache() {
        return cacheService;
    }

    @Override
    public ValueWrapper get(Object key) {
        if (key == null) {
            return null;
        }
        
        String cacheKey = generateCacheKey(key);
        Object value = cacheService.get(cacheKey);
        
        if (value != null) {
            log.debug("Spring Cache命中: cache={}, key={}", name, cacheKey);
            return () -> value;
        }
        
        log.debug("Spring Cache未命中: cache={}, key={}", name, cacheKey);
        return null;
    }

    @Override
    public <T> T get(Object key, Class<T> type) {
        ValueWrapper wrapper = get(key);
        if (wrapper == null) {
            return null;
        }
        
        Object value = wrapper.get();
        if (value == null) {
            return null;
        }
        
        if (type.isInstance(value)) {
            return type.cast(value);
        }
        
        throw new IllegalStateException("Cached value is not of required type [" + type.getName() + "]: " + value);
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T get(Object key, Callable<T> valueLoader) {
        ValueWrapper wrapper = get(key);
        if (wrapper != null) {
            return (T) wrapper.get();
        }
        
        // 缓存未命中，执行valueLoader
        try {
            T value = valueLoader.call();
            put(key, value);
            return value;
        } catch (Exception e) {
            throw new RuntimeException("ValueLoader execution failed", e);
        }
    }

    @Override
    public void put(Object key, Object value) {
        if (key == null) {
            return;
        }
        
        String cacheKey = generateCacheKey(key);
        cacheService.put(cacheKey, value, defaultTtl);
        log.debug("Spring Cache设置: cache={}, key={}, ttl={}s", name, cacheKey, defaultTtl);
    }

    @Override
    public void evict(Object key) {
        if (key == null) {
            return;
        }
        
        String cacheKey = generateCacheKey(key);
        cacheService.delete(cacheKey);
        log.debug("Spring Cache清除: cache={}, key={}", name, cacheKey);
    }

    @Override
    public void clear() {
        // 清空整个缓存区域
        cacheService.deleteByPattern(name + ":*");
        log.debug("Spring Cache清空: cache={}", name);
    }

    /**
     * 生成缓存key
     * 格式: cacheName:key
     */
    private String generateCacheKey(Object key) {
        return name + ":" + key.toString();
    }
}