/*
 * 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 flex.messaging;

import flex.messaging.config.ConfigMap;
import flex.messaging.config.ConfigurationException;
import flex.messaging.log.Log;

public abstract class FactoryDestination extends Destination {
    private static final String FACTORY = "factory";
    private static final String DEFAULT_FACTORY = "java";

    // Errors
    private static int INVALID_FACTORY = 11103;
    private static int FACTORY_CANNOT_BE_RETURNED = 11118;

    // FactoryDestination's properties 
    private FlexFactory factory;
    private String source;
    private String scope = FlexFactory.SCOPE_REQUEST;

    // FactoryDestination internal
    private String factoryId = DEFAULT_FACTORY;
    private FactoryInstance factoryInstance;
    private ConfigMap factoryProperties;

    //--------------------------------------------------------------------------
    //
    // Constructor
    //
    //--------------------------------------------------------------------------

    /**
     * Constructs an unmanaged <code>FactoryDestination</code> instance.
     */
    public FactoryDestination() {
        this(false);
    }

    /**
     * Constructs a <code>FactoryDestination</code> with the indicated management.
     *
     * @param enableManagement <code>true</code> if the <code>FactoryDestination</code>
     *                         is manageable; otherwise <code>false</code>.
     */
    public FactoryDestination(boolean enableManagement) {
        super(enableManagement);
    }

    //--------------------------------------------------------------------------
    //
    // Initialize, validate, start, and stop methods. 
    //
    //--------------------------------------------------------------------------

    /**
     * Initializes the <code>FactoryDestination</code> with the properties.
     *
     * @param id         the factory id
     * @param properties Properties for the <code>FactoryDestination</code>.
     */
    public void initialize(String id, ConfigMap properties) {
        super.initialize(id, properties);

        if (properties == null || properties.size() == 0)
            return;

        // Need to cache this for later. TODO: We shouldn't need to do this.
        factoryProperties = properties;

        factoryId = properties.getPropertyAsString(FACTORY, factoryId);
        scope = properties.getPropertyAsString(FlexFactory.SCOPE, scope);
        source = properties.getPropertyAsString(FlexFactory.SOURCE, source);

        if (source == null)
            source = getId();

        if (factory != null)
            factory.initialize(getId(), factoryProperties);
    }

    /**
     * Verifies that the <code>FactoryDestination</code> is in valid state before
     * it is started.
     */
    protected void validate() {
        if (isValid())
            return;

        super.validate();

        if (factory == null) {
            if (factoryId == null) {
                factoryId = DEFAULT_FACTORY;
            }
            MessageBroker broker = getService().getMessageBroker();
            FlexFactory f = broker.getFactory(factoryId);
            if (f == null) {
                ConfigurationException ex = new ConfigurationException();
                ex.setMessage(INVALID_FACTORY, new Object[]{getId(), factoryId});
                throw ex;
            }
            factory = f;
        }

        if (scope == null)
            scope = FlexFactory.SCOPE_REQUEST;

        if (source == null)
            source = getId();
    }

    //--------------------------------------------------------------------------
    //
    // Public Getters and Setters for Destination properties
    //         
    //--------------------------------------------------------------------------    

    /**
     * Returns the factory of the <code>FactoryDestination</code>. Before a valid
     * <code>FlexFactory</code> can be returned, <code>MessageBroker</code> and
     * hence <code>Service</code> of the <code>Destination</code> has to be set.
     *
     * @return FlexFactory the FlexFactory object
     */
    public FlexFactory getFactory() {
        if (factory == null) {
            if (factoryId == null) {
                factoryId = DEFAULT_FACTORY;
            }
            if (getService() == null) {
                // Factory cannot be returned without ''{0}'' set.
                ConfigurationException ex = new ConfigurationException();
                ex.setMessage(FACTORY_CANNOT_BE_RETURNED, new Object[]{"Service"});
                throw ex;
            }
            if (getService().getMessageBroker() == null) {
                // Factory cannot be returned without ''{0}'' set.
                ConfigurationException ex = new ConfigurationException();
                ex.setMessage(FACTORY_CANNOT_BE_RETURNED, new Object[]{"MessageBroker"});
                throw ex;
            }
            MessageBroker broker = getService().getMessageBroker();
            FlexFactory f = broker.getFactory(factoryId);
            if (f == null) {
                ConfigurationException ex = new ConfigurationException();
                ex.setMessage(INVALID_FACTORY, new Object[]{getId(), factoryId});
                throw ex;
            }
            factory = f;
        }
        return factory;
    }

    /**
     * Sets the factory of the <code>FactoryDestination</code>.
     * <code>MessageBroker</code> has to know the factory before it can be
     * assigned to the destination.
     *
     * @param id The id of the factory.
     */
    public void setFactory(String id) {
        if (isStarted()) {
            MessageBroker broker = getService().getMessageBroker();
            FlexFactory factory = broker.getFactory(id);
            if (factory == null) {
                ConfigurationException ex = new ConfigurationException();
                ex.setMessage(INVALID_FACTORY, new Object[]{getId(), factory});
                throw ex;
            }
            setFactory(factory);
        }
        factoryId = id;
    }

    /**
     * Sets the factory of the <code>FactoryDestination</code>.
     *
     * @param factory the FlexFactory object
     */
    public void setFactory(FlexFactory factory) {
        this.factory = factory;
    }

    /**
     * Returns the <code>FactoryInstance</code>. <code>FactoryInstance</code>
     * stores configuration state used for retrieving an instance from
     * the factory. This needs to be called after calling <code>setSource</code>
     * and <code>setScope</code> methods.
     *
     * @return FactoryInstance current FactoryInstance object
     */
    public FactoryInstance getFactoryInstance() {
        // This is needed for HibernateAssembler
        return getFactoryInstance(factoryProperties);
    }

    /**
     * Returns a <code>FactoryInstance</code> using the properties passed in.
     *
     * @param properties Properties to be used while creating the <code>FactoryInstance</code>.
     */
    private FactoryInstance getFactoryInstance(ConfigMap properties) {
        // Automatically create a factory instance if not already set  
        if (factoryInstance == null)
            factoryInstance = createFactoryInstance(properties);

        return factoryInstance;
    }

    /**
     * Creates a factory instance using the properties passed in.
     *
     * @param properties Properties to be used while creating the <code>FactoryInstance</code>.
     */
    private FactoryInstance createFactoryInstance(ConfigMap properties) {
        if (properties == null)
            properties = new ConfigMap();

        properties.put(FlexFactory.SOURCE, source);
        properties.put(FlexFactory.SCOPE, scope);
        FactoryInstance factoryInstance = getFactory().createFactoryInstance(getId(), properties);
        return factoryInstance;
    }

    /**
     * Returns the scope of the <code>FactoryDestination</code>.
     *
     * @return scope of the <code>FactoryDestination</code>.
     */
    public String getScope() {
        return scope;
    }

    /**
     * Sets the scope of the <code>FactoryDestination</code> that is used
     * in <code>FactoryInstance</code> creation. Scope cannot be changed to and
     * from application scope once <code>FactoryInstance</code> is initialized.
     *
     * @param scope the scope
     */
    public void setScope(String scope) {
        if (factoryInstance != null) {
            if (FlexFactory.SCOPE_APPLICATION.equals(this.scope)
                    && !FlexFactory.SCOPE_APPLICATION.equals(scope)) {
                if (Log.isWarn())
                    Log.getLogger(getLogCategory()).warn(
                            "Current scope is " + FlexFactory.SCOPE_APPLICATION
                                    + " and it cannot be changed to " + scope
                                    + " once factory instance is initialized.");
                return;
            } else if (!FlexFactory.SCOPE_APPLICATION.equals(this.scope)
                    && FlexFactory.SCOPE_APPLICATION.equals(scope)) {
                if (Log.isWarn())
                    Log.getLogger(getLogCategory()).warn(
                            "Current scope is " + this.scope
                                    + " and it cannot be changed to " + FlexFactory.SCOPE_APPLICATION
                                    + " once factory instance is initialized.");
                return;
            }
            factoryInstance.setScope(scope);
        }
        this.scope = scope;
    }

    /**
     * Gets the source of the <code>FactoryDestination</code>.
     *
     * @return the source of the <code>FactoryDestination</code>.
     */
    public String getSource() {
        return source;
    }

    /**
     * Sets the source of the <code>FactoryDestination</code> that is used
     * in <code>FactoryInstance</code> creation. Source cannot be changed once
     * <code>FactoryInstance</code> is initialized and the scope is application.
     *
     * @param source the source string
     */
    public void setSource(String source) {
        if (factoryInstance != null) {
            if (FlexFactory.SCOPE_APPLICATION.equals(scope)) {
                if (Log.isWarn())
                    Log.getLogger(getLogCategory()).warn(
                            "Source of the destination cannot be changed once "
                                    + "factory instance is already initialized and it has "
                                    + FlexFactory.SCOPE_APPLICATION + " scope");
                return;
            }
            factoryInstance.setSource(source);
        }
        this.source = source;
    }

    /**
     * This method first calls stop on its superclass <code>Destination</code> and then
     * removes any assemblers from the ServletContext or Session that are ready for removal.
     * If an assembler is only used by a single destination (attribute-id==destination-id) then
     * it is removed.  If an assembler is shared across destinations, (attribute-id&lt;&gt;destination-id)
     * then it is only removed if its reference count (maintained in <code>MessageBroker</code>) is
     * down to zero
     */
    public void stop() {
        if (isStarted()) {
            super.stop();
            // destroy factory instance to free up resources
            if (factory != null && (factory instanceof DestructibleFlexFactory))
                ((DestructibleFlexFactory) factory).destroyFactoryInstance(factoryInstance);
        } else {
            super.stop();
        }
    }
}