/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache 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.apache.org/licenses/LICENSE-2.0
 *
 * 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.apache.oodt.cas.pushpull.config;

//OODT imports
import org.apache.oodt.cas.pushpull.exceptions.ConfigException;
import org.apache.oodt.cas.pushpull.objectfactory.PushPullObjectFactory;
import org.apache.oodt.cas.pushpull.retrievalsystem.RemoteFileMetKeys;
import org.apache.oodt.cas.filemgr.ingest.Ingester;
import org.apache.oodt.cas.metadata.util.PropertiesUtils;

//JDK imports
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * This class will parse a java .properties file for FileRetrievalSystem so that
 * information can be easily accessed through getter methods.
 * 
 * @author bfoster
 * 
 */
public class Config implements ConfigMetKeys {

    private ProtocolInfo pi;

    private ParserInfo parserInfo;

    private Ingester ingester;

    private URL fmUrl;

    private String productTypeDetectionFile;

    private boolean useTracker;

    private boolean onlyDefinedTypes;

    private int recommendedThreadCount;

    private int maxFailedDownloads;

    private boolean writeMetFile;
    
    private String metFileExtension;

    private String[] listOfMetadataToOutput;

    private File baseStagingArea;

    /* our log stream */
    private static final Logger LOG = Logger.getLogger(Config.class.getName());

    /**
     * Constructor
     * 
     * @param fileName
     *            Name of the configuration file to parse
     */
    public Config() {
        pi = new ProtocolInfo();
        parserInfo = new ParserInfo();
        this.maxFailedDownloads = 10;
        this.recommendedThreadCount = 8;
        listOfMetadataToOutput = new String[] { RemoteFileMetKeys.PRODUCT_NAME,
                RemoteFileMetKeys.RETRIEVED_FROM_LOC,
                RemoteFileMetKeys.DATA_PROVIDER, RemoteFileMetKeys.FILE_SIZE,
                RemoteFileMetKeys.PRODUCT_TYPE };
        int i = 1;
        do {
            this.baseStagingArea = new File("./" + STAGING_AREA_PREFIX + "_"
                    + i++);
        } while (this.baseStagingArea.exists());
    }

    /**
     * Opens the configuration file and adds its properties to System properties
     * 
     * @return
     */
    public void loadConfigFile(File configFile) throws ConfigException {

        // load properties from configuration file
        try {
            System.getProperties().load(new FileInputStream(configFile));
        } catch (Exception e) {
            throw new ConfigException("Failed to load properties file : "
                    + e.getMessage());
        }

        // parse properties and xml file specified in config file
        try {
            loadProperties();
        } catch (Exception e) {
            throw new ConfigException(
                    "Failed to get properties from properties file : "
                            + e.getMessage());
        }
    }

    public void setProtocolInfo(ProtocolInfo pi) {
        this.pi = pi;
    }

    public void setUseTracker(boolean useTracker) {
        this.useTracker = useTracker;
    }

    public void setIngester(Ingester ingester) {
        this.ingester = ingester;
    }
    
    public void setFmUrl(URL fmUrl){
        this.fmUrl = fmUrl;
    }

    public void setTempInfoFileExtension(String extension) {
        this.metFileExtension = extension;
    }

    public void setRecommendedThreadCount(int count) {
        this.recommendedThreadCount = count;
    }

    public void setMaxAllowedFailedDownloads(int max) {
        this.maxFailedDownloads = max;
    }

    public void setOnlyDownloadDefinedTypes(boolean onlyDefinedTypes) {
        this.onlyDefinedTypes = onlyDefinedTypes;
    }

    public void setBaseStagingArea(File baseStagingArea) {
        this.baseStagingArea = baseStagingArea;
    }

    public void setProductTypeDetectionFile(String filePath) {
        this.productTypeDetectionFile = filePath;
    }
    
    public void setWriteMetFile(boolean writeMetFile) {
    	this.writeMetFile = writeMetFile;
    }

