package com.walker.infrastructure.arguments;

import com.walker.infrastructure.arguments.support.DefaultVariable;
import com.walker.infrastructure.utils.StringUtils;
import com.walker.security.SystemLogMan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 抽象的参数管理器实现。
 * @author shikeying
 *
 */
public abstract class AbstractArgumentsManager implements ArgumentsManager {

	protected Logger logger = LoggerFactory.getLogger(getClass());
	
	private Object source;
	
	/* 分组集合 */
	private Map<String, Group> groupMap = new TreeMap<String, Group>();
	
	/* 变量集合与组ID映射关系：key=groupId, value=variable ID set */
	private ConcurrentHashMap<String, List<String>> variableMap = new ConcurrentHashMap<String, List<String>>(8);
	
	private ConcurrentHashMap<String, Variable> allVars = new ConcurrentHashMap<String, Variable>(32);
	
	private Object lock = new Object();
	
	@Override
	public void setSource(Object source){
		assert (source != null);
		this.source = source;
	}
	
	@Override
	public void afterPropertiesSet() throws Exception{
		SystemLogMan.getInstance().checkMan();
//		if(this.source == null){
//			throw new ArgumentsException("parameter: source is not found!");
//		}
		
		List<Group> groupList = null;
		
		try{
			groupList = load(source);
		} catch(Exception ex){
			throw new ArgumentsException("业务加载配置参数失败:" + ex.getMessage(), ex);
		}
		
		initGroup(groupList);
		
		if(logger.isDebugEnabled()){
			logger.debug("~~~~~~~~~~~~~~~~~ 系统加载所有配置参数-start ~~~~~~~~~~~~~~~~~");
			for(Variable v : allVars.values()){
				logger.debug(v.toString());
			}
			logger.debug("~~~~~~~~~~~~~~~~~ 系统加载所有配置参数-end ~~~~~~~~~~~~~~~~~");
		}
	}
	
	private void initGroup(List<Group> groupList){
		if(groupList != null){
			Collections.sort(groupList);
			for(Group g : groupList){
				groupMap.put(g.getId(), g);
				initVariableInGroup(g);
			}
		}
	}
	
	private void initVariableInGroup(Group group){
		List<Variable> varList = group.getChildren();
		if(varList != null && varList.size() > 0){
			List<String> varIds = new ArrayList<String>(8);
			for(Variable v : varList){
				allVars.put(v.getId(), v);
				varIds.add(v.getId());
			}
			variableMap.put(group.getId(), varIds);
		} else
			variableMap.put(group.getId(), null);
	}
	
	/**
	 * 加载具体的参数数据，并返回分组集合信息，分组中包含了可变参数数据。</p>
	 * 子类实现具体加载过程。
	 * @param source 输入参数，由业务设置加载数据的原始参数，如：xml文件、数据源等。
	 * @return
	 */
	protected abstract List<Group> load(Object source) throws Exception;
	
	/**
	 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	 * 
	 * 以下为系统提供的标准API
	 * 
	 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	 */
	
	@Override
	public Variable getVariable(String id) {
		assert (StringUtils.isNotEmpty(id));
		Variable var = allVars.get(id);
		if(var == null)
			throw new ElementNotFoundException("variable not found: " + id);
		return var;
	}

	@Override
	public void persist(String variableId, Object value) {
		if(groupMap.size() > 1)
			throw new ArgumentsException("存在多个分组，请调用方法: persist(String groupId, String variableId, Object value)");
		String groupId = groupMap.keySet().iterator().next();
		persist(groupId, variableId, value);
	}

	@Override
	public void persist(String groupId, String variableId, Object value) {
		assert (StringUtils.isNotEmpty(groupId));
		assert (value != null);
		
		/* 更新实体中的数据 */
		try {
			saveVariable(groupId, variableId, value);
		} catch (Exception e) {
			throw new ArgumentsException("更新可变参数到业务中出现错误: " + e.getMessage(), e);
		}
		
		synchronized (lock) {
			updateCache(groupId, variableId, value);
		}
	}
	
	private void updateCache(String groupId, String variableId, Object value){
		if(groupMap.get(groupId) == null)
			throw new IllegalArgumentException("not found group id: " + groupId);
		List<String> existVarSet = variableMap.get(groupId);
		if(existVarSet == null)
			throw new ArgumentsException("not found variable in cache: " + variableId);
		if(existVarSet.contains(variableId)){
			// 暂时先强制转换成具体对象，调用更改值的方法，后续扩充时需要注意，可能会不合适。
			DefaultVariable current = (DefaultVariable)allVars.get(variableId);
			current.setValue(value);
		} else
			throw new ElementNotFoundException("var id: " + variableId);
	}
	
