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.*;
   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.uif.UifParameters;
  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);
      }
  
      @RequestMapping(method = RequestMethod.POST, params = "methodToCall=navigate")
      public ModelAndView navigate(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                   HttpServletRequest request, HttpServletResponse response) {
          InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
          String pageId = form.getActionParamaterValue(UifParameters.NAVIGATE_TO_PAGE_ID);
  
          return getUIFModelAndView(instanceEditorForm, pageId);
      }
  
      /**
       *  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.getInstance().get(0));
              instanceEditorForm.setSelectedHolding(instanceEditorForm.getInstance().getOleHoldings());
              instanceEditorForm.setSelectedItem(instanceEditorForm.getInstance().getItems().getItem().get(0));
              if(instanceEditorForm.getInstance().getSourceHoldings() != null) {
                  instanceEditorForm.setSelectedSourceHolding(
                         getInstanceEditorFormDataHandler().buildSourceHoldingForUI(instanceEditorForm));
             }
 
             getInstanceEditorFormDataHandler().setLocationDetails(instanceEditorForm);
             //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("")) {
                 OleHoldings holdingData = instanceEditorForm.getInstance().getOleHoldings();
                 String holdingId = instanceEditorForm.getInstance().getOleHoldings().getHoldingsIdentifier();
                 String holdingXmlContent = getInstanceEditorFormDataHandler().buildHoldingContent(holdingData);
                 String holdingRecordUpdateResponse =
                         getDocstoreHelperService().updateInstanceRecord(holdingId, OLEConstants.HOLDING_DOC_TYPE, holdingXmlContent);
 
                 for (int item = 0; item < instanceEditorForm.getInstance().getItems().getItem().size(); item++) {
                     Item itemData = instanceEditorForm.getInstance().getItems().getItem().get(item);
                     String itemId = instanceEditorForm.getInstance().getItems().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);
                     }
                 }
                 SourceHoldings sourceHoldings = getInstanceEditorFormDataHandler().buildSourceHoldings(instanceEditorForm);
                 String sourceHoldingId = sourceHoldings.getHoldingsIdentifier();
                 String sourceHoldinXml  =  getInstanceEditorFormDataHandler().buildSourceHoldingContent(sourceHoldings);
                 String sourceHoldingUpdateResponse =
                         getDocstoreHelperService().updateInstanceRecord(sourceHoldingId, "sourceHoldings", sourceHoldinXml);
             }  else {
                 Instance instance = new Instance();
                 instanceEditorForm.setInstance(instance);
                 Item oleItem = instanceEditorForm.getSelectedItem();
                 Items items = new Items();
                 items.setItem(Arrays.asList(oleItem));
                 instanceEditorForm.getInstance().setItems(items);
                 instanceEditorForm.getInstance().setOleHoldings(instanceEditorForm.getSelectedHolding());
                 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 Instance());
         instanceEditorForm.setSelectedHolding(new OleHoldings());
         instanceEditorForm.setSelectedSourceHolding(new SourceEditorForUI());
         instanceEditorForm.setSelectedItem(new Item());
         return getUIFModelAndView(finalForm, OLEConstants.HOLDINGS_PAGE);
         //return getUIFModelAndView(form);
     }
 
     /**
      *   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().getItems().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<Item> existingItemsFromDoc = instanceEditorForm.getInstance().getItems().getItem();
         List<Item> oleItems = new ArrayList<Item>();
 
         for(int i=0;i<existingItemsFromDoc.size();i++){
             oleItems.add(existingItemsFromDoc.get(i));
         }
         oleItems.add(new Item());
         instanceEditorForm.setItemRecordMetaData(new InstanceRecordMetaData());
         instanceEditorForm.getInstance().getItems().setItem(oleItems);
         instanceEditorForm.setHdnIndex(oleItems.size());
         int hdnIndex = instanceEditorForm.getHdnIndex();
         instanceEditorForm.setSelectedItem(instanceEditorForm.getInstance().getItems().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<Item> existingItemsFromDoc = instanceEditorForm.getInstance().getItems().getItem();
         List<Item> oleItems = new ArrayList<Item>();
 
         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().getItems().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;
     }
 
     /*@RequestMapping(params = "methodToCall=addExtentOfOwnership")
     public ModelAndView addExtentOfOwnership(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                              HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         index++;
         List<ExtentOfOwnershipForUI> extentOfOwnershipForUI = instanceEditorForm.getSelectedHolding().getExtentOfOwnershipForUI();
         extentOfOwnershipForUI.add(index, new ExtentOfOwnershipForUI());
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
     @RequestMapping(params = "methodToCall=removeExtentOfOwnership")
     public ModelAndView removeExtentOfOwnership(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                                 HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         List<ExtentOfOwnershipForUI> extentOfOwnershipForUI = instanceEditorForm.getSelectedHolding().getExtentOfOwnershipForUI();
         if (extentOfOwnershipForUI.size() > 1)
             extentOfOwnershipForUI.remove(index);
         return super.updateComponent(instanceEditorForm, result, request, response);
     }*/
 
     @RequestMapping(params = "methodToCall=addAccessInformation")
     public ModelAndView addAccessInformation(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                              HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         index++;
         List<Uri> accessInformation = instanceEditorForm.getSelectedHolding().getUri();
         accessInformation.add(index, new Uri());
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
     @RequestMapping(params = "methodToCall=removeAccessInformation")
     public ModelAndView removeAccessInformation(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                                 HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         List<Uri> accessInformation = instanceEditorForm.getSelectedHolding().getUri();
         if (accessInformation.size() > 1)
             accessInformation.remove(index);
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
     @RequestMapping(params = "methodToCall=addHoldingNotes")
     public ModelAndView addHoldingNotes(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                              HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         index++;
         List<Note> holdingsNote = instanceEditorForm.getSelectedHolding().getNote();
         holdingsNote.add(index, new Note());
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
     @RequestMapping(params = "methodToCall=removeHoldingNotes")
     public ModelAndView removeHoldingNotes(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                                 HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         List<Note> holdingsNote = instanceEditorForm.getSelectedHolding().getNote();
         if (holdingsNote.size() > 1)
             holdingsNote.remove(index);
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
     /**
      * This method will add the controlField record based on the selected Line index and updates the component.
      * @param form
      * @param result
      * @param request
      * @param response
      * @return  ModelAndView
      */
     @RequestMapping(params = "methodToCall=addControlField")
     public ModelAndView addControlField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                         HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         index++;
         List<MarcEditorControlField> marcEditorControlFieldList = instanceEditorForm.getSelectedSourceHolding().getControlFields();
         marcEditorControlFieldList.add(index, new MarcEditorControlField());
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
     /**
      *  This method will remove the controlField based on the index position and updates the component.
      * @param form
      * @param result
      * @param request
      * @param response
      * @return  ModelAndView
      */
     @RequestMapping(params = "methodToCall=removeControlField")
     public ModelAndView removeControlField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                            HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         List<MarcEditorControlField> editorControlFieldList = instanceEditorForm.getSelectedSourceHolding().getControlFields();
         if (editorControlFieldList.size() > 1)
             editorControlFieldList.remove(index);
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
     /**
      *  This method will add the datField record based on the selected Line index and updates the component.
      * @param form
      * @param result
      * @param request
      * @param response
      * @return ModelAndView
      */
     @RequestMapping(params = "methodToCall=addDataField")
     public ModelAndView addDataField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                      HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         index++;
         List<MarcEditorDataField> editorDataFieldList = instanceEditorForm.getSelectedSourceHolding().getDataFields();
         editorDataFieldList.add(index, new MarcEditorDataField());
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
     /**
      *    This method will remove the dataField based on the index position and updates the component.
      * @param form
      * @param result
      * @param request
      * @param response
      * @return ModelAndView
      */
     @RequestMapping(params = "methodToCall=removeDataField")
     public ModelAndView removeDataField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                         HttpServletRequest request, HttpServletResponse response) {
         InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
         int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
         List<MarcEditorDataField> marcEditorDataFieldList = instanceEditorForm.getSelectedSourceHolding().getDataFields();
         if (marcEditorDataFieldList.size() > 1)
             marcEditorDataFieldList.remove(index);
         return super.updateComponent(instanceEditorForm, result, request, response);
     }
 
 
 }