/*
 * 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.client.FlexClient;
import flex.messaging.endpoints.Endpoint;
import flex.messaging.io.TypeMarshallingContext;
import flex.messaging.security.LoginManager;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.security.Principal;

/**
 * The <tt>FlexContext</tt> is a utility class that exposes the current execution context.
 * It provides access to <tt>FlexSession</tt> and <tt>FlexClient</tt> instances associated
 * with the current message being processed, as well as global context via the <tt>MessageBroker</tt>,
 * <tt>ServletContext</tt> and <tt>ServletConfig</tt> for the application.
 * Any, or all, of the properties exposed by this class may be <code>null</code> depending upon
 * the current execution context so test for that before attempting to interact with them.
 */
public class FlexContext
{
    private static ThreadLocal<FlexClient> flexClients = new ThreadLocal<FlexClient>();
    private static ThreadLocal<FlexSession> sessions = new ThreadLocal<FlexSession>();
    private static ThreadLocal<MessageBroker> messageBrokers = new ThreadLocal<MessageBroker>();
    private static ThreadLocal<Endpoint> endpoints = new ThreadLocal<Endpoint>();
    private static ThreadLocal<HttpServletResponse> responses = new ThreadLocal<HttpServletResponse>();
    private static ThreadLocal<HttpServletRequest> requests = new ThreadLocal<HttpServletRequest>();
    private static ThreadLocal<HttpServletRequest> tunnelRequests = new ThreadLocal<HttpServletRequest>();
    private static ThreadLocal<ServletConfig> servletConfigs = new ThreadLocal<ServletConfig>();
    private static ThreadLocal<Boolean> messageFromPeer = new ThreadLocal<Boolean>();
    private static ThreadLocal<MessageRoutedNotifier> messageRoutedNotifiers = new ThreadLocal<MessageRoutedNotifier>();
    private static ServletConfig lastGoodServletConfig;

    private FlexContext()
    {
    }

    /**
     * Users should not call this.
     *
     * @param flexClient the Flex client
     * @param session the Flex session
     * @param broker the message broker
     * @param request the http servlet request
     * @param response the http servlet response
     * @param servletConfig the servlet config
     */
    public static void setThreadLocalObjects(FlexClient flexClient,
                                             FlexSession session,
                                             MessageBroker broker,
                                             HttpServletRequest request,
                                             HttpServletResponse response,
                                             ServletConfig servletConfig)
    {
        if (flexClients == null) // In case releaseThreadLocalObjects has been called.
            return;

        flexClients.set(flexClient);
        sessions.set(session);
        messageBrokers.set(broker);
        requests.set(request);
        responses.set(response);
        setThreadLocalServletConfig(servletConfig);
        messageFromPeer.set(Boolean.FALSE);
    }

    /**
     * Users should not call this.
     *
     * @param flexClient the Flex client
     * @param session the Flex session
     * @param broker the message broker
     */
    public static void setThreadLocalObjects(FlexClient flexClient, FlexSession session, MessageBroker broker)
    {
        setThreadLocalObjects(flexClient, session, broker, null, null, null);
    }

    /**
     * Users should not call this.
     *
     */
    public static void clearThreadLocalObjects()
    {
        if (flexClients == null) // In case releaseThreadLocalObjects has been called.
            return;

        flexClients.remove();
        sessions.remove();
        messageBrokers.remove();
        endpoints.remove();
        requests.remove();
        responses.remove();
        tunnelRequests.remove();
        servletConfigs.remove();
        messageFromPeer.remove();
        messageRoutedNotifiers.remove();

        TypeMarshallingContext.clearThreadLocalObjects();
    }

    /**
     * The HttpServletResponse for the current request if the request is via HTTP.
     * Returns null if the client is using a non-HTTP channel.
     * Available for users.
     *
     * @return HttpServletRequest current HttpServletRequest object
     */
    public static HttpServletRequest getHttpRequest()
    {
        return requests != null? requests.get() : null;
    }

    /**
     * Users should not call this.
     *
     * @param value HttpServletRequest object
     */
    public static void setThreadLocalHttpRequest(HttpServletRequest value)
    {
        if (requests == null)
            return;

        if (value == null)
            requests.remove();
        else
            requests.set(value);
    }

