/* ===================================================================
    * Copyright 2002-06 SRI International.
    * Released under the MOZILLA PUBLIC LICENSE Version 1.1
    * which can be obtained at http://www.mozilla.org/MPL/MPL-1.1.html
    * This software is distributed on an "AS IS"
    * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
    * See the License for the specific language governing rights and
    * limitations under the License.
    * =================================================================== */
  package com.sri.emo.commandline.defaults;
  
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import org.apache.log4j.Logger;
  import com.jcorporate.expresso.core.db.DBException;
  import com.jcorporate.expresso.core.dbobj.DBObject;
  import com.jcorporate.expresso.core.dbobj.ValidValue;
  import com.jcorporate.expresso.core.security.SuperUser;
  import com.sri.common.util.ObjectCombinator;
  import com.sri.emo.annotations.NodeTag;
  import com.sri.emo.commandline.NodeTracker;
  import com.sri.emo.commandline.SqlRowGenerator;
  import com.sri.emo.controller.DecisionMatrix;
  import com.sri.emo.dbobj.Node;
  import com.sri.emo.dbobj.Part;
  import com.sri.emo.dbobj.PartsFactory;
  import com.sri.emo.dbobj.PickList;
  import com.sri.emo.dbobj.StepAttributes;
  import com.sri.emo.dbobj.WizDecisionSet;
  import com.sri.emo.dbobj.WizDefinition;
  import com.sri.emo.dbobj.WizStep;
  import com.sri.emo.wizard.WizDefinitionRepository;
  import com.sri.emo.wizard.completion.persistence.CompletionDefinition;
  import com.sri.emo.wizard.expressoimpl.SelectionWizDefinitionRepository;
  import com.sri.emo.wizard.selection.EmoSelectionWizard;
  import com.sri.emo.wizard.selection.management.PromptStepType;
  
  /***
   * Exports wizards.
   * 
   * @author Michael Rimov
   */
  public class WizardExporter extends AbstractNodeExportSupport {
  
  	/***
  	 * Log4j logger.
  	 */
  	private final Logger log = Logger.getLogger(WizardExporter.class);
  
  	/***
  	 * Set of tag names we're looking for in exporting.
  	 */
  	private final Set tags;
  
  	/***
  	 * Constructs a wizard exporter with the specified services.
  	 * 
  	 * @param nodeTracker
  	 *            tracker of nodes.
  	 * @param generator
  	 *            sql row generator for export.
  	 * @param tags
  	 *            the tags we're exporting.
  	 */
  	public WizardExporter(final NodeTracker nodeTracker,
  			final SqlRowGenerator generator, String[] tags) {
  		super(nodeTracker, generator);
  
  		this.tags = new HashSet(Arrays.asList(tags));
  	}
  
  	/***
  	 * Factory method to create the selection wizard repository.
  	 * 
  	 * @return
  	 */
  	protected WizDefinitionRepository getWizardRepository() {
  		return new SelectionWizDefinitionRepository();
  	}
  
  	/***
  	 * Exports all wizards to the printwriter.
  	 * 
  	 * @param writer
  	 *            the writer.
  	 * @return number of total dbobject records exported.
  	 * @throws DBException
  	 */
  	public int exportAllWizards(PrintWriter writer) throws DBException {
  		int recordCount = 0;
  		int wizardCount = 0;
 		if (log.isInfoEnabled()) {
 			log.info("Exporting Wizards");
 		}
 
 		List allWizards = getWizardRepository().listAll(WizDefinition.FLD_NAME);
 		for (Iterator wizardIterator = allWizards.iterator(); wizardIterator
 				.hasNext();) {
 			WizDefinition wizardDefinition = null;
 			try {
 				wizardDefinition = (WizDefinition) wizardIterator.next();
 				recordCount += exportWizard(wizardDefinition, writer);
 			} catch (Exception ex) {
 				log.error("Error exporting wizard " + wizardDefinition, ex);
 			}
 		}
 
 		if (log.isInfoEnabled()) {
 			log.info("Processed " + wizardCount + " wizards.");
 		}
 
 		return recordCount;
 	}
 
 	/***
 	 * Exports a given wizard given the wizard definition.
 	 * 
 	 * @param wizardDefinition
 	 * @param writer
 	 * @return number of records exported.
 	 * @throws DBException
 	 */
 	private int exportWizard(final WizDefinition wizardDefinition, final PrintWriter writer) throws DBException {
 		int recordsExported = 0;
 
 		try {
 
 			if (isSelectionWizard(wizardDefinition)) {
 				// We have to export everything or nothing -- so what we do
 				// is have the code write to a string writer instead of the
 				// normal
 				// printstream.
 				// If then everything was successfully added, we flush the
 				// entire
 				// printstream to the output writer.
 				StringWriter stringWriter = new StringWriter();
 				PrintWriter transactionalWriter = new PrintWriter(stringWriter);
 				try {
 					recordsExported += exportSelectionWizard(wizardDefinition,
 							transactionalWriter);
 				} finally {
 					transactionalWriter.close();
 				}
 
 				// If we got here, then we were successfull.
 				if (recordsExported > 0) {
 					writer.print(stringWriter.toString());
 				}
 				stringWriter = null;
 				transactionalWriter = null;
 			} else {
 				List recordsToExport = exportCompletionWizard(wizardDefinition);
 				for (Iterator i = recordsToExport.iterator(); i.hasNext();) {
 					DBObject eachObject = (DBObject) i.next();
 					recordsExported += this.writeDBObject(writer, eachObject);
 				}
 			}
 
 		} catch (DependentNodesNotTaggedException ex) {
 			System.err.println(ex.getMessage());
 			log.error("Error writing wizard " + wizardDefinition
 					+ " missing one or more nodes", ex);
 		} catch (IncompleteDecisionMatrixException ex) {
 			System.err.println(ex.getMessage());
 			log.error("Skipping selection wizard " + wizardDefinition
 					+ " due to incomplete selection matrix.", ex);
 		}
 		return recordsExported;
 	}
 
 	/***
 	 * Checks to see if the given target node contains the tags necessary for
 	 * export.
 	 * 
 	 * @param targetNode
 	 * @return
 	 * @throws DBException
 	 */
 	private boolean isNodeTaggedForExport(Node targetNode) throws DBException {
 		List targetTags = targetNode.getTags();
 		if (targetTags == null || targetTags.size() == 0) {
 			return false;
 		}
 
 		for (int i = 0; i < targetTags.size(); i++) {
 			NodeTag eachTag = (NodeTag) targetTags.get(i);			
 			if (tags.contains(eachTag.getTagValue())) {
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	/***
 	 * Retrieve a list of dbobjects to export for the given completion wizard.
 	 * 
 	 * @param wizard
 	 * @return list of dbobjects to export.
 	 * @throws DBException
 	 * @throws DependentNodesNotTaggedException
 	 */
 	private List exportCompletionWizard(final WizDefinition wizard)
 			throws DBException, DependentNodesNotTaggedException {
 		List recordsToExport = new ArrayList();
 		recordsToExport.add(wizard);
 		CompletionDefinition completion = (CompletionDefinition) wizard
 				.getAdditionalInfo();
 		Node targetNode = completion.getTargetNode();
 
 		if (!isNodeTaggedForExport(targetNode)) {
 			throw new DependentNodesNotTaggedException(wizard, targetNode);
 		}
 
 		recordsToExport.add(completion);
 		List allDetails = completion.getCompletionDetails();
 		for (Iterator detailIterator = allDetails.iterator(); detailIterator.hasNext();) {
 			DBObject eachDetail = (DBObject)detailIterator.next();
 			recordsToExport.add(eachDetail);
 		}
 
 		return recordsToExport;
 	}
 
 	/***
 	 * Hack -- since the wizard API provides a unified view of all wizards, we
 	 * check the wizard definition running controller. If it is selection wizard
 	 * controller, then we return true.
 	 * 
 	 * @param wizardDefinition
 	 *            the wizard definition to examine.
 	 * @return
 	 * @throws DBException
 	 */
 	private boolean isSelectionWizard(WizDefinition wizardDefinition)
 			throws DBException {
 		if (EmoSelectionWizard.class.getName().equals(
 				wizardDefinition.getField(WizDefinition.FLD_WIZARD))) {
 			return true;
 		}
 
 		return false;
 	}
 
 	/***
 	 * Exports the selection wizard and related objects.
 	 * 
 	 * @param wizard
 	 * @param writer
 	 * @return
 	 * @throws DBException
 	 * @throws DependentNodesNotTaggedException
 	 * @throws IncompleteDecisionMatrixException
 	 */
 	private int exportSelectionWizard(WizDefinition wizard, PrintWriter writer)
 			throws DBException, DependentNodesNotTaggedException,
 			IncompleteDecisionMatrixException {
 		int result = 0;
 		result += writeDBObject(writer, wizard);
 		result += writeDBObject(writer, (DBObject) wizard.getAdditionalInfo());
 
 		List pages = wizard.getPageDefinitions();
 		List notTaggedNodes = new ArrayList();
 		for (Iterator pageIterator = pages.iterator(); pageIterator.hasNext();) {
 			WizStep eachStep = (WizStep) pageIterator.next();
 			try {
 				result += writeDBObject(writer, eachStep);
 	
 				// Also add additional info
 				if (eachStep.getNodeType() != null) {
 					result += exportNodeType(writer, eachStep.getNodeType()
 							.getEntityName());
 				}
 	
 				// Write step attributes
 				List stepAttributes = eachStep.getStepAttributeList();
 				for (Iterator attributeIterator = stepAttributes.iterator(); attributeIterator
 						.hasNext();) {
 					StepAttributes eachAttribute = (StepAttributes) attributeIterator
 							.next();
 					result += writeDBObject(writer, eachAttribute);
 				}
 	
 				switch (eachStep.getStepType()) {
 				
 				case PromptStepType.CUSTOM_PICKLIST:
 					/***
 					 * TODO: SelectionWizardManager.buildWizardSteps currently
 					 * doesn't have an implementation for custom picklists??
 					 */
 					break;
 	
 				case PromptStepType.INSTANCE_PICKLIST:
 					String nodeId = eachStep
 							.getStepAttribute(StepAttributes.ATTRIBUTE_INSTANCE_ID);
 					Node n = new Node();
 					n.setNodeId(nodeId);
 					n.retrieve();
 					if (!this.isNodeTaggedForExport(n)) {
 						throw new DependentNodesNotTaggedException(wizard, n);
 					}
 	
 					String attributeId = eachStep
 							.getStepAttribute(StepAttributes.ATTRIBUTE_INSTANCE_FIELD);
 					Part part = new Part();
 					part.setPartId(attributeId);
 					part.retrieve();
 					result += writeDBObject(writer, part);
 	
 					break;
 	
 				case PromptStepType.MODEL_PICKLIST:
 					Part picklistPart = PartsFactory
 							.getPart(eachStep
 									.getStepAttribute(StepAttributes.ATTRIBUTE_MODEL_FIELD));
 					if (picklistPart != null && picklistPart.hasPicklist()) {
 						result += writeDBObject(writer, picklistPart);
 					}
 					break;
 	
 				}
 	
 				// Write picklist -- it may or may not be associated with the node.
 				if (WizStep.CUSTOM_PICKLIST == eachStep.getStepType()) {
 					String attribType = eachStep
 							.getStepAttribute(StepAttributes.ATTRIBUTE_PICKLIST_ID);
 	
 					List list = eachStep.getPicklistMenu(attribType);
 					for (Iterator picklistIterator = list.iterator(); picklistIterator
 							.hasNext();) {
 						PickList picklist = (PickList) picklistIterator.next();
 						result += writeDBObject(writer, picklist);
 					}
 				}
 				
 			} catch (DependentNodesNotTaggedException ex) {
 				//Gather all the nodes not tagged and throw later
 				//throw them in one giant exception.
 				assert ex.getSingleDependentNode() != null;
 				notTaggedNodes.add(ex.getSingleDependentNode());
 			}
 
 		}
 		
 		if (notTaggedNodes.size() > 0) {
 			throw new DependentNodesNotTaggedException(wizard, (Node[])notTaggedNodes.toArray(new Node[notTaggedNodes.size()]));
 		}
 
 		result += exportDecisionMatrixForWizard(wizard, writer);
 
 		return result;
 	}
 	
 	private void checkAllDecisionNodesPopulated(WizDefinition wizard) throws IncompleteDecisionMatrixException, DBException {
 		 List pertinentSteps = wizard.getPertinentDecisionSteps();		
         DecisionMatrix decisionMatrix = new DecisionMatrix(wizard.getId());
         ObjectCombinator combinator = buildObjectCombinator(pertinentSteps);
         for (Iterator i = combinator.iterator(); i.hasNext();) {
         	ValidValue[] pickList = (ValidValue[]) i.next();
         	
         	//Load the picklist into a map.
         	Map idToVVMap = new HashMap(pickList.length);
         	for (int index = 0; index < pickList.length; index++) {
                 ValidValue onePick = pickList[index];
                 WizStep oneStep = (WizStep) pertinentSteps.get(index);
                 idToVVMap.put(new Integer(oneStep.getFieldInt(WizStep.FLD_ID)), new Integer(onePick.getKey()));
         	}
             WizDecisionSet decisionSet = decisionMatrix.getDecision(idToVVMap);
             if (decisionSet == null) {
            	 throw new IncompleteDecisionMatrixException(wizard);
             }
         }
 	}
 	
     /***
      * Constructs an object combinator given a list of wizard steps that
      * are pertinent to the current wizard.
      *
      * @param pertinentSteps List A list of WizSteps.
      * @return ObjectCombinator constructed ObjectCombinator
      */
     private ObjectCombinator buildObjectCombinator(final List pertinentSteps) {
         ValidValue[][] allPossibleValidValues = new ValidValue[pertinentSteps.size()][];
         for (int i = 0; i < pertinentSteps.size(); i++) {
             WizStep oneStep = (WizStep) pertinentSteps.get(i);
             allPossibleValidValues[i] = oneStep.getMenuItems();
         }
 
         return new ObjectCombinator(allPossibleValidValues, ValidValue.class);
     }
 	
 
 	/***
 	 * Exports the decision matrix.
 	 * 
 	 * @param writer
 	 * @param wizard
 	 * @return
 	 * @throws DBException
 	 * @throws IncompleteDecisionMatrixException
 	 */
 	private int exportDecisionMatrixForWizard(WizDefinition wizard,
 			PrintWriter printWriter) throws DBException,
 			DependentNodesNotTaggedException, IncompleteDecisionMatrixException {
 		int count = 0;
 		WizDecisionSet decisionQuery = new WizDecisionSet(SuperUser.INSTANCE);
 		decisionQuery.setWizardId(wizard.getId());
 
 		checkAllDecisionNodesPopulated(wizard);
 		
 		List allDecisions = decisionQuery.searchAndRetrieveList();
 		List failedNodes  = new ArrayList();
 
 		for (Iterator decisionIterator = allDecisions.iterator(); decisionIterator
 				.hasNext();) {
 			
 			WizDecisionSet eachDecision = (WizDecisionSet) decisionIterator
 					.next();
 			Node decisionNode = eachDecision.getDecisionNode();
 			
 	
 			try {
 				if (!isNodeTaggedForExport(decisionNode)) {
 					throw new DependentNodesNotTaggedException(wizard, decisionNode);
 				}
 	
 				count += writeDBObject(printWriter, eachDecision);
 	
 				List allDecisionEntities = eachDecision.getDecisionEntities();
 				for (Iterator entityIterator = allDecisionEntities.iterator(); entityIterator
 						.hasNext();) {
 					DBObject eachDecisionEntity = (DBObject) entityIterator.next();
 					count += writeDBObject(printWriter, eachDecisionEntity);
 				}
 			} catch (DependentNodesNotTaggedException ex) {
 				//Grab all dependent node failures so we 
 				//can get all of the missing nodes in one run
 				//
 				failedNodes.add(decisionNode);
 			}
 		}
 		
 		
 		if (failedNodes.size() > 0) {
 			//Throw a new node exception, this time with all the failed nodes.
 			throw new DependentNodesNotTaggedException(wizard, (Node[])failedNodes.toArray(new Node[failedNodes.size()]));
 		}
 
 		return count;
 	}
 
 }