package org.kuali.student.lum.course.service.assembler;
   
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.Comparator;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.List;
   import java.util.Map;
  import java.util.Set;
  import java.util.Map.Entry;
  
  import org.kuali.student.common.assembly.BOAssembler;
  import org.kuali.student.common.assembly.BaseDTOAssemblyNode;
  import org.kuali.student.common.assembly.BaseDTOAssemblyNode.NodeOperation;
  import org.kuali.student.common.assembly.data.AssemblyException;
  import org.kuali.student.common.dto.DtoConstants;
  import org.kuali.student.common.exceptions.DoesNotExistException;
  import org.kuali.student.common.exceptions.InvalidParameterException;
  import org.kuali.student.common.exceptions.MissingParameterException;
  import org.kuali.student.common.exceptions.OperationFailedException;
  import org.kuali.student.common.util.UUIDHelper;
  import org.kuali.student.lum.course.dto.LoDisplayInfo;
  import org.kuali.student.lum.lo.dto.LoCategoryInfo;
  import org.kuali.student.lum.lo.dto.LoInfo;
  import org.kuali.student.lum.lo.dto.LoLoRelationInfo;
  import org.kuali.student.lum.lo.service.LearningObjectiveService;
  
  
  public class LoAssembler implements BOAssembler<LoDisplayInfo, LoInfo> {
  
  	private LearningObjectiveService loService;
  	
  	@Override
  	public LoDisplayInfo assemble(LoInfo lo, LoDisplayInfo loDisplayInfo,
  			boolean shallowBuild) throws AssemblyException {
  		
  		LoDisplayInfo loDisplay = (null != loDisplayInfo) ? loDisplayInfo : new LoDisplayInfo();
  		
  		loDisplay.setLoInfo(lo);
  
  		if (!shallowBuild) {
  			String loId = lo.getId();
  			try {
  				List<LoCategoryInfo> loCategories = loService.getLoCategoriesForLo(loId);
  				loDisplay.setLoCategoryInfoList(loCategories);
  			} catch (DoesNotExistException e) {
  			} catch (Exception e) {
  				throw new AssemblyException("Error getting learning objective categories", e);
  			}
  			try {
  				List<LoInfo> childLos = loService.getRelatedLosByLoId(loId,CourseAssemblerConstants.COURSE_LO_RELATION_INCLUDES);
  				for(LoInfo childLo:childLos){
  					LoDisplayInfo childLoDisplay = assemble(childLo, null, shallowBuild);
  					childLoDisplay.setParentLoRelationid(lo.getId());
  					childLoDisplay.setParentRelType(CourseAssemblerConstants.COURSE_LO_RELATION_INCLUDES);
  					loDisplay.getLoDisplayInfoList().add(childLoDisplay);
  				}
  				if(loDisplay.getLoDisplayInfoList().size()>1){
  					Collections.sort(loDisplay.getLoDisplayInfoList(), LoDisplayComparator.getInstance());
  				}
  			} catch (DoesNotExistException e) {
  			} catch (Exception e) {
  				throw new AssemblyException("Error getting learning objective", e);
  			}
  
  		}
  		return loDisplay;
  	}
  
  	@Override
  	//Creation of categories is done in the LoCategoryRpcGwtServlet
  	public BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> disassemble(
  			LoDisplayInfo loDisplay, NodeOperation operation)
  			throws AssemblyException {
  		
  		BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> result = new BaseDTOAssemblyNode<LoDisplayInfo, LoInfo>(this);
  		
  		//see if this is a new LuInfo
  		if (loDisplay == null || loDisplay.getLoInfo() == null) {
  			throw new AssemblyException("Lo can not be null");
  		}
  		if (NodeOperation.CREATE != operation && null == loDisplay.getLoInfo().getId()) {
  			throw new AssemblyException("Lo id can not be null");
  		}
  		
  		//set the id if it's not there already(important for creating relations)
  		loDisplay.getLoInfo().setId(UUIDHelper.genStringUUID(loDisplay.getLoInfo().getId()));
  		
  		//Default these values
  		loDisplay.getLoInfo().setType(CourseAssemblerConstants.COURSE_LO_TYPE);
  		loDisplay.getLoInfo().setLoRepositoryKey(CourseAssemblerConstants.COURSE_LO_REPOSITORY_KEY);
  		
  		
  		//Populate the node
  		result.setBusinessDTORef(loDisplay);
  		result.setNodeData(loDisplay.getLoInfo());
  		result.setOperation(operation);
  		
 		//Process the child los
 		try {
 			List<BaseDTOAssemblyNode<?, ?>> childLoNodes = disassembleChildLos(loDisplay, operation);
 			result.getChildNodes().addAll(childLoNodes);
 		} catch (DoesNotExistException e) {
 		} catch (Exception e) {
 			throw new AssemblyException("Error disassembling child los", e);
 		} 
 
 		//Process the categories
 		try {
 			List<BaseDTOAssemblyNode<?, ?>> categoryNodes = disassembleCategories(loDisplay, operation);
 			result.getChildNodes().addAll(categoryNodes);
 		} catch (Exception e) {
 			throw new AssemblyException("Error disassembling categories", e);
 		} 
 		
 		return result;
 	}
 
 	private List<BaseDTOAssemblyNode<?, ?>> disassembleCategories(
 			LoDisplayInfo loDisplay, NodeOperation operation) throws AssemblyException {
 		
 		List<BaseDTOAssemblyNode<?, ?>> results = new ArrayList<BaseDTOAssemblyNode<?, ?>>();
 		
 		//Category relations
 		Set<String> currentCategoryIds = new HashSet<String>();
 		//Get current relations
 		if (!NodeOperation.CREATE.equals(operation)) {
 			try {
 				List<LoCategoryInfo> categories = loService.getLoCategoriesForLo(loDisplay.getLoInfo().getId());
 				for (LoCategoryInfo category : categories) {
 					currentCategoryIds.add(category.getId());
 				}
 			} catch (DoesNotExistException e) {
 			} catch (Exception e) {
 				throw new AssemblyException("Error getting categories",	e);
 			}
 		}
 		//Update
 		for (LoCategoryInfo category : loDisplay.getLoCategoryInfoList()) {
 
 			// If this is a format create/new activity update then all activities will be created
 		    if (NodeOperation.CREATE == operation
 		            || (NodeOperation.UPDATE == operation &&  !currentCategoryIds.contains(category.getId()))) {
 		    	
 		    	LoCategoryRelationInfo loCategoryRelation = new LoCategoryRelationInfo();
 		    	loCategoryRelation.setCategoryId(category.getId());
 		    	loCategoryRelation.setLoId(loDisplay.getLoInfo().getId());
 		    	
                 BaseDTOAssemblyNode<LoDisplayInfo, LoCategoryRelationInfo> relationToAddNode = new BaseDTOAssemblyNode<LoDisplayInfo, LoCategoryRelationInfo>(null);
                 relationToAddNode.setNodeData(loCategoryRelation);
                 relationToAddNode.setOperation(NodeOperation.CREATE);
                 results.add(relationToAddNode);
 
                 currentCategoryIds.remove(category.getId());
 		    } else if (NodeOperation.UPDATE == operation
 					&& currentCategoryIds.contains(category.getId())) {
                 currentCategoryIds.remove(category.getId());
 			} 
 		}
 		//Delete leftovers
 		for(String categoryId:currentCategoryIds){
 	    	LoCategoryRelationInfo loCategoryRelation = new LoCategoryRelationInfo();
 	    	loCategoryRelation.setCategoryId(categoryId);
 	    	loCategoryRelation.setLoId(loDisplay.getLoInfo().getId());
 	    	
             BaseDTOAssemblyNode<LoDisplayInfo, LoCategoryRelationInfo> relationToDeleteNode = new BaseDTOAssemblyNode<LoDisplayInfo, LoCategoryRelationInfo>(null);
             relationToDeleteNode.setNodeData(loCategoryRelation);
             relationToDeleteNode.setOperation(NodeOperation.DELETE);
             results.add(relationToDeleteNode);
 		}
 		
 		return results;
 	}
 
 	private List<BaseDTOAssemblyNode<?, ?>> disassembleChildLos(LoDisplayInfo loDisplay, NodeOperation operation) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, AssemblyException{
 		List<BaseDTOAssemblyNode<?, ?>> results = new ArrayList<BaseDTOAssemblyNode<?, ?>>();
 		Map<String,LoLoRelationInfo> currentLoRelations = new HashMap<String,LoLoRelationInfo>();
 		//Make lu lu relations
 		if (!NodeOperation.CREATE.equals(operation)) {
 			try {
 				List<LoLoRelationInfo> loRelations = loService.getLoLoRelationsByLoId(loDisplay.getLoInfo().getId());
 				for (LoLoRelationInfo loRelation : loRelations) {
 					//getLoLoRelationsByLoId returns if the lo is related or if it is the owner(this seems wrong)
 					if(CourseAssemblerConstants.COURSE_LO_RELATION_INCLUDES.equals(loRelation.getType())&&
 							!loDisplay.getLoInfo().getId().equals(loRelation.getRelatedLoId())){
 						currentLoRelations.put(loRelation.getRelatedLoId(), loRelation);
 					}
 				}
 			} catch (DoesNotExistException e) {
 			} catch (Exception e) {
 				throw new AssemblyException("Error getting categories",	e);
 			}
 		}
 		
 		// Loop through all the activities in this format
 		for (LoDisplayInfo childDisplay : loDisplay.getLoDisplayInfoList()) {
 		    
 		    // Set the state of the child LO to match the state of the parent
 		    // LO. This end up propagating the program state to all of the LOs,
 		    // since we set parent LO state to program state earlier in the code
 		    childDisplay.getLoInfo().setState(loDisplay.getLoInfo().getState());
 		    
 			// If this is a format create/new activity update then all activities will be created
 		    if (NodeOperation.CREATE == operation
 		            || (NodeOperation.UPDATE == operation &&  !currentLoRelations.containsKey(childDisplay.getLoInfo().getId()))) {
 		        		    
                 // the lo does not exist, so create
                 // Assemble and add the lo
 		    	childDisplay.getLoInfo().setId(null);
                 BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = this
                         .disassemble(childDisplay, NodeOperation.CREATE);
                 results.add(loNode);
 
                 // Create the relationship and add it as well
                 LoLoRelationInfo relation = new LoLoRelationInfo();
                 relation.setLoId(loDisplay.getLoInfo().getId());
                 relation.setRelatedLoId(loNode.getNodeData().getId());
                 relation.setType(CourseAssemblerConstants.COURSE_LO_RELATION_INCLUDES);
                 
                 // Relations can only have states of Active or SUSPENDED
                 // DO NOT use states like Approve, Draft, etc on relations
                 // Will default to Active
                 relation.setState(DtoConstants.STATE_ACTIVE);
                 
 
                 BaseDTOAssemblyNode<LoDisplayInfo, LoLoRelationInfo> relationNode = new BaseDTOAssemblyNode<LoDisplayInfo, LoLoRelationInfo>(
                         null);
                 relationNode.setNodeData(relation);
                 relationNode.setOperation(NodeOperation.CREATE);
 
                 results.add(relationNode);
             } else if (NodeOperation.UPDATE == operation
 					&& currentLoRelations.containsKey(childDisplay.getLoInfo().getId())) {
 				// If the lo already has this child lo, then just update the
 				// child lo
 				BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = this
 						.disassemble(childDisplay, NodeOperation.UPDATE);
 				results.add(loNode);
 
 				// remove this entry from the map so we can tell what needs to
 				// be deleted at the end
 				currentLoRelations.remove(childDisplay.getLoInfo().getId());
 			} else if (NodeOperation.DELETE == operation
                     && currentLoRelations.containsKey(childDisplay.getLoInfo().getId())) {
 			    
                 // Delete the Format and its relation
 				LoLoRelationInfo relationToDelete = currentLoRelations.get(childDisplay.getLoInfo().getId());
                 BaseDTOAssemblyNode<LoDisplayInfo, LoLoRelationInfo> relationToDeleteNode = new BaseDTOAssemblyNode<LoDisplayInfo, LoLoRelationInfo>(
                         null);
                 relationToDeleteNode.setNodeData(relationToDelete);
                 relationToDeleteNode.setOperation(NodeOperation.DELETE);
                 results.add(relationToDeleteNode);
             
                 BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = this
                 .disassemble(childDisplay, NodeOperation.DELETE);
                 results.add(loNode);                                
 
                 // remove this entry from the map so we can tell what needs to
                 // be deleted at the end
                 currentLoRelations.remove(childDisplay.getLoInfo().getId());			    
 			}
 		}         
 
         // Now any leftover lo ids are no longer needed, so delete
         // los and relations
         for (Entry<String, LoLoRelationInfo> entry : currentLoRelations.entrySet()) {
             // Create a new relation with the id of the relation we want to
             // delete
         	LoLoRelationInfo relationToDelete = entry.getValue();
             BaseDTOAssemblyNode<LoDisplayInfo, LoLoRelationInfo> relationToDeleteNode = new BaseDTOAssemblyNode<LoDisplayInfo, LoLoRelationInfo>(
                     null);
             relationToDeleteNode.setNodeData(relationToDelete);
             relationToDeleteNode.setOperation(NodeOperation.DELETE);
             results.add(relationToDeleteNode);
 
             LoInfo loToDelete = loService.getLo(entry.getKey());
             LoDisplayInfo loDisplayToDelete = this.assemble(loToDelete, null, false);
             BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = this.disassemble(loDisplayToDelete, NodeOperation.DELETE);
             results.add(loNode);                                            
         }
 		return results;
 		
 	}
 
 	public void setLoService(LearningObjectiveService loService) {
 		this.loService = loService;
 	}
 
 	public static class LoDisplayComparator implements Comparator<LoDisplayInfo>{
 		private static LoDisplayComparator instance = new LoDisplayComparator();
 		@Override
 		public int compare(LoDisplayInfo o1, LoDisplayInfo o2) {
 			String o1Sequence = o1.getLoInfo().getAttributes().get(CourseAssemblerConstants.COURSE_LO_SEQUENCE);
 			String o2Sequence = o1.getLoInfo().getAttributes().get(CourseAssemblerConstants.COURSE_LO_SEQUENCE);
 			if(o1Sequence!=null){
 				return o1Sequence.compareTo(o2Sequence);
 			}else if(o2Sequence!=null){
 				return -1;
 			}
 			return 0;
 		}
 		public static LoDisplayComparator getInstance() {
 			return instance;
 		}
 	}
 }