package org.apache.fulcrum.testcontainer;

/*
 * 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 org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.logger.ConsoleLogger;
import org.apache.fulcrum.testcontainer.avalon.logger.Log4J2Logger;
import org.apache.fulcrum.yaafi.framework.container.ServiceContainer;
import org.apache.fulcrum.yaafi.framework.factory.ServiceContainerConfiguration;
import org.apache.fulcrum.yaafi.framework.factory.ServiceContainerFactory;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.config.Configurator;

/**
 * This is a simple YAAFI based container that can be used in unit test
 * of the fulcrum components.
 *
 * @author <a href="mailto:siegfried.goeschl@it20one.at">Siegfried Goeschl</a>
 */
public class YAAFIContainer extends AbstractLogEnabled implements Container
{
    /** The YAAFI configuration */
    private ServiceContainerConfiguration config;

    /** Component manager */
    private ServiceContainer manager;

    /** The log level for the ConsoleLogger */
    //private int logLevel = ConsoleLogger.LEVEL_DEBUG;
    private Level logLevel = Level.DEBUG;
    
    org.apache.logging.log4j.Logger logger;

    /**
     * Constructor.
     */
    public YAAFIContainer()
    {
        //this.enableLogging( new ConsoleLogger( logLevel ) );
        logger = LogManager.getLogger( "avalon" );
        Configurator.setLevel( "avalon",logLevel );
        this.enableLogging( new Log4J2Logger( logger ) );
        this.config = new ServiceContainerConfiguration();
    }

    /**
     * Constructor.
     *
     * @param logLevel the log level to be used: {@link ConsoleLogger} LEVEL_*.
     */
    public YAAFIContainer(int logLevel)
    {
        logger = LogManager.getLogger( "avalon" );
        if (logLevel == ConsoleLogger.LEVEL_DEBUG) {
            this.logLevel = Level.DEBUG;
        }  else if (logLevel == ConsoleLogger.LEVEL_DEBUG) {
                this.logLevel = Level.DEBUG;
        }  else if (logLevel == ConsoleLogger.LEVEL_INFO) {
            this.logLevel = Level.INFO;
        }  else if (logLevel == ConsoleLogger.LEVEL_WARN) {
            this.logLevel = Level.WARN;
        }  else if (logLevel == ConsoleLogger.LEVEL_ERROR) {
            this.logLevel = Level.ERROR;
        }  else if (logLevel == ConsoleLogger.LEVEL_FATAL) {
            this.logLevel = Level.FATAL;
        }  else if (logLevel == ConsoleLogger.LEVEL_DISABLED) {
            this.logLevel = Level.OFF;
        } else {
            this.logLevel = Level.INFO;
        }
        Configurator.setLevel( "avalon", this.logLevel );
        this.enableLogging( new Log4J2Logger( logger ) );
        this.config = new ServiceContainerConfiguration();
    }

    /**
     * Starts up the container and initializes it.
     *
     * @param configFileName Name of the component configuration file
     * @param roleFileName Name of the role configuration file
     */
    public void startup(
        String configFileName,
        String roleFileName,
        String parametersFileName )
    {
        getLogger().debug("Starting YAAFI container... ");
        getLogger().debug( "with logger: " + getLogger().getClass().getName());

        this.config.setComponentConfigurationLocation( configFileName );
        this.config.setComponentRolesLocation( roleFileName );
        this.config.setParametersLocation( parametersFileName );
        this.config.setLogger( new Log4J2Logger( logger ) );

        File configFile = new File(configFileName);

        if (!configFile.exists())
        {
            throw new RuntimeException(
                "Could not initialize the container because the config file could not be found:" + configFile);
        }

        try
        {
            initialize();
            getLogger().info("YAFFI Container ready.");
        }
        catch (Exception e)
        {
            getLogger().error("Could not initialize the container", e);
            throw new RuntimeException("Could not initialize the container");
        }
    }

    // -------------------------------------------------------------
    // Avalon lifecycle interfaces
    // -------------------------------------------------------------

    /**
     * Initializes the container.
     *
     * @throws Exception generic exception
     */
    public void initialize() throws Exception
    {
        this.manager = ServiceContainerFactory.create(
            this.config
            );
    }

    /**
     * Disposes of the container and releases resources.
     */
    public void dispose()
    {
        getLogger().debug("Disposing of container...");
        if( this.manager != null )
        {
            this.manager.dispose();
        }
        getLogger().info("YAFFI Container has been disposed.");
    }

    /**
     * Returns an instance of the named component.
     *
     * @param roleName Name of the role the component fills.
     * @throws ComponentException generic exception
     */
    public Object lookup(String roleName) throws ComponentException
    {
        try
        {
            return this.manager.lookup(roleName);
        }
        catch( Exception e )
        {
            String msg = "Failed to lookup role " + roleName;
            throw new ComponentException(roleName,msg,e);
        }
    }

    /**
     * Releases the component implementing the Component interface. This
     * interface is deprecated but still around in Fulcrum
     *
     * @param component instance of the component to release
     */
    public void release(Component component)
    {
        this.manager.release(component);
    }

    /**
     * Releases the component.
     *
     * @param component component to be released
     */
    public void release(Object component)
    {
        this.manager.release(component);
    }
}