package org.apache.fulcrum.yaafi.framework.factory;

/*
 * 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.
 */

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Hashtable;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.DefaultContext;
import org.apache.avalon.framework.logger.ConsoleLogger;
import org.apache.avalon.framework.logger.Logger;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.lang3.StringUtils;
import org.apache.fulcrum.yaafi.framework.constant.AvalonMerlinConstants;
import org.apache.fulcrum.yaafi.framework.container.ServiceConstants;
import org.apache.fulcrum.yaafi.framework.crypto.CryptoStreamFactory;
import org.apache.fulcrum.yaafi.framework.util.InputStreamLocator;
import org.apache.fulcrum.yaafi.framework.util.Validate;

/**
 * Helper class to capture configuration related stuff. The are two ways for
 * setting up the configuration:
 * <ul>
 * <li>set all parameters manually</li>
 * <li>use a containerConfiguration file and provide the remaining settings</li>
 * </ul>
 *
 * The Avalon context and configuration are created by
 * <ul>
 * <li>createFinalContext()</li>
 * <li>createFinalConfiguration()</li>
 * </ul>
 *
 * @author <a href="mailto:siegfried.goeschl@it20one.at">Siegfried Goeschl</a>
 */

public class ServiceContainerConfiguration {
        /** our default implementation class of the service container */
        private String serviceContainerClazzName;

        /** the location of the component role file */
        private String componentRolesLocation;

        /** is the component role file encrypted? */
        private String isComponentRolesEncrypted;

        /** the location of the component configuration file */
        private String componentConfigurationLocation;

        /** is the component configuration file encrypted? */
        private String isComponentConfigurationEncrypted;

        /** the location of the paramaters file */
        private String parametersLocation;

        /** is the parameters file encrypted? */
        private String isParametersEncrypted;

        /** the user-supplied Avalon context */
        private DefaultContext context;

        /** the Avalon logger */
        private Logger logger;

        /** the application directory */
        private String applicationRootDir;

        /** the temporary directory */
        private String tempRootDir;

        /** the class loader passed in the Avalon Context */
        private ClassLoader componentClassLoader;

        /** the type of container where YAAFI is embedded */
        private String containerFlavour;

        /** the caller-supplied container configuration */
        private Configuration containerConfiguration;

        /** to lookup service in the parent container */
        private ServiceManager parentServiceManager;

        /** a list of ServiceManager maintaining their own services */
        private String[] serviceManagerList;

        /** Constructor */
        public ServiceContainerConfiguration() {
                this(ConsoleLogger.LEVEL_DEBUG);
        }

        /**
         * Constructor.
         *
         * @param logLevel the log level for the console logger.
         */
        public ServiceContainerConfiguration(int logLevel) {
                this.logger = new ConsoleLogger(logLevel);
                this.containerFlavour = ServiceConstants.AVALON_CONTAINER_YAAFI;
                this.serviceContainerClazzName = ServiceConstants.CLAZZ_NAME;
                this.componentRolesLocation = ServiceConstants.COMPONENT_ROLE_VALUE;
                this.isComponentRolesEncrypted = "false";
                this.componentConfigurationLocation = ServiceConstants.COMPONENT_CONFIG_VALUE;
                this.isComponentConfigurationEncrypted = "false";
                this.parametersLocation = ServiceConstants.COMPONENT_PARAMETERS_VALUE;
                this.isParametersEncrypted = "false";
                this.context = new DefaultContext();
                this.applicationRootDir = new File("").getAbsolutePath();
                this.tempRootDir = System.getProperty("java.io.tmpdir", ".");
                this.componentClassLoader = this.getClass().getClassLoader();
        }

        /**
         * Add a new entry to the context by creating a new one.
         * 
         * @param name  the name of the new entry
         * @param value the value of the new entry
         */
        public void addToContext(String name, Object value) {
                Validate.notEmpty(name, "name");
                Validate.notNull(value, "value");
                this.getContext().put(name, value);
        }