    /**
     * The HttpServletResponse for the current request if the request is via HTTP.
     * Returns null if the using an non-HTTP channel.
     * Available for users.
     *
     * @return HttpServletResponse current HttpServletResponse object
     */
    public static HttpServletResponse getHttpResponse()
    {
        return responses != null? responses.get() : null;
    }

    /**
     * Users should not call this.
     *
     * @param value HttpServletResponse object
     */
    public static void setThreadLocalHttpResponse(HttpServletResponse value)
    {
        if (responses == null)
            return;

        if (value == null)
            responses.remove();
        else
            responses.set(value);
    }

    /**
     * The HttpServletRequest for the current request if it is transporting a tunneled protocol.
     * Returns null if the current request protocol it not tunneled.
     * Available for users.
     *
     * @return HttpServletRequest tunnel HttpServletRequest object
     */
    public static HttpServletRequest getTunnelHttpRequest()
    {
        return tunnelRequests != null? tunnelRequests.get() : null;
    }

    /**
     * Users should not call this.
     *
     * @param value HttpServletRequest object
     */
    public static void setThreadLocalTunnelHttpRequest(HttpServletRequest value)
    {
        if (tunnelRequests == null)
            return;

        if (value == null)
            tunnelRequests.remove();
        else
            tunnelRequests.set(value);
    }

    /**
     * The ServletConfig for the current request, uses the last known ServletConfig
     * when the request is not via HTTP.  Available for users.
     *
     * @return ServletConfig current ServletConfig object
     */
    public static ServletConfig getServletConfig()
    {
        if (servletConfigs != null && servletConfigs.get() != null)
        {
            return servletConfigs.get();
        }
        return lastGoodServletConfig;
    }

    /**
     * Users should not call this.
     *
     * @param value ServletConfig object
     */
    public static void setThreadLocalServletConfig(ServletConfig value)
    {
        if (servletConfigs == null)
            return;

        if (value == null)
        {
            servletConfigs.remove();
        }
        else
        {
            servletConfigs.set(value);
            lastGoodServletConfig = value;
        }
    }

    /**
     * The ServletContext for the current web application.
     *
     * @return ServletContext current ServletContext object
     */
    public static ServletContext getServletContext()
    {
        return getServletConfig() != null? getServletConfig().getServletContext() : null;
    }

    /**
     * The FlexClient for the current request. Available for users.
     *
     * @return FlexClient the current FlexClient object
     */
    public static FlexClient getFlexClient()
    {
        return flexClients != null? flexClients.get() : null;
    }

    /**
     * Users should not call this.
     *
     * @param flexClient FlexClient object
     */
    public static void setThreadLocalFlexClient(FlexClient flexClient)
    {
        if (flexClients == null)
            return;

        if (flexClient == null)
            flexClients.remove();
        else
            flexClients.set(flexClient);
    }

    /**
     * The FlexSession for the current request.  Available for users.
     *
     * @return FlexSession the current FlexSession object
     */
    public static FlexSession getFlexSession()
    {
        return sessions != null? sessions.get() : null;
    }

    /**
     * Users should not call this.
     *
     * @param session FlexSession object
     */
    public static void setThreadLocalSession(FlexSession session)
    {
        if (sessions == null)
            return;

        if (session == null)
            sessions.remove();
        else
            sessions.set(session);
    }

    /**
     * The MessageBroker for the current request.  Not available for users.
     *
     * @return The MessageBroker for the current request
     */
    public static MessageBroker getMessageBroker()
    {
        return messageBrokers != null? messageBrokers.get() : null;
    }

    /**
     * Users should not call this.
     *
     * @param value MessageBroker object
     */
    public static void setThreadLocalMessageBroker(MessageBroker value)
    {
        // This is a special case because MessageBroker is sometimes accessed by
        // services, destinations, adapters during shutdown so it needs to be set
        // on the context even if a previous MessageBrokerServlet#destroy called
        // releaseThreadLocalObjects.
        if (messageBrokers == null)
            messageBrokers = new ThreadLocal<MessageBroker>();

        if (value == null)
            messageBrokers.remove();
        else
            messageBrokers.set(value);
    }

    /**
     * The Endpoint for the current message. Not available for users.
     *
     * @return The Endpoint for the current message
     */
    public static Endpoint getEndpoint()
    {
        return endpoints != null? endpoints.get() : null;
    }

