/*
    * 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.program.service.assembler;
  
  import java.util.List;
  
  import org.apache.log4j.Logger;
  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.AmountInfo;
  import org.kuali.student.common.exceptions.DoesNotExistException;
  import org.kuali.student.lum.lu.dto.CluInfo;
  import org.kuali.student.lum.lu.service.LuService;
  import org.kuali.student.lum.program.dto.ProgramVariationInfo;
  import org.kuali.student.lum.service.assembler.CluAssemblerUtils;
  
  /**
   * @author KS
   *
   */
  public class ProgramVariationAssembler implements BOAssembler<ProgramVariationInfo, CluInfo> {
      final static Logger LOG = Logger.getLogger(ProgramVariationAssembler.class);
  
      private LuService luService;
      private CluAssemblerUtils cluAssemblerUtils;
      private ProgramAssemblerUtils programAssemblerUtils;
  
      @Override
      public ProgramVariationInfo assemble(CluInfo clu, ProgramVariationInfo programVariation, boolean shallowBuild) throws AssemblyException {
  
          ProgramVariationInfo pvInfo = (null != programVariation) ? programVariation : new ProgramVariationInfo();
  
          // Copy all the data from the clu to the programvariation
          programAssemblerUtils.assembleBasics(clu, pvInfo);
          programAssemblerUtils.assembleIdentifiers(clu, pvInfo);
          programAssemblerUtils.assembleBasicAdminOrgs(clu, pvInfo);
          programAssemblerUtils.assembleFullOrgs(clu, pvInfo);
          programAssemblerUtils.assembleAtps(clu, pvInfo);
          programAssemblerUtils.assembleLuCodes(clu, pvInfo);
          programAssemblerUtils.assemblePublications(clu, pvInfo);
          
          if (!shallowBuild) {
          	programAssemblerUtils.assembleRequirements(clu, pvInfo);
          	pvInfo.setResultOptions(programAssemblerUtils.assembleResultOptions(clu.getId()));
              pvInfo.setLearningObjectives(cluAssemblerUtils.assembleLos(clu.getId(), shallowBuild));
          }
          
          pvInfo.setIntensity((null != clu.getIntensity()) ? clu.getIntensity().getUnitType() : null);
          pvInfo.setStdDuration(clu.getStdDuration());
          pvInfo.setCampusLocations(clu.getCampusLocations());  
          pvInfo.setEffectiveDate(clu.getEffectiveDate());
          pvInfo.setDescr(clu.getDescr());
          pvInfo.setVersionInfo(clu.getVersionInfo());
  
          return pvInfo;
      }
  
      @Override
      public BaseDTOAssemblyNode<ProgramVariationInfo, CluInfo> disassemble(ProgramVariationInfo variation, NodeOperation operation) throws AssemblyException {
      	BaseDTOAssemblyNode<ProgramVariationInfo, CluInfo> result = new BaseDTOAssemblyNode<ProgramVariationInfo, CluInfo>(this);
      	
      	if (variation == null) {
  			// FIXME Unsure now if this is an exception or just return null or
  			// empty assemblyNode
  		    LOG.error("Variation to disassemble is null!");
  			throw new AssemblyException("Variation can not be null");
  		}
  
  		CluInfo clu;
  		try {
  			clu = (NodeOperation.UPDATE == operation) ? luService.getClu(variation.getId()) : new CluInfo();
          } catch (Exception e) {
  			throw new AssemblyException("Error getting existing learning unit during variation update", e);
          } 
          
          boolean stateChanged = NodeOperation.UPDATE == operation && variation.getState() != null && !variation.getState().equals(clu.getState());
          
          clu.setState(variation.getState());
          programAssemblerUtils.disassembleBasics(clu, variation);
          if (variation.getId() == null)
          	variation.setId(clu.getId());
          programAssemblerUtils.disassembleIdentifiers(clu, variation, operation);
          programAssemblerUtils.disassembleAdminOrgs(clu, variation, operation);
          programAssemblerUtils.disassembleAtps(clu, variation, operation);
         programAssemblerUtils.disassembleLuCodes(clu, variation, operation);        
         programAssemblerUtils.disassemblePublications(clu, variation, operation, result);
 
         if(variation.getProgramRequirements() != null && !variation.getProgramRequirements().isEmpty()) {
         	programAssemblerUtils.disassembleRequirements(clu, variation, operation, result, stateChanged);
         }
         
         if (variation.getResultOptions() != null) {
             disassembleResultOptions(variation, operation, result);           
         }
 
         if (variation.getLearningObjectives() != null) {
             disassembleLearningObjectives(variation, operation, result);
         }
  
 		AmountInfo intensity = new AmountInfo();
 		intensity.setUnitType(variation.getIntensity());
 		clu.setIntensity(intensity);
 		clu.setStdDuration(variation.getStdDuration());
         clu.setCampusLocations(variation.getCampusLocations());
         clu.setEffectiveDate(variation.getEffectiveDate());
         clu.setDescr(variation.getDescr());
         clu.setVersionInfo(variation.getVersionInfo());        
         
 		// Add the Clu to the result
 		result.setNodeData(clu);
 		result.setOperation(operation);
 		result.setBusinessDTORef(variation);
 		return result;
     	
     }
 
     private void disassembleLearningObjectives(ProgramVariationInfo variation, NodeOperation operation, BaseDTOAssemblyNode<ProgramVariationInfo, CluInfo> result) throws AssemblyException {
         try {
             List<BaseDTOAssemblyNode<?, ?>> loResults = cluAssemblerUtils.disassembleLos(variation.getId(), variation.getState(),  variation.getLearningObjectives(), operation);
             if (loResults != null) {
                 result.getChildNodes().addAll(loResults);
             }
         } catch (DoesNotExistException e) {
         } catch (Exception e) {
             throw new AssemblyException("Error while disassembling los", e);
         }
     }
 
     private void disassembleResultOptions(ProgramVariationInfo variation, NodeOperation operation, BaseDTOAssemblyNode<ProgramVariationInfo, CluInfo> result) throws AssemblyException {
         BaseDTOAssemblyNode<?, ?> resultOptions = cluAssemblerUtils.disassembleCluResults(
         		variation.getId(), variation.getState(), variation.getResultOptions(), operation, ProgramAssemblerConstants.DEGREE_RESULTS, "Result options", "Result option");
         if (resultOptions != null) {
             result.getChildNodes().add(resultOptions);           
         }
     }
     
     // Spring setter
     public void setLuService(LuService luService) {
         this.luService = luService;
     }
     
     public void setCluAssemblerUtils(CluAssemblerUtils cluAssemblerUtils) {
         this.cluAssemblerUtils = cluAssemblerUtils;
     }
 
     public void setProgramAssemblerUtils(ProgramAssemblerUtils programAssemblerUtils) {
         this.programAssemblerUtils = programAssemblerUtils;
     }
 }