package frame.config;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.xml.sax.EntityResolver;

import frame.role.UserRightContainer;


public class ContextConfigerLoader {

	protected static Logger logger;
	private static ContextConfigerLoader instance;
	private static LoaderContainer configLoaderContainer;
	private static UserRightContainer userRightContainer;
	private List<VirtualPathConfig> virtualPathList;
	private List<CallableConfig> callablList;

	static {
		logger = Logger.getLogger(ContextConfigerLoader.class);
		configLoaderContainer = LoaderContainer.getInstance();
		userRightContainer = UserRightContainer.getInstance();
	}

	private ContextConfigerLoader() {
		virtualPathList = new ArrayList<VirtualPathConfig>();
		callablList = new ArrayList<CallableConfig>();
	}

	public synchronized static ContextConfigerLoader getInstance() {
		if (instance == null) {
			instance = new ContextConfigerLoader();
		}

		return instance;
	}

	public void load() {
		String path = Configer.getPath_MainConfig();
		File file = new File(path);

		loadOneFile(file);
	}

	private void loadOneFile(File file) {
		try {
			logger.debug("load dispatch file:" + file);
			InputStream inputStream = new FileInputStream(file);

			try {
				SAXReader reader = new SAXReader();
				reader.setValidation(false);

				Document doc = reader.read(inputStream);
				Element root = doc.getRootElement();

				loadParams(root);
				loadConfigLoader(root);
				loadFreeVisit(root);
				loadLimitedVisit(root);
				loadVirtualPathConfig(root);
				loadCallableConfig(root);
				loadDataRight(root);
			} 
			catch (DocumentException e) {
				logger.error("can not load dispatch file: " + file);
				logger.error(e);
			} finally {
				try {
					inputStream.close();
				} catch (IOException e) {
				}
			}
		} catch (Exception e) {
			logger.error(e);
		}
	}
	
	public void loadClasses() throws Exception {
		//1.
		for (VirtualPathConfig virtualPath: virtualPathList) {
			loadOneVirtualPath(virtualPath);
		}
		
		//2.
		for (CallableConfig callableConfig: callablList) {
			loadOneDispatch(callableConfig);
		}
	}

	private void loadParams(Element root) throws Exception {
		Iterator<?> iterator = root.elementIterator(Node_Param);

		while (iterator.hasNext()) {
			Element element = (Element) iterator.next();

			String name = element.attributeValue(Node_Param_Name);
			String value = element.attributeValue(Node_Param_Value);
			boolean client = Util.stringToBoolean(element.attributeValue(Node_Param_Client));

			Configer.addParam(name, value, client);
		}

		Configer.afterLoadParams();
	}

	private void loadFreeVisit(Element root) throws Exception {
		Iterator<?> iterator = root.elementIterator(Node_FreeVisit);

		while (iterator.hasNext()) {
			Element element = (Element) iterator.next();

			Iterator<?> typeIterator = element.elementIterator(Node_Type);
			while (typeIterator.hasNext()) {
				Element elemnet = (Element) typeIterator.next();
				String type = elemnet.getTextTrim();
				loadOneFreeVisitType(type);
			}

			Iterator<?> resourceIterator = element.elementIterator(Node_Resource);
			while (resourceIterator.hasNext()) {
				Element elemnet = (Element) resourceIterator.next();
				String resource = elemnet.getTextTrim();
				loadOneFreeVisitResource(resource);
			}

			Iterator<?> callIterator = element.elementIterator(Node_Call);
			while (callIterator.hasNext()) {
				Element elemnet = (Element) callIterator.next();
				String call = elemnet.getTextTrim();
				loadOneFreeVisitCall(call);
			}
			
			Iterator<?> excludeIterator = element.elementIterator(Node_Exclude);
			while (excludeIterator.hasNext()) {
				Element elemnet = (Element) excludeIterator.next();
				String exclude = elemnet.getTextTrim();
				loadOneExcludeResource(exclude);
			}
		}
	}
	
	private void loadLimitedVisit(Element root) {
		Iterator<?> iterator = root.elementIterator(Node_LimitedVisit);

		while (iterator.hasNext()) {
			Element element = (Element) iterator.next();

			Iterator<?> typeIterator = element.elementIterator(Node_RoleResource);
			while (typeIterator.hasNext()) {
				Element elemnet = (Element) typeIterator.next();
				String role = elemnet.attributeValue(Node_RoleResource_Role);
				String resource = elemnet.attributeValue(Node_RoleResource_Resource);
				userRightContainer.addRoleResource(role, resource);
			}
		}
	}