    /**
     * Parses the properties which were added to System properties by
     * loadConfigFile(). Stores info for access by getter methods
     * 
     * @throws ConfigException
     * @throws InstantiationException
     * @throws IOException
     * @throws FileNotFoundException
     * @throws ClassNotFoundException
     * @throws ClassNotFoundException
     */
    void loadProperties() throws ConfigException, InstantiationException,
            FileNotFoundException, IOException, ClassNotFoundException {
        this.loadExternalConfigFiles();
        this.loadProtocolTypes();
        this.loadParserInfo();
        this.loadIngester();
        this.loadMiscVariables();
        this.loadProductTypeDetection();
        this.loadMetadataListToOutput();
    }

    void loadExternalConfigFiles() throws ConfigException {
        String[] externalConfigs = PropertiesUtils
                .getProperties(EXTERNAL_PROPERTIES_FILES);
        for (String externalConfig : externalConfigs) {
            try {
                System.getProperties().load(
                        new FileInputStream(new File(externalConfig)));
            } catch (Exception e) {
                throw new ConfigException("Failed to load default config file "
                        + externalConfig + " : " + e.getMessage());
            }
        }
    }

    void loadProtocolTypes() throws ConfigException {
        LOG.log(Level.INFO,
                "Associating protocol types with ProtocolFactories . . .");
        String[] protocolFactoryInfoFiles = PropertiesUtils
                .getProperties(PROTOCOL_FACTORY_INFO_FILES);
        for (String file : protocolFactoryInfoFiles) {
            try {
                pi.loadProtocolFactoryInfoFromFile(new File(file));
            } catch (Exception e) {
                throw new ConfigException(
                        "Failed to load ProtocolFactory config file " + file
                                + " : " + e.getMessage());
            }
        }
    }

    void loadParserInfo() throws ConfigException {
        LOG.log(Level.INFO, "Associating parsers with RetrievalMethods . . .");
        String[] parserInfoFiles = PropertiesUtils
                .getProperties(PARSER_INFO_FILES);
        for (String file : parserInfoFiles) {
            try {
                parserInfo.loadParserInfo(new File(file));
            } catch (Exception e) {
                throw new ConfigException("Failed to load parser info file "
                        + file + " : " + e.getMessage());
            }
        }
    }

    void loadIngester() throws InstantiationException, ConfigException {
        try {
            String fmUrlStr = PropertiesUtils.getProperties(INGESTER_FM_URL,
                    new String[] { NO_FM_SPECIFIED })[0];

            if (fmUrlStr.equals(NO_FM_SPECIFIED)) {
                LOG
                        .log(Level.INFO,
                                "No file manager url specified: no ingester will be used");
            } else {
                String ingesterClass = PropertiesUtils
                        .getProperties(INGESTER_CLASS)[0];
                String dataTransferClass = PropertiesUtils
                        .getProperties(INGESTER_DATA_TRANSFER)[0];
                String cacheFactoryClass = System.getProperty(CACHE_FACTORY_CLASS);

                LOG.log(Level.INFO, "Configuring and building ingester: ["
                        + ingesterClass + "]: data transfer: ["
                        + dataTransferClass + "]: to ingest to file manager: ["
                        + fmUrlStr + "]");

                if (cacheFactoryClass != null) {
                    LOG.log(Level.INFO, "Configuring Ingester cache: ["
                            + cacheFactoryClass + "]");
                }

                this.ingester = PushPullObjectFactory.createIngester(
                        ingesterClass, cacheFactoryClass);
                
                this.fmUrl = safeGetUrlFromString(fmUrlStr);

            }

        } catch (Exception e) {
            e.printStackTrace();
            throw new ConfigException("Failed to load Ingester : "
                    + e.getMessage());
        }
    }

    void loadProductTypeDetection() throws ConfigException {
        try {
            this.productTypeDetectionFile = PropertiesUtils
                    .getProperties(TYPE_DETECTION_FILE)[0];
            LOG.log(Level.INFO, "Loading product type detection file: "
                    + productTypeDetectionFile);
        } catch (Exception e) {
            throw new ConfigException(
                    "Failed to load ProductTypeDetection file '"
                            + productTypeDetectionFile + "' : "
                            + e.getMessage());
        }
    }

