/*

  * Copyright 2011 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.rice.krad.web.controller;

 import org.apache.commons.lang.ArrayUtils;

 import org.apache.log4j.Logger;

 import org.kuali.rice.kew.util.KEWConstants;

 import org.kuali.rice.krad.bo.PersistableAttachment;

 import org.kuali.rice.krad.bo.PersistableBusinessObject;

 import org.kuali.rice.krad.datadictionary.DocumentEntry;

 import org.kuali.rice.krad.document.MaintenanceDocument;

 import org.kuali.rice.krad.exception.ValidationException;

 import org.kuali.rice.krad.maintenance.Maintainable;

 import org.kuali.rice.krad.maintenance.MaintenanceUtils;

 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;

 import org.kuali.rice.krad.service.MaintenanceDocumentService;

 import org.kuali.rice.krad.util.GlobalVariables;

 import org.kuali.rice.krad.util.KRADConstants;

 import org.kuali.rice.krad.web.form.DocumentFormBase;

 import org.kuali.rice.krad.web.form.MaintenanceForm;

 import org.kuali.rice.krad.web.form.UifFormBase;

 import org.springframework.stereotype.Controller;

 import org.springframework.validation.BindingResult;

 import org.springframework.web.bind.annotation.ModelAttribute;

 import org.springframework.web.bind.annotation.RequestMapping;

 import org.springframework.web.servlet.ModelAndView;

 import javax.servlet.http.HttpServletRequest;

 import javax.servlet.http.HttpServletResponse;

 /**

  * Controller for <code>MaintenanceView</code> screens which operate on

  * <code>MaintenanceDocument</code> instances

  *

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 @Controller

 @RequestMapping(value = "/maintenance")

 public class MaintenanceDocumentController extends DocumentControllerBase {

     protected static final Logger LOG = Logger.getLogger(MaintenanceDocumentController.class);

     @Override

     public MaintenanceForm createInitialForm(HttpServletRequest request) {

         return new MaintenanceForm();

     }

     /**

      * After the document is loaded calls method to setup the maintenance object

      */

     @Override

     @RequestMapping(params = "methodToCall=docHandler")

     public ModelAndView docHandler(@ModelAttribute("KualiForm") DocumentFormBase formBase, BindingResult result,

             HttpServletRequest request, HttpServletResponse response) throws Exception {

         // TODO getting double view if we call base, not sure how to handle

         // so pasting in superclass code

         // super.docHandler(formBase, request, response);

         // * begin copy/paste from the base

         MaintenanceForm form = (MaintenanceForm) formBase;

         // in all of the following cases we want to load the document

         if (ArrayUtils.contains(DOCUMENT_LOAD_COMMANDS, form.getCommand()) && form.getDocId() != null) {

             loadDocument(form);

         } else if (KEWConstants.INITIATE_COMMAND.equals(form.getCommand())) {

             createDocument(form);

         } else {

             LOG.error("docHandler called with invalid parameters");

             throw new IllegalStateException("docHandler called with invalid parameters");

         }

         // * end copy/paste from the base

         if (KEWConstants.ACTIONLIST_COMMAND.equals(form.getCommand()) ||

                 KEWConstants.DOCSEARCH_COMMAND.equals(form.getCommand()) ||

                 KEWConstants.SUPERUSER_COMMAND.equals(form.getCommand()) ||

                 KEWConstants.HELPDESK_ACTIONLIST_COMMAND.equals(form.getCommand()) && form.getDocId() != null) {

             // TODO: set state in view

             // form.setReadOnly(true);

             form.setMaintenanceAction((form.getDocument()).getNewMaintainableObject().getMaintenanceAction());

             // Retrieving the FileName from BO table

             Maintainable tmpMaintainable = form.getDocument().getNewMaintainableObject();

             if (tmpMaintainable.getDataObject() instanceof PersistableAttachment) {

                 PersistableAttachment bo = (PersistableAttachment) getBusinessObjectService()

                         .retrieve((PersistableBusinessObject) tmpMaintainable.getDataObject());

                 if (bo != null) {

                     request.setAttribute("fileName", bo.getFileName());

                 }

             }

         } else if (KEWConstants.INITIATE_COMMAND.equals(form.getCommand())) {

             // form.setReadOnly(false);

             setupMaintenance(form, request, KRADConstants.MAINTENANCE_NEW_ACTION);

         } else {

             LOG.error("We should never have gotten to here");

             throw new IllegalStateException("docHandler called with invalid parameters");

         }

         return getUIFModelAndView(form);

     }

     /**

      * Default method for controller that setups a new

      * <code>MaintenanceView</code> with the default new action

      */

     @RequestMapping(params = "methodToCall=" + KRADConstants.Maintenance.METHOD_TO_CALL_NEW)

     @Override

     public ModelAndView start(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,

             HttpServletRequest request, HttpServletResponse response) {

         MaintenanceForm maintenanceForm = (MaintenanceForm) form;

         setupMaintenance(maintenanceForm, request, KRADConstants.MAINTENANCE_NEW_ACTION);

         return getUIFModelAndView(maintenanceForm);

     }

     /**

      * Setups a new <code>MaintenanceView</code> with the edit maintenance

      * action

      */

     @RequestMapping(params = "methodToCall=" + KRADConstants.Maintenance.METHOD_TO_CALL_EDIT)

     public ModelAndView maintenanceEdit(@ModelAttribute("KualiForm") MaintenanceForm form, BindingResult result,

             HttpServletRequest request, HttpServletResponse response) throws Exception {

         setupMaintenance(form, request, KRADConstants.MAINTENANCE_EDIT_ACTION);

         return getUIFModelAndView(form);

     }

     /**

      * Setups a new <code>MaintenanceView</code> with the copy maintenance

      * action

      */

     @RequestMapping(params = "methodToCall=" + KRADConstants.Maintenance.METHOD_TO_CALL_COPY)

     public ModelAndView maintenanceCopy(@ModelAttribute("KualiForm") MaintenanceForm form, BindingResult result,

             HttpServletRequest request, HttpServletResponse response) throws Exception {

         setupMaintenance(form, request, KRADConstants.MAINTENANCE_COPY_ACTION);

         return getUIFModelAndView(form);

     }

     /**

      * Setups a new <code>MaintenanceView</code> with the new with existing

      * maintenance action

      */

     @RequestMapping(params = "methodToCall=" + KRADConstants.Maintenance.METHOD_TO_CALL_NEW_WITH_EXISTING)

     public ModelAndView maintenanceNewWithExisting(@ModelAttribute("KualiForm") MaintenanceForm form,

             BindingResult result, HttpServletRequest request, HttpServletResponse response) throws Exception {

         setupMaintenance(form, request, KRADConstants.MAINTENANCE_NEWWITHEXISTING_ACTION);

         return getUIFModelAndView(form);

     }

     /**

      * Sets up the <code>MaintenanceDocument</code> on initial get request

      *

      * <p>

      * First step is to create a new document instance based on the query

      * parameters (document type name or object class name). Then call the

      * <code>Maintainable</code> to do setup on the object being maintained.

      * </p>

      *

      * @param form - <code>MaintenanceForm</code> instance

      * @param request - HTTP request object

      * @param maintenanceAction - the maintenance action (new, new from existing, edit, copy)

      * being request

      * @throws Exception

      */

     protected void setupMaintenance(MaintenanceForm form, HttpServletRequest request, String maintenanceAction) {

         MaintenanceDocument document = form.getDocument();

         // create a new document object, if required

         if (document == null) {

             document = getMaintenanceDocumentService()

                     .setupNewMaintenanceDocument(form.getDataObjectClassName(), form.getDocTypeName(),

                             maintenanceAction);

             form.setDocument(document);

             form.setDocTypeName(document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName());

         }

         // set action on form

         form.setMaintenanceAction(maintenanceAction);

         // invoke maintenance document service to setup the object for maintenance

         getMaintenanceDocumentService().setupMaintenanceObject(document, maintenanceAction, request.getParameterMap());

         // for new maintainable check if a maintenance lock exists and if so

         // warn the user

         if (KRADConstants.MAINTENANCE_NEW_ACTION.equals(maintenanceAction)) {

             MaintenanceUtils.checkForLockingDocument(document, false);

         }

         // Retrieve notes topic display flag from data dictionary and add to

         // document

         // TODO: should be in the view as permission

         DocumentEntry entry = KRADServiceLocatorWeb.getDocumentDictionaryService()

                 .getMaintenanceDocumentEntry(document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName());

         document.setDisplayTopicFieldInNotes(entry.getDisplayTopicFieldInNotes());

     }

     /**

      * Override route to retrieve the maintenance object if it is an attachment

      *

      * @see DocumentControllerBase.route

      *      (DocumentFormBase, HttpServletRequest, HttpServletResponse)

      */

     @Override

     @RequestMapping(params = "methodToCall=route")

     public ModelAndView route(@ModelAttribute("KualiForm") DocumentFormBase form, BindingResult result,

             HttpServletRequest request, HttpServletResponse response) throws Exception {

         ModelAndView modelAndView;

         try {

             modelAndView = super.route(form, result, request, response);

             MaintenanceDocument document = (MaintenanceDocument) form.getDocument();

             if (document.getNewMaintainableObject().getDataObject() instanceof PersistableAttachment) {

                 PersistableAttachment bo = (PersistableAttachment) getBusinessObjectService()

                         .retrieve((PersistableBusinessObject) document.getNewMaintainableObject().getDataObject());

                 request.setAttribute("fileName", bo.getFileName());

             }

         } catch (ValidationException vex) {

             if (GlobalVariables.getMessageMap().hasNoErrors()) {

                 throw new RuntimeException("Validation Exception with no error message.", vex);

             }

             modelAndView = getUIFModelAndView(form);

         }

         return modelAndView;

     }

     protected MaintenanceDocumentService getMaintenanceDocumentService() {

         return KRADServiceLocatorWeb.getMaintenanceDocumentService();

     }

 }