        /**
         * Add a hashtable to the context
         * 
         * @param hashtable the Hashtable to be added
         */
        public void addToContext(Hashtable<?, ?> hashtable) {
                Validate.notNull(hashtable, "hashtable");

                String name = null;
                Object value = null;
                Enumeration<?> keys = hashtable.keys();

                while (keys.hasMoreElements()) {
                        name = (String) keys.nextElement();
                        value = hashtable.get(name);
                        this.addToContext(name, value);
                }
        }

        /**
         * Create the final Avalon context passed to YAAFI containing
         * <ul>
         * <li>user-supplied context</li>
         * <li>urn:avalon:home</li>
         * <li>urn:avalon:temp</li>
         * <li>urn:avalon:name</li>
         * <li>urn:avalon:partition</li>
         * <li>urn:avalon:classloader</li>
         * </ul>
         *
         * @return the final Context
         * @throws Exception if filename not defined
         * @throws IOException if file not found
         */

        public Context createFinalContext() throws IOException, Exception {
                // 1) add the application root dir

                this.addToContext(AvalonMerlinConstants.URN_AVALON_HOME, this.getApplicationRootDir());

                // 2) add the temp root dir

                this.addToContext(AvalonMerlinConstants.URN_AVALON_TEMP, this.getTempRootDir());

                // 3) add the Avalon name

                this.addToContext(AvalonMerlinConstants.URN_AVALON_NAME, ServiceConstants.ROLE_NAME);

                // 4) add the Avalon partition name

                this.addToContext(AvalonMerlinConstants.URN_AVALON_PARTITION, "root");

                // 5) add the class loader

                this.addToContext(AvalonMerlinConstants.URN_AVALON_CLASSLOADER, this.getComponentClassLoader());

                return this.getContext();
        }

