/*
 * Copyright 2008 the original author or authors.
 *
 * Licensed 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.wamblee.system.core;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 
 * @author $author$
 * @version $Revision$
 */
public class DefaultScope implements Scope {
    private List<Scope> parents;

    private Map<String, Object> properties;

    private Map<String, Object> runtimes;

    private Map<ProvidedInterface, ProvidedInterfaceImplementation> provided;

    private List<ProvidedInterface> externallyProvided;

    /**
     * Creates a new DefaultScope object.
     * 
     */
    public DefaultScope(List<ProvidedInterface> aExternallyProvided) {
        this(aExternallyProvided.toArray(new ProvidedInterface[0]));
    }

    /**
     * Creates a new DefaultScope object.
     * 
     */
    public DefaultScope(ProvidedInterface[] aExternallyProvided) {
        this(aExternallyProvided, new ArrayList<Scope>());
    }

    /**
     * Creates a new DefaultScope object.
     * 
     */
    public DefaultScope(ProvidedInterface[] aExternallyProvided, Scope aParent) {
        this(aExternallyProvided, Arrays.asList(new Scope[] { aParent }));
    }

    /**
     * Creates a new DefaultScope object.
     * 
     */
    public DefaultScope(ProvidedInterface[] aExternallyProvided,
        List<Scope> aParent) {
        parents = new ArrayList<Scope>(aParent);
        properties = new HashMap<String, Object>();
        runtimes = new HashMap<String, Object>();
        provided = new HashMap<ProvidedInterface, ProvidedInterfaceImplementation>();
        externallyProvided = new ArrayList<ProvidedInterface>();
        externallyProvided.addAll(Arrays.asList(aExternallyProvided));
    }

    @Override
    public List<ProvidedInterface> getProvidedInterfaces() {
        return Collections.unmodifiableList(externallyProvided);
    }

    @Override
    public Object get(String aKey) {
        return properties.get(aKey);
    }

    @Override
    public void put(String aKey, Object aValue) {
        properties.put(aKey, aValue);
    }

    @Override
    public void addRuntime(Component aComponent, Object aRuntime) {
        runtimes.put(aComponent.getName(), aRuntime);
    }

    @Override
    public Object getRuntime(Component aComponent) {
        return runtimes.get(aComponent.getName());
    }

    @Override
    public Object getRuntime(String aName) {
        return runtimes.get(aName);
    }

    @Override
    synchronized public void publishInterface(ProvidedInterface aInterface,
        Object aImplementation) {
        provided.put(aInterface, new ProvidedInterfaceImplementation(
            aInterface, aImplementation));
    }

    @Override
    public <T> T getInterfaceImplementation(ProvidedInterface aInterface,
        Class<T> aType) {
        if (aInterface == null) {
            return null;
        }

        ProvidedInterfaceImplementation providedIntf = provided.get(aInterface);

        if (providedIntf == null) {
            for (Scope parent : parents) {
                T impl = parent.getInterfaceImplementation(aInterface, aType);

                if (impl != null) {
                    return impl;
                }
            }

            return null;
        } else {
            return providedIntf.getImplementation(aType);
        }
    }
}