package org.kuali.student.lum.program.client.core.edit;

 import java.util.ArrayList;

 import java.util.List;

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

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

 import org.kuali.student.common.ui.client.application.Application;

 import org.kuali.student.common.ui.client.application.ViewContext;

 import org.kuali.student.common.ui.client.mvc.Callback;

 import org.kuali.student.common.ui.client.mvc.DataModel;

 import org.kuali.student.common.ui.client.mvc.HasCrossConstraints;

 import org.kuali.student.common.ui.client.mvc.ModelRequestCallback;

 import org.kuali.student.common.ui.client.mvc.history.HistoryManager;

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

 import org.kuali.student.common.ui.client.validator.ValidatorClientUtils;

 import org.kuali.student.common.ui.client.widgets.KSButton;

 import org.kuali.student.common.ui.client.widgets.KSButtonAbstract;

 import org.kuali.student.common.ui.client.widgets.notification.KSNotification;

 import org.kuali.student.common.ui.client.widgets.notification.KSNotifier;

 import org.kuali.student.common.ui.shared.IdAttributes.IdType;

 import org.kuali.student.common.validation.dto.ValidationResultInfo;

 import org.kuali.student.lum.common.client.widgets.AppLocations;

 import org.kuali.student.lum.program.client.ProgramConstants;

 import org.kuali.student.lum.program.client.ProgramRegistry;

 import org.kuali.student.lum.program.client.ProgramSections;

 import org.kuali.student.lum.program.client.ProgramUtils;

 import org.kuali.student.lum.program.client.core.CoreController;

 import org.kuali.student.lum.program.client.events.AfterSaveEvent;

 import org.kuali.student.lum.program.client.events.ChangeViewEvent;

 import org.kuali.student.lum.program.client.events.MetadataLoadedEvent;

 import org.kuali.student.lum.program.client.events.ModelLoadedEvent;

 import org.kuali.student.lum.program.client.events.StateChangeEvent;

 import org.kuali.student.lum.program.client.events.StoreRequirementIDsEvent;

 import org.kuali.student.lum.program.client.events.UpdateEvent;

 import org.kuali.student.lum.program.client.properties.ProgramProperties;

 import org.kuali.student.lum.program.client.rpc.AbstractCallback;

 import com.google.gwt.core.client.GWT;

 import com.google.gwt.event.dom.client.ClickEvent;

 import com.google.gwt.event.dom.client.ClickHandler;

 import com.google.gwt.event.shared.HandlerManager;

 import com.google.gwt.user.client.Window;

 /**

  * @author Igor

  */

 public class CoreEditController extends CoreController {

     private final KSButton saveButton = new KSButton(ProgramProperties.get().common_save());

     private final KSButton cancelButton = new KSButton(ProgramProperties.get().common_cancel(), KSButtonAbstract.ButtonStyle.ANCHOR_LARGE_CENTERED);

     /**

      * Constructor.

      *

      * @param programModel

      */

     public CoreEditController(DataModel programModel, ViewContext viewContext, HandlerManager eventBus) {

         super(programModel, viewContext, eventBus);

         configurer = GWT.create(CoreEditConfigurer.class);

         bind();

     }

     @Override

     protected void configureView() {

         super.configureView();

         if (!initialized) {

             eventBus.fireEvent(new MetadataLoadedEvent(programModel.getDefinition(), this));

             List<Enum<?>> excludedViews = new ArrayList<Enum<?>>();

             excludedViews.add(ProgramSections.PROGRAM_REQUIREMENTS_EDIT);

             excludedViews.add(ProgramSections.SUPPORTING_DOCUMENTS_EDIT);

             excludedViews.add(ProgramSections.SUMMARY);

             addCommonButton(ProgramProperties.get().program_menu_sections(), saveButton, excludedViews);

             addCommonButton(ProgramProperties.get().program_menu_sections(), cancelButton, excludedViews);

             initialized = true;

         }

     }

     private void bind() {

         saveButton.addClickHandler(new ClickHandler() {

             @Override

             public void onClick(ClickEvent event) {

                 doSave();

             }

         });

         cancelButton.addClickHandler(new ClickHandler() {

             @Override

             public void onClick(ClickEvent event) {

                 doCancel();

             }

         });

         eventBus.addHandler(StoreRequirementIDsEvent.TYPE, new StoreRequirementIDsEvent.Handler() {

             @Override

             public void onEvent(StoreRequirementIDsEvent event) {

                 List<String> ids = event.getProgramRequirementIds();

                 programModel.set(QueryPath.parse(ProgramConstants.PROGRAM_REQUIREMENTS), new Data());

                 Data programRequirements = getDataProperty(ProgramConstants.PROGRAM_REQUIREMENTS);

                 if (programRequirements == null) {

                     Window.alert("Cannot find program requirements in data model.");

                     GWT.log("Cannot find program requirements in data model", null);

                     return;

                 }

                 for (String id : ids) {

                     programRequirements.add(id);

                 }

                 doSave();

             }

         });

         eventBus.addHandler(ChangeViewEvent.TYPE, new ChangeViewEvent.Handler() {

             @Override

             public void onEvent(ChangeViewEvent event) {

                 showView(event.getViewToken());

             }

         });

         eventBus.addHandler(UpdateEvent.TYPE, new UpdateEvent.Handler() {

             @Override

             public void onEvent(UpdateEvent event) {

                 doSave(event.getOkCallback());

             }

         });

         eventBus.addHandler(StateChangeEvent.TYPE, new StateChangeEvent.Handler() {

             @Override

             public void onEvent(final StateChangeEvent event) {

                 programModel.validateNextState(new Callback<List<ValidationResultInfo>>() {

                     @Override

                     public void exec(List<ValidationResultInfo> result) {

                         boolean isSectionValid = isValid(result, true);

                         if (isSectionValid) {

                             Callback<Boolean> callback = new Callback<Boolean>() {

                                 @Override

                                 public void exec(Boolean result) {

                                     if (result) {

                                         reloadMetadata = true;

                                         loadMetadata(new Callback<Boolean>() {

                                             @Override

                                             public void exec(Boolean result) {

                                                 if (result) {

                                                     ProgramUtils.syncMetadata(configurer, programModel.getDefinition());

                                                     HistoryManager.navigate(AppLocations.Locations.VIEW_CORE_PROGRAM.getLocation(), context);

                                                 }

                                             }

                                         });

                                     }

                                 }

                             };

                             updateState(event.getProgramStatus().getValue(), callback);

                          } else {

                             KSNotifier.add(new KSNotification("Unable to save, please check fields for errors.", false, true, 5000));

                         }

                     }

                 });

             }

         });

     }

     private void doCancel() {

         showView(ProgramSections.SUMMARY);

     }

     @Override

     protected void doSave() {

         doSave(NO_OP_CALLBACK);

     }

     @Override

     protected void loadModel(ModelRequestCallback<DataModel> callback) {

         ViewContext viewContext = getViewContext();

         if (viewContext.getIdType() == IdType.COPY_OF_OBJECT_ID) {

             createNewVersionAndLoadModel(callback, viewContext);

         } else {

             super.loadModel(callback);

         }

     }

     protected void createNewVersionAndLoadModel(final ModelRequestCallback<DataModel> callback, final ViewContext viewContext) {

         Data data = new Data();

         Data versionData = new Data();

         versionData.set(new Data.StringKey("versionIndId"), getViewContext().getId());

         versionData.set(new Data.StringKey("versionComment"), "Core Program Version");

         data.set(new Data.StringKey("versionInfo"), versionData);

         programRemoteService.saveData(data, new AbstractCallback<DataSaveResult>(ProgramProperties.get().common_retrievingData()) {

             @Override

             public void onSuccess(DataSaveResult result) {

                 super.onSuccess(result);

                 viewContext.setIdType(IdType.OBJECT_ID);

                 viewContext.setId(getStringProperty(ProgramConstants.ID));

                 refreshModelAndView(result);

                 callback.onModelReady(programModel);

                 eventBus.fireEvent(new ModelLoadedEvent(programModel));

             }

             @Override

             public void onFailure(Throwable caught) {

                 super.onFailure(caught);

                 callback.onRequestFail(caught);

             }

         });

     }

     private void doSave(final Callback<Boolean> okCallback) {

         requestModel(new ModelRequestCallback<DataModel>() {

             @Override

             public void onModelReady(DataModel model) {

                 CoreEditController.this.updateModelFromCurrentView();

                 model.validate(new Callback<List<ValidationResultInfo>>() {

                     @Override

                     public void exec(List<ValidationResultInfo> result) {

                         boolean isSectionValid = isValid(result, true);

                         if (isSectionValid) {

                             saveData(okCallback);

                         } else {

                             okCallback.exec(false);

                             KSNotifier.add(new KSNotification("Unable to save, please check fields for errors.", false, true, 5000));

                         }

                     }

                 });

             }

             @Override

             public void onRequestFail(Throwable cause) {

                 GWT.log("Unable to retrieve model for validation and save", cause);

             }

         });

     }

     private void saveData(final Callback<Boolean> okCallback) {

         programRemoteService.saveData(programModel.getRoot(), new AbstractCallback<DataSaveResult>(ProgramProperties.get().common_savingData()) {

             @Override

             public void onSuccess(DataSaveResult result) {

                 super.onSuccess(result);

                 //Clear warning states on field and any warnings stored in ApplicationContext;

                 clearAllWarnings();

                 Application.getApplicationContext().clearValidationWarnings();

                 List<ValidationResultInfo> validationResults = result.getValidationResults();

                 Application.getApplicationContext().addValidationWarnings(validationResults);

                 if (ValidatorClientUtils.hasErrors(validationResults)) {

                     isValid(result.getValidationResults(), false, true);

                     StringBuilder msg = new StringBuilder();

                     for (ValidationResultInfo vri : result.getValidationResults()) {

                             if(!msg.toString().contains(vri.getMessage()))

                                     msg.append(vri.getMessage() + " ");

                     }

                     if (msg.length() > 0)

                             KSNotifier.add(new KSNotification(msg.toString(), false, true, 5000));

                     okCallback.exec(false);

                 } else {

                     refreshModelAndView(result);

                     if (ProgramSections.getViewForUpdate().contains(getCurrentViewEnum().name())) {

                         processBeforeShow = false;

                         showView(getCurrentViewEnum());

                     }

                     resetFieldInteractionFlag();

                     throwAfterSaveEvent();

                     HistoryManager.logHistoryChange();

                     if (ValidatorClientUtils.hasWarnings(validationResults)){

                                             isValid(result.getValidationResults(), false, true);                                            

                                             KSNotifier.show("Saved with Warnings");

                                     } else {

                         KSNotifier.show(ProgramProperties.get().common_successfulSave());

                                     }                                  

                     okCallback.exec(true);

                 }

             }

         });

     }

     private void throwAfterSaveEvent() {

         eventBus.fireEvent(new AfterSaveEvent(programModel, this));

     }

     @Override

     public void onModelLoadedEvent() {

         Enum<?> changeSection = ProgramRegistry.getSection();

         if (changeSection != null) {

             showView(changeSection);

             ProgramRegistry.setSection(null);

         } else {

             String id = (String) programModel.get(ProgramConstants.ID);

             if (id == null) {

                 showView(ProgramSections.PROGRAM_DETAILS_EDIT);

             } else {

                 showView(ProgramSections.SUMMARY);

             }

         }

     }

         @Override

         public void beforeShow(final Callback<Boolean> onReadyCallback) {

                 if(!initialized){

                         Application.getApplicationContext().clearCrossConstraintMap(null);

                         Application.getApplicationContext().clearPathToFieldMapping(null);

                 }

                 //Clear the parent path again

                 Application.getApplicationContext().setParentPath("");

                 super.beforeShow(onReadyCallback);

         }

         //Before show is called before the model is bound to the widgets. We need to update cross constraints after widget binding

         //This gets called twice which is not optimal

         @Override

         public <V extends Enum<?>> void showView(V viewType,

                         final Callback<Boolean> onReadyCallback) {

                 Callback<Boolean> updateCrossConstraintsCallback = new Callback<Boolean>(){

                         public void exec(Boolean result) {

                                 onReadyCallback.exec(result);

                         for(HasCrossConstraints crossConstraint:Application.getApplicationContext().getCrossConstraints(null)){

                                 crossConstraint.reprocessWithUpdatedConstraints();

                         }

                         showWarnings();        

                         }

         };

                 super.showView(viewType, updateCrossConstraintsCallback);

         }

 }