    void loadMetadataListToOutput() {
        listOfMetadataToOutput = PropertiesUtils.getProperties(
                MET_LIST_TO_PRINT, new String[] {
                        RemoteFileMetKeys.PRODUCT_NAME,
                        RemoteFileMetKeys.RETRIEVED_FROM_LOC,
                        RemoteFileMetKeys.DATA_PROVIDER,
                        RemoteFileMetKeys.FILE_SIZE,
                        RemoteFileMetKeys.PRODUCT_TYPE });
    }

    void loadMiscVariables() {
        onlyDefinedTypes = (PropertiesUtils.getProperties(
                ALLOW_ONLY_DEFINED_TYPES, new String[] { "false" })[0]
                .toLowerCase().equals("true"));
        useTracker = (PropertiesUtils.getProperties(USE_TRACKER,
                new String[] { "false" })[0].toLowerCase().equals("true"));
        this.recommendedThreadCount = Integer.parseInt(PropertiesUtils
                .getProperties(FILE_RET_SYSTEM_REC_THREAD_COUNT,
                        new String[] { "8" })[0]);
        this.maxFailedDownloads = Integer.parseInt(PropertiesUtils
                .getProperties(FILE_RET_SYSTEM_MAX_ALLOWED_FAIL_DOWNLOADS,
                        new String[] { "10" })[0]);
        metFileExtension = PropertiesUtils.getProperties(MET_FILE_EXT,
                new String[] { "info.tmp" })[0];
        this.writeMetFile = Boolean.getBoolean(WRITE_MET_FILE);
        String timeoutString = PropertiesUtils.getProperties(
                PROTOCOL_TIMEOUT_MS, new String[] { "600000" })[0];
        if (timeoutString == null)
            timeoutString = "0";
        pi.setDownloadTimeout(Long.parseLong(timeoutString));
        pi.setPageSize(Integer.parseInt(PropertiesUtils.getProperties(
                PROTOCOL_PAGE_SIZE, new String[] { "8" })[0]));
        this.baseStagingArea = new File(PropertiesUtils.getProperties(
                DATA_FILE_BASE_STAGING_AREA,
                new String[] { this.baseStagingArea.getPath() })[0]);
    }

    public ProtocolInfo getProtocolInfo() {
        return this.pi;
    }

    public Ingester getIngester() {
        return this.ingester;
    }
    
    public URL getFmUrl(){
        return this.fmUrl;
    }

    public boolean useTracker() {
        return useTracker;
    }

    public String getMetFileExtension() {
        return this.metFileExtension;
    }

    public String getProductTypeDetectionFile() {
        return this.productTypeDetectionFile;
    }

    public int getRecommendedThreadCount() {
        return this.recommendedThreadCount;
    }

    public int getMaxFailedDownloads() {
        return this.maxFailedDownloads;
    }

    public boolean onlyDownloadDefinedTypes() {
        return this.onlyDefinedTypes;
    }

    public String[] getListOfMetadataToOutput() {
        return this.listOfMetadataToOutput;
    }

    public ParserInfo getParserInfo() {
        return this.parserInfo;
    }

    public File getBaseStagingArea() {
        return this.baseStagingArea;
    }
    
    public boolean getWriteMetFile() {
    	return this.writeMetFile;
    }

    public Config clone() {
        Config config = new Config();
        config.baseStagingArea = this.baseStagingArea;
        config.ingester = this.ingester;
        config.fmUrl = this.fmUrl;
        config.listOfMetadataToOutput = this.listOfMetadataToOutput;
        config.maxFailedDownloads = this.maxFailedDownloads;
        config.metFileExtension = this.metFileExtension;
        config.onlyDefinedTypes = this.onlyDefinedTypes;
        config.parserInfo = this.parserInfo;
        config.pi = this.pi;
        config.productTypeDetectionFile = this.productTypeDetectionFile;
        config.recommendedThreadCount = this.recommendedThreadCount;
        config.useTracker = this.useTracker;
        config.writeMetFile = this.writeMetFile;
        return config;
    }

    private static URL safeGetUrlFromString(String urlStr) {
        URL url = null;

        try {
            url = new URL(urlStr);
        } catch (MalformedURLException e) {
            LOG.log(Level.WARNING, "Unable to generate url from url string: ["
                    + urlStr + "]: Message: " + e.getMessage());
        }

        return url;
    }

}