/*

  * Copyright 2007 The Kuali Foundation

  *

  * Licensed under the Educational Community License, Version 1.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/ecl1.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.student.lum.service.assembler;

 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.dto.RichTextInfo;

 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.lum.course.dto.LoDisplayInfo;

 import org.kuali.student.lum.course.service.assembler.LoAssembler;

 import org.kuali.student.lum.lo.dto.LoInfo;

 import org.kuali.student.lum.lo.service.LearningObjectiveService;

 import org.kuali.student.lum.lu.dto.CluLoRelationInfo;

 import org.kuali.student.lum.lu.dto.CluResultInfo;

 import org.kuali.student.lum.lu.dto.ResultOptionInfo;

 import org.kuali.student.lum.lu.service.LuService;

 import java.util.ArrayList;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Map.Entry;

 /**

  * This is a description of what this class does - jimt don't forget to fill this in.

  *

  * @author Kuali Rice Team (kuali-rice@googlegroups.com)

  *

  */

 public class CluAssemblerUtils {

     private LuService luService;

     private LearningObjectiveService loService;

     private LoAssembler loAssembler;

     public List<String> assembleCluResults(List<String> resultTypes, List<CluResultInfo> cluResults) throws AssemblyException{

                 if(resultTypes==null){

                         throw new AssemblyException("result types can not be null");

                 }

                 List<String> results = new ArrayList<String>();

                 //Loop through all the CluResults to find those with the matching types

                 for(CluResultInfo cluResult:cluResults){

                         if(resultTypes.contains(cluResult.getType())){

                                 //Loop through all options and add to the list of Strings

                                 for(ResultOptionInfo resultOption: cluResult.getResultOptions()){

                                         results.add(resultOption.getResultComponentId());

                                 }

                         }

                 }

                 return results;

         }

     public BaseDTOAssemblyNode<?, ?> disassembleCluResults(String cluId,

                         String cluState, List<String> options, NodeOperation operation, String resultType,

                         String resultsDescription, String resultDescription) throws AssemblyException {

                 BaseDTOAssemblyNode<List<String>, CluResultInfo> cluResultNode = new BaseDTOAssemblyNode<List<String>, CluResultInfo>(null);

                 if(resultType==null){

                         throw new AssemblyException("resultType can not be null");

                 }

                 // Get the current options and put them in a map of option type id/cluResult

                 Map<String, ResultOptionInfo> currentResults = new HashMap<String, ResultOptionInfo>();

                 CluResultInfo cluResult = null;

         //TODO Check this for proper handling of multiple CluResultInfos?  

                 //If this is not a create, lookup the results for this clu

                 if (!NodeOperation.CREATE.equals(operation)) {

                         try {

                                 List<CluResultInfo> cluResultList = luService.getCluResultByClu(cluId);

                                 for (CluResultInfo currentResult : cluResultList) {

                                         if (resultType.equals(currentResult.getType())) {

                                                 cluResult = currentResult;

                                                 if(NodeOperation.DELETE.equals(operation)){

                                                         //if this is a delete, then we only need the CluResultInfo

                                                         cluResultNode.setOperation(NodeOperation.DELETE);

                                                 }else{

                                                         //Find all the Result options and store in a map for easy access later

                                                         cluResultNode.setOperation(NodeOperation.UPDATE);

                                                         for(ResultOptionInfo resultOption:currentResult.getResultOptions()){

                                                                 // Set the state of the result option so it appears in the KSLU_RSLT_OPT table

                                                             // States include Draft, Approved, Superseded etc.

                                                             resultOption.setState(cluState);

                                                             currentResults.put(resultOption.getResultComponentId(), resultOption);

                                                         }

                                                 }

                                         }

                                 }

                         } catch (DoesNotExistException e) {

                         } catch (InvalidParameterException e) {

                                 throw new AssemblyException("Error getting related " + resultsDescription, e);

                         } catch (MissingParameterException e) {

                                 throw new AssemblyException("Error getting related " + resultsDescription, e);

                         } catch (OperationFailedException e) {

                                 throw new AssemblyException("Error getting related " + resultsDescription, e);

                         }

                 }

                 //If this is a delete we don't need the result options, just the CluResultInfo

                 if(!NodeOperation.DELETE.equals(operation)){

                         if(cluResult == null){

                                 //Create a new resultInfo of the given type if one does not exist and set operation to Create

                                 cluResult = new CluResultInfo();

                                 cluResult.setCluId(cluId);

                                 cluResult.setState(cluState);

                                 cluResult.setType(resultType);

                                 RichTextInfo desc = new RichTextInfo();

                                 desc.setPlain(resultsDescription);

                                 cluResult.setDesc(desc);

                                 cluResult.setEffectiveDate(new Date());

                                 cluResultNode.setOperation(NodeOperation.CREATE);

                         }

                         cluResult.setResultOptions(new ArrayList<ResultOptionInfo>());

             // Set the state of the result so it appears in the KSLU_CLU_RSLT table

             // States include Draft, Approved, Superseded etc.

                         cluResult.setState(cluState);

                         // Loop through all the credit options in this clu

                         for (String optionType : options) {

                                 if(currentResults.containsKey(optionType)){

                                         //If the option exists already copy it to the new list of result options

                                         ResultOptionInfo resultOptionInfo = currentResults.get(optionType);

                                         // Set the state of the result option so it appears in the KSLU_RSLT_OPT table

                     // States include Draft, Approved, Superseded etc.

                                         resultOptionInfo.setState(cluState);

                                         cluResult.getResultOptions().add(resultOptionInfo);

                                 }else{

                                         //Otherwise create a new result option

                                         ResultOptionInfo resultOptionInfo = new ResultOptionInfo();

                                         RichTextInfo desc = new RichTextInfo();

                                         desc.setPlain(resultDescription);

                                         resultOptionInfo.setDesc(desc);

                                         resultOptionInfo.setResultComponentId(optionType);

                                         // Set the state of the result option so it appears in the KSLU_RSLT_OPT table

                     // States include Draft, Approved, Superseded etc.

                     resultOptionInfo.setState(cluState);

                                         cluResult.getResultOptions().add(resultOptionInfo);

                                 }

                         }

                 }

                 cluResultNode.setNodeData(cluResult);

                 return cluResultNode;

         }

     public List<LoDisplayInfo> assembleLos(String cluId, boolean shallowBuild) throws AssemblyException {

         List<LoDisplayInfo> loInfos = new ArrayList<LoDisplayInfo>();

         try {

             List<CluLoRelationInfo> cluLoRelations = luService.getCluLoRelationsByClu(cluId);

             for (CluLoRelationInfo cluLoRelation : cluLoRelations) {

                 String loId = cluLoRelation.getLoId();

                 LoInfo lo = loService.getLo(loId);

                 loInfos.add(loAssembler.assemble(lo, null, shallowBuild));

             }

         } catch (Exception e) {

             throw new AssemblyException("Error getting learning objectives", e);

         }

         return loInfos;

     }

         public List<BaseDTOAssemblyNode<?, ?>> disassembleLos(String cluId, String cluState, List<LoDisplayInfo> loInfos,

                         NodeOperation operation) throws AssemblyException, DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException{

                 // TODO Auto-generated method stub

                 List<BaseDTOAssemblyNode<?, ?>> results = new ArrayList<BaseDTOAssemblyNode<?, ?>>();

                 // Get the current formats and put them in a map of format id/relation

                 // id

                 Map<String, CluLoRelationInfo> currentCluLoRelations = new HashMap<String, CluLoRelationInfo>();

                 try {

                         List<CluLoRelationInfo> cluLoRelations = luService.getCluLoRelationsByClu(cluId);

                         for(CluLoRelationInfo cluLoRelation:cluLoRelations){

                                 if(CluAssemblerConstants.CLU_LO_CLU_SPECIFIC_RELATION.equals(cluLoRelation.getType())){

                                         currentCluLoRelations.put(cluLoRelation.getLoId(), cluLoRelation);

                                 }

                         }

                 } catch (DoesNotExistException e) {

                 } catch (Exception e) {

                         throw new AssemblyException("Error finding related Los", e);

                 }

                 // Loop through all the los in this clu

                 for(LoDisplayInfo loDisplay : loInfos){

                         // If this is a clu create/new lo update then all los will be created

                     if (NodeOperation.CREATE == operation

                             || (NodeOperation.UPDATE == operation &&  !currentCluLoRelations.containsKey(loDisplay.getLoInfo().getId()))) {

                 // the lo does not exist, so create

                 // Assemble and add the lo

                             loDisplay.getLoInfo().setId(null);

                             loDisplay.getLoInfo().setState(cluState);

                 BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = loAssembler

                         .disassemble(loDisplay, NodeOperation.CREATE);

                 results.add(loNode);

                 // Create the relationship and add it as well

                 CluLoRelationInfo relation = new CluLoRelationInfo();

                 relation.setCluId(cluId);

                 relation.setLoId(loNode.getNodeData().getId());

                 relation.setType(CluAssemblerConstants.CLU_LO_CLU_SPECIFIC_RELATION);

                 // Relations can be either Active or Suspended

                 // For now, we set them all to Active

                 // DO NOT use states like draft, superseded, etc for relations

                 relation.setState(DtoConstants.STATE_ACTIVE);

                 BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo> relationNode = new BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo>(

                         null);

                 relationNode.setNodeData(relation);

                 relationNode.setOperation(NodeOperation.CREATE);

                 results.add(relationNode);

             } else if (NodeOperation.UPDATE == operation

                                         && currentCluLoRelations.containsKey(loDisplay.getLoInfo().getId())) {

                                 // On update, we need to change the state of the LO to

                 // match the state of the parent program

                 loDisplay.getLoInfo().setState(cluState);

                 BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = loAssembler

                                 .disassemble(loDisplay, NodeOperation.UPDATE);

                                 results.add(loNode);

                                 // remove this entry from the map so we can tell what needs to

                                 // be deleted at the end

                                 currentCluLoRelations.remove(loDisplay.getLoInfo().getId());

                         } else if (NodeOperation.DELETE == operation

                     && currentCluLoRelations.containsKey(loDisplay.getLoInfo().getId())) {

                 // Delete the Format and its relation

                                 CluLoRelationInfo relationToDelete = currentCluLoRelations.get(loDisplay.getLoInfo().getId());

                 BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo> relationToDeleteNode = new BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo>(

                         null);

                 relationToDeleteNode.setNodeData(relationToDelete);

                 relationToDeleteNode.setOperation(NodeOperation.DELETE);

                 results.add(relationToDeleteNode);

                 BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = loAssembler

                                         .disassemble(loDisplay, NodeOperation.DELETE);

                 results.add(loNode);

                 // remove this entry from the map so we can tell what needs to

                 // be deleted at the end

                 currentCluLoRelations.remove(loDisplay.getLoInfo().getId());

                         }

                 }

         // Now any leftover lo ids are no longer needed, so delete

         // los and relations

         for (Entry<String, CluLoRelationInfo> entry : currentCluLoRelations.entrySet()) {

             // Create a new relation with the id of the relation we want to

             // delete

                 CluLoRelationInfo relationToDelete = entry.getValue();

             BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo> relationToDeleteNode = new BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo>(

                     null);

             relationToDeleteNode.setNodeData(relationToDelete);

             relationToDeleteNode.setOperation(NodeOperation.DELETE);

             results.add(relationToDeleteNode);

             LoInfo loToDelete = loService.getLo(entry.getKey());

             LoDisplayInfo loDisplayToDelete = loAssembler.assemble(loToDelete, null, false);

             BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = loAssembler

                             .disassemble(loDisplayToDelete, NodeOperation.DELETE);

             results.add(loNode);

         }

                 return results;

         }

     // Spring setters

     public void setLuService(LuService luService) {

         this.luService = luService;

     }

     public void setLoService(LearningObjectiveService loService) {

         this.loService = loService;

     }

     public void setLoAssembler(LoAssembler loAssembler) {

         this.loAssembler = loAssembler;

     }

 }