package com.walker.support.redis.cache;

import com.walker.cache.AbstractCacheProvider;
import com.walker.cache.Cache;
import com.walker.infrastructure.utils.StringUtils;
import com.walker.support.redis.RedisHelper;

import java.util.Map;

/**
 * Redis方式缓存提供者实现
 * @author shikeying
 *
 * @param <T>
 */
public abstract class RedisCacheProvider<T> extends AbstractCacheProvider<T> {

	private RedisHelper redisHelper;

	public void setRedisHelper(RedisHelper redisHelper) {
		this.redisHelper = redisHelper;
	}

	@Override
	protected Cache provideCacheInstance(String name, Map<String, String> param){
//		RedisCache cache = null;
		if(this.isUseRedis()){
			RedisCache cache = new RedisCache(name, param);
			cache.setRedisHelper(this.redisHelper);
			cache.setSupportExpiredCache(this.supportExpiredCache);	// 2024-01-05
			return cache;
		} else {
			return super.provideCacheInstance(name, param);
		}
	}

	@Override
	public void destroy() throws Exception {
		if(!this.isUseRedis()){
			// 本地缓存
//			if(userCache != null)
//				userCache.clear();
			super.destroy();
		} else {
			// redis 缓存，先清空，2023-08-26
			// 这里不能清空，否则，系统停止时会调用该方法，让redis磁盘中数据清空！ 2023-09-02
//			userCache.clear();
		}
	}

	@Override
	protected int loadDataToCache(Cache cache) {
		return 0;
	}

	@Override
	public T getCacheData(String key) {
		if(this.isUseRedis()){
			return (T)getRedisCache().get(key, getProviderType());
		} else {
			return super.getCacheData(key);
		}
	}

	protected RedisCache getRedisCache(){
		return (RedisCache)this.getCache();
	}

	@Override
	public long getCacheCount(){
		if(this.isUseRedis()){
			return getRedisCache().getPersistentSize();
		} else {
			return super.getCacheCount();
		}
	}

	@Override
	public void removeCacheData(String key) {
		if(this.isUseRedis()){
			getRedisCache().remove(key);
		} else {
			super.removeCacheData(key);
		}
	}

	@Override
	public void updateCacheData(String key, T data) {
		if(this.isUseRedis()){
			getRedisCache().replace(key, data);
		} else {
			super.updateCacheData(key, data);
		}
	}

	@Override
	public void putCacheData(String key, T data){
		if(this.isUseRedis()){
			getRedisCache().put(key, data);
		} else {
			super.putCacheData(key, data);
		}
	}

	/**
	 * 添加支持数据过期的缓存方法。
	 * @param key
	 * @param data
	 * @param expiredSeconds 过期秒数
	 * @date 2022-11-13
	 */
	@Override
	public void putCacheData(String key, T data, long expiredSeconds){
		assert (StringUtils.isNotEmpty(key));
		assert (data != null);
		assert(expiredSeconds > 0);
		if(this.isUseRedis()){
			getRedisCache().put(key, data, expiredSeconds);
		} else {
			super.putCacheData(key, data, expiredSeconds);
		}
	}

	@Override
	public void reload() throws Exception{
		if(this.isUseRedis()){
//			destroy();
//			afterPropertiesSet();
			// 2023-09-04 目前redis重新加载机制和本地缓存一样，都要删除原有缓存数据。
			super.reload();
		} else {
			super.reload();
		}
	}

	/**
	 * 缓存对象不再需要单独根下面的独立的key方式。
	 * @param key
	 * @return
	 * @date 2024-01-05
	 */
	@Deprecated
	public String getRedisRootData(String key){
		return getRedisCache().getRootData(key);
	}

	public boolean isSupportExpiredCache() {
		return supportExpiredCache;
	}

	/**
	 * 设置是否支持缓存失效，因为redis失效是针对key，因此HashMap方式是作为整体失效的！
	 * <pre>
	 *     1) 默认不支持缓存失效，此时使用Map方式存储数据
	 *     2) 当设置运行失效时，必须采用字符串形式的数据结构
	 *     3) 该选项只对hashmap数据结构有效。
	 * </pre>
	 * @param supportExpiredCache
	 * @date 2024-01-05
	 */
	public void setSupportExpiredCache(boolean supportExpiredCache) {
		this.supportExpiredCache = supportExpiredCache;
	}

	private boolean supportExpiredCache = false;
}