package org.kuali.ole.describe.controller;
   
   import org.apache.log4j.Logger;
   import org.kuali.ole.OLEConstants;
   import org.kuali.ole.UnQualifiedDublinRecordHandler;
   import org.kuali.ole.describe.bo.OleBibliographicRecordStatus;
   import org.kuali.ole.docstore.model.xmlpojo.ingest.AdditionalAttributes;
   import org.kuali.ole.describe.bo.DublinEditorField;
   import org.kuali.ole.describe.bo.DublinEditorFormDataHandler;
  import org.kuali.ole.describe.form.DublinEditorForm;
  import org.kuali.ole.describe.service.DocstoreHelperService;
  import org.kuali.ole.pojo.dublin.unqualified.UnQualifiedDublinRecord;
  import org.kuali.rice.krad.service.BusinessObjectService;
  import org.kuali.rice.krad.service.KRADServiceLocator;
  import org.kuali.rice.krad.uif.UifParameters;
  import org.kuali.rice.krad.util.GlobalVariables;
  import org.kuali.rice.krad.web.controller.UifControllerBase;
  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;
  import java.util.*;
  
  /**
   * DublinEditorController is the controller class for Dublin Editor
   */
  
  @Controller
  @RequestMapping(value = "/dublincomponents")
  public class DublinEditorController
          extends UifControllerBase {
      /**
       * @see org.kuali.rice.krad.web.controller.UifControllerBase#createInitialForm(javax.servlet.http.HttpServletRequest)
       */
      private static final Logger LOG = Logger.getLogger(DublinEditorController.class);
  
      private DublinEditorFormDataHandler dublinEditorFormDataHandler;
      private DocstoreHelperService docstoreHelperService;
  
      /**
       * This method creates a instance of DublinEditorForm
       *
       * @param request
       * @return DublinEditorForm
       */
      @Override
      protected DublinEditorForm createInitialForm(HttpServletRequest request) {
          return new DublinEditorForm();
      }
  
      /**
       * This method takes the initial request when click on DublinEditor Screen.
       *
       * @param form
       * @param result
       * @param request
       * @param response
       * @return ModelAndView
       */
      @Override
      @RequestMapping(params = "methodToCall=start")
      public ModelAndView start(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                HttpServletRequest request, HttpServletResponse response) {
          DublinEditorForm dublinEditorForm = (DublinEditorForm) form;
          return super.start(dublinEditorForm, result, request, response);
      }
  
      /**
       * This method   will add the dublin record based on the selected Line index and updates the component.
       *
       * @param form
       * @param result
       * @param request
       * @param response
       * @return ModelAndView
       */
      @RequestMapping(params = "methodToCall=addField")
      public ModelAndView addDublinField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                         HttpServletRequest request, HttpServletResponse response) {
          DublinEditorForm dublinEditorForm = (DublinEditorForm) form;
          int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
          index++;
          List<DublinEditorField> dublinEditorFieldList = dublinEditorForm.getDublinFieldList();
          dublinEditorFieldList.add(index, new DublinEditorField());
  //        return super.updateComponent(dublinEditorForm, result, request, response);
          return super.getUIFModelAndView(dublinEditorForm);
      }
  
      /**
       * This method will remove the DublinField based on the index position and updates the component.
       *
       * @param form
       * @param result
       * @param request
      * @param response
      * @return ModelAndView
      */
     @RequestMapping(params = "methodToCall=removeField")
     public ModelAndView removeDublinField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                           HttpServletRequest request, HttpServletResponse response) {
         DublinEditorForm dublinEditorForm = (DublinEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         String selectedCollection = form.getActionParamaterValue(UifParameters.SELLECTED_COLLECTION_PATH);
         List<DublinEditorField> dublinEditorFieldList = dublinEditorForm.getDublinFieldList();
         List<DublinEditorField> existingEditorFieldList;
         if (dublinEditorFieldList.size() > 1)
             dublinEditorFieldList.remove(index);
         if (selectedCollection.equalsIgnoreCase("existingDublinFieldList")) {
             existingEditorFieldList = dublinEditorForm.getExistingDublinFieldList();
             if (existingEditorFieldList.size() > 0) {
                 existingEditorFieldList.remove(index);
             }
         }
 //        return super.updateComponent(dublinEditorForm, result, request, response);
         return super.getUIFModelAndView(dublinEditorForm);
     }
 
     /**
      * This method will ingest new record to docStore if uuid is null else it will update exisiting record.
      * Once the responce has been received from docStore,then form has been nullified.
      * if response has not received from docStore then form nullified in catch block.
      *
      * @param form
      * @param result
      * @param request
      * @param response
      * @return ModelAndView
      */
     @RequestMapping(params = "methodToCall=submit")
     public ModelAndView submit(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                HttpServletRequest request, HttpServletResponse response) {
         String responseFromDocstore = null;
         DublinEditorForm dublinEditorForm = (DublinEditorForm) form;
         String bibliographicRecordStatusCode = dublinEditorForm.getBibStatus();
         String uuid = dublinEditorForm.getUuid();
         AdditionalAttributes additionalAttributes = new AdditionalAttributes();
         String content = "";
         BusinessObjectService boService = KRADServiceLocator.getBusinessObjectService();
         Map parentCriteria = new HashMap();
         parentCriteria.put("bibliographicRecordStatusCode", bibliographicRecordStatusCode);
         OleBibliographicRecordStatus bibliographicRecordStatus = boService
                 .findBySinglePrimaryKey(OleBibliographicRecordStatus.class, parentCriteria);
         if (bibliographicRecordStatus != null) {
             dublinEditorForm.setCreatedBy(GlobalVariables.getUserSession().getLoggedInUserPrincipalName());
             dublinEditorForm.setCreatedDate(bibliographicRecordStatus.getSourceDate());
             content = getDublinEditorFormDataHandler().buildDublinRecordForDocStore(form, uuid);
             additionalAttributes.setAttribute("dateEntered", bibliographicRecordStatus.getSourceDate().toString());
             additionalAttributes.setAttribute("createdBy", GlobalVariables.getUserSession().getLoggedInUserPrincipalName());
         }
         try {
             if (uuid != null && !uuid.trim().equals("")) {
                 responseFromDocstore = getDocstoreHelperService()
                         .persistToDocstoreWithAdditionalAttributesForEditor(content, additionalAttributes, uuid,
                                 OLEConstants.UNQUALIFIED_DUBLIN_FORMAT);
             } else {
                 responseFromDocstore = getDocstoreHelperService()
                         .persistToDocstoreWithAdditionalAttributesForEditor(content, additionalAttributes, null,
                                 OLEConstants.UNQUALIFIED_DUBLIN_FORMAT);
             }
             LOG.info("responseFromDocstore---->" + responseFromDocstore);
             dublinEditorForm.setDublinFieldList(Arrays.asList(new DublinEditorField()));
             dublinEditorForm.setExistingDublinFieldList(new ArrayList<DublinEditorField>());
             dublinEditorForm.setUuid("");
             dublinEditorForm.setMessage("Record saved successfully.");
         } catch (Exception e) {
             //e.printStackTrace();
             LOG.error("refreshLeftTree Exception:" + e);
             dublinEditorForm.setDublinFieldList(Arrays.asList(new DublinEditorField()));
             dublinEditorForm.setExistingDublinFieldList(new ArrayList<DublinEditorField>());
             dublinEditorForm.setMessage("Failed to save record.");
         }
         return getUIFModelAndView(dublinEditorForm, "DublinEditorViewPage");
     }
 
     /**
      * This method will fetch the DublinEditorForm records.
      *
      * @param form
      * @param result
      * @param request
      * @param response
      * @return ModelAndView
      */
     @RequestMapping(params = "methodToCall=loadDublinRecord")
     public ModelAndView loadDublinRecord(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                          HttpServletRequest request, HttpServletResponse response) {
         DublinEditorForm dublinEditorForm = (DublinEditorForm) form;
         String uuid = dublinEditorForm.getUuid();
         try {
             String docStoreData = getDocstoreHelperService().getDocstoreData(uuid);
             UnQualifiedDublinRecord unQualifiedDublinRecord = new UnQualifiedDublinRecordHandler().fromXML(docStoreData);
             dublinEditorForm.setExistingDublinFieldList(getDublinEditorFormDataHandler().buildDublinEditorFields(unQualifiedDublinRecord));
             dublinEditorForm.setDublinFieldList(new ArrayList<DublinEditorField>(Arrays.asList(new DublinEditorField())));
             //dublinEditorForm.setUuid("");
         } catch (Exception e) {
             //e.printStackTrace();
             LOG.error("loadDublinRecord Exception:" + e);
         }
         return getUIFModelAndView(dublinEditorForm, "DublinEditorViewPage");
     }
 
     /**
      * Gets the DublinEditorFormDataHandler attribute.
      *
      * @return Returns DublinEditorFormDataHandler.
      */
     private DublinEditorFormDataHandler getDublinEditorFormDataHandler() {
         if (null == dublinEditorFormDataHandler) {
             dublinEditorFormDataHandler = new DublinEditorFormDataHandler();
         }
         return dublinEditorFormDataHandler;
     }
 
     /**
      * Gets the docstoreHelperService attribute.
      *
      * @return Returns docstoreHelperService.
      */
     private DocstoreHelperService getDocstoreHelperService() {
         if (null == docstoreHelperService) {
             return new DocstoreHelperService();
         }
         return docstoreHelperService;
     }
 
     /**
      * Sets the docstoreHelperService attribute value.
      *
      * @param docstoreHelperService
      */
     public void setDocstoreHelperService(DocstoreHelperService docstoreHelperService) {
         this.docstoreHelperService = docstoreHelperService;
     }
 
     /**
      * used for test case.
      *
      * @param result
      * @param request
      * @param response
      * @param dublinEditorForm
      * @return ModelAndView
      */
     protected ModelAndView callSuper(BindingResult result, HttpServletRequest request, HttpServletResponse response, DublinEditorForm dublinEditorForm) {
 //        return super.updateComponent(dublinEditorForm, result, request, response);
         return super.getUIFModelAndView(dublinEditorForm);
     }
 
 }