/**
    * Copyright 2005-2013 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.rice.kew.batch;
  
  import org.kuali.rice.core.api.CoreApiServiceLocator;
  import org.kuali.rice.core.api.impex.xml.DirectoryXmlDocCollection;
  import org.kuali.rice.core.api.impex.xml.FileXmlDocCollection;
  import org.kuali.rice.core.api.impex.xml.XmlDocCollection;
  import org.kuali.rice.core.api.impex.xml.ZipXmlDocCollection;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileReader;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.text.Format;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Calendar;
  import java.util.Collection;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  
  
  /**
   * Utility class responsible for polling and ingesting XML data files
   * containing various forms of workflow engine data (e.g. document types
   * and rules).
   * Loaded files and problem files are placed into a subdirectory of a
   * configured 'loaded' and 'problem' directory, respectively.
   * "Problem-ness" is determined by inspecting a 'processed' flag on each <code>XmlDoc</code>
   * in each collection.  If not all <code>XmlDoc</code>s are marked 'processed' an
   * error is assumed, and the collection file (e.g. for a Zip, the Zip file) is moved
   * to the 'problem' directory.
   * As such, it is the <b><code>XmlIngesterService</code>'s responsibility</b> to mark
   * any unknown or otherwise innocuous non-failure non-processed files, as 'processed'.
   * A different mechanism can be developed if this proves to be a problem, but for now
   * it is simple enough for the <code>XmlIngesterService</code> to determine this.
   * @see org.kuali.rice.kew.batch.XmlPollerService
   * @see org.kuali.rice.kew.batch.XmlIngesterServiceImpl
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public class XmlPollerServiceImpl implements XmlPollerService {
  
      private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger
              .getLogger(XmlPollerServiceImpl.class);
      private static final Format DIR_FORMAT = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss-SSS");
  
      /**
       * Specifies the polling interval that should be used with this task.
       */
      private int pollIntervalSecs = 5 * 60; // default to 5 minutes
      /**
       * Specifies the initial delay the poller should wait before starting to poll
       */
      private int initialDelaySecs = 30; // default to 30 seconds
      /**
       * Location in which to find XML files to load.
       */
      private String xmlPendingLocation;
      /**
       * Location in which to place successfully loaded XML files.
       */
      private String xmlCompletedLocation;
      /**
       * Location in which to place XML files which have failed to load.
       */
      private String xmlProblemLocation;
      
      private String xmlParentDirectory;
      private static final String PENDING_MOVE_FAILED_ARCHIVE_FILE = "movesfailed";
      private static final String NEW_LINE = "\n";
  
      public void run() {
          // if(!directoriesWritable()){
          //     LOG.error("Error writing to xml data directories. Stopping xmlLoader ...");
          //     this.cancel();
          // }
          LOG.debug("checking for xml data files...");
          File[] files = getXmlPendingDir().listFiles();
          if (files == null || files.length == 0) {
          	return;
          }
          LOG.info("Found " + files.length + " files to ingest.");
          List<XmlDocCollection> collections = new ArrayList<XmlDocCollection>();
         for (File file : files)
         {
             if (file.isDirectory())
             {
                 collections.add(new DirectoryXmlDocCollection(file));
             } else if (file.getName().equals(PENDING_MOVE_FAILED_ARCHIVE_FILE))
             {
                 // the movesfailed file...ignore this
                 continue;
             } else if (file.getName().toLowerCase().endsWith(".zip"))
             {
                 try
                 {
                     collections.add(new ZipXmlDocCollection(file));
                 } catch (IOException ioe)
                 {
                     LOG.error("Unable to load file: " + file);
                 }
             } else if (file.getName().endsWith(".xml"))
             {
                 collections.add(new FileXmlDocCollection(file));
             } else
             {
                 LOG.warn("Ignoring extraneous file in xml pending directory: " + file);
             }
         }
 
         // Cull any resources which were already processed and whose moves failed
         Iterator collectionsIt = collections.iterator();
         Collection<XmlDocCollection> culled = new ArrayList<XmlDocCollection>();
         while (collectionsIt.hasNext()) {
             XmlDocCollection container = (XmlDocCollection) collectionsIt.next();
             // if a move has already failed for this archive, ignore it
             if (inPendingMoveFailedArchive(container.getFile())) {
                 LOG.info("Ignoring previously processed resource: " + container);
                 culled.add(container);
             }
         }
         collections.removeAll(culled);
 
         if (collections.size() == 0) {
             LOG.debug("No valid new resources found to ingest");
             return;
         }
 
         Date LOAD_TIME = Calendar.getInstance().getTime();
         // synchronization around date format should not be an issue as this code is single-threaded
         File completeDir = new File(getXmlCompleteDir(), DIR_FORMAT.format(LOAD_TIME));
         File failedDir = new File(getXmlProblemDir(), DIR_FORMAT.format(LOAD_TIME));
 
         // now ingest the containers
         Collection failed = null;
         try {
             failed = CoreApiServiceLocator.getXmlIngesterService().ingest(collections);
         } catch (Exception e) {
             LOG.error("Error ingesting data", e);
             //throw new RuntimeException(e);
         }
     
         // now iterate through all containers again, and move containers to approprate dir
         LOG.info("Moving files...");
         collectionsIt = collections.iterator();
         while (collectionsIt.hasNext()) {
             XmlDocCollection container = (XmlDocCollection) collectionsIt.next();
             LOG.debug("container: " + container);
             try {
                 // "close" the container
                 // this only matters for ZipFiles for now
                 container.close();
             } catch (IOException ioe) {
                 LOG.warn("Error closing " + container, ioe);
             }
             if (failed.contains(container)) {
                 // some docs must have failed, move the whole
                 // container to the failed dir
                 if (container.getFile() != null) {
                     LOG.error("Moving " + container.getFile() + " to problem dir.");
                     if ((!failedDir.isDirectory() && !failedDir.mkdirs())
                         || !moveFile(failedDir, container.getFile())) {
                         LOG.error("Could not move: " + container.getFile());
                         recordUnmovablePendingFile(container.getFile(), LOAD_TIME);         
                     }
                 }
             } else {
                 if (container.getFile() != null) {
                     LOG.info("Moving " + container.getFile() + " to loaded dir.");
                     if((!completeDir.isDirectory() && !completeDir.mkdirs())
                         || !moveFile(completeDir, container.getFile())){
                         LOG.error("Could not move: " + container.getFile());
                         recordUnmovablePendingFile(container.getFile(), LOAD_TIME);         
                     }
                 }
             }
         }
     }
 
     private boolean inPendingMoveFailedArchive(File xmlDataFile){
         if (xmlDataFile == null) return false;
         BufferedReader inFile = null;
         File movesFailedFile = new File(getXmlPendingDir(), PENDING_MOVE_FAILED_ARCHIVE_FILE);
         if (!movesFailedFile.isFile()) return false;
         try {
             inFile = new BufferedReader(new FileReader(movesFailedFile));
             String line;
             
             while((line = inFile.readLine()) != null){
                 String trimmedLine = line.trim();
                 if(trimmedLine.equals(xmlDataFile.getName()) ||
                    trimmedLine.startsWith(xmlDataFile.getName() + "=")) { 
                     return true;
                 }
             }
         } catch (IOException e){
             LOG.warn("Error reading file " + movesFailedFile);
             //TODO try reading the pending file or stop?
         } finally {
             if (inFile != null) try {
                 inFile.close();
             } catch (Exception e) {
                 LOG.warn("Error closing buffered reader for " + movesFailedFile);
             }
         }
       
         return false;
     }
 
     private boolean recordUnmovablePendingFile(File unMovablePendingFile, Date dateLoaded){
         boolean recorded = false;
         FileWriter archiveFile = null;
         try{
             archiveFile = new FileWriter(new File(getXmlPendingDir(), PENDING_MOVE_FAILED_ARCHIVE_FILE), true);  
             archiveFile.write(unMovablePendingFile.getName() + "=" + dateLoaded.getTime() + NEW_LINE);
             recorded = true;
         } catch (IOException e){
             LOG.error("Unable to record unmovable pending file " + unMovablePendingFile.getName() + "in the archive file " + PENDING_MOVE_FAILED_ARCHIVE_FILE);
         } finally {
             if (archiveFile != null) {
                 try {
                     archiveFile.close();
                 } catch (IOException ioe) {
                     LOG.error("Error closing unmovable pending file", ioe);
                 }
             }
         }
         return recorded;       
     }
 
     private boolean moveFile(File toDirectory, File fileToMove){
         boolean moved = true;
         if (!fileToMove.renameTo(new File(toDirectory.getPath(), fileToMove.getName()))){
             LOG.error("Unable to move file " + fileToMove.getName() + " to directory " + toDirectory.getPath());
             moved = false;
         }
         return moved;
     }
 
     private File getXmlPendingDir() {
         return new File(getXmlPendingLocation());
     }
 
     private File getXmlCompleteDir() {
         return new File(getXmlCompletedLocation());
     }
 
     private File getXmlProblemDir() {
         return new File(getXmlProblemLocation());
     }
 
     public String getXmlCompletedLocation() {
         return xmlCompletedLocation;
     }
 
     public void setXmlCompletedLocation(String xmlCompletedLocation) {
         this.xmlCompletedLocation = xmlCompletedLocation;
     }
 
     public String getXmlPendingLocation() {
         return xmlPendingLocation;
     }
 
     /*public boolean validate(File uploadedFile) {
         XmlDataLoaderFileFilter filter = new XmlDataLoaderFileFilter();
         return filter.accept(uploadedFile);
     }*/
 
     public void setXmlPendingLocation(String xmlPendingLocation) {
         this.xmlPendingLocation = xmlPendingLocation;
     }
 
     public String getXmlProblemLocation() {
         return xmlProblemLocation;
     }
 
     public void setXmlProblemLocation(String xmlProblemLocation) {
         this.xmlProblemLocation = xmlProblemLocation;
     }
     public String getXmlParentDirectory() {
         return xmlParentDirectory;
     }
     public void setXmlParentDirectory(String xmlDataParentDirectory) {
         this.xmlParentDirectory = xmlDataParentDirectory;
     }
 
     /**
      * Sets the polling interval time in seconds
      * @param seconds the polling interval time in seconds
      */
     public void setPollIntervalSecs(int seconds) {
         this.pollIntervalSecs = seconds;
     }
 
     /**
      * Gets the polling interval time in seconds
      * @return the polling interval time in seconds
      */
     public int getPollIntervalSecs() {
         return this.pollIntervalSecs;
     }
 
     /**
      * Sets the initial delay time in seconds
      * @param seconds the initial delay time in seconds
      */
     public void setInitialDelaySecs(int seconds) {
         this.initialDelaySecs = seconds;
     }
 
     /**
      * Gets the initial delay time in seconds
      * @return the initial delay time in seconds
      */
     public int getInitialDelaySecs() {
         return this.initialDelaySecs;
     }
 }