package com.walker.cache;

import com.walker.db.page.GenericPager;
import com.walker.infrastructure.utils.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.FactoryBean;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 抽象的缓存对象提供者。</p>
 * 每个应用缓存对象都需要实现一个此对象，如：用户缓存、参数缓存等。
 * @author shikeying
 *
 * @param <T>
 */
public abstract class AbstractCacheProvider<T> implements CacheProvider<T>, FactoryBean<CacheProvider<T>> {

	protected static Logger logger = LoggerFactory.getLogger(AbstractCacheProvider.class);

	protected Cache userCache = null;

	// 加载的缓存总记录数
	protected AtomicLong count = new AtomicLong(0);

	// 是否支持分页加载（初始化缓存）
	private boolean loadPage = false;

	private int pageSize = 128;

	private long createTime = 0;

	private Map<String, String> cacheParam = null;
	private boolean useRedis = false;

	public boolean isUseRedis() {
		return useRedis;
	}

	public void setUseRedis(boolean useRedis) {
		this.useRedis = useRedis;
	}

	@Override
	public Map<String, String> getCacheParam() {
		return cacheParam;
	}

	public void setCacheParam(Map<String, String> cacheParam) {
		this.cacheParam = cacheParam;
	}

	@Override
	public long getCreateTime() {
		return createTime;
	}

	@Override
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	@Override
	public boolean isLoadPage() {
		return loadPage;
	}

	@Override
	public void setLoadPage(boolean loadPage) {
		this.loadPage = loadPage;
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		if(getProviderType() == null)
			throw new AbstractMethodError("getProviderType() must be enforced!");
		String name = getProviderName();
		if(StringUtils.isEmpty(name)){
			name = String.valueOf(System.currentTimeMillis());
		}
		if(userCache != null){
			// 2023-08-26
			userCache = null;
		}
//			userCache = new RigidMemoryCache(name);
		// 这里修改，使用用户自定义的缓存对象实例 2016-11-17
		userCache = provideCacheInstance(name, getCacheParam());
		this.createTime = System.currentTimeMillis();

		if(isUseRedis()){
			// 2023-06-14 让具体子类实现去加载，因为可能存在持久化数据变动，因此让业务决定如何重新加载!
			// 如果是基于数据库的缓存，如：redis，并且库中已经存在数据，就不需要初始化进去
//				long dbSize = this.size();
//				if(dbSize > 0){
//					logger.info("缓存'"+name+"'基于数据库缓存，而且已经存在数据，因此不再初始化加载");
//					return;
//				}
		}

		if(this.loadPage){
			// 分页加载数据
			GenericPager<T> firstPage = this.loadPageDataToCache(userCache, 1, pageSize);
			if(firstPage == null){
				logger.info("...... 未加载到任何业务数据作为缓存，第一页空：" + this.getProviderName());
				return;
			}

			count.set(firstPage.getTotalRows());
			if(count.get() > 0){
				int pageCount = firstPage.getPageCount();
				logger.info("缓存 '" + this.getProviderName() + "' 数据分页 = " + pageCount);
				if(pageCount > 1){
					// pageCount = 2 or 3/4/5...
					for(int i=2; i<pageCount+1; i++){
						this.loadPageDataToCache(userCache, i, pageSize);
						logger.debug("......... 加载了一次缓存数据：" + i);
					}
				}
			}

		} else {
			// 一次全部加载，只针对小数据量情况
			count.set(loadDataToCache(userCache));
		}
		logger.info("cache '" + name + "' loaded size of datas: " + count);
	}

	/**
	 * 提供一个缓存对象实例，默认会返回一个内存管理的hashmap缓存实例。</p>
	 * 如果业务要使用自定义如：redis，请覆盖该方法。
	 * @param param
	 * @return
	 */
	protected Cache provideCacheInstance(String name, Map<String, String> param){
		return new RigidMemoryCache(name);
	}

	/**
	 * 由应用系统加载持久化数据到缓存对象中，如下：
	 * <pre>
	 * List<T> list = getResultFromDB();
	 * for(T data : list){
	 * 	cache.put(data.getId(), data);
	 * }
	 * </pre>
	 * @param cache
	 * @return
	 */
	protected abstract int loadDataToCache(Cache cache);

	/**
	 * 分页加载数据到缓存中
	 * @param cache
	 * @param pageIndex
	 * @param pageSize
	 * @return
	 */
	protected GenericPager<T> loadPageDataToCache(Cache cache, int pageIndex, int pageSize){
		return null;
	}

