/*
    * Copyright 2006 The Kuali Foundation
    *
    * Licensed under the Educational Community License, Version 2.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/ecl2.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.ole.module.purap.document.service;
  
  import org.kuali.ole.integration.purap.CapitalAssetSystem;
  import org.kuali.ole.module.purap.businessobject.*;
  import org.kuali.ole.module.purap.document.ContractManagerAssignmentDocument;
  import org.kuali.ole.module.purap.document.PurchaseOrderDocument;
  import org.kuali.ole.module.purap.document.PurchaseOrderSplitDocument;
  import org.kuali.ole.module.purap.document.RequisitionDocument;
  import org.kuali.ole.select.document.OlePurchaseOrderDocument;
  import org.kuali.ole.vnd.businessobject.VendorDetail;
  import org.kuali.ole.vnd.businessobject.VendorTransmissionFormatDetail;
  import org.kuali.rice.core.api.util.type.KualiDecimal;
  import org.kuali.rice.krad.bo.Note;
  
  import java.io.ByteArrayOutputStream;
  import java.util.HashMap;
  import java.util.List;
  
  /**
   * Defines methods that must be implemented by classes providing a PurchaseOrderService.
   */
  public interface PurchaseOrderService extends PurchasingDocumentSpecificService {
  
      public boolean isCommodityCodeRequiredOnPurchaseOrder();
  
      public boolean isPurchaseOrderOpenForProcessing(Integer poId);
  
      public boolean isPurchaseOrderOpenForProcessing(PurchaseOrderDocument purchaseOrderDocument);
  
      /**
       * Creates an automatic purchase order document using the given requisition document
       *
       * @param reqDocument The requisition document that this method will use to create the Automated Purchase Order (APO).
       */
      public void createAutomaticPurchaseOrderDocument(RequisitionDocument reqDocument);
  
      /**
       * Creates a PurchaseOrderDocument from given RequisitionDocument. Both documents need to be saved after this method is called.
       *
       * @param reqDocument         The requisition document that this method will use to create the purchase order.
       * @param newSessionUserId    The session user id that we'll use to invoke the performLogicWithFakedUserSession method of
       *                            PurapService.
       * @param contractManagerCode The contract manager code that we'll need to set on the purchase order.
       * @return The purchase order document object that is created by this method.
       */
      public PurchaseOrderDocument createPurchaseOrderDocument(RequisitionDocument reqDocument, String newSessionUserId, Integer contractManagerCode);
  
      /**
       * Creates and saves the purchase order change document (for example, PurchaseOrderAmendmentDocument) based on an existing
       * purchase order document.
       *
       * @param documentNumber        The document number of the existing purchase order document from which we try to create a new change
       *                              document.
       * @param docType               The document type of the new change document.
       * @param newDocumentStatusCode The status code that we want to set on the existing purchase order document after the new change
       *                              document is created.
       * @return The resulting new purchase order change document created by this method.
       */
      public PurchaseOrderDocument createAndSavePotentialChangeDocument(String documentNumber, String docType, String newDocumentStatusCode);
  
      /**
       * Creates and routes the purchase order change document (for example, PurchaseOrderCloseDocument) based on an existing purchase
       * order document.
       *
       * @param
       * @param documentNumber         The document number of the existing purchase order document from which we try to create a new change
       *                               document.
       * @param docType                The document type of the new change document.
       * @param annotation             The annotation that we'll use to invoke the routeDocument method of DocumentService.
       * @param adhocRoutingRecipients The adhocRoutingRecipients that we'll use to invoke the routeDocument method of
       *                               DocumentService.
       * @param newDocumentStatusCode  The status code that we want to set on the existing purchase order document after the new change
       *                               document is created.
       * @return The resulting new purchase order change document created by this method.
       */
      public PurchaseOrderDocument createAndRoutePotentialChangeDocument(String documentNumber, String docType, String annotation, List adhocRoutingRecipients, String newDocumentStatusCode);
  
      /**
       * Creates and saves a Purchase Order Split document based on the old PO document, and the items from that PO that the
       * new Split PO is to contain.
       *
       * @param newPOItems      The List<PurchaseOrderItem> of the items that the new Split PO is to contain
       * @param currentDocument The original PurchaseOrderDocument
       * @param copyNotes       A boolean.  True if notes are to be copied from the old document to the new.
      * @param splitNoteText   A String containing the text of the note to be added to the old document.
      * @return A PurchaseOrderSplitDocument containing the given list of items
      */
     public PurchaseOrderSplitDocument createAndSavePurchaseOrderSplitDocument(List<PurchaseOrderItem> newPOItems, PurchaseOrderDocument currentDocument, boolean copyNotes, String splitNoteText);
 
     /**
      * Obtains the internal purchasing dollar limit amount for a purchase order document.
      *
      * @param po The purchase order document for which this method is obtaining the internal purchasing dollar limit.
      * @return The internal purchasing dollar limit for the given purchase order document.
      */
     public KualiDecimal getInternalPurchasingDollarLimit(PurchaseOrderDocument po);
 
     public boolean printPurchaseOrderQuoteRequestsListPDF(String documentNumber, ByteArrayOutputStream baosPDF);
 
     public boolean printPurchaseOrderQuotePDF(PurchaseOrderDocument po, PurchaseOrderVendorQuote povq, ByteArrayOutputStream baosPDF);
 
     /**
      * Creates and displays the pdf document for the purchase order, sets the transmit dates, calls the
      * takeAllActionsForGivenCriteria method in PurApWorkflowIntegrationService to perform all the workflow related steps that are
      * necessary as part of the document initial print transmission and then performs the setup of initial of open document of the
      * purchase order.
      *
      * @param documentNumber The document number of the purchase order document that we want to perform the first transmit.
      * @param baosPDF        The ByteArrayOutputStream object that was passed in from the struts action so that we could display the pdf on
      *                       the browser.
      */
     public void performPurchaseOrderFirstTransmitViaPrinting(String documentNumber, ByteArrayOutputStream baosPDF);
 
     /**
      * Creates and displays the pdf document for the purchase order with a draft watermark
      *
      * @param documentNumber The document number of the purchase order document that we want to perform the first transmit.
      * @param baosPDF        The ByteArrayOutputStream object that was passed in from the struts action so that we could display the pdf on
      *                       the browser.
      */
     public void performPurchaseOrderPreviewPrinting(String documentNumber, ByteArrayOutputStream baosPDF);
 
     /**
      * Generates and displays the purchase order pdf by invoking the generatePurchaseOrderPdf method of the PrintService.
      *
      * @param documentNumber The document number of the purchase order document that we want to print the pdf.
      * @param baosPDF        The ByteArrayOutputStream object that we'll use to display the pdf on the browser.
      */
     public void performPrintPurchaseOrderPDFOnly(String documentNumber, ByteArrayOutputStream baosPDF);
 
     /**
      * Generates and displays the purchase order retransmit pdf by invoking the generatePurchaseOrderPdfForRetransmission method of
      * the PrintService.
      *
      * @param po      The purchase order document to be retransmitted.
      * @param baosPDF The ByteArrayOutputStream object that we'll use to display the pdf on the browser.
      */
     public void retransmitPurchaseOrderPDF(PurchaseOrderDocument po, ByteArrayOutputStream baosPDF);
 
     /**
      * Performs the steps needed to complete the newly approved purchase order document, which consists of setting the current and
      * pending indicators for the purchase order document and if the status is not pending transmission, then calls the
      * attemptsSetupOfInitialOpenOfDocument to set the statuses, the initial open date and save the document.
      *
      * @param po The newly approved purchase order document that we want to complete.
      */
     public void completePurchaseOrder(PurchaseOrderDocument po);
 
     public void retransmitB2BPurchaseOrder(PurchaseOrderDocument po);
 
     public void completePurchaseOrderAmendment(PurchaseOrderDocument po);
 
     /**
      * Obtains the purchase order document whose current indicator is true, given a purchase order id which is the
      * purapDocumentIdentifier.
      *
      * @param id The po id (purapDocumentIdentifier) that we'll use to retrieve the current purchase order document.
      * @return The current purchase order document (the po whose current indicator is true).
      */
     public PurchaseOrderDocument getCurrentPurchaseOrder(Integer id);
 
     /**
      * Obtains the purchase order document given the document number.
      *
      * @param documentNumber The document number of the purchase order that we want to retrieve.
      * @return The purchase order document whose document number is the given document number.
      */
     public PurchaseOrderDocument getPurchaseOrderByDocumentNumber(String documentNumber);
 
     /**
      * Sets the current and pending indicators of the new purchase order and the old purchase order as well as its status, then save
      * the purchase order.
      *
      * @param newPO The new purchase order document that has been approved.
      */
     public void setCurrentAndPendingIndicatorsForApprovedPODocuments(PurchaseOrderDocument newPO);
 
     /**
      * Sets the current and pending indicators of the new purchase order and the old purchase order as well as their statuses, then
      * save the purchase order.
      *
      * @param newPO The new purchase order document that has been disapproved.
      */
     public void setCurrentAndPendingIndicatorsForDisapprovedChangePODocuments(PurchaseOrderDocument newPO);
 
     /**
      * Sets the current and pending indicators of the new purchase order and the old purchase order as well as their statuses, then
      * save the purchase order.
      *
      * @param newPO The new purchase order document that has been canceled.
      */
     public void setCurrentAndPendingIndicatorsForCancelledChangePODocuments(PurchaseOrderDocument newPO);
 
     /**
      * Sets the current and pending indicators of the new purchase order and the old purchase order as well as their statuses, then
      * save the purchase order.
      *
      * @param newPO The new purchase order reopen document that has been canceled.
      */
     public void setCurrentAndPendingIndicatorsForCancelledReopenPODocuments(PurchaseOrderDocument newPO);
 
     /**
      * Sets the current and pending indicators of the new purchase order and the old purchase order as well as their statuses, then
      * save the purchase order.
      *
      * @param newPO The new purchase order reopen document that has been disapproved.
      */
     public void setCurrentAndPendingIndicatorsForDisapprovedReopenPODocuments(PurchaseOrderDocument newPO);
 
     /**
      * Sets the current and pending indicators of the new purchase order and the old purchase order as well as their statuses, then
      * save the purchase order
      *
      * @param newPO The new purchase order remove hold document that has been canceled.
      */
     public void setCurrentAndPendingIndicatorsForCancelledRemoveHoldPODocuments(PurchaseOrderDocument newPO);
 
     /**
      * Sets the current and pending indicators of the new purchase order and the old purchase order as well as their statuses, then
      * save the purchase order.
      *
      * @param newPO The new purchase order remove hold document that has been disapproved.
      */
     public void setCurrentAndPendingIndicatorsForDisapprovedRemoveHoldPODocuments(PurchaseOrderDocument newPO);
 
     /**
      * Obtains the oldest purchase order given the purchase order object to be used to search, then calls the updateNotes method to
      * set the notes on the oldest purchase order and finally return the oldest purchase order.
      *
      * @param po                     The current purchase order object from which we want to obtain the oldest purchase order.
      * @param documentBusinessObject The documentBusinessObject of the current purchase order object.
      * @return The oldest purchase order whose purchase order id is the same as the current purchase order's id.
      */
     public PurchaseOrderDocument getOldestPurchaseOrder(PurchaseOrderDocument po, PurchaseOrderDocument documentBusinessObject);
 
     /**
      * Obtains all the notes that belong to this purchase order given the purchase order id.
      *
      * @param id The purchase order id (purapDocumentIdentifier).
      * @return The list of notes that belong to this purchase order.
      */
     public List<Note> getPurchaseOrderNotes(Integer id);
 
     public List<PurchaseOrderQuoteStatus> getPurchaseOrderQuoteStatusCodes();
 
     /**
      * Performs a threshold check on the purchase order to determine if any attribute on the purchase order
      * falls within a defined threshold. This check is only perfromed if the receiving required flag is set to N.
      *
      * @param po
      */
     public void setReceivingRequiredIndicatorForPurchaseOrder(PurchaseOrderDocument po);
 
     /**
      * If there are commodity codes on the items on the PurchaseOrderDocument that
      * haven't existed yet on the vendor that the PurchaseOrderDocument is using,
      * then we will spawn a new VendorDetailMaintenanceDocument automatically to
      * update the vendor with the commodity codes that aren't already existing on
      * the vendor.
      *
      * @param po The PurchaseOrderDocument containing the vendor that we want to update.
      */
     public void updateVendorCommodityCode(PurchaseOrderDocument po);
 
     /**
      * Checks the item list for newly added unordered items.
      *
      * @param po
      * @return
      */
     public boolean hasNewUnorderedItem(PurchaseOrderDocument po);
 
     /**
      * Check whether each of the items contain commodity code, if so then loop
      * through the vendor commodity codes on the vendor to find out whether the
      * commodity code on the item has existed on the vendor. While doing that,
      * also check whether there exists a default commodity code on the vendor,
      * although we only need to check this until we find a vendor commodity code
      * with default indicator set to true. If we didn't find any matching
      * commodity code in the existing vendor commodity codes, then add the new
      * commodity code to a List of commodity code, create a new vendor commodity
      * code and set all of its attributes appropriately, including setting the
      * default indicator to true if we had not found any existing default commodity
      * code on the vendor, then add the newly created vendor commodity code to
      * the vendor (which is a deep copy of the original vendor on the PO).
      * After we're done with all of the items, if the List that contains the
      * commodity code that were being added to the vendor is not empty, then
      * for each entry on that list, we should create an empty VendorCommodityCode
      * to be added to the old vendor (the original vendor that is on the PO document).
      * The reason we're combining all of these processing here is so that we don't
      * need to loop through items and vendor commodity codes too many times.
      *
      * @param po The PurchaseOrderDocument containing the vendor that we want to update.
      * @return VendorDetail the vendorDetail object which is a deep copy of the original
      *         vendorDetail on the PurchaseOrderDocument, whose commodity codes have
      *         already been updated based on our findings on the items' commodity codes.
      */
     public VendorDetail updateVendorWithMissingCommodityCodesIfNecessary(PurchaseOrderDocument po);
 
     /**
      * Determines if a purchase order item is new unordered item.
      *
      * @param poItem
      * @return
      */
     public boolean isNewUnorderedItem(PurchaseOrderItem poItem);
 
     /**
      * Determines if a purchase order item is newly added on
      * the Purchase Order Amendment Document.
      *
      * @param poItem
      * @return
      */
     public boolean isNewItemForAmendment(PurchaseOrderItem poItem);
 
     /**
      * Used to provide sublists of the list of the original PO's items according to whether they
      * are marked to be moved or not.  Retrieving the item from the hash with the key of 'movingPOItems'
      * will retrieve those Items which should move, using 'remainingPOItems'.
      *
      * @param items A List<PurchaseOrderItem> from the original PO of a Split.
      * @return A HashMap<String, List<PurchaseOrderItem>> of categorized lists of items
      */
     public HashMap<String, List<PurchaseOrderItem>> categorizeItemsForSplit(List<PurchaseOrderItem> items);
 
     /**
      * Creates a PurchaseOrderVendorQuote based on the data on the selected vendor and the document number.
      *
      * @param headerId       The vendorHeaderGeneratedIdentifier of the selected vendor.
      * @param detailId       The vendorDetailAssignedIdentifier of the selected vendor.
      * @param documentNumber The documentNumber of the PurchaseOrderDocument containing this quote.
      * @return The resulting PurchaseOrderVendorQuote object.
      */
     public PurchaseOrderVendorQuote populateQuoteWithVendor(Integer headerId, Integer detailId, String documentNumber);
 
     /**
      * This method takes care of creating PurchaseOrderDocuments from a list of Requisitions on an ACM
      *
      * @param acmDoc An assign a contract manager document
      */
     public void processACMReq(ContractManagerAssignmentDocument acmDoc);
 
     /**
      * This gets a list of Purchase Orders in Open status and checks to see if their
      * line item encumbrances are all fully disencumbered and if so then the Purchase
      * Order is closed and notes added to indicate the change occurred in batch
      *
      * @return boolean true if the job is completed successfully and false otherwise.
      */
     public boolean autoCloseFullyDisencumberedOrders();
 
 
     /**
      * - PO status is OPEN
      * - Recurring payment type code is not null
      * - Vendor Choice is not Sub-Contract
      * - PO End Date <= parm date (comes from system parameter)
      * - Verify that the system parameter date entered is not greater than the current date minus three months.
      * If the date entered is invalid, the batch process will halt and an error will be generated.
      * - Close and disencumber all recurring PO's that have end dates less than
      * the system parameter date.
      * - Set the system parameter date to mm/dd/yyyy after processing.
      * - Send email indicating that the job ran and which orders were closed.
      * Mail it to the AUTO_CLOSE_RECURRING_PO_EMAIL_ADDRESSES in system parameter.
      *
      * @return boolean true if the job is completed successfully and false otherwise.
      */
     public boolean autoCloseRecurringOrders();
 
 
     /**
      * Return a list of PurchasingCapitalAssetItems where each item would have a CapitalAssetSystem. The CapitalAssetSystem provides
      * the capital asset information such as asset numbers and asset type.
      *
      * @param poId Purchase Order ID used to retrieve the asset information for the current PO
      * @return List of PurchasingCapitalAssetItems (each of which contain a CapitalAssetSystem)
      */
     public List<PurchasingCapitalAssetItem> retrieveCapitalAssetItemsForIndividual(Integer poId);
 
 
     /**
      * Return a CapitalAssetSystem which provides the capital asset information such as asset numbers and asset type.
      *
      * @param poId Purchase Order ID used to retrieve the asset information for the current PO
      * @return CapitalAssetSystem
      */
     public CapitalAssetSystem retrieveCapitalAssetSystemForOneSystem(Integer poId);
 
 
     /**
      * Return a list of CapitalAssetSystems which provide the capital asset information such as asset numbers and asset type.
      *
      * @param poId Purchase Order ID used to retrieve the asset information for the current PO
      * @return List of CapitalAssetSystems
      */
     public List<CapitalAssetSystem> retrieveCapitalAssetSystemsForMultipleSystem(Integer poId);
 
 
     /**
      * This method gets all the Purchase orders that are waiting for faxing
      *
      * @return List of POs
      */
     public List<PurchaseOrderDocument> getPendingPurchaseOrderFaxes();
 
     /**
      * Retrieves the purchase orders current status
      *
      * @param poId
      * @return
      */
     public String getPurchaseOrderAppDocStatus(Integer poId);
 
     /**
      * This method is to  send an FYI to fiscal officers for general ledger entries created for amend purchase order
      *
      * @param po
      */
     public void sendFyiForGLEntries(PurchaseOrderDocument po);
 
     public void initiateTransmission(PurchaseOrderDocument po, PurApItem item);
 
     public boolean processFTPTransmission(VendorTransmissionFormatDetail vendorTransmissionFormatDetail, String file, String ediFileName);
 
     public PurchaseOrderDocument createAndRoutePotentialChangeDocument(OlePurchaseOrderDocument olePurchaseOrderDocument, String docType, String annotation, List adhocRoutingRecipients, String currentDocumentStatusCode);
 }