package com.walker.cache;

import com.walker.cache.tree.CacheTree;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 应用系统缓存管理器默认实现
 * @author shikeying
 *
 */
public final class SimpleCacheManager {

	private static final transient Logger logger = LoggerFactory.getLogger(SimpleCacheManager.class);

	private static boolean initialized = false;

	private static final Object lock = new Object();

	private static final Map<Class<?>, CacheProvider<?>> cacheProvidersMap = new ConcurrentHashMap<Class<?>, CacheProvider<?>>();
	// 2023-01-04 能通过 CacheProvider.getProviderName() 获取到缓存对象
	private static final Map<String, CacheProvider<?>> cacheProvidersNameMap = new ConcurrentHashMap<String, CacheProvider<?>>();

	private SimpleCacheManager(){}

//	/**
//	 * 返回系统配置参数缓存对象提供者
//	 * @return
//	 */
//	@SuppressWarnings("unchecked")
//	public static final CacheProvider<PreferenceEntity> getPreferenceCacheProvider(){
//		CacheProvider<?> cp = cacheProvidersMap.get(PreferenceEntity.class);
//		if(cp == null) return null;
//		if(cp.getProviderType() == PreferenceEntity.class){
//			return (CacheProvider<PreferenceEntity>)cp;
//		} else
//			throw new RuntimeException("preferenceCache must be type of " + PreferenceEntity.class.getName());
//	}

	/**
	 * 根据缓存对象提供者名字，返回缓存对象。
	 * @param cacheProviderName
	 * @return
	 * @date 2023-01-04
	 */
	public static final CacheProvider<?> getCacheProvider(String cacheProviderName){
		CacheProvider<?> cp = cacheProvidersNameMap.get(cacheProviderName);
		if(cp == null)
			throw new NullPointerException("not found cacheProvider: " + cacheProviderName);
		return cp;
	}

	/**
	 * 返回缓存提供者
	 * @param clazz 对应实体类型，如：<code>PreferenceEntity.class</code>
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static final <T> CacheProvider<T> getCacheProvider(Class<T> clazz){
		CacheProvider<?> cp = cacheProvidersMap.get(clazz);
		if(cp == null)
			throw new NullPointerException("not found cacheProvider: " + clazz.getName());
		return (CacheProvider<T>)cp;
	}

	/**
	 * 返回缓存树提供者对象
	 * @param clazz 对应实体类型，如：<code>CodeEntity.class</code>
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static final <T> CacheTree<T> getCacheTreeProvider(Class<T> clazz){
		CacheProvider<?> cp = getCacheProvider(clazz);
		if(CacheTree.class.isAssignableFrom(cp.getClass())){
			return (CacheTree<T>)cp;
		}
		throw new UnsupportedOperationException(clazz.getName() + " is not a CacheTree!");
	}

	/**
	 * 返回系统定义的所有缓存对象。如果不存返回<code>null</code>
	 * @return
	 */
	@Deprecated
	public static final Collection<CacheProvider<?>> getCacheProviders(){
		if(cacheProvidersMap.size() == 0)
			return null;
		return cacheProvidersMap.values();
	}

	/**
	 * 获得所有缓存提供者对象集合，该方法替代：{@linkplain SimpleCacheManager#getCacheProviders()}
	 * @return
	 * @date 2023-08-27
	 */
	public static final List<CacheProvider<?>> getCacheProviderList(){
		List<CacheProvider<?>> data = new ArrayList<>();
		for(CacheProvider<?> cp : cacheProvidersNameMap.values()){
			data.add(cp);
		}
		return data;
	}

	public void setCacheProviders(List<CacheProvider<?>> cacheProviders){
		if(cacheProviders == null) return;
		if(!initialized){
			synchronized (lock) {
				try{
					// 在这里初始化所有缓存对象
					for(CacheProvider<?> cp : cacheProviders){
//						registeredCaches.put(cp.getProviderName(), cp.getCache());
						cacheProvidersMap.put(cp.getProviderType(), cp);
						cacheProvidersNameMap.put(cp.getProviderName(), cp);
					}
					initialized = true;

				} catch(Throwable cause){
					throw new Error("初始化系统缓存失败。", cause);
				}
			}
		}
	}

	/**
	 * 向缓存管理器中添加（注册）一个缓存对象
	 * @param cacheProvider
	 * @return 注册成功返回<code>true</code>
	 */
	public static final boolean addCacheProvider(CacheProvider<?> cacheProvider){
		assert (cacheProvider != null);
//		CacheProvider<?> cache = cacheProvidersMap.get(cacheProvider.getProviderType());
		if(!cacheProvidersMap.containsKey(cacheProvider.getProviderType())){
			cacheProvidersMap.put(cacheProvider.getProviderType(), cacheProvider);
			cacheProvidersNameMap.put(cacheProvider.getProviderName(), cacheProvider);
			return true;
		} else {
//			throw new IllegalStateException("cache already exist, can't add repeatly: " + cacheProvider.getProviderName());
			cacheProvidersNameMap.put(cacheProvider.getProviderName(), cacheProvider);
			logger.debug("已经存在了缓存对象，不能重复注册: " + cacheProvider.getProviderType() + ", cacheName=" + cacheProvider.getProviderName());
			return false;
		}
	}
}