/*
    * Copyright 2005-2007 The Kuali Foundation
    * 
    * 
    * Licensed under the Educational Community License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * 
    * http://www.opensource.org/licenses/ecl2.php
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.kuali.rice.edl.impl;
  
  import org.apache.log4j.Logger;
  import org.kuali.rice.core.api.util.xml.XmlHelper;
  import org.kuali.rice.core.api.util.xml.XmlJotter;
  import org.kuali.rice.edl.impl.bo.EDocLiteAssociation;
  import org.kuali.rice.edl.impl.service.EDocLiteService;
  import org.kuali.rice.edl.impl.service.EdlServiceLocator;
  import org.kuali.rice.kew.api.WorkflowRuntimeException;
  import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;
  import org.kuali.rice.ksb.api.KsbApiServiceLocator;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.transform.Templates;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.Map;
  
  
  /**
   * Creates EDL controllers.  Contains a cache of parsed EDL configurations.  The parsed config is a definition name related to 
   * a Map containing config element and their associated class.
   * 
   * @author Kuali Rice Team (rice.collab@kuali.org)
   *
   */
  public class EDLControllerFactory {
  
  	private static final Logger LOG = Logger.getLogger(EDLControllerFactory.class);
  	
  	private static final String CONFIG_CACHE_GROUP_NAME = "EDLConfig";
  
  	//private static Map edlConfigCache = new HashMap();
  
  	public static EDLController createEDLController(EDocLiteAssociation edlAssociation, EDLGlobalConfig edlGlobalConfig) {
          EDLController edlController = new EDLController();
  		edlController.setEdocLiteAssociation(edlAssociation);
  
  		try {
  			edlController.setEdlGlobalConfig(edlGlobalConfig);
  			edlController.setDefaultDOM(getDefaultDOM(edlAssociation));
  			loadConfigProcessors(edlController, edlGlobalConfig);
  			loadPreProcessors(edlController, edlGlobalConfig);
  			loadPostProcessor(edlController, edlGlobalConfig);
  			loadStateComponents(edlController, edlGlobalConfig);
  			loadStyle(edlController);
  			
  		} catch (Exception e) {
              String edl = null;
              if (edlAssociation != null) {
                  edl = edlAssociation.getEdlName();
              }
              String message = "Error creating controller for EDL" + (edl == null ? "" : ": " + edl);
              LOG.error(message, e);
  			throw new WorkflowRuntimeException("Problems creating controller for EDL: " + edl, e);
  		}
  
  		return edlController;
  	}
  
  	public static EDLController createEDLController(EDocLiteAssociation edlAssociation, EDLGlobalConfig edlGlobalConfig, DocumentRouteHeaderValue document) {
  		EDLController edlController = createEDLController(edlAssociation, edlGlobalConfig);
  		try {
  			Document defaultDom = edlController.getDefaultDOM();
  			Document documentDom = XmlHelper.readXml(document.getDocContent());
  			// get the data node and import it into our default DOM
  			Element documentData = (Element) documentDom.getElementsByTagName(EDLXmlUtils.DATA_E).item(0);
  			if (documentData != null) {
  				Element defaultDomEDL = EDLXmlUtils.getEDLContent(defaultDom, false);
  				Element defaultDomData = (Element) defaultDomEDL.getElementsByTagName(EDLXmlUtils.DATA_E).item(0);
  				defaultDomEDL.replaceChild(defaultDom.importNode(documentData, true), defaultDomData);
  			}
  			if (LOG.isDebugEnabled()) {
  				LOG.debug("Created default Node from document id " + document.getDocumentId() + " content " + XmlJotter.jotNode(defaultDom));
  			}
  		} catch (Exception e) {
  			throw new WorkflowRuntimeException("Problems creating controller for EDL " + edlAssociation.getEdlName() + " document " + document.getDocumentId(), e);
  		}
  		return edlController;
 	}
 
 	private synchronized static void loadStyle(EDLController edlController) throws Exception {
 		EDocLiteService edlService = getEDLService();
 		Templates styleSheet = null;
 		styleSheet = edlService.getStyleAsTranslet(edlController.getEdocLiteAssociation().getStyle());
 		edlController.setStyle(styleSheet);
 	}
 	
 	private synchronized static void loadPreProcessors(EDLController edlController, EDLGlobalConfig edlGlobalConfig) {
 		edlController.setPreProcessors(cloneConfigMap(edlGlobalConfig.getPreProcessors(), edlController.getDefaultDOM()));
 	}
 	
 	private synchronized static void loadPostProcessor(EDLController edlController, EDLGlobalConfig edlGlobalConfig) {
 		edlController.setPostProcessors(cloneConfigMap(edlGlobalConfig.getPostProcessors(), edlController.getDefaultDOM()));
 	}
 	
 	private synchronized static void loadStateComponents(EDLController edlController, EDLGlobalConfig edlGlobalConfig) {
 		edlController.setStateComponents(cloneConfigMap(edlGlobalConfig.getStateComponents(), edlController.getDefaultDOM()));
 	}
 
 	private synchronized static void loadConfigProcessors(EDLController edlController, EDLGlobalConfig edlGlobalConfig) throws Exception {
 		EDocLiteAssociation edlAssociation = edlController.getEdocLiteAssociation();
 		Map configProcessorMappings = fetchConfigFromCache(edlAssociation.getDefinition());
 		if (configProcessorMappings != null) {
 			edlController.setConfigProcessors(cloneConfigMap(configProcessorMappings, edlController.getDefaultDOM()));
 		} else {
 			// these are classes mapped to the conf element from the edlconfig.
 			Document document = getEDLService().getDefinitionXml(edlAssociation);
 			Element definitionElement = (Element) document.getFirstChild();
 
 			configProcessorMappings = new LinkedHashMap();
 			edlController.setEdlGlobalConfig(edlGlobalConfig);
 			NodeList edlDefinitionNodes = definitionElement.getChildNodes();
 			for (int i = 0; i < edlDefinitionNodes.getLength(); i++) {
 				Node definitionNode = edlDefinitionNodes.item(i);
 				Class configProcessorClass = edlGlobalConfig.getConfigProcessor(definitionNode);
 				if (configProcessorClass != null) {
 					configProcessorMappings.put(definitionNode, configProcessorClass);
 				}
 			}
 			putConfigInCache(edlAssociation.getDefinition(), configProcessorMappings);
 //			edlConfigCache.put(edlAssociation.getDefinition(), configProcessorMappings);
 			loadConfigProcessors(edlController, edlGlobalConfig);
 		}
 	}
 	
 	protected synchronized static Map fetchConfigFromCache(String definition) {
 		return (Map) KsbApiServiceLocator.getCacheAdministrator().getFromCache(getConfigCacheKey(definition));
 	}
 	
 	private synchronized static void putConfigInCache(String definition, Map configProcessorMappings) {
 		KsbApiServiceLocator.getCacheAdministrator().putInCache(getConfigCacheKey(definition), configProcessorMappings, CONFIG_CACHE_GROUP_NAME);
 	}
 	
 	private static String getConfigCacheKey(String definition) {
 		return CONFIG_CACHE_GROUP_NAME + ":" + definition;
 	}
 	
 	private synchronized static Map cloneConfigMap(Map configMap, Document defaultDom) {
 		Map tempConfigProcessors = new LinkedHashMap();
 		for (Iterator iter = configMap.entrySet().iterator(); iter.hasNext();) {
 			Map.Entry configProcessorMapping = (Map.Entry) iter.next();
 			tempConfigProcessors.put(defaultDom.importNode((Node)configProcessorMapping.getKey(), true), configProcessorMapping.getValue());
 		}
 		return tempConfigProcessors;
 	}
 
 	private static EDocLiteService getEDLService() {
 		return EdlServiceLocator.getEDocLiteService();
 	}
 
 	private static Document getDefaultDOM(EDocLiteAssociation edlAssociation) throws Exception {
 		Document dom = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
 		Element rootElement = dom.createElement("documentContent"); // this is a
 		// throwback
 		// to some
 		// original
 		// madness
 		// to get EDL routing over a year ago we need to look into this being
 		// eliminated.
 		dom.appendChild(rootElement);
 		Element edlContentElement = EDLXmlUtils.getEDLContent(dom, true);
 		EDLXmlUtils.getDataFromEDLDocument(edlContentElement, true);
 		
 		// get the data element that was just created ***jitrue***
 		Element edlData = EDLXmlUtils.getChildElement(edlContentElement, EDLXmlUtils.DATA_E);
 		// set edlName attribute on data element of default DOM ***jitrue***
 		edlData.setAttribute("edlName", edlAssociation.getEdlName());
 		
 		return dom;
 	}
 
 	public static void flushDefinitionFromConfigCache(String definition) {
 		KsbApiServiceLocator.getCacheAdministrator().flushEntry(getConfigCacheKey(definition));
 //		edlConfigCache.remove(defName);
 	}
 	
 	public static void flushDefinitionCache() {
 		KsbApiServiceLocator.getCacheAdministrator().flushGroup(CONFIG_CACHE_GROUP_NAME);
 	}
 }