/*
 * 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 org.apache.ace.http.listener;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.servlet.Servlet;
import javax.servlet.http.HttpServlet;

import org.apache.ace.http.listener.constants.HttpConstants;
import org.apache.felix.dm.DependencyActivatorBase;
import org.apache.felix.dm.DependencyManager;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.service.http.HttpService;
import org.osgi.service.log.LogService;

/**
 * Service responsible for registrating HttpServlets at HttpServices.<p>
 *
 * When a HttpServlet is being added or removed, the callback methods in this class are being
 * called via the DependencyManager. A Servlet is being added to all HttpServices currently
 * available or removed from all available HttpServices.<p>
 *
 * In case a HttpService is being added or removed, other callback methods are being called
 * via the DependencyManager. When a HttpService is added, all previously registered Servlets
 * are being registered to this new HttpService. In case of removal, all Servlet endpoints are
 * being removed from the HttpService that is going to be removed.<p>
 */
public class Activator extends DependencyActivatorBase {

    private volatile LogService m_log; // injected
    private final Set<ServiceReference> m_httpServices = new HashSet<ServiceReference>();
    private final Map<ServiceReference, String> m_servlets = new HashMap<ServiceReference, String>();
    private BundleContext m_context;

    @Override
    public synchronized void init(BundleContext context, DependencyManager manager) throws Exception {
        m_context = context;
        manager.add(createComponent()
            .setImplementation(this)
            .add(createServiceDependency()
                .setService(LogService.class)
                .setRequired(false))
            .add(createServiceDependency()
                .setService(HttpService.class)
                .setAutoConfig(false)
                .setCallbacks("addHttpService", "removeHttpService"))
            .add(createServiceDependency()
                .setService(HttpServlet.class)
                .setAutoConfig(false)
                .setCallbacks("addHttpServlet", "changeHttpServlet", "removeHttpServlet")));
    }

    /**
     * Callback method used in case a HttpServlet is being added. This Servlet is being added
     * to all available HttpServices under the endpoint configured via the Configurator.
     *
     * @param ref  reference to the Servlet
     */
    public synchronized void addHttpServlet(ServiceReference ref) {
        // register servlet to all HttpServices
        String endpoint = (String)ref.getProperty(HttpConstants.ENDPOINT);
        m_servlets.put(ref, endpoint);
        Servlet servlet = (Servlet)m_context.getService(ref);
        for (ServiceReference reference : m_httpServices) {
            HttpService httpService = (HttpService) m_context.getService(reference);
            try {
                if ((httpService != null) && (endpoint != null) && (servlet != null)) {
                    httpService.registerServlet(endpoint, servlet, null, null);
                }
                else {
                    m_log.log(LogService.LOG_WARNING, "Unable to register servlet with endpoint '" + endpoint + "'");
                }
            }
            catch (Exception e) {
                m_log.log(LogService.LOG_WARNING, "Already registered under existing endpoint", e);
            }
        }
    }

    public synchronized void changeHttpServlet(ServiceReference ref) {
        removeServlet(ref, m_servlets.get(ref));
        addHttpServlet(ref);
    }

    /**
     * Callback method used in case a HttpServlet is being removed. This Servlet is being removed
     * from all available HttpServices using the endpoint configured via the Configurator.
     *
     * @param ref  reference to the Servlet
     */
    public synchronized void removeHttpServlet(ServiceReference ref) {
        // remove servlet from all HttpServices
        String endpoint = (String)ref.getProperty(HttpConstants.ENDPOINT);
        removeServlet(ref, endpoint);
    }

    private void removeServlet(ServiceReference ref, String endpoint) {
        m_servlets.remove(ref);
        for (ServiceReference reference : m_httpServices) {
            HttpService httpService = (HttpService) m_context.getService(reference);
            if ((httpService != null) && (endpoint != null)) {
                try {
                    httpService.unregister(endpoint);
                }
                catch (Exception e) {
                    m_log.log(LogService.LOG_WARNING, "Servlet cannot be unregistered, maybe not registered under this endpoint", e);
                }
            }
        }
    }

    /**
     * Callback method used in case a HttpService is being added. To this Service all previously
     * registered Servlet are added under the endpoints of the Servlets (which are configured
     * via the Configurator).
     *
     * @param ref  reference to the Service
     */
    public synchronized void addHttpService(ServiceReference ref, HttpService httpService) {
        m_httpServices.add(ref);
        // register all servlets to this new HttpService
        for (ServiceReference reference : m_servlets.keySet()) {
            Servlet servlet = (Servlet)m_context.getService(reference);
            String endpoint = (String)reference.getProperty(HttpConstants.ENDPOINT);
            if ((servlet != null) && (endpoint != null)) {
                try {
                    httpService.registerServlet(endpoint, servlet, null, null);
                }
                catch (Exception e) {
                    m_log.log(LogService.LOG_WARNING, "Already registered under existing endpoint", e);
                }
            }
        }
    }

    /**
     * Callback method used in case a HttpService is being removed. From this Service all previously
     * registered Servlet are removed using the endpoints of the Servlets (which are configured
     * via the Configurator).
     *
     * @param ref  reference to the Service
     */
    public synchronized void removeHttpService(ServiceReference ref, HttpService httpService) {
        m_httpServices.remove(ref);
        // remove references from the unregistered HttpService
        unregisterEndpoints(httpService);
    }

    @Override
    public synchronized void destroy(BundleContext context, DependencyManager arg1) throws Exception {
        for (ServiceReference httpRef : m_httpServices) {
            HttpService httpService = (HttpService)m_context.getService(httpRef);
            if (httpService != null) {
                unregisterEndpoints(httpService);
            }
        }
        m_httpServices.clear();
        m_servlets.clear();
        m_context = null;
    }

    /**
     * Unregisters all Servlets (via their endpoints) from the HttpService being passed to
     * this method.
     *
     * @param httpService  the HttpService that is being unregistered
     */
    private void unregisterEndpoints(HttpService httpService) {
        for (ServiceReference reference : m_servlets.keySet()) {
            String endpoint = (String)reference.getProperty(HttpConstants.ENDPOINT);
            if (endpoint != null) {
                try {
                    httpService.unregister(endpoint);
                }
                catch (Exception e) {
                    m_log.log(LogService.LOG_WARNING, "Servlet cannot be unregistered, maybe not registered under this endpoint", e);
                }
            }
        }
    }
}