    /**
     * Users should not call this.
     *
     * @param value Endpoint object
     */
    public static void setThreadLocalEndpoint(Endpoint value)
    {
        if (endpoints == null)
            return;

        if (value == null)
            endpoints.remove();
        else
            endpoints.set(value);
    }

    /**
     * Users should not call this.
     *
     * @return MessageRoutedNotifier object
     */
    public static MessageRoutedNotifier getMessageRoutedNotifier()
    {
        return messageRoutedNotifiers != null? messageRoutedNotifiers.get() : null;
    }

    /**
     * Users should not call this.
     *
     * @param value MessageRoutedNotifier object
     */
    public static void setMessageRoutedNotifier(MessageRoutedNotifier value)
    {
        if (messageRoutedNotifiers == null)
            return;

        if (value == null)
            messageRoutedNotifiers.remove();
        else
            messageRoutedNotifiers.set(value);
    }

    /**
     * Indicates whether the current message being processed came from a server peer
     * in a cluster.
     *
     * @return true if message from a peer
     */
    public static boolean isMessageFromPeer()
    {
        return messageFromPeer != null? messageFromPeer.get() : false;
    }

    /**
     * Sets a thread local indicating whether the message being processed came from
     * a server peer in a cluster.
     *
     * @param value True if the message came from a peer; otherwise false.
     */
    public static void setMessageFromPeer(boolean value)
    {
        if (messageFromPeer == null)
            return;

        messageFromPeer.set(value);
    }

    /**
     * Users should not call this.
     *
     * @return true if per-client-authentication is turned on.
     */
    public static boolean isPerClientAuthentication()
    {
        MessageBroker messageBroker = getMessageBroker();
        if (messageBroker == null)
            return false;

        LoginManager loginManager = messageBroker.getLoginManager();
        return loginManager == null? false : loginManager.isPerClientAuthentication();
    }

    /**
     * Returns the principal associated with the session or client depending on whether
     * perClientauthentication is being used.  If the client has not
     * authenticated the principal will be null.
     *
     * @return The principal associated with the session.
     */
    public static Principal getUserPrincipal()
    {
        if (isPerClientAuthentication())
        {
            FlexClient client = getFlexClient();
            return client != null? client.getUserPrincipal() : null;
        }

        FlexSession session = getFlexSession();
        return session != null? session.getUserPrincipal() : null;
    }

    /**
     * Sets the Principal on either the current FlexClient or FlexSession depending upon whether
     * perClientAuthentication is in use.
     *
     * @param userPrincipal The principal to associate with the FlexClient or FlexSession
     *                      depending upon whether perClientAuthentication is in use.
     */
    public static void setUserPrincipal(Principal userPrincipal)
    {
        if (isPerClientAuthentication())
            getFlexClient().setUserPrincipal(userPrincipal);
        else
            getFlexSession().setUserPrincipal(userPrincipal);
    }

    /**
     * Create the static thread local storage.
     */
    public static void createThreadLocalObjects()
    {
        if (flexClients == null) // Allocate if needed.
        {
            flexClients = new ThreadLocal<FlexClient>();
            sessions = new ThreadLocal<FlexSession>();
            messageBrokers = new ThreadLocal<MessageBroker>();
            endpoints = new ThreadLocal<Endpoint>();
            responses = new ThreadLocal<HttpServletResponse>();
            requests = new ThreadLocal<HttpServletRequest>();
            tunnelRequests = new ThreadLocal<HttpServletRequest>();
            servletConfigs = new ThreadLocal<ServletConfig>();
            messageFromPeer = new ThreadLocal<Boolean>();
            messageRoutedNotifiers = new ThreadLocal<MessageRoutedNotifier>();
        }
    }

    /**
     * Destroy the static thread local storage.
     * Call ONLY on shutdown
     */
    public static void releaseThreadLocalObjects()
    {
        clearThreadLocalObjects();
        
        flexClients = null;
        sessions = null;
        messageBrokers = null;
        endpoints = null;
        responses = null;
        requests = null;
        tunnelRequests = null;
        servletConfigs = null;
        messageFromPeer = null;
        messageRoutedNotifiers = null;
    }
}