/*
 * JBoss, Home of Professional Open Source
 * Copyright 2013, Red Hat, Inc. and individual contributors
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.richfaces.application;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.faces.FacesException;
import javax.faces.context.FacesContext;

/**
 * <p>
 * Tracker class to provide access to various framework implementation services. Examples of such services are:
 * {@link org.richfaces.skin.SkinFactory}, TBD.
 * </p>
 *
 *
 * <p>
 * This class managess application-scoped service factories that are stored in the map with {@link Thread#currentThread()}
 * Context classloader as the key. Therefore, there is only one instance per JEE application in the current JVM.
 * </p>
 * <p>
 * actuall cal for the service instance delegated to the current factory
 * </p>
 * <img src="services.png" alt="services tracking class diagramm"/>
 *
 *
 * <p>
 * <b>Note:</b> in initial state this class is not synchronized and presumes that all modification operations are done in a
 * context of single-thread (in JSF initialization listener).
 * </p>
 *
 * @author Nick Belaevski
 * @since 4.0
 */
public final class ServiceTracker {
    /**
     * <p class="changed_added_4_0">
     * </p>
     */
    private static final Map<ClassLoader, ServicesFactory> INSTANCES = new ConcurrentHashMap<ClassLoader, ServicesFactory>();

    /**
     * <p class="changed_added_4_0">
     * This class supposed to use with static methods only and cannot be instantiated.
     * </p>
     */
    private ServiceTracker() {
    }

    /**
     * <p class="changed_added_4_0">
     * Get service instance for given type. This is a wrapper method for {@link #getService(FacesContext, Class)} that gets
     * faces context by {@link FacesContext#getCurrentInstance()} call, if needed.
     * </p>
     *
     * @param <T> The service type, usually interface.
     * @param target Service type class.
     * @return service implementation instance.
     */
    public static <T> T getService(Class<T> target) {
        return getServicesFactory().getInstance(target);
    }

    /**
     * <p class="changed_added_4_0">
     * Get service instance for given type.
     * </p>
     *
     * @param <T> The service type, usually interface.
     * @param context current {@link FacesContext}.
     * @param target Service type class.
     * @return service instance.
     */
    public static <T> T getService(FacesContext context, Class<T> target) {
        return getServicesFactory().getInstance(target);
    }

    private static ServicesFactory getServicesFactory() {
        if (!INSTANCES.containsKey(getCurrentLoader())) {
            throw new FacesException("Service Tracker has not been initialized");
        }
        ServicesFactory service = INSTANCES.get(getCurrentLoader());
        return service;
    }

    private static ClassLoader getCurrentLoader() {
        ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        if (null == contextClassLoader) {
            contextClassLoader = ServiceTracker.class.getClassLoader();
        }
        return contextClassLoader;
    }

    /**
     * <p class="changed_added_4_0">
     * Set service factory implementation for the current context.
     * </p>
     *
     * @param factory
     */
    public static void setFactory(ServicesFactory factory) {
        INSTANCES.put(getCurrentLoader(), factory);
    }

    /**
     * <p class="changed_added_4_0">
     * Release factory service associated with current context.
     * </p>
     */
    public static void release() {
        ServicesFactory servicesFactory = INSTANCES.remove(getCurrentLoader());
        servicesFactory.release();
    }

    /**
     * Provides proxy which delegates to the given targetService interface once the method is invoked on the targetService.
     *
     * @param targetService the service to delegate operations to
     * @return proxy which delegates to the given targetService
     */
    @SuppressWarnings("unchecked")
    public static <T> T getProxy(final Class<T> targetService) {
        return (T) Proxy.newProxyInstance(getCurrentLoader(), new Class<?>[] { targetService }, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                T service = ServiceTracker.getService(targetService);
                if (service == null) {
                    throw new IllegalStateException("Failed to obtain service " + targetService.getSimpleName());
                }
                return method.invoke(service, args);
            }
        });
    }
}