	@Override
	public void persist(List<Object[]> changedList){
		if(changedList == null) return;
		for(Object[] arr : changedList){
			if(arr.length != 3)
				throw new IllegalArgumentException("输入参数不正确，集合中为数组，每个数组需要三个元素: groupId, variableId, value.");
			if(StringUtils.isEmpty(arr[0].toString()))
				throw new IllegalArgumentException("第一个参数:groupId不存在或者是空值");
			if(StringUtils.isEmpty(arr[1].toString()))
				throw new IllegalArgumentException("第二个参数:variableId不存在或者是空值");
			if(arr[2] == null)
				throw new IllegalArgumentException("第三个参数:value不存在或者是空值");
		}
		
		/* 更新实体中的数据 */
		try {
			saveVariables(changedList);
		} catch (Exception e) {
			throw new ArgumentsException("更新可变参数到业务中出现错误: " + e.getMessage(), e);
		}
		
		synchronized (lock){
			for(Object[] args : changedList){
				updateCache(args[0].toString(), args[1].toString(), args[2]);
			}
		}
	}
	
	@Override
	public void insert(List<Object[]> insertList) {
		if(insertList == null) return;
		for(Object[] arr : insertList){
			if(arr.length != 2)
				throw new IllegalArgumentException("输入参数不正确，集合中为数组，每个数组需要两个元素: group, variable.");
			if(StringUtils.isEmpty(arr[0].toString()))
				throw new IllegalArgumentException("第一个参数:group不存在或者是空值");
			if(StringUtils.isEmpty(arr[1].toString()))
				throw new IllegalArgumentException("第二个参数:variable不存在或者是空值");
		}
		/* 更新实体中的数据 */
		try {
			insertVariables(insertList);
		} catch (Exception e) {
			throw new ArgumentsException("新建可变参数出现错误: " + e.getMessage(), e);
		}
		
		synchronized (lock){
			for(Object[] args : insertList){
				insertCache((Group)args[0], (Variable)args[1]);
			}
		}
	}
	
	/**
	 * 由子类来实现具体的更新介质中的参数，如：数据库、配置文件等。
	 * @param groupId 分组ID
	 * @param variableId 可变参数ID
	 * @param value 更新的值
	 * @throws Exception
	 */
	protected abstract void saveVariable(String groupId
			, String variableId, Object value) throws Exception;
	
	/**
	 * 子类实现持久化更新参数信息到介质中，如：数据库、配置文件等。</p>
	 * 批量更新方法，集合中是数组对象，Object[]{groupId, variableId, value}</br>
	 * 即：分组ID、可变参数ID、更新的值。
	 * @param changedList 需要更新的参数集合。
	 * @throws Exception
	 */
	protected abstract void saveVariables(List<Object[]> changedList) throws Exception;
	
	/**
	 * 加入新的参数集合，集合中是数组对象，Object[]{group, variable}
	 * 如果已经存在该参数，则不再创建。
	 * @param insertList
	 * @throws Exception
	 */
	protected abstract void insertVariables(List<Object[]> insertList) throws Exception;

	private void insertCache(Group group, Variable variable){
		assert (group != null);
		assert (variable != null);
		if(!groupMap.containsKey(group.getId())){
			groupMap.put(group.getId(), group);
		}
		if(!allVars.containsKey(variable.getId())){
			// 不包含才加入到缓存
			allVars.put(variable.getId(), variable);
			List<String> varList = variableMap.get(group.getId());
			if(varList == null){
				varList = new ArrayList<String>(2);
				variableMap.put(group.getId(), varList);
			}
			varList.add(variable.getId());
		}
	}
	
	@Override
	public List<Group> getGroupList() {
		if(groupMap.size() == 0) return null;
		List<Group> list = new ArrayList<Group>(8);
		for(Iterator<Group> it = groupMap.values().iterator(); it.hasNext();){
			list.add(it.next());
		}
		Collections.sort(list);
		return list;
	}

	@Override
	public List<Variable> getVariableList(String groupId) {
		assert (StringUtils.isNotEmpty(groupId));
		if(groupMap.size() == 0){
			return null;
		}
		List<String> varIds = variableMap.get(groupId);
		if(varIds == null)
			return null;
		
		List<Variable> result = new ArrayList<Variable>(8);
		Variable var = null;
		for(String vid : varIds){
			var = allVars.get(vid);
			if(var == null) throw new ElementNotFoundException("var id: " + vid);
			result.add(var);
		}
		return result;
	}

	@Override
	public void destroy() throws Exception{
		this.source = null;
		this.groupMap.clear();
		this.variableMap.clear();
		this.allVars.clear();
	}
}