package org.kuali.student.lum.lu.ui.course.server.gwt;

 import java.util.List;

 import org.apache.commons.beanutils.PropertyUtils;

 import org.apache.log4j.Logger;

 import org.kuali.student.common.assembly.data.Data;

 import org.kuali.student.common.dto.CurrencyAmountInfo;

 import org.kuali.student.common.dto.DtoConstants;

 import org.kuali.student.common.exceptions.AlreadyExistsException;

 import org.kuali.student.common.exceptions.CircularRelationshipException;

 import org.kuali.student.common.exceptions.DataValidationErrorException;

 import org.kuali.student.common.exceptions.DependentObjectsExistException;

 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.exceptions.PermissionDeniedException;

 import org.kuali.student.common.exceptions.UnsupportedActionException;

 import org.kuali.student.common.exceptions.VersionMismatchException;

 import org.kuali.student.common.ui.client.service.DataSaveResult;

 import org.kuali.student.common.ui.server.gwt.DataService;

 import org.kuali.student.core.proposal.dto.ProposalInfo;

 import org.kuali.student.core.proposal.service.ProposalService;

 import org.kuali.student.core.statement.dto.ReqCompFieldInfo;

 import org.kuali.student.core.statement.dto.ReqComponentInfo;

 import org.kuali.student.core.statement.dto.StatementTreeViewInfo;

 import org.kuali.student.core.statement.service.StatementService;

 import org.kuali.student.lum.course.dto.ActivityInfo;

 import org.kuali.student.lum.course.dto.CourseCrossListingInfo;

 import org.kuali.student.lum.course.dto.CourseFeeInfo;

 import org.kuali.student.lum.course.dto.CourseInfo;

 import org.kuali.student.lum.course.dto.CourseJointInfo;

 import org.kuali.student.lum.course.dto.CourseRevenueInfo;

 import org.kuali.student.lum.course.dto.CourseVariationInfo;

 import org.kuali.student.lum.course.dto.FormatInfo;

 import org.kuali.student.lum.course.dto.LoDisplayInfo;

 import org.kuali.student.lum.course.service.CourseService;

 import org.kuali.student.lum.lrc.dto.ResultComponentInfo;

 import org.kuali.student.lum.lu.LUConstants;

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

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

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

 import org.kuali.student.lum.statement.typekey.ReqComponentFieldTypes;

 import org.springframework.transaction.annotation.Transactional;

 @Transactional(noRollbackFor={DoesNotExistException.class},rollbackFor={Throwable.class})

 public class CopyCourseServiceImpl {

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

         private DataService courseDataService;

         private DataService courseProposalDataService;

         private CourseService courseService;

         private LuService luService;

         private StatementService statementService;

         private ProposalService proposalService;

         private String defaultDocumentType=LUConstants.PROPOSAL_TYPE_COURSE_CREATE;

         private String defaultState=DtoConstants.STATE_DRAFT;

         private List<String> ignoreProperties;

         public DataSaveResult createCopyCourse(String originalCluId) throws Exception {

                 //Copy the course and use the data service to return

                 CourseInfo copiedCourse = copyCourse(originalCluId);

                 DataSaveResult result = new DataSaveResult();

                 result.setValue(courseDataService.getData(copiedCourse.getId()));

                 return result;

         }

         public DataSaveResult createCopyCourseProposal(String originalProposalId) throws Exception {

                 //Copy the proposal and use the data service to return

                 ProposalInfo copiedProposal = copyProposal(originalProposalId);

                 //Grab the data object so it is transformed

                 Data data = courseProposalDataService.getData(copiedProposal.getId());

                 //Save it so that it goes through the filters and creates workflow

                 return courseProposalDataService.saveData(data);

         }

         private CourseInfo copyCourse(String originalCluId) throws Exception{

                 //Copy the course

                 return copyCourse(originalCluId, null, defaultState, ignoreProperties, statementService, luService, courseService);

         }

         private ProposalInfo copyProposal(String originalProposalId) throws Exception{

                 try {

                         //Get the original Proposal

                         ProposalInfo originalProposal = proposalService.getProposal(originalProposalId);

                         //Copy the course from the original Proposal

                         String originalCluId = originalProposal.getProposalReference().get(0);

                         CourseInfo copiedCourse = copyCourse(originalCluId);

                         //Clear ids and set the reference to the copied course

                         originalProposal.setId(null);

                         originalProposal.setWorkflowId(null);

                         originalProposal.setState(defaultState);

                         originalProposal.setType(defaultDocumentType);

                         originalProposal.getProposalReference().set(0, copiedCourse.getId());

                         originalProposal.getProposerOrg().clear();

                         originalProposal.getProposerPerson().clear();

             originalProposal.setName(null);

                         //Create the proposal

                         ProposalInfo copiedProposal = proposalService.createProposal(defaultDocumentType, originalProposal);

                         return copiedProposal;

                 } catch (Exception e) {

                         LOG.error("Error copying proposal id:" + originalProposalId, e);

                         throw e;

                 }

         }

         private void resetIds(CourseInfo course) {

                 //Clear/Reset Joint info ids

                 for(CourseJointInfo joint:course.getJoints()){

                         joint.setRelationId(null);

                 }

                 //Clear Los

                 for(LoDisplayInfo lo:course.getCourseSpecificLOs()){

                         resetLoRecursively(lo);

                 }

                 //Clear format/activity ids

                 for(FormatInfo format:course.getFormats()){

                         format.setId(null);

                         for(ActivityInfo activity:format.getActivities()){

                                 activity.setId(null);

                         }

                 }

                 //Clear result component ids

                 for(ResultComponentInfo result:course.getCreditOptions()){

                         result.setId(null);

                 }

                 //Clear cross listing ids

                 for(CourseCrossListingInfo crossListing:course.getCrossListings()){

                         crossListing.setId(null);

                 }

                 //Clear Expenditures

                 for(AffiliatedOrgInfo orgInfo:course.getExpenditure().getAffiliatedOrgs()){

                         orgInfo.setId(null);

                 }

                 //Clear Fees

                 for(CourseFeeInfo fee:course.getFees()){

                         fee.setId(null);

                         for(CurrencyAmountInfo feeAmount:fee.getFeeAmounts()){

                                 feeAmount.setId(null);

                         }

                 }

                 //Clear revenue

                 for(CourseRevenueInfo revenue:course.getRevenues()){

                         revenue.setId(null);

                         for(AffiliatedOrgInfo orgInfo:revenue.getAffiliatedOrgs()){

                                 orgInfo.setId(null);

                         }

                 }

                 //Clear variation ids

                 for(CourseVariationInfo variation:course.getVariations()){

                         variation.setId(null);

                 }

         }

         private void resetLoRecursively(LoDisplayInfo lo){

                 //Clear out all the Lo ids recursively

                 lo.getLoInfo().setId(null);

                 for(LoDisplayInfo nestedLo:lo.getLoDisplayInfoList()){

                         resetLoRecursively(nestedLo);

                 }

         }

         private void clearStatementTreeViewIds(

                         List<StatementTreeViewInfo> statementTreeViews, String newState, LuService luService) throws OperationFailedException {

                 //Clear out all statement ids recursively

                 for(StatementTreeViewInfo statementTreeView:statementTreeViews){

                         clearStatementTreeViewIdsRecursively(statementTreeView, newState, luService);

                 }

         }

         /**

          * Clears out ids recursively and also copies adhock clusets

          * @param statementTreeView

          * @param luService

          * @throws OperationFailedException

          */

         private void clearStatementTreeViewIdsRecursively(StatementTreeViewInfo statementTreeView, String newState,LuService luService) throws OperationFailedException{

                 statementTreeView.setId(null);

                 statementTreeView.setState(newState);

                 //clear out all the nested requirement components

                 for(ReqComponentInfo reqComp:statementTreeView.getReqComponents()){

                         reqComp.setId(null);

                         reqComp.setState(newState);

                         for(ReqCompFieldInfo field:reqComp.getReqCompFields()){

                                 field.setId(null);

                                 //copy any clusets that are adhoc'd and set the field value to the new cluset

                                 if(ReqComponentFieldTypes.COURSE_CLUSET_KEY.getId().equals(field.getType())||

                                    ReqComponentFieldTypes.PROGRAM_CLUSET_KEY.getId().equals(field.getType())||

                                    ReqComponentFieldTypes.CLUSET_KEY.getId().equals(field.getType())){

                                         try {

                                                 CluSetInfo cluSet = luService.getCluSetInfo(field.getValue());

                                                 cluSet.setId(null);

                                                 cluSet.setState(newState);

                                                 //Clear clu ids if membership info exists, they will be re-added based on membership info 

                                                 if (cluSet.getMembershipQuery() != null){

                                                         cluSet.getCluIds().clear();

                                                         cluSet.getCluSetIds().clear();

                                                 }

                                                 cluSet = luService.createCluSet(cluSet.getType(), cluSet);

                                                 field.setValue(cluSet.getId());

                                         } catch (Exception e) {

                                                 throw new OperationFailedException("Error copying clusets.", e);

                                         }

                                 }

                         }

                 }

                 //recurse through nested statements

                 for(StatementTreeViewInfo child: statementTreeView.getStatements()){

                         clearStatementTreeViewIdsRecursively(child,newState,luService);

                 }

         }

     private void copyStatements(String originalCluId, String newCluId, String newState,

                         StatementService statementService, LuService luService, CourseService courseService) throws OperationFailedException, DoesNotExistException, InvalidParameterException, MissingParameterException, PermissionDeniedException, DataValidationErrorException {

                 //Get the course statements

                 List<StatementTreeViewInfo> statementTreeViews = courseService.getCourseStatements(originalCluId,null,null);

                 //Clear out the ids and create causing a copy to be made

                 if(statementTreeViews!=null){

                         clearStatementTreeViewIds(statementTreeViews,newState,luService);

                         for(StatementTreeViewInfo statementTreeView:statementTreeViews){

                                 courseService.createCourseStatement(newCluId, statementTreeView);

                         }

                 }

         }

         private CourseInfo copyCourse(String originalCluId, String newCluId, String newState, List<String> ignoreProperties, StatementService statementService, LuService luService, CourseService courseService) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException, PermissionDeniedException, AlreadyExistsException, DataValidationErrorException, VersionMismatchException, CircularRelationshipException, DependentObjectsExistException, UnsupportedActionException{

                 CourseInfo originalCourse = courseService.getCourse(originalCluId);

                 resetIds(originalCourse);

                 originalCourse.setCourseTitle("Copy of "+originalCourse.getCourseTitle());

                 //Default the newState to the existing course state if no state was set.

                 //State should never be null

                 if(newState==null){

                         newState = originalCourse.getState();

                 }

                 originalCourse.setId(newCluId);

                 originalCourse.setState(newState);

         originalCourse.setPilotCourse(false);

                 //Loop through the ignore properties and null out the values

                 if(ignoreProperties!=null){

                         for(String property:ignoreProperties){

                                 try {

                                         PropertyUtils.setProperty(originalCourse, property, null);

                                 } catch (Exception e) {

                                         throw new InvalidParameterException("Ignore property is invalid and is causing an exception.",e);

                                 }

                         }

                 }

                 CourseInfo newCourse = courseService.createCourse(originalCourse);

         copyStatements(originalCluId, newCourse.getId(), newState, statementService, luService, courseService);

                 return newCourse;

         }

         public void setCourseService(CourseService courseService) {

                 this.courseService = courseService;

         }

         public void setLuService(LuService luService) {

                 this.luService = luService;

         }

         public void setStatementService(StatementService statementService) {

                 this.statementService = statementService;

         }

         public void setProposalService(ProposalService proposalService) {

                 this.proposalService = proposalService;

         }

         public void setCourseDataService(DataService courseDataService) {

                 this.courseDataService = courseDataService;

         }

         public void setCourseProposalDataService(DataService courseProposalDataService) {

                 this.courseProposalDataService = courseProposalDataService;

         }

         public void setDefaultDocumentType(String defaultDocumentType) {

                 this.defaultDocumentType = defaultDocumentType;

         }

         public void setDefaultState(String defaultState) {

                 this.defaultState = defaultState;

         }

         public void setIgnoreProperties(List<String> ignoreProperties) {

                 this.ignoreProperties = ignoreProperties;

         }

 }