package org.kuali.ole.module.purap.document.web.controller;
   
   import org.apache.commons.lang.StringUtils;
   import org.apache.struts.upload.FormFile;
   import org.kuali.ole.module.purap.PurapConstants;
   import org.kuali.ole.module.purap.PurapPropertyConstants;
   import org.kuali.ole.module.purap.businessobject.PurApAccountingLine;
   import org.kuali.ole.module.purap.businessobject.PurApAccountingLineParser;
   import org.kuali.ole.module.purap.businessobject.PurApItem;
  import org.kuali.ole.module.purap.document.OlePurchasingAccountsPayableDocument;
  import org.kuali.ole.module.purap.document.PurchasingAccountsPayableDocument;
  import org.kuali.ole.module.purap.document.PurchasingAccountsPayableDocumentBase;
  import org.kuali.ole.module.purap.document.service.impl.OLEPurchaseAccountsPayableControllerBaseServiceImpl;
  import org.kuali.ole.module.purap.document.web.form.OlePurchasingAccountsPayableFormBase;
  import org.kuali.ole.module.purap.document.web.form.OlePurchasingFormBase;
  import org.kuali.ole.module.purap.service.PurapAccountingService;
  import org.kuali.ole.sys.OLEConstants;
  import org.kuali.ole.sys.OLEPropertyConstants;
  import org.kuali.ole.sys.businessobject.AccountingLine;
  import org.kuali.ole.sys.businessobject.SourceAccountingLine;
  import org.kuali.ole.sys.context.SpringContext;
  import org.kuali.ole.sys.document.validation.event.AddAccountingLineEvent;
  import org.kuali.ole.sys.exception.AccountingLineParserException;
  import org.kuali.ole.sys.web.controller.OLEKualiAccountingDocumentControllerBase;
  import org.kuali.ole.sys.web.struts.KualiAccountingDocumentFormBase;
  import org.kuali.rice.kew.api.WorkflowDocument;
  import org.kuali.rice.kew.api.exception.WorkflowException;
  import org.kuali.rice.krad.document.Copyable;
  import org.kuali.rice.krad.service.DocumentService;
  import org.kuali.rice.krad.service.KualiRuleService;
  import org.kuali.rice.krad.service.PersistenceService;
  import org.kuali.rice.krad.util.GlobalVariables;
  import org.kuali.rice.krad.util.ObjectUtils;
  import org.kuali.rice.krad.web.form.DocumentFormBase;
  import org.kuali.rice.krad.web.form.TransactionalDocumentFormBase;
  import org.kuali.rice.krad.web.form.UifFormBase;
  import org.kuali.rice.krad.web.service.ControllerService;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.beans.factory.annotation.Qualifier;
  import org.springframework.stereotype.Controller;
  import org.springframework.validation.BindingResult;
  import org.springframework.web.bind.ServletRequestBindingException;
  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.io.FileNotFoundException;
  import java.io.IOException;
  import java.math.BigDecimal;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  /**
   * Created by premkumarv on 10/7/14.
   */
  
  @Controller
  @RequestMapping(value = "/OlePurchasingAccountsPayableControllerBase")
  public class OlePurchasingAccountsPayableControllerBase extends OLEKualiAccountingDocumentControllerBase {
  
      @Override
      @RequestMapping(params = "methodToCall=copy")
      public ModelAndView copy(@ModelAttribute("KualiForm") TransactionalDocumentFormBase form)  {
  //        TODO: Need to remove from comment super.copy(form) and remove below try/catch
  
  //        ModelAndView modelAndView = super.copy(form);
  
          try {
              ((Copyable) form.getDocument()).toCopy();
          } catch (WorkflowException e) {
              e.printStackTrace();
          }
  
          OlePurchasingAccountsPayableDocument purapDocument = (OlePurchasingAccountsPayableDocument) form.getDocument();
  
          //refresh accounts in each item....
          List<PurApItem> items = purapDocument.getItems();
  
          for (PurApItem item : items) {
              item.getNewSourceLine().setAccountLinePercent(new BigDecimal(0));
              //set default sequence number.
              for (PurApAccountingLine account : item.getSourceAccountingLines()) {
                  account.setSequenceNumber(0);
              }
          }
  
          return getModelAndView(form);
      }
  
      /**
       * @param documentFormBase
       * @throws WorkflowException
       */
      /*@Override
     protected void loadDocument(DocumentFormBase documentFormBase) throws WorkflowException {
         super.loadDocument(documentFormBase);
         OlePurchasingAccountsPayableFormBase purapForm = (OlePurchasingAccountsPayableFormBase) documentFormBase;
         OlePurchasingAccountsPayableDocument document = (OlePurchasingAccountsPayableDocument) purapForm.getDocument();
 
         // refresh the account summary (note this also updates the account amounts)
         purapForm.refreshAccountSummmary();
 
         for (org.kuali.rice.krad.bo.Note note : (java.util.List<org.kuali.rice.krad.bo.Note>) document.getNotes()) {
             note.refreshReferenceObject("attachment");
         }
 
         // sort the below the line
         SpringContext.getBean(PurapService.class).sortBelowTheLine(document);
 
         updateBaseline(document, (OlePurchasingAccountsPayableFormBase) documentFormBase);
     }*/
 
     /**
      * Updates the baseline accounts on form and doc.
      *
 
      * @param form
      */
     /*protected <T extends OlePurchasingAccountsPayableDocument, V extends OLEKualiAccountingDocumentFormBase> void updateBaseline(OlePurchasingAccountsPayableDocument document, OlePurchasingAccountsPayableFormBase form) {
         // clear out the old lines first
         for (PurApItem item : document.getItems()) {
             // clear out the old lines first
             item.getBaselineSourceAccountingLines().clear();
 
             for (PurApAccountingLine sourceAccount : item.getSourceAccountingLines()) {
                 // JHK: KFSMI-287 - removed deep copy since this object will be thrown away after the page renders, we just need a
                 // different path to have them stored on the form
                 // ESPECIALLY since PURAP does not allow lines to be reverted (see calls to setRevertible)
                 item.getBaselineSourceAccountingLines().add(sourceAccount);
             }
         }
     }
 
     /**
      * @param form
      * @param result
      * @param request
      * @param response
      * @return
      * @throws Exception
      */
     @RequestMapping(params = "methodToCall=refreshAccountSummary")
     public ModelAndView refreshAccountSummary(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                               HttpServletRequest request, HttpServletResponse response) throws Exception {
         OlePurchasingAccountsPayableFormBase purapForm = (OlePurchasingAccountsPayableFormBase) form;
         OlePurchasingAccountsPayableDocument document = (OlePurchasingAccountsPayableDocument) purapForm.getDocument();
         SpringContext.getBean(PurapAccountingService.class).updateAccountAmounts(document);
         purapForm.refreshAccountSummmary();
         return getModelAndView(form);
 
     }
 
     /**
      * @see org.kuali.ole.sys.web.struts.KualiAccountingDocumentActionBase#uploadAccountingLines(boolean, org.apache.struts.action.ActionForm)
      */
     @Override
     protected void uploadAccountingLines(boolean isSource, DocumentFormBase form) throws FileNotFoundException, IOException {
         OlePurchasingAccountsPayableFormBase purapForm = (OlePurchasingAccountsPayableFormBase) form;
         PurchasingAccountsPayableDocumentBase purapDocument = (PurchasingAccountsPayableDocumentBase) purapForm.getFinancialDocument();
         PurApAccountingLineParser accountingLineParser = (PurApAccountingLineParser) purapDocument.getAccountingLineParser();
         List importedLines = null;
         String errorPathPrefix = PurapConstants.ACCOUNT_DISTRIBUTION_ERROR_KEY;
         //String errorPathPrefix = "accountDistributionnewSourceLine";
 
         // import the lines
         try {
             FormFile sourceFile = purapForm.getSourceFile();
             checkUploadFile(sourceFile);
             GlobalVariables.getMessageMap().clearErrorPath();
             GlobalVariables.getMessageMap().addToErrorPath(errorPathPrefix);
             importedLines = accountingLineParser.importSourceAccountingLines(sourceFile.getFileName(), sourceFile.getInputStream(), purapDocument);
             GlobalVariables.getMessageMap().removeFromErrorPath(errorPathPrefix);
         } catch (AccountingLineParserException e) {
             GlobalVariables.getMessageMap().putError(errorPathPrefix, e.getErrorKey(), e.getErrorParameters());
         }
 
         // add to list those lines successfully imported
         if (importedLines != null) {
             for (Iterator iter = importedLines.iterator(); iter.hasNext(); ) {
                 PurApAccountingLine importedLine = (PurApAccountingLine) iter.next();
                 //boolean rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AddAccountingLineEvent(errorPathPrefix, purapForm.getDocument(), (AccountingLine) importedLine));
                 //if (rulePassed) {
                 // add accountingLine
                 SpringContext.getBean(PersistenceService.class).retrieveNonKeyFields(importedLine);
                 ((OlePurchasingFormBase) purapForm).addAccountDistributionsourceAccountingLine(importedLine);
                 //}
             }
         }
     }
 
     /**
      * @param form
      * @param result
      * @param request
      * @param response
      * @return
      * @throws Exception
      */
     @Override
     @RequestMapping(params = "methodToCall=insertSourceLine")
     public ModelAndView insertSourceLine(@ModelAttribute("KualiForm") DocumentFormBase form, BindingResult result,
                                          HttpServletRequest request, HttpServletResponse response) throws Exception {
         // It would be preferable to find a way to genericize the KualiAccountingDocument methods but this will work for now
         OlePurchasingAccountsPayableFormBase purapForm = (OlePurchasingAccountsPayableFormBase) form;
 
         // index of item selected
         int itemIndex = getSelectedLine(request);
         PurApItem item = null;
 
         // if custom processing of an accounting line is not done then insert a line generically.
         if (processCustomInsertAccountingLine(purapForm, request) == false) {
             String errorPrefix = null;
             PurApAccountingLine line = null;
             boolean rulePassed = false;
             if (itemIndex >= 0) {
                 item = (PurApItem) ((PurchasingAccountsPayableDocument) purapForm.getDocument()).getItem((itemIndex));
                 line = (PurApAccountingLine) ObjectUtils.deepCopy(item.getNewSourceLine());
                 //SpringContext.getBean(AccountService.class).populateAccountingLineChartIfNeeded(line);
                 errorPrefix = OLEPropertyConstants.DOCUMENT + "." + PurapPropertyConstants.ITEM + "[" + Integer.toString(itemIndex) + "]." + OLEConstants.NEW_SOURCE_ACCT_LINE_PROPERTY_NAME;
                 rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AddAccountingLineEvent(errorPrefix, purapForm.getDocument(), (AccountingLine) line));
             } else if (itemIndex == -2) {
                 //corrected: itemIndex == -2 is the only case for distribute account
                 //This is the case when we're inserting an accounting line for distribute account.
                 line = ((OlePurchasingFormBase) purapForm).getAccountDistributionnewSourceLine();
                 //SpringContext.getBean(AccountService.class).populateAccountingLineChartIfNeeded(line);
                 errorPrefix = PurapPropertyConstants.ACCOUNT_DISTRIBUTION_NEW_SRC_LINE;
                 rulePassed = SpringContext.getBean(KualiRuleService.class).applyRules(new AddAccountingLineEvent(errorPrefix, purapForm.getDocument(), (AccountingLine) line));
             }
 
             if (rulePassed) {
                 // add accountingLine
                 SpringContext.getBean(PersistenceService.class).retrieveNonKeyFields(line);
                 if (itemIndex >= 0) {
                     insertAccountingLine(purapForm, item, line);
                     // clear the temp account
                     item.resetAccount();
                 } else if (itemIndex == -2) {
                     //this is the case for distribute account
                     ((OlePurchasingFormBase) purapForm).addAccountDistributionsourceAccountingLine(line);
                 }
             }
         }
 
         return getModelAndView(form);
     }
 
     /**
      * Insert the given Accounting Line in several appropriate places in the given item and given form.
      *
      * @param financialDocumentForm A form that inherits from PurchasingAccountsPaybleFormBase
      * @param item                  A PurApItem
      * @param line                  A PurApAccountingLine
      */
     protected void insertAccountingLine(OlePurchasingAccountsPayableFormBase financialDocumentForm, PurApItem item, PurApAccountingLine line) {
         PurchasingAccountsPayableDocument preq = (PurchasingAccountsPayableDocument) financialDocumentForm.getDocument();
 
         Integer index = item.getSourceAccountingLines().size() + 1;
         line.setSequenceNumber(index);
         // add it to the item
         item.getSourceAccountingLines().add(line);
     }
 
     /**
      * Allows the custom processing of an accounting line during a call to insert source line. If a custom method for inserting an
      * accounting line was performed, then a value of true must be returned.
      *
      * @param purapForm
      * @param request
      * @return boolean indicating if validation succeeded
      */
     public boolean processCustomInsertAccountingLine(OlePurchasingAccountsPayableFormBase purapForm, HttpServletRequest request) {
         return false;
     }
 
     /**
      * Insert the given Accounting Line in several appropriate places in the given item and given form.
      *
      * @param financialDocumentForm A form that inherits from KualiAccountingDocumentFormBase
      * @param item                  A PurApItem
      * @param line                  A PurApAccountingLine
      */
     protected void insertAccountingLine(KualiAccountingDocumentFormBase financialDocumentForm, PurApItem item, PurApAccountingLine line) {
         // add it to the item
         item.getSourceAccountingLines().add(line);
     }
 
     /**
      * @param form
      * @param result
      * @param request
      * @param response
      * @return
      * @throws Exception
      */
     @Override
     @RequestMapping(params = "methodToCall=deleteSourceLine")
     public ModelAndView deleteSourceLine(@ModelAttribute("KualiForm") DocumentFormBase form, BindingResult result,
                                          HttpServletRequest request, HttpServletResponse response) throws Exception {
         OlePurchasingAccountsPayableFormBase purapForm = (OlePurchasingAccountsPayableFormBase) form;
 
         String[] indexes = getSelectedLineForAccounts(request);
         int itemIndex = Integer.parseInt(indexes[0]);
         int accountIndex = Integer.parseInt(indexes[1]);
 
         PurApItem item = (PurApItem) ((PurchasingAccountsPayableDocument) purapForm.getDocument()).getItem((itemIndex));
         if (itemIndex == -2) {
             item.getSourceAccountingLines().remove(accountIndex);
         } else {
             item.getSourceAccountingLines().remove(accountIndex);
             List<PurApAccountingLine> purApAccountingLineList = item.getSourceAccountingLines();
             BigDecimal initialPercent = new BigDecimal(0);
             for (PurApAccountingLine purApAccountingLine : purApAccountingLineList) {
                 initialPercent = initialPercent.add(purApAccountingLine.getAccountLinePercent());
             }
             initialPercent = new BigDecimal(100).subtract(initialPercent);
             if (initialPercent.intValue() > 0) {
                 item.resetAccount(initialPercent);
             } else {
                 item.resetAccount(new BigDecimal(0));
             }
         }
         return getModelAndView(form);
 
     }
 
 
     /**
      * @param form
      * @param request
      * @return
      */
     @Override
     public SourceAccountingLine getSourceAccountingLine(DocumentFormBase form, HttpServletRequest request) {
         String[] indexes = getSelectedLineForAccounts(request);
         int itemIndex = Integer.parseInt(indexes[0]);
         int accountIndex = Integer.parseInt(indexes[1]);
         OlePurchasingAccountsPayableFormBase purchasingAccountsPayableForm = (OlePurchasingAccountsPayableFormBase) form;
         SourceAccountingLine line;
         if (itemIndex == -2) {
             line = customAccountRetrieval(accountIndex, purchasingAccountsPayableForm);
         } else {
             PurApItem item = (PurApItem) ((PurchasingAccountsPayableDocument) purchasingAccountsPayableForm.getDocument()).getItem((itemIndex));
             line = (SourceAccountingLine) ObjectUtils.deepCopy(item.getSourceAccountingLines().get(accountIndex));
         }
         return line;
     }
 
     /**
      * Perform custom processing on accounting lines. See <code>getSelectedLineForAccounts</code>.
      *
      * @param accountIndex                  The index of the account into the request parameter
      * @param purchasingAccountsPayableForm A form which inherits from PurchasingAccountsPayableFormBase
      * @return A SourceAccountingLine
      */
     protected SourceAccountingLine customAccountRetrieval(int accountIndex, OlePurchasingAccountsPayableFormBase purchasingAccountsPayableForm) {
         // default impl returns null
         return null;
     }
 
     /**
      * Will return an array of Strings containing 2 indexes, the first String is the item index and the second String is the account
      * index. These are obtained by parsing the method to call parameter from the request, between the word ".line" and "." The
      * indexes are separated by a semicolon (:)
      *
      * @param request The HttpServletRequest
      * @return An array of Strings containing pairs of two indices, an item index and a account index
      */
     protected String[] getSelectedLineForAccounts(HttpServletRequest request) {
         String accountString = new String();
         String parameterName = (String) request.getAttribute(OLEConstants.METHOD_TO_CALL_ATTRIBUTE);
         if (StringUtils.isNotBlank(parameterName)) {
             accountString = StringUtils.substringBetween(parameterName, ".line", ".");
         }
         String[] result = StringUtils.split(accountString, ":");
 
         return result;
     }
 
     /**
      * @param response
      * @return
      * @throws ServletRequestBindingException
      * @throws FileNotFoundException
      * @throws IOException
      */
     @Override
     @RequestMapping(method = RequestMethod.POST, params = "methodToCall=downloadBOAttachment")
     public ModelAndView downloadAttachment(DocumentFormBase form, HttpServletResponse response) {
         PurchasingAccountsPayableDocument document = (PurchasingAccountsPayableDocument) ((OlePurchasingAccountsPayableFormBase) form).getDocument();
 
         for (org.kuali.rice.krad.bo.Note note : (java.util.List<org.kuali.rice.krad.bo.Note>) document.getNotes()) {
             note.refreshReferenceObject("attachment");
         }
         return super.downloadAttachment(form, response);
     }
 
 
     /*@Override
     protected void processAccountingLineOverrides(List accountingLines) {
         //do nothing purap handles these differently
     }
 
     /**
      * @param uifForm
      * @param result
      * @param request
      * @param response
      * @return
      */
     @RequestMapping(method = RequestMethod.POST, params = "methodToCall=calculate")
     public ModelAndView calculate(@ModelAttribute("KualiForm") UifFormBase uifForm) {
         return getModelAndView(uifForm);
 
     }
 
     /**
      * @param uifForm
      * @param result
      * @param request
      * @param response
      * @return
      */
     @RequestMapping(method = RequestMethod.POST, params = "methodToCall=clearAllTaxes")
     public ModelAndView clearAllTaxes(@ModelAttribute("KualiForm") UifFormBase uifForm, BindingResult result,
                                       HttpServletRequest request,
                                       HttpServletResponse response) {
         return getModelAndView(uifForm);
 
     }
 
     protected void customCalculate(OlePurchasingAccountsPayableDocument purapDoc) {
         // do nothing by default
     }
 
     /**
      * @param uifForm
      * @param request
      * @param response
      * @return
      */
 
     @RequestMapping(method = RequestMethod.POST, params = "methodToCall=showAllAccounts")
     public ModelAndView showAllAccounts(@ModelAttribute("KualiForm") UifFormBase uifForm,
                                         HttpServletRequest request,
                                         HttpServletResponse response) {
         OlePurchasingAccountsPayableFormBase olePurchasingAccountsPayableFormBase = (OlePurchasingAccountsPayableFormBase) uifForm;
         String accountingLineTab = "AccountingLines";
         String value = null;
 
         Map<String, String> tabStates = olePurchasingAccountsPayableFormBase.getTabStates();
         Map<String, String> newTabStates = new HashMap<String, String>();
         for (Map.Entry<String, String> tabEntry : tabStates.entrySet()) {
             if (tabEntry.getKey().startsWith(accountingLineTab)) {
                 newTabStates.put(tabEntry.getKey(), "OPEN");
             } else {
                 if (tabEntry.getValue() instanceof String) {
                     value = tabEntry.getValue();
                 } else {
                     //This is the case where the value is an Array of String,
                     //so we'll have to get the first element
                     Object result = tabEntry.getValue();
                     result.getClass();
                     value = ((String[]) result)[0];
                 }
                 newTabStates.put(tabEntry.getKey(), value);
             }
         }
         olePurchasingAccountsPayableFormBase.setTabStates(newTabStates);
         return getModelAndView(uifForm);
 
     }
 
     /**
      *
      * @param uifForm
      * @param request
      * @param response
      * @return
      */
 
     @RequestMapping(method = RequestMethod.POST, params = "methodToCall=hideAllAccounts")
     public ModelAndView hideAllAccounts(@ModelAttribute("KualiForm") UifFormBase uifForm,
                                         HttpServletRequest request,
                                         HttpServletResponse response) {
         OlePurchasingAccountsPayableFormBase olePurchasingAccountsPayableFormBase = (OlePurchasingAccountsPayableFormBase) uifForm;
         String accountingLineTab = "AccountingLines";
         String value = null;
 
         Map<String, String> tabStates = olePurchasingAccountsPayableFormBase.getTabStates();
         Map<String, String> newTabStates = new HashMap<String, String>();
         for (Map.Entry<String, String> tabEntry : tabStates.entrySet()) {
             if (tabEntry.getKey().startsWith(accountingLineTab)) {
                 newTabStates.put(tabEntry.getKey(), "CLOSE");
             } else {
                 if (tabEntry.getValue() instanceof String) {
                     value = tabEntry.getValue();
                 } else {
                     //This is the case where the value is an Array of String,
                     //so we'll have to get the first element
                     Object result = tabEntry.getValue();
                     result.getClass();
                     value = ((String[]) result)[0];
                 }
                 newTabStates.put(tabEntry.getKey(), value);
             }
         }
         olePurchasingAccountsPayableFormBase.setTabStates(newTabStates);
         return getModelAndView(uifForm);
 
     }
 
 
     @Override
     @RequestMapping(method = RequestMethod.POST, params = "methodToCall=insertNote")
     public ModelAndView insertNote(DocumentFormBase form) {
         OlePurchasingAccountsPayableDocument document = (OlePurchasingAccountsPayableDocument) ((OlePurchasingAccountsPayableFormBase) form).getDocument();
         WorkflowDocument workflowDocument = document.getDocumentHeader().getWorkflowDocument();
 
         if (workflowDocument.isInitiated()) {
             try {
                 SpringContext.getBean(DocumentService.class).saveDocument(document);
             } catch (WorkflowException e) {
                 e.printStackTrace();
             }
         }
 
         return super.insertNote(form);
 
     }
 
     @Override
     protected OLEPurchaseAccountsPayableControllerBaseServiceImpl getControllerService() {
         return (OLEPurchaseAccountsPayableControllerBaseServiceImpl)  super.getControllerService();
     }
 
     @Override
     @Autowired
     @Qualifier("olePurchaseAccountsPayableControllerBaseService")
     public void setControllerService(ControllerService controllerService) {
         super.setControllerService(controllerService);
     }
 
 
 }