/*
 * Copyright 2013 The Kuali Foundation.
 * 
 * Licensed under the Educational Community License, Version 1.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/ecl1.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;

import org.kuali.rice.core.api.CoreApiServiceLocator;
import org.kuali.rice.core.api.impex.xml.*;
import org.kuali.rice.kew.batch.XmlPollerService;

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.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

public abstract class OleXmlPollerServiceImpl implements OleXmlPollerService {



        private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(OleXmlPollerServiceImpl.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();
                Arrays.sort(files);
                if (files == null || files.length == 0) {
                        return;
                }
                LOG.info("Found " + files.length + " files to ingest.");
                for (int i = 0; i < files.length; i++) {
                        LOG.info(files[i].getAbsolutePath());
                }
                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 = getIngesterService().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);
                                        }
                                }
                        }
                }
        }

    protected abstract XmlIngesterService getIngesterService();

    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;
        }
}