package org.kuali.ole.editor.contoller;
   
   import org.apache.log4j.Logger;
   import org.kuali.ole.OLEConstants;
   import org.kuali.ole.docstore.model.xmlpojo.ingest.AdditionalAttributes;
   import org.kuali.ole.docstore.model.xmlpojo.work.instance.oleml.*;
   import org.kuali.ole.docstore.model.xstream.work.instance.oleml.WorkInstanceOlemlRecordProcessor;
   import org.kuali.ole.editor.bo.InstanceEditorFormDataHandler;
   import org.kuali.ole.editor.bo.InstanceRecordMetaData;
  import org.kuali.ole.editor.form.InstanceEditorForm;
  import org.kuali.ole.editor.service.DiscoveryHelperService;
  import org.kuali.ole.editor.service.DocstoreHelperService;
  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.bind.annotation.RequestMethod;
  import org.springframework.web.servlet.ModelAndView;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.util.*;
  
  /**
   * InstanceEditorController is the controller class for Instance Editor
   */
  @Controller
  @RequestMapping(value = "/instanceeditor")
  
  public class InstanceEditorController extends UifControllerBase {
  
      private DocstoreHelperService docstoreHelperService;
      private InstanceEditorFormDataHandler instanceEditorFormDataHandler;
      private DiscoveryHelperService discoveryHelperService;
  
      private static final Logger LOG = Logger.getLogger(InstanceEditorController.class);
  
      /**
       *   This method creates a instance of InstanceEditorForm
       * @param httpServletRequest
       * @return  InstanceEditorForm
       */
      @Override
      protected InstanceEditorForm createInitialForm(HttpServletRequest httpServletRequest) {
          return new InstanceEditorForm();
      }
  
      /**
       * This method takes the initial request when click on InstanceEditor 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) {
          InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
          return super.start(instanceEditorForm, result, request, response);
      }
  
      /**
       *  This method will fetch the holding/Item records based on the AdditionalAttributes.
       * @param form
       * @param result
       * @param request
       * @param response
       * @return  ModelAndView
       */
      @RequestMapping(params = "methodToCall=loadInstanceRecord")
      public ModelAndView loadInstanceRecord(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                             HttpServletRequest request, HttpServletResponse response) {
          InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
          String instanceIdentifier = request.getParameter("uuid");
          if (null == instanceIdentifier) {
              instanceIdentifier = instanceEditorForm.getUuid();
          }
          instanceEditorForm.setExisting("true");
          try {
              String docStoreData = getDocstoreHelperService().getDocstoreData(instanceIdentifier);
              InstanceCollection instanceCollection = new WorkInstanceOlemlRecordProcessor().fromXML(docStoreData);
              instanceEditorForm.setInstance(instanceCollection.getInstanceCollection().get(0));
  
              //Building Left Pane hierarchy
              getInstanceEditorFormDataHandler().buildLeftPaneData(instanceEditorForm);
  
              //Building MetaData fields
              getInstanceEditorFormDataHandler().setMetaData(instanceEditorForm, OLEConstants.HOLDING_DOC_TYPE);
  
              StringBuffer instanceEditorSuccessMessage = new StringBuffer(OLEConstants.INSTANCE_EDITOR_LOAD_SUCCESS);
              instanceEditorForm.setMessage(instanceEditorSuccessMessage.toString());
          } catch (Exception e) {
              StringBuffer instanceEditorErrorMessage = new StringBuffer(OLEConstants.INSTANCE_EDITOR_LOAD_FAILURE).append(" :: \n" + e.getMessage());
              instanceEditorForm.setMessage(instanceEditorErrorMessage.toString());
              LOG.error(instanceEditorErrorMessage);
         }
         return getUIFModelAndView(instanceEditorForm, OLEConstants.HOLDINGS_PAGE);
     }
 
     /**
      *  This method will ingest new record to docStore if uuid is null else it will update exisiting record.
      *  and nullify the form.
      * @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;
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         String uuid = instanceEditorForm.getUuid();
         try {
             if (uuid != null && !uuid.trim().equals("")) {
                 OleHolding holdingData = instanceEditorForm.getInstance().getHoldings();
                 String holdingId = instanceEditorForm.getInstance().getHoldings().getHoldingsIdentifier();
                 String holdingXmlContent = getInstanceEditorFormDataHandler().buildHoldingContent(holdingData);
                 String holdingRecordUpdateResponse =
                         getDocstoreHelperService().updateInstanceRecord(holdingId, OLEConstants.HOLDING_DOC_TYPE, holdingXmlContent);
                 for (int item = 0; item < instanceEditorForm.getInstance().getItem().size(); item++) {
                     OleItem itemData = instanceEditorForm.getInstance().getItem().get(item);
                     String itemId = instanceEditorForm.getInstance().getItem().get(item).getItemIdentifier();
                     String itemXmlContent = getInstanceEditorFormDataHandler().buildItemContent(itemData);
                     if (itemId == null) {   //New Item
                         //TODO: Change logic to get Instance UUID. As we are loading existing Instance Identifier, we are getting directly from form
                         String instanceUuid = uuid;
                         String itemRecordUpdateResponse =
                                 getDocstoreHelperService().createItemForInstanceRecord(instanceUuid, OLEConstants.ITEM_DOC_TYPE, itemXmlContent);
                     } else {
                         String itemRecordUpdateResponse =
                             getDocstoreHelperService().updateInstanceRecord(itemId, OLEConstants.ITEM_DOC_TYPE, itemXmlContent);
                     }
 
                 }
             }  else {
                 OleItem oleItem = instanceEditorForm.getSelectedItem();
                 instanceEditorForm.getInstance().setItem(Arrays.asList(oleItem));
                 String content =  getInstanceEditorFormDataHandler().buildInstanceRecordForDocStore(instanceEditorForm, uuid);
                 responseFromDocstore = getDocstoreHelperService().
                         instanceRecordCallToDocstore(content, null, OLEConstants.OLEML_FORMAT);
             }
             instanceEditorForm.setUuid("");
             StringBuffer instanceEditorSuccessMessage = new StringBuffer(OLEConstants.INSTANCE_EDITOR_SUCCESS);
             instanceEditorForm.setMessage(instanceEditorSuccessMessage.toString());
         } catch (Exception e) {
             StringBuffer instanceEditorErrorMessage = new StringBuffer(OLEConstants.INSTANCE_EDITOR_FAILURE).append(" :: \n" + e.getMessage());
             instanceEditorForm.setMessage(instanceEditorErrorMessage.toString());
             LOG.error(instanceEditorErrorMessage);
         }
         InstanceEditorForm finalForm = instanceEditorForm;
         instanceEditorForm.setInstance(new OleInstance());
         return getUIFModelAndView(finalForm, OLEConstants.HOLDINGS_PAGE);
     }
 
     /**
      *   This Method will update the Left Pane hierarchy details.
      * @param form
      * @param result
      * @param request
      * @param response
      * @return  ModelAndView
      */
     @RequestMapping(params = "methodToCall=updateLeftPane")
     public ModelAndView updateLeftPane(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                        HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         String hiddenVal = instanceEditorForm.getHdnUuid();
         int hdnIndex = instanceEditorForm.getHdnIndex();
         instanceEditorForm.setSelectedItem(instanceEditorForm.getInstance().getItem().get(hdnIndex));
         DiscoveryHelperService discoveryHelperService = getDiscoveryHelperService();
 
         List responseFromSOLR =  discoveryHelperService.getResponseFromSOLR("id", hiddenVal);
         String docType = null;
         for (Iterator iterator = responseFromSOLR.iterator(); iterator.hasNext(); ) {
             Map map = (Map) iterator.next();
             if (map.containsKey(OLEConstants.DOC_TYPE)) {
                 String list = (String) map.get(OLEConstants.DOC_TYPE);
                 docType = list;
                 break;
             }
         }
         if (docType.toString().equals(OLEConstants.ITEM_DOC_TYPE)) {
             getInstanceEditorFormDataHandler().setMetaData(instanceEditorForm, OLEConstants.ITEM_DOC_TYPE);
 
             return getUIFModelAndView(instanceEditorForm, OLEConstants.ITEM_PAGE);
         } else {
             return getUIFModelAndView(instanceEditorForm, OLEConstants.HOLDINGS_PAGE);
         }
     }
 
     /**
      * This method adds the existingItem records from docStore in to oleItems and it will be set in InstanceEditorForm.
      * @param form
      * @param result
      * @param request
      * @param response
      * @return ModelAndView
      */
     @RequestMapping(method = RequestMethod.POST,params = "methodToCall=addNewItem")
     public ModelAndView addItemRecord(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                       HttpServletRequest request, HttpServletResponse response){
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         List<OleItem> existingItemsFromDoc = instanceEditorForm.getInstance().getItem();
         List<OleItem> oleItems = new ArrayList<OleItem>();
 
         for(int i=0;i<existingItemsFromDoc.size();i++){
             oleItems.add(existingItemsFromDoc.get(i));
         }
         oleItems.add(new OleItem());
         instanceEditorForm.setItemRecordMetaData(new InstanceRecordMetaData());
         instanceEditorForm.getInstance().setItem(oleItems);
         instanceEditorForm.setHdnIndex(oleItems.size());
         int hdnIndex = instanceEditorForm.getHdnIndex();
         instanceEditorForm.setSelectedItem(instanceEditorForm.getInstance().getItem().get(hdnIndex-1));
         return getUIFModelAndView(instanceEditorForm, OLEConstants.ITEM_PAGE);
     }
 
     /**
      * This method will get new itemData
      * @param form
      * @param result
      * @param request
      * @param response
      * @return
      */
     @RequestMapping(method = RequestMethod.POST,params = "methodToCall=getNewItemData")
     public ModelAndView getNewItemData(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                        HttpServletRequest request, HttpServletResponse response){
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         List<OleItem> existingItemsFromDoc = instanceEditorForm.getInstance().getItem();
         List<OleItem> oleItems = new ArrayList<OleItem>();
 
         for(int i=0;i<existingItemsFromDoc.size();i++){
             oleItems.add(existingItemsFromDoc.get(i));
         }
         instanceEditorForm.setHdnIndex(oleItems.size());
         int hdnIndex = instanceEditorForm.getHdnIndex();
         instanceEditorForm.setSelectedItem(instanceEditorForm.getInstance().getItem().get(hdnIndex-1));
         return getUIFModelAndView(instanceEditorForm, OLEConstants.ITEM_PAGE);
     }
 
     /**
      *  Used for Test-case
      * @param result
      * @param request
      * @param response
      * @param instanceEditorForm
      * @return ModelAndView
      */
     protected ModelAndView callSuper(BindingResult result, HttpServletRequest request, HttpServletResponse response, InstanceEditorForm instanceEditorForm) {
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
     /**
      *  Gets the docstoreHelperService attribute
      * @return  Returns DocstoreHelperService
      */
     private DocstoreHelperService getDocstoreHelperService() {
         if (null == docstoreHelperService) {
             return new DocstoreHelperService();
         }
         return docstoreHelperService;
     }
 
     /**
      *    Sets the docstoreHelperService attribute values.
      * @param docstoreHelperService
      */
     public void setDocstoreHelperService(DocstoreHelperService docstoreHelperService) {
         this.docstoreHelperService = docstoreHelperService;
     }
 
     /**
      *  Gets the InstanceEditorFormDataHandler attribute.
      * @return Returns InstanceEditorFormDataHandler.
      */
     private InstanceEditorFormDataHandler getInstanceEditorFormDataHandler() {
         if (null == instanceEditorFormDataHandler) {
             instanceEditorFormDataHandler = new InstanceEditorFormDataHandler();
         }
         return instanceEditorFormDataHandler;
     }
 
     /**
      *  This method returns AdditionalAttributes instance from the list of Extension.
      * @param extensionList
      * @return  AdditionalAttributes
      */
     private AdditionalAttributes getFirstAdditionalAttributes(List<Extension> extensionList) {
         for (Extension ext : extensionList) {
             for (Object obj : ext.getContent()) {
                 if (obj instanceof AdditionalAttributes) {
                     return (AdditionalAttributes) obj;
                 }
             }
         }
         return null;
     }
 
     /**
      * Sets the discoveryHelperService attribute value.
      * @param discoveryHelperService
      */
     public void setDiscoveryHelperService(DiscoveryHelperService discoveryHelperService) {
         this.discoveryHelperService = discoveryHelperService;
     }
 
     /**
      *  Gets the discoveryHelperService attribute.
      * @return Returns DiscoveryHelperService.
      */
     public DiscoveryHelperService getDiscoveryHelperService() {
         if (null == discoveryHelperService) {
             return new DiscoveryHelperService();
         }
         return discoveryHelperService;
     }
 }