package org.kuali.ole.ingest;
   
   import org.kuali.ole.BibliographicRecordHandler;
   import org.kuali.ole.DataCarrierService;
   import org.kuali.ole.OLEConstants;
   import org.kuali.ole.OLETranscationalRecordGenerator;
   import org.kuali.ole.ingest.pojo.IngestRecord;
   import org.kuali.ole.ingest.pojo.MatchBo;
   import org.kuali.ole.ingest.pojo.ProfileAttributeBo;
  import org.kuali.ole.ingest.pojo.ProfileTerm;
  import org.kuali.ole.pojo.OleBibRecord;
  import org.kuali.ole.pojo.OleOrderRecord;
  import org.kuali.ole.pojo.OleTxRecord;
  import org.kuali.ole.pojo.bib.BibliographicRecord;
  import org.kuali.ole.pojo.bib.Collection;
  import org.kuali.ole.pojo.edi.EDIOrder;
  import org.kuali.ole.pojo.edi.EDIOrders;
  import org.kuali.ole.pojo.edi.LineItemOrder;
  import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
  import org.kuali.rice.krad.service.BusinessObjectService;
  import org.kuali.rice.krad.service.KRADServiceLocator;
  import org.kuali.rice.krms.api.KrmsApiServiceLocator;
  import org.kuali.rice.krms.api.engine.*;
  import org.kuali.rice.krms.impl.repository.AgendaBo;
  import org.xml.sax.SAXException;
  
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.xpath.XPathExpressionException;
  import java.io.IOException;
  import java.net.URISyntaxException;
  import java.util.*;
  
  /**
   * AbstractIngestProcessor which does the pre-processing for Staff Upload process to create Requisition.
   */
  public abstract class AbstractIngestProcessor {
      private static final String NAMESPACE_CODE_SELECTOR = "namespaceCode";
      private static final String NAME_SELECTOR = "name";
      private BusinessObjectService businessObjectService;
      private List<EngineResults> engineResults = new ArrayList<EngineResults>();
  
      String marcXMLContent;
      String ediXMLContent;
      private IngestRecord ingestRecord;
  
      /**
       *  Gets the engineResults attribute.
       * @return engineResults
       */
  
      public List<EngineResults> getEngineResults() {
          return engineResults;
      }
  
      /**
       *   This method takes the initial request when Ingesting a record.
       * @param ingestRecord
       */
  
      public void start(IngestRecord ingestRecord) {
          this.ingestRecord = ingestRecord;
  
          byPassLogicForPreProcess(ingestRecord.getMarcFileContent(), ingestRecord.getEdiFileContent(), ingestRecord.getByPassPreProcessing());
          try {
              process();
          } catch (URISyntaxException e) {
              System.out.println(e.getMessage());
          } catch (IOException e) {
              System.out.println(e.getMessage());
          } catch (SAXException e) {
              System.out.println(e.getMessage());
          } catch (XPathExpressionException e) {
              System.out.println(e.getMessage());
          } catch (ParserConfigurationException e) {
              System.out.println(e.getMessage());
          } catch (InterruptedException e) {
              System.out.println(e.getMessage());
          }
          postProcess();
      }
  
      /**
       * This method forwards to preProcess method if preProcessReq is true else sets the marcXmlContent and ediXmlContent.
       * @param rawMarcContent
       * @param rawEdiContent
       * @param preProcessingReq
       */
      private void byPassLogicForPreProcess(String rawMarcContent, String rawEdiContent, boolean preProcessingReq) {
          if (preProcessingReq) {
              preProcess(rawMarcContent, rawEdiContent);
          } else {
              marcXMLContent = rawMarcContent;
              ediXMLContent = rawEdiContent;
          }
      }
  
      /**
       *   This method forwards to preProcessMarc and preProcessEDI method.
       * @param rawMarcContent
      * @param rawEdiContent
      */
     private void preProcess(String rawMarcContent, String rawEdiContent) {
         marcXMLContent = preProcessMarc(rawMarcContent);
         ediXMLContent = preProcessEDI(rawEdiContent);
     }
 
     /**
      *  This method starts the process for marcXmlContent and ediXmlContent.
      * @throws URISyntaxException
      * @throws IOException
      * @throws SAXException
      * @throws XPathExpressionException
      * @throws ParserConfigurationException
      * @throws InterruptedException
      */
     public void process() throws URISyntaxException, IOException, SAXException, XPathExpressionException, ParserConfigurationException, InterruptedException {
         Engine engine = KrmsApiServiceLocator.getEngine();
 
         HashMap<String, String> map = new HashMap<String, String>();
         map.put("AGENDA_NAME", ingestRecord.getAgendaName());
         List<MatchBo> matchBos = (List<MatchBo>) getBusinessObjectService().findMatching(MatchBo.class, map);
 
         HashMap<String, Object> agendaValue = new HashMap<String, Object>();
         agendaValue.put("nm", ingestRecord.getAgendaName());
         List<AgendaBo> agendaBos = (List<AgendaBo>) getBusinessObjectService().findMatching(AgendaBo.class, agendaValue);
         AgendaBo agendaBo = agendaBos.get(0);
 
         SelectionCriteria selectionCriteria =
                 SelectionCriteria.createCriteria(null, getSelectionContext(agendaBo.getContext().getName()), getAgendaContext(ingestRecord.getAgendaName()));
 
         ExecutionOptions executionOptions = new ExecutionOptions();
         executionOptions.setFlag(ExecutionFlag.LOG_EXECUTION, true);
 
         OLETranscationalRecordGenerator oleTranscationalRecordGenerator = new OLETranscationalRecordGenerator();
         EDIOrders ediOrders = oleTranscationalRecordGenerator.fromXml(ediXMLContent);
 
         BibliographicRecordHandler bibliographicRecordHandler = new BibliographicRecordHandler();
         Collection bibliographicRecords = bibliographicRecordHandler.fromXML(marcXMLContent);
 
         List<BibliographicRecord> records = bibliographicRecords.getRecords();
 
         List<ProfileAttributeBo> profileAttributeBos = getProfileAttributeBos(ingestRecord.getAgendaName());
 
         EDIOrder ediOrder = ediOrders.getOrders().get(0);
         //TODO: Removing this validation as need to fix in OLE_Rice1.0-from load summary if re-ingested
         //TODO: the num of marc and edi files may not match as the edi order is a whole and needs to be broken
         //TODO: into one marc to one line item order and not one marc to one edi order.
         // if (isNumMarcMatchingNumEdiRecords(ediOrder, records)) {
         for (Iterator<BibliographicRecord> iterator = records.iterator(); iterator.hasNext(); ) {
             BibliographicRecord bibliographicRecord = iterator.next();
             String singleMarcXML = bibliographicRecordHandler.generateXML(bibliographicRecord);
             Map<String, String> valuesMap = bibliographicRecordHandler.valuesMapFromXML(singleMarcXML);
 
             Facts.Builder factBuilder = Facts.Builder.create();
             for (Iterator<MatchBo> matchBoIterator = matchBos.iterator(); matchBoIterator.hasNext(); ) {
                 MatchBo matchBo = matchBoIterator.next();
                 ProfileTerm term = new ProfileTerm();
                 term.setIncomingField(valuesMap.get(matchBo.getIncomingField()));
                 term.setExistingField(matchBo.getExistingField());
                 factBuilder.addFact(matchBo.getTermName(), term);
             }
 
             DataCarrierService dataCarrierService = GlobalResourceLoader.getService(OLEConstants.DATA_CARRIER_SERVICE);
             dataCarrierService.addData(OLEConstants.REQUEST_BIB_RECORD, bibliographicRecord);
             dataCarrierService.addData(OLEConstants.PROFILE_ATTRIBUTE_LIST, profileAttributeBos);
 
             EngineResults engineResult = engine.execute(selectionCriteria, factBuilder.build(), executionOptions);
             OleBibRecord oleBibRecord = (OleBibRecord) engineResult.getAttribute(OLEConstants.OLE_BIB_RECORD);
             OleOrderRecord oleOrderRecord = new OleOrderRecord();
             oleOrderRecord.setAgendaName(ingestRecord.getAgendaName());
             oleOrderRecord.setOleOriginalBibRecordFileName(ingestRecord.getOriginalMarcFileName());
             oleOrderRecord.setOriginalEDIFileName(ingestRecord.getOriginalEdiFileName());
             oleOrderRecord.setOriginalRecord(bibliographicRecord);
             oleOrderRecord.setDescription(ingestRecord.getAgendaDescription());
             oleOrderRecord.setOriginalEdi(ediOrder);
 
             if (null != oleBibRecord) {
                 oleOrderRecord.setOleBibRecord(oleBibRecord);
                 OleTxRecord oleTxRecord = getMatchingTxRecord(ediOrder, bibliographicRecord, profileAttributeBos);
                 oleOrderRecord.setOleTxRecord(oleTxRecord);
             }
             List<ResultEvent> allResults = engineResult.getAllResults();
             for (Iterator<ResultEvent> resultEventIterator = allResults.iterator(); resultEventIterator.hasNext(); ) {
                 ResultEvent resultEvent = resultEventIterator.next();
                 String ruleEvaluated = null;
                 if (resultEvent.getType().equals("Rule Evaluated")) {
                     ruleEvaluated = resultEvent.getSource() + " : " + resultEvent.getResult();
                     List rulesEvaluatedList = (List) oleOrderRecord.getMessageMap().get("rulesEvaluated");
                     if (null == rulesEvaluatedList) {
                         rulesEvaluatedList = new ArrayList();
                     }
                     rulesEvaluatedList.add(ruleEvaluated);
                     oleOrderRecord.addMessageToMap("rulesEvaluated", rulesEvaluatedList);
                 }
             }
             engineResult.setAttribute(OLEConstants.OLE_ORDER_RECORD, oleOrderRecord);
             engineResults.add(engineResult);
         }
         //} else {
 //        EngineResultsImpl exceptionResult = new EngineResultsImpl();
 //        exceptionResult.setAttribute(OLEConstants.OLE_ORDER_RECORD, null);
 //        engineResults.add(exceptionResult);
         // }
     }
 
     /**
      *  This method checks the size of marc record  and edi record, if it is equal it will return true otherwise return false.
      * @param ediOrder
      * @param records
      * @return   boolean
      */
     private boolean isNumMarcMatchingNumEdiRecords(EDIOrder ediOrder, List<BibliographicRecord> records) {
         return records.size() == ediOrder.getLineItemOrder().size();
     }
 
     /**
      *  This method returns Vendor Profile code based on profileAttributeBo.
      * @param profileAttributeBo
      * @return   attributeValue.
      */
     private String getVendorProfileCode(List<ProfileAttributeBo> profileAttributeBo) {
         for (Iterator<ProfileAttributeBo> iterator = profileAttributeBo.iterator(); iterator.hasNext(); ) {
             ProfileAttributeBo attributeBo = iterator.next();
             if (attributeBo.getAttributeName().equals(OLEConstants.VENDOR_PROFILE_CODE)) {
                 return attributeBo.getAttributeValue();
             }
         }
         return null;
     }
 
     /**
      *  This method gets the ProfileAttributeBos based on agendaName.
      * @param agendaName
      * @return  matching
      */
     public List<ProfileAttributeBo> getProfileAttributeBos(String agendaName) {
         HashMap map = new HashMap();
         map.put("agenda_name", agendaName);
         List<ProfileAttributeBo> matching = (List<ProfileAttributeBo>) getBusinessObjectService().findMatching(ProfileAttributeBo.class, map);
         return matching;
     }
 
     /**
      * This method gets the oleTxRecord based on lineItemOrder,ediOrder.
      * @param ediOrder
      * @param bibliographicRecord
      * @param profileAttributeBos
      * @return  oleTxRecord
      */
     private OleTxRecord getMatchingTxRecord(EDIOrder ediOrder, BibliographicRecord bibliographicRecord, List<ProfileAttributeBo> profileAttributeBos) {
         LineItemOrderMatcherForBib lineItemOrderMatcherForBib = new LineItemOrderMatcherForBib();
         LineItemOrder lineItemOrder = lineItemOrderMatcherForBib.getLineItemOrder(ediOrder.getLineItemOrder(), bibliographicRecord, getVendorProfileCode(profileAttributeBos));
         OleTxRecord oleTxRecord = OleTxRecordBuilder.getInstance().build(lineItemOrder, profileAttributeBos, ediOrder);
         return oleTxRecord;
     }
 
     /**
      *  Gets the instance of businessObjectService.
      *  if businessObjectService is null it will create a new instance else it will return existing businessObjectService.
      * @return  businessObjectService
      */
     private BusinessObjectService getBusinessObjectService() {
         if (null == businessObjectService) {
             businessObjectService = KRADServiceLocator.getBusinessObjectService();
         }
         return businessObjectService;
     }
 
     /**
      *  This method returns selector map contains OLE code  and contextName.
      * @param contextName
      * @return  selector
      */
     protected Map<String, String> getSelectionContext(String contextName) {
         Map<String, String> selector = new HashMap<String, String>();
         selector.put(NAMESPACE_CODE_SELECTOR, "OLE");
         selector.put(NAME_SELECTOR, contextName);
         return selector;
     }
 
     /**
      *   This method returns selector map contains agendaName
      * @param agendaName
      * @return  selector
      */
     protected Map<String, String> getAgendaContext(String agendaName) {
         Map<String, String> selector = new HashMap<String, String>();
         selector.put(NAME_SELECTOR, agendaName);
         return selector;
     }
 
     public abstract String preProcessMarc(String marcFileContent);
 
     public abstract String preProcessEDI(String ediFileContent);
 
     public abstract void postProcess();
 
 }