package com.walker.cache.tree;

import com.walker.cache.AbstractCacheProvider;
import com.walker.cache.Cachable;
import com.walker.cache.Cache;
import com.walker.infrastructure.utils.StringUtils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public abstract class AbstractCacheTreeProvider<T> extends AbstractCacheProvider<T>
		implements CacheTree<T> {

	public static final String SUPER_ROOT_KEY = "cacheTree_super_root_key";
		
	@Override
	public List<String> getRootKeys() {
//		CacheTreeNode node = (CacheTreeNode)this.getCacheData(SUPER_ROOT_KEY);
		CacheTreeNode node = this.get(SUPER_ROOT_KEY);
		if(node != null){
			Collection<CacheTreeNode> rootList = node.getChildren();
			if(rootList == null || rootList.size() == 0){
				return null;
			}
			List<String> result = new ArrayList<String>(rootList.size());
			if(rootList != null){
				for(Iterator<CacheTreeNode> i = rootList.iterator(); i.hasNext();)
					result.add(i.next().getKey());
				return result;
			}
		}
		return null;
	}

	@Override
	public Collection<CacheTreeNode> getRootList() {
//		CacheTreeNode node = (CacheTreeNode)this.getCacheData(SUPER_ROOT_KEY);
		CacheTreeNode node = this.get(SUPER_ROOT_KEY);
		if(node != null){
			return node.getChildren();
		}
		return null;
	}

	@Override
	public CacheTreeNode getOneRootNode(String key) {
		return searchTreeNode(key);
	}

	@Override
	public CacheTreeNode searchTreeNode(String key) {
		assert (StringUtils.isNotEmpty(key));
//		CacheTreeNode node = (CacheTreeNode)this.getCacheData(SUPER_ROOT_KEY);
		CacheTreeNode node = this.get(SUPER_ROOT_KEY);
		if(node != null){
			return node.search(key);
		}
		return null;
	}
	
	public List<CacheTreeNode> searchTreeNodeList(String keyLike){
		CacheTreeNode node = this.get(SUPER_ROOT_KEY);
		if(node != null){
//			String[] keys = StringUtils.stringToArray(keyLike, " ");
//			if(keys != null && keys.length > 1){
//				if(logger.isDebugEnabled()){
//					logger.debug("搜索树，查询条件有多个：" + keys.length);
//					for(String s : keys){
//						logger.debug(s);
//					}
//				}
//				return node.searchLike(keys);
//			} else {
//				return node.searchLike(keyLike);
//			}
			return node.searchLike(keyLike);
		}
		return null;
	}
	
	public List<CacheTreeNode> searchTreeNodeList(String[] keys){
		CacheTreeNode node = this.get(SUPER_ROOT_KEY);
		if(node != null){
			return node.searchLike(keys);
		}
		return null;
	}

	@Override
	protected int loadDataToCache(Cache cache) {
		try{
			Map<String, CacheTreeNode> rootMap = loadRootList();
			if(rootMap == null || rootMap.size() == 0){
				logger.info("no root cache loaded in '" + this.getProviderName() + "'.");
				cache.put(SUPER_ROOT_KEY, createSuperRoot());
				return 0;
			}
			
			/* 加载其他子节点集合，这些不是树结构，都是平级的子对象，需要组装成树 */
			Map<String, CacheTreeNode> childMap = loadChildList();
			addListToCache(rootMap.values().iterator(), cache);
			
			if(childMap != null && childMap.size() > 0){
				mountTree(childMap, cache);
			}
			
			/* 把之前多个根节点删除，合并为一个超根节点 */
			CacheTreeNode superRoot = createSuperRoot();
			for(Iterator<Cachable> i = cache.getIterator(); i.hasNext();){
				superRoot.addChild((CacheTreeNode)(i.next().getValue()));
			}
			cache.clear();
			cache.put(SUPER_ROOT_KEY, superRoot);
			
			int total = rootMap.size();
			
			/* 把所有加载过的业务数据以列表平铺的形式放入缓存，可以分别使用 */
			addListToCache(rootMap.values().iterator(), cache);
			if(childMap != null){
				addListToCache(childMap.values().iterator(), cache);
				total += childMap.size();
			}
			
			return total;
			
		} catch(Exception ex){
			throw new Error("failed to loading user cache:" + this.getProviderName(), ex);
		}
	}
	
	private CacheTreeNode createSuperRoot(){
		return new DefaultCacheTreeNode(SUPER_ROOT_KEY, "superRoot", null, null);
	}
	
	private void mountTree(Map<String, CacheTreeNode> childMap, Cache cache){
		CacheTreeNode _node = null;
		for(Iterator<CacheTreeNode> i = childMap.values().iterator(); i.hasNext();){
			_node = i.next();
			mountMiddleNode(_node, childMap, cache);
		}
	}
	
	private void mountMiddleNode(CacheTreeNode currentNode
			, Map<String, CacheTreeNode> childMap, Cache cache){
//		logger.debug("-------------> cache = " + cache);
//		logger.debug("-------------> currentNode = " + currentNode);
		CacheTreeNode _parentNode = (CacheTreeNode)cache.get(currentNode.getParentId());
		if(_parentNode == null){
			// 没有找到上级根节点，说明是比较靠下的子节点
			_parentNode = childMap.get(currentNode.getParentId());
			if(_parentNode == null)
				throw new NullPointerException("parent node not found, current: " + currentNode);
			_parentNode.addChild(currentNode);
			mountMiddleNode(_parentNode, childMap, cache);
		} else if(parentIsRoot(_parentNode.getParentId())) {
			// 父对象是根节点
			_parentNode.addChild(currentNode);
//			logger.debug("找到了挂在root下的子节点：" + _parentNode);
		}
	}
	
	private void addListToCache(Iterator<CacheTreeNode> iterator, Cache cache){
		for(Iterator<CacheTreeNode> i = iterator; i.hasNext();)
			addObjectToCache(i.next(), cache);
	}
	private void addObjectToCache(CacheTreeNode node, Cache cache){
		assert (node != null && node.getSource() != null);
		cache.put(node.getKey(), node);
	}

	/**
	 * 从业务中加载根节点，即：第一级节点所有数据。</p>
	 * 注意：在树结构中，没有默认的根节点，第一级节点会存在多个，</br>
	 * 也可以认为存在多个根节点。
	 * @return
	 */
	protected abstract Map<String, CacheTreeNode> loadRootList();
	
	/**
	 * 从业务中加载处了第一级节点之外的所有其他节点数据。</p>
	 * 加载的方式由子类实施各种策略，如：大批量的分段加载等。</br>
	 * 这些集合中的对象不是树结构，只要返回包装为<code>CacheTreeNode</code>类型对象即可。</br>
	 * 由系统负责对树的组装。
	 * @return
	 */
	protected abstract Map<String, CacheTreeNode> loadChildList();
	
	/**
	 * 把实体对象转换成<code>CacheTreeNode</code>,由最终业务实现。
	 * @param entity
	 * @return
	 */
	protected abstract CacheTreeNode toCacheTreeNode(T entity);
	
	@Override
	public void putCacheData(String key, T data){
		CacheTreeNode node = toCacheTreeNode(data);
		if(node == null)
			throw new AbstractMethodError();
		CacheTreeNode vRoot = this.get(SUPER_ROOT_KEY);
		if(vRoot != null){
			if(StringUtils.isEmpty(node.getParentId()) || parentIsRoot(node.getParentId()))
				vRoot.addChild(node); // 如果没有上级信息，就加入到虚拟根下边。
			else {
				CacheTreeNode _parent = vRoot.search(node.getParentId());
				if(_parent != null){
					_parent.addChild(node);
				} else
					throw new NullPointerException("not found parent in node: " + node);
			}
		} else {
			// 不存在虚拟根节点，说明是第一个元素
			throw new NullPointerException("not found virtual Root in '" + getProviderName() + "'.");
		}
		getCache().put(key, node);
	}
	
	@Override
	public void removeCacheData(String key) {
		// TODO Auto-generated method stub
		getCache().remove(key);
//		CacheTreeNode vRoot = (CacheTreeNode)this.getCacheData(SUPER_ROOT_KEY);
		CacheTreeNode vRoot = this.get(SUPER_ROOT_KEY);
		if(vRoot != null){
			if(StringUtils.isNotEmpty(key)){
				CacheTreeNode removed = vRoot.remove(key);
				logger.debug("removed CacheTreeNode: " + removed);
			}
		}
	}
	
	@Override
	public void updateCacheData(String key, T data) {
		// TODO Auto-generated method stub
		assert (StringUtils.isNotEmpty(key));
		assert (data != null);
		CacheTreeNode node = toCacheTreeNode(data);
		if(node == null)
			throw new AbstractMethodError();
		getCache().replace(key, node);
//		CacheTreeNode vRoot = (CacheTreeNode)this.getCacheData(SUPER_ROOT_KEY);
		CacheTreeNode vRoot = this.get(SUPER_ROOT_KEY);
		if(vRoot != null){
			CacheTreeNode oldNode = vRoot.search(key);
			if(oldNode != null){
				oldNode.cloneProperties(node);
			}
		}
	}
	
	@SuppressWarnings("unchecked")
	@Override
	public T getCacheData(String key) {
		assert (StringUtils.isNotEmpty(key));
		CacheTreeNode node = get(key);
		if(node != null && node.getSource() != null){
			return (T)node.getSource();
		}
//		throw new RuntimeException("not found source in CacheTreeNode, not Class T in getCacheData().");
		return null;
	}
	
	@Override
	public CacheTreeNode get(String key){
		return (CacheTreeNode)getCache().get(key);
//		if(node == null)
//			throw new NullPointerException("not found cache data: " + key);
//		return node;
	}
	
	/**
	 * 根据上级ID判断上级节点是否根节点，通常根节点为0或root表示。
	 * @param parentId
	 * @return
	 */
	private boolean parentIsRoot(String parentId){
		if(parentId.equalsIgnoreCase(ROOT_FLAG_NAME) || parentId.equals(ROOT_FLAG_ZERO))
			return true;
		return false;
	}
}