	@Override
	public void destroy() throws Exception {
		if(userCache != null){
			// 这里不能在销毁时擦除数据，否则redis实现会直接删除磁盘缓存数据！2023-09-02
//			userCache.clear();
		}
	}

	@Override
	public Cache getCache() {
		if(userCache == null)
			throw new NullPointerException("not found cache: " + getProviderName());
		return userCache;
	}

	@SuppressWarnings("unchecked")
	@Override
	public T getCacheData(String key) {
		assert (StringUtils.isNotEmpty(key));
		return (T)userCache.get(key);
	}

	@Override
	public long getCacheCount(){
		return count.get();
	}

	@Override
	public void removeCacheData(String key) {
		userCache.remove(key);
		count.decrementAndGet();
		if(count.get() < 0){
			count.set(0);
		}
	}

	@Override
	public void updateCacheData(String key, T data) {
		assert (StringUtils.isNotEmpty(key));
		assert (data != null);
		userCache.replace(key, data);
	}

	@Override
	public void putCacheData(String key, T data){
		assert (StringUtils.isNotEmpty(key));
		assert (data != null);
		userCache.put(key, data);
		count.incrementAndGet();
	}

	@Override
	public void putCacheData(String key, T data, long expiredSeconds){
		assert (StringUtils.isNotEmpty(key));
		assert (data != null);
		assert(expiredSeconds > 0);
		userCache.put(key, data, expiredSeconds);
		// 带有时间期限的数据，不再记录累加数据量(这样无意义)
	}

	public String toString(){
		return new StringBuilder().append("cacheName = ").append(getProviderName())
				.append(", cache = ").append(userCache).toString();
	}

	@Override
	public void reload() throws Exception{
//		destroy();
		if(userCache != null) {
			// 2023-09-04 重新加载时，原有缓存会被擦出，redis中的也会被删除！
			userCache.clear();
			userCache = null;
		}
		afterPropertiesSet();
	}

	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// 修改时间：2014-11-24
	// 作者：shikeying
	// 描述：把cacheProvider改成FactoryBean对象，这样就会优先比其他bean提早初始化。
	// 以下为修改后，需要实现的方法
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


	@Override
	public CacheProvider<T> getObject() throws Exception {
		logger.debug("............通过CacheProviderFactoryBean获得缓存对象: " + this.getProviderName());
		SimpleCacheManager.addCacheProvider(this);
		return this;
	}

	@Override
	public Class<?> getObjectType() {
		return CacheProvider.class;
	}

	@Override
	public boolean isSingleton() {
		return true;
	}

	@Override
	public long size(){
		return this.userCache.size();
	}

	/**
	 * 返回给定限制的缓存数据集合
	 * @param maxSize 限制的最大数量
	 * @return
	 */
	@Override
	public Collection<Object> queryListLimit(int maxSize){
		return this.userCache.queryListLimit(maxSize);
	}

	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	//~ 集合操作方法，是用集合就不能重复使用Map方式了!!!
	//~ 2023-06-13 操作集合，但目前没有使用，感觉删除整个集合还比较麻烦。
	//~ 2023-06-14 确定使用该对象，并测试结果。
	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	@Override
	public void putCacheList(String key, List<T> data){
		this.putCacheList(key, data, 0);
	}

	@Override
	public void putCacheList(String key, List<T> data, long expiredSeconds){
		if(StringUtils.isEmptyList(data)){
			throw new IllegalArgumentException("list is required!");
		}
		if(StringUtils.isEmpty(key)){
			throw new IllegalArgumentException("key is required!");
		}
		this.userCache.putList(key, (List<Object>)data, expiredSeconds);
	}

	@Override
	public void putCacheListAppend(String key, T data){
		this.checkKey(key, data);
		this.userCache.putListAppend(key, data);
	}

	@Override
	public List<T> getCacheList(String key){
		if(StringUtils.isEmpty(key)){
			throw new IllegalArgumentException("key is required!");
		}
		return (List<T>)this.userCache.getList(key, 0, -1, getProviderType());
	}

	@Override
	public void removeCacheList(String key, T data){
		this.userCache.removeList(key, data);
	}

	@Override
	public void removeCacheList(String key){
		this.userCache.removeList(key);
	}
	private void checkKey(String key, T data){
		if(data == null){
			throw new IllegalArgumentException("data is required!");
		}
		if(StringUtils.isEmpty(key)){
			throw new IllegalArgumentException("key is required!");
		}
	}
}