        /**
         * Create a final configuration.
         *
         * @return the configuration
         */
        public Configuration createFinalConfiguration() {
                DefaultConfiguration result = null;

                if (this.getContainerConfiguration() != null) {
                        return this.getContainerConfiguration();
                } else {
                        // the root element is "fulcrum-yaafi"

                        result = new DefaultConfiguration(ServiceConstants.ROLE_NAME);

                        // add the following fragement
                        //
                        // <containerFlavour>merlin</containerFlavour>

                        DefaultConfiguration containerFlavourConfig = new DefaultConfiguration(
                                        ServiceConstants.CONTAINERFLAVOUR_CONFIG_KEY);

                        containerFlavourConfig.setValue(this.getContainerFlavour());

                        result.addChild(containerFlavourConfig);

                        // add the following fragement
                        //
                        // <containerClazzName>...</containerClazzName>

                        DefaultConfiguration containerClazzNameConfig = new DefaultConfiguration(
                                        ServiceConstants.CONTAINERCLAZZNAME_CONFIG_KEY);

                        containerClazzNameConfig.setValue(this.getServiceContainerClazzName());

                        result.addChild(containerClazzNameConfig);

                        // add the following fragement
                        //
                        // <componentRoles>
                        // <location>../conf/componentRoles.xml</location>
                        // <isEncrypted>true</isEncrypted>
                        // </componentRoles>

                        DefaultConfiguration componentRolesConfig = new DefaultConfiguration(ServiceConstants.COMPONENT_ROLE_KEYS);

                        DefaultConfiguration componentRolesLocation = new DefaultConfiguration(
                                        ServiceConstants.COMPONENT_LOCATION_KEY);

                        componentRolesLocation.setValue(this.getComponentRolesLocation());

                        DefaultConfiguration componentRolesIsEncrypted = new DefaultConfiguration(
                                        ServiceConstants.COMPONENT_ISENCRYPTED_KEY);

                        componentRolesIsEncrypted.setValue(this.isComponentRolesEncrypted());

                        componentRolesConfig.addChild(componentRolesLocation);
                        componentRolesConfig.addChild(componentRolesIsEncrypted);

                        result.addChild(componentRolesConfig);

                        // add the following fragement
                        //
                        // <componentConfiguration>
                        // <location>../conf/componentRoles.xml</location>
                        // <isEncrypted>true</isEncrypted>
                        // </componentConfiguration>

                        DefaultConfiguration componentConfigurationConfig = new DefaultConfiguration(
                                        ServiceConstants.COMPONENT_CONFIG_KEY);

                        DefaultConfiguration componentConfigurationLocation = new DefaultConfiguration(
                                        ServiceConstants.COMPONENT_LOCATION_KEY);

                        componentConfigurationLocation.setValue(this.getComponentConfigurationLocation());

                        DefaultConfiguration componentConfigurationIsEncrypted = new DefaultConfiguration(
                                        ServiceConstants.COMPONENT_ISENCRYPTED_KEY);

                        componentConfigurationIsEncrypted.setValue(this.isComponentConfigurationEncrypted());

                        componentConfigurationConfig.addChild(componentConfigurationLocation);
                        componentConfigurationConfig.addChild(componentConfigurationIsEncrypted);

                        result.addChild(componentConfigurationConfig);

                        // Add the following fragement
                        //
                        // <parameters>
                        // <location>../conf/parameters.properties</location>
                        // <isEncrypted>true</isEncrypted>
                        // </parameters>

                        DefaultConfiguration parameterConfigurationConfig = new DefaultConfiguration(
                                        ServiceConstants.COMPONENT_PARAMETERS_KEY);

                        DefaultConfiguration parameterConfigurationLocation = new DefaultConfiguration(
                                        ServiceConstants.COMPONENT_LOCATION_KEY);

                        parameterConfigurationLocation.setValue(this.getParametersLocation());

                        DefaultConfiguration parameterConfigurationIsEncrypted = new DefaultConfiguration(
                                        ServiceConstants.COMPONENT_ISENCRYPTED_KEY);

                        parameterConfigurationIsEncrypted.setValue(this.isParametersEncrypted());

                        parameterConfigurationConfig.addChild(parameterConfigurationLocation);
                        parameterConfigurationConfig.addChild(parameterConfigurationIsEncrypted);

                        result.addChild(parameterConfigurationConfig);

                        // Add the following fragement
                        //
                        // <serviceManagers>
                        // <serviceManagers>springFrameworkService</serviceManager>
                        // </serviceManagers>

                        if (this.hasServiceManagerList()) {
                                DefaultConfiguration serviceManagerListConfig = new DefaultConfiguration(
                                                ServiceConstants.SERVICEMANAGER_LIST_KEY);

                                for (int i = 0; i < this.serviceManagerList.length; i++) {
                                        DefaultConfiguration serviceManagerConfig = new DefaultConfiguration(
                                                        ServiceConstants.SERVICEMANAGER_KEY);

                                        serviceManagerConfig.setValue(this.serviceManagerList[i]);

                                        serviceManagerListConfig.addChild(serviceManagerConfig);
                                }

                                result.addChild(serviceManagerListConfig);
                        }

                        return result;
                }
        }

        /////////////////////////////////////////////////////////////////////////
        // Generated Getters/Setters
        /////////////////////////////////////////////////////////////////////////

        /**
         * @return Returns the serviceContainerClazzName.
         */
        private String getServiceContainerClazzName() {
                return this.serviceContainerClazzName;
        }

        /**
         * @return Returns the componentConfigurationLocation.
         */
        private String getComponentConfigurationLocation() {
                return componentConfigurationLocation;
        }

        /**
         * @param componentConfigurationLocation The componentConfigurationLocation to
         *                                       set.
         */
        public void setComponentConfigurationLocation(String componentConfigurationLocation) {
                Validate.notNull(componentConfigurationLocation, "componentConfigurationLocation");
                this.componentConfigurationLocation = componentConfigurationLocation;
        }

        /**
         * @return Returns the componentRolesLocation.
         */
        private String getComponentRolesLocation() {
                return componentRolesLocation;
        }