	private void loadVirtualPathConfig(Element root) throws Exception {
		Iterator<?> iterator = root.elementIterator("virtualPaths");

		while (iterator.hasNext()) {
			Element element = (Element) iterator.next();

			Iterator<?> mappingIterator = element.elementIterator("virtualPath");
			while (mappingIterator.hasNext()) {
				Element elemnet = (Element) mappingIterator.next();

				String path = elemnet.attributeValue("path");
				String target = elemnet.attributeValue("target");
				String className = elemnet.attributeValue("classname");

				VirtualPathConfig virtualPath = new VirtualPathConfig(path, target, className);
				virtualPathList.add(virtualPath);
			}
		}
	}

	private void loadCallableConfig(Element root) throws Exception {
		Iterator<?> iterator = root.elementIterator(Node_Callable);
		while (iterator.hasNext()) {
			Element element = (Element) iterator.next();

			Iterator<?> mappingIterator = element.elementIterator(Node_Mapping);
			while (mappingIterator.hasNext()) {
				Element elemnet = (Element) mappingIterator.next();

				String path = elemnet.attributeValue(Node_Mapping_Path);
				String classname = elemnet.attributeValue(Node_Mapping_ClassName);

				CallableConfig callableConfig = new CallableConfig(path, classname);
				callablList.add(callableConfig);
			}
		}
	}

	private void loadConfigLoader(Element root) throws Exception {
		Iterator<?> iterator = root.elementIterator(Node_ConfigLoader);

		while (iterator.hasNext()) {
			Element element = (Element) iterator.next();
			Iterator<?> configIterator = element.elementIterator(Node_ConfigLoader_Loader);

			while (configIterator.hasNext()) {
				Element loaderEl = (Element) configIterator.next();

				String name = loaderEl.attributeValue(Node_ConfigLoader_Loader_Name);
				String active = loaderEl.attributeValue(Node_ConfigLoader_Loader_Active);
				String classname = loaderEl.attributeValue(Node_ConfigLoader_Loader_ClassName);
				Class<?> clazz = Class.forName(classname);

				ILoader configLoader;
				Method getInstance = null;
				try {
					getInstance = clazz.getDeclaredMethod("getInstance");
				} catch (NoSuchMethodException e) {
				}

				if (getInstance != null) {
					configLoader = (ILoader) getInstance.invoke(null);
				} else {
					configLoader = (ILoader) clazz.newInstance();
				}

				configLoader.setName(name);
				configLoader.setActive(Util.stringToBoolean(active));

				configLoaderContainer.add(configLoader);
			}
		}
	}

	private void loadDataRight(Element root) throws Exception {
		Iterator<?> iterator = root.elementIterator(Node_DataFilter);

		while (iterator.hasNext()) {
			Element element = (Element) iterator.next();
			Iterator<?> filterIterator = element.elementIterator(Node_DataFilter_Filter);

			while (filterIterator.hasNext()) {
				Element filterEl = (Element) filterIterator.next();

				String tablename = filterEl.attributeValue(Node_DataFilter_Filter_TableName);
				String where = filterEl.attributeValue(Node_DataFilter_Filter_Where);

				userRightContainer.addDataRight(tablename, where);
			}
		}
	}

	private void loadOneFreeVisitType(String type) {
		if (Util.isEmptyStr(type)) {
			return;
		}

		mainDispatcher.appendFreeVisitType(type);
	}

	private void loadOneFreeVisitResource(String resource) {
		if (Util.isEmptyStr(resource)) {
			return;
		}

		mainDispatcher.appendFreeVisitResource(resource);
	}

	private void loadOneFreeVisitCall(String call) {
		if (Util.isEmptyStr(call)) {
			return;
		}

		mainDispatcher.appendFreeVisitCalls(call);
	}
	
	private void loadOneExcludeResource(String exclude) {
		if (Util.isEmptyStr(exclude)) {
			return;
		}

		mainDispatcher.appendExcludeResources(exclude);
	}
	
	private void loadOneVirtualPath(VirtualPathConfig virtualPath) throws Exception {
		if (virtualPath.invalid()) {
			return;
		}

		mainDispatcher.appendVirtualPaths(virtualPath.getPath(), virtualPath.getTarget(), virtualPath.getClassName());
	}

	private void loadOneDispatch(CallableConfig callableConfig) throws Exception {
		if (callableConfig.invalid()) {
			return;
		}

		mainDispatcher.appendCallableClass(callableConfig.getPath(), callableConfig.getClassName());
	}

}