package org.kuali.student.lum.program.service.assembler;

 import org.apache.log4j.Logger;

 import org.kuali.student.core.assembly.BOAssembler;

 import org.kuali.student.core.assembly.BaseDTOAssemblyNode;

 import org.kuali.student.core.assembly.BaseDTOAssemblyNode.NodeOperation;

 import org.kuali.student.core.assembly.data.AssemblyException;

 import org.kuali.student.core.exceptions.DoesNotExistException;

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

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

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

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

 import org.kuali.student.lum.program.dto.CredentialProgramInfo;

 import org.kuali.student.lum.service.assembler.CluAssemblerUtils;

 import java.util.List;

 import java.util.Map;

 public class CredentialProgramAssembler implements BOAssembler<CredentialProgramInfo, CluInfo> {

     final static Logger LOG = Logger.getLogger(CredentialProgramAssembler.class);

     private ProgramAssemblerUtils programAssemblerUtils;

     private CluAssemblerUtils cluAssemblerUtils;

     private LuService luService;

     @Override

     public CredentialProgramInfo assemble(CluInfo clu,

                                           CredentialProgramInfo credentialProgram,

                                           boolean shallowBuild)

             throws AssemblyException {

         CredentialProgramInfo cpInfo = (null != credentialProgram) ? credentialProgram : new CredentialProgramInfo();

         // Copy all the data from the clu to the credential program

         if (!ProgramAssemblerConstants.CREDENTIAL_PROGRAM_TYPES.contains(clu.getType())) {

             throw new AssemblyException("CredentialProgramAssembler.assemble() called for Clu of incorrect type: " + clu.getType());

         }

         cpInfo.setCredentialProgramType(clu.getType());

         cpInfo.setDescr(clu.getDescr());

         cpInfo.setVersionInfo(clu.getVersionInfo());

         programAssemblerUtils.assembleBasics(clu, cpInfo);

         programAssemblerUtils.assembleIdentifiers(clu, cpInfo);

         if (null != clu.getOfficialIdentifier().getLevel()) {

             cpInfo.setProgramLevel(clu.getOfficialIdentifier().getLevel());

         }

         programAssemblerUtils.assembleBasicAdminOrgs(clu, cpInfo);

         for (AdminOrgInfo org : clu.getAdminOrgs()) {

             if (ProgramAssemblerConstants.INSTITUTION.equals(org.getType())) {

                 cpInfo.setInstitution(org);

             }

         }

         programAssemblerUtils.assembleAtps(clu, cpInfo);

         programAssemblerUtils.assembleLuCodes(clu, cpInfo);

         if (!shallowBuild) {

                 programAssemblerUtils.assembleRequirements(clu, cpInfo);

                 cpInfo.setLearningObjectives(cluAssemblerUtils.assembleLos(clu.getId(), shallowBuild));

                 cpInfo.setResultOptions(programAssemblerUtils.assembleResultOptions(clu.getId()));

         }

         try {

             cpInfo.setCoreProgramIds(luService.getRelatedCluIdsByCluId(clu.getId(), ProgramAssemblerConstants.HAS_CORE_PROGRAM));

         } catch (Exception e) {

             throw new AssemblyException(e);

         }

         return cpInfo;

     }

     @Override

     public BaseDTOAssemblyNode<CredentialProgramInfo, CluInfo> disassemble(

             CredentialProgramInfo credential, NodeOperation operation)

             throws AssemblyException {

         BaseDTOAssemblyNode<CredentialProgramInfo, CluInfo> result = new BaseDTOAssemblyNode<CredentialProgramInfo, CluInfo>(this);

         if (credential == null) {

             // FIXME Unsure now if this is an exception or just return null or

             // empty assemblyNode

             LOG.error("credentialProgram to disassemble is null!");

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

         }

         CluInfo clu;

         try {

             clu = (NodeOperation.UPDATE == operation) ? luService.getClu(credential.getId()) : new CluInfo();

         } catch (Exception e) {

                         throw new AssemblyException("Error getting existing learning unit during CoreProgram update", e);

         } 

         boolean stateChanged = NodeOperation.UPDATE == operation && credential.getState() != null && !credential.getState().equals(clu.getState());

         programAssemblerUtils.disassembleBasics(clu, credential);

         if (credential.getId() == null)

             credential.setId(clu.getId());

         programAssemblerUtils.disassembleIdentifiers(clu, credential, operation);

         programAssemblerUtils.disassembleAdminOrgs(clu, credential, operation);     

         programAssemblerUtils.disassembleAtps(clu, credential, operation);

         programAssemblerUtils.disassembleLuCodes(clu, credential, operation);

         if (credential.getProgramRequirements() != null && !credential.getProgramRequirements().isEmpty()) {

             programAssemblerUtils.disassembleRequirements(clu, credential, operation, result, stateChanged);

         }

         if (credential.getResultOptions() != null) {

             disassembleResultOptions(credential, operation, result);

         }

         if (credential.getLearningObjectives() != null) {

             disassembleLearningObjectives(credential, operation, result);

         }

         clu.setDescr(credential.getDescr());

         clu.setType(credential.getCredentialProgramType());

         if (credential.getCoreProgramIds() != null && credential.getCoreProgramIds().size() > 0) {

             disassembleCorePrograms(credential, operation, result);

         }

         // Add the Clu to the result

         result.setNodeData(clu);

         result.setOperation(operation);

         result.setBusinessDTORef(credential);

         return result;

     }

     private void disassembleResultOptions(CredentialProgramInfo credential, NodeOperation operation, BaseDTOAssemblyNode<CredentialProgramInfo, CluInfo> result) throws AssemblyException {

         BaseDTOAssemblyNode<?, ?> resultOptions = cluAssemblerUtils.disassembleCluResults(

                 credential.getId(), credential.getState(), credential.getResultOptions(), operation, ProgramAssemblerConstants.DEGREE_RESULTS, "Result options", "Result option");

         if (resultOptions != null) {

             result.getChildNodes().add(resultOptions);

         }

     }

     private void disassembleLearningObjectives(CredentialProgramInfo credential, NodeOperation operation, BaseDTOAssemblyNode<CredentialProgramInfo, CluInfo> result) throws AssemblyException {

         try {

             List<BaseDTOAssemblyNode<?, ?>> loResults = cluAssemblerUtils.disassembleLos(credential.getId(), credential.getState(), credential.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 disassembleCorePrograms(CredentialProgramInfo credential, NodeOperation operation, BaseDTOAssemblyNode<CredentialProgramInfo, CluInfo> result) throws AssemblyException {

         List<BaseDTOAssemblyNode<?, ?>> coreResults;

         try {

             Map<String, String> currentRelations = null;

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

                 currentRelations = programAssemblerUtils.getCluCluRelations(credential.getId(), ProgramAssemblerConstants.HAS_CORE_PROGRAM);

             }

             for (String coreProgramId : credential.getCoreProgramIds()) {

                 coreResults = programAssemblerUtils.addAllRelationNodes(credential.getId(), coreProgramId, ProgramAssemblerConstants.HAS_CORE_PROGRAM, operation, currentRelations);

                 if (coreResults != null && coreResults.size() > 0) {

                     result.getChildNodes().addAll(coreResults);

                 }

             }

             if (currentRelations != null && currentRelations.size() > 0) {

                 for (Map.Entry<String, String> entry : currentRelations.entrySet()) {

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

                     // delete

                     CluCluRelationInfo relationToDelete = new CluCluRelationInfo();

                     relationToDelete.setId(entry.getValue());

                     BaseDTOAssemblyNode<Object, CluCluRelationInfo> relationToDeleteNode = new BaseDTOAssemblyNode<Object, CluCluRelationInfo>(

                             null);

                     relationToDeleteNode.setNodeData(relationToDelete);

                     relationToDeleteNode.setOperation(NodeOperation.DELETE);

                     result.getChildNodes().add(relationToDeleteNode);

                 }

             }

         } catch (Exception e) {

             throw new AssemblyException("Error while disassembling Core programs", e);

         }

     }

     public void setProgramAssemblerUtils(ProgramAssemblerUtils programAssemblerUtils) {

         this.programAssemblerUtils = programAssemblerUtils;

     }

     public void setLuService(LuService luService) {

         this.luService = luService;

     }

     public void setCluAssemblerUtils(CluAssemblerUtils cluAssemblerUtils) {

         this.cluAssemblerUtils = cluAssemblerUtils;

     }

 }