        /**
         * @param componentRolesLocation The componentRolesLocation to set.
         */
        public void setComponentRolesLocation(String componentRolesLocation) {
                this.componentRolesLocation = componentRolesLocation;
        }

        /**
         * @return Returns the context.
         */
        private DefaultContext getContext() {
                return context;
        }

        /**
         * @param context The context to set.
         */
        public void setContext(Context context) {
                if (context instanceof DefaultContext) {
                        this.context = (DefaultContext) context;
                } else {
                        this.context = new DefaultContext(context);
                }
        }

        /**
         * @return Returns the isComponentConfigurationEncrypted.
         */
        private String isComponentConfigurationEncrypted() {
                return isComponentConfigurationEncrypted;
        }

        /**
         * @param isComponentConfigurationEncrypted The
         *                                          isComponentConfigurationEncrypted to
         *                                          set.
         */
        public void setComponentConfigurationEncrypted(String isComponentConfigurationEncrypted) {
                this.isComponentConfigurationEncrypted = isComponentConfigurationEncrypted;
        }

        /**
         * @return Returns the isComponentRolesEncrypted.
         */
        private String isComponentRolesEncrypted() {
                return isComponentRolesEncrypted;
        }

        /**
         * @param isComponentRolesEncrypted The isComponentRolesEncrypted to set.
         */
        public void setComponentRolesEncrypted(String isComponentRolesEncrypted) {
                this.isComponentRolesEncrypted = isComponentRolesEncrypted;
        }

        /**
         * @return Returns the isParametersEncrypted.
         */
        private String isParametersEncrypted() {
                return isParametersEncrypted;
        }

        /**
         * @param isParametersEncrypted The isParametersEncrypted to set.
         */
        public void setParametersEncrypted(String isParametersEncrypted) {
                Validate.notEmpty(isParametersEncrypted, "isParametersEncrypted");
                this.isParametersEncrypted = isParametersEncrypted;
        }

        /**
         * @return Returns the logger.
         */
        public Logger getLogger() {
                return logger;
        }

        /**
         * @param logger The logger to set.
         */
        public void setLogger(Logger logger) {
                this.logger = logger;
        }

        /**
         * @return Returns the parametersLocation.
         */
        private String getParametersLocation() {
                return parametersLocation;
        }

        /**
         * @param parametersLocation The parametersLocation to set.
         */
        public void setParametersLocation(String parametersLocation) {
                this.parametersLocation = parametersLocation;
        }

        /**
         * @return Returns the applicationRootDir.
         */
        private File getApplicationRootDir() {
                return new File(applicationRootDir);
        }

        /**
         * @param applicationRootDir The applicationRootDir to set.
         */
        public void setApplicationRootDir(String applicationRootDir) {
                Validate.notNull(applicationRootDir, "applicationRootDir");

                if (applicationRootDir.equals(".")) {
                        this.applicationRootDir = new File("").getAbsolutePath();
                } else {
                        this.applicationRootDir = new File(applicationRootDir).getAbsolutePath();
                }
        }

        /**
         * @return Returns the tempRootDir.
         * @throws Exception 
         * @throws IOException 
         */
        private File getTempRootDir() throws IOException, Exception {
                return makeAbsoluteFile(this.getApplicationRootDir(), this.tempRootDir);
        }

        /**
         * @param tempRootDir The tempRootDir to set.
         */
        public void setTempRootDir(String tempRootDir) {
                Validate.notNull(tempRootDir, "tempRootDir");
                this.tempRootDir = tempRootDir;
        }

        /**
         * @return Returns the classLoader.
         */
        private ClassLoader getComponentClassLoader() {
                return componentClassLoader;
        }

        /**
         * @param componentClassLoader The classLoader to set.
         */
        public void setComponentClassLoader(ClassLoader componentClassLoader) {
                Validate.notNull(componentClassLoader, "componentClassLoader");
                this.componentClassLoader = componentClassLoader;
        }

        /**
         * @return Returns the containerFlavour.
         */
        private String getContainerFlavour() {
                return containerFlavour;
        }

        /**
         * @param containerFlavour The containerFlavour to set.
         */
        public void setContainerFlavour(String containerFlavour) {
                this.containerFlavour = containerFlavour;
        }

        /**
         * @return Returns the containerConfiguration.
         */
        private Configuration getContainerConfiguration() {
                return containerConfiguration;
        }

        /**
         * @param containerConfiguration The containerConfiguration to set.
         */
        public void setContainerConfiguration(Configuration containerConfiguration) {
                this.containerConfiguration = containerConfiguration;
        }

        /**
         * Get the parent service manager to find service managed by the parent
         * container.
         *
         * @return the parent container
         */

        public ServiceManager getParentServiceManager() {
                return parentServiceManager;
        }

        /**
         * Set the parent service manager to find service managed by the parent
         * container.
         *
         * @param parentServiceManager the parent container
         */
        public void setParentServiceManager(ServiceManager parentServiceManager) {
                this.parentServiceManager = parentServiceManager;
        }

        /**
         * Get a list of service manager managing their own set of services.
         *
         * @return a list of service implementing the ServiceManager interface
         */
        public String[] getServiceManagerList() {
                return serviceManagerList;
        }

        /**
         * Set a list of service manager managing their own set of services.
         *
         * @param serviceManagerList a list of service implementing the ServiceManager
         *                           interface
         */
        public void setServiceManagerList(String[] serviceManagerList) {
                this.serviceManagerList = serviceManagerList;
        }

        /**
         * @return true if there is a service manager defined
         */
        public boolean hasServiceManagerList() {
                if (this.serviceManagerList != null && this.serviceManagerList.length > 0)
                        return true;
                return false;
        }

        /**
         * Loads a containerConfiguration file and set is as the Avalon configuration to
         * be used for Configurable.configure(). Take care that the implementation uses
         * an InputStreamLocator to find the containerConfiguration which uses the
         * previously set application root directory.
         *
         * @param location the location of the containerConfiguration
         * @throws IOException loading the configuration failed
         */
        public void loadContainerConfiguration(String location) throws IOException {
                this.loadContainerConfiguration(location, "false");
        }

        /**
         * Loads a containerConfiguration file and set is as the Avalon configuration to
         * be used for Configurable.configure(). Take care that the implementation uses
         * an InputStreamLocator to find the containerConfiguration which uses the
         * previously set application root directory.
         *
         * @param location    the location of the containerConfiguration
         * @param isEncrypted is the file encrypted
         * @throws IOException loading the configuration failed
         */
        public void loadContainerConfiguration(String location, String isEncrypted) throws IOException {
                Configuration result = null;

                InputStreamLocator locator = new InputStreamLocator(this.getApplicationRootDir(), this.getLogger());

                DefaultConfigurationBuilder builder = new DefaultConfigurationBuilder();
                InputStream is = locator.locate(location);

                if (is != null) {
                        try {
                                is = CryptoStreamFactory.getDecryptingInputStream(is, isEncrypted);
                                result = builder.build(is);
                                this.setContainerConfiguration(result);
                        } catch (Exception e) {
                                String msg = "Unable to parse the following file : " + location;
                                this.getLogger().error(msg, e);
                                throw new IOException(msg);
                        }
                } else {
                        String msg = "Unable to locate the containerConfiguration file : " + location;
                        this.getLogger().error(msg);
                        throw new IOException(msg);
                }
        }

        /**
         * Determines the absolute file.
         * 
         * @param baseDir  the base directory
         * @param fileName the filename
         * @return the absolute path
         */
        private static File makeAbsoluteFile(File baseDir, String fileName) throws IOException, Exception {
                if (baseDir.exists()) {
                        if (!StringUtils.isEmpty(fileName)) {
                                File result = new File(fileName);
                                if (!result.isAbsolute()) {
                                        result = new File(baseDir, fileName);
                                }
                                return result;
                        } else {
                                throw new Exception("No filename specified");
                        }
                } else {
                        throw new IOException("The directory does not exist");
                }
        }
}