/*
 * 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.axis2.jaxws.handler;

import org.apache.axis2.jaxws.core.MessageContext;
import org.apache.axis2.jaxws.description.EndpointDescription;
import org.apache.axis2.jaxws.message.Message;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * The <tt>MEPContext</tt> is the version of the MessageContext
 * that will be given to application handlers as the handler list 
 * is traversed.  It is only to be used by application handlers.
 * 
 * The MEPContext object is constructed using a non-null request
 * context.  Once the request has been fully processed in the JAX-WS engine,
 * the response context should be set on this.  Since the response context
 * is always last, it takes priority in all MEPContext methods.
 * 
 */
public class MEPContext implements javax.xml.ws.handler.MessageContext {

    // If this a request flow, then the MEP contains the request MC.
    // If this a response flow, then the MEP contains both the request MC and the response MC.
    // (Note that access to the requestMC properties is sometimes synchronized in the
    // response flow.)
    protected MessageContext requestMC;
    protected MessageContext responseMC;
    
    private Map<String, Scope> scopes;  // APPLICATION or HANDLER scope for properties
    
    /*
     * Flag to indicate whether we're being called from a handler or an application
     * (endpoint or client).  Users of MEPContext should use the 'is' and
     * 'set' appropriately for this flag.  The most likely scenario is to set the
     * flag to true after the server-side inbound handlers are complete.
     * 
     * TODO, all methods should use this flag to check for access rights
     */
    private boolean ApplicationAccessLocked = false;

    /*
     * Ideally this would be "protected", but we want the junit tests to see it.
     */
    public MEPContext(MessageContext requestMsgCtx) {
        this.requestMC = requestMsgCtx;
        scopes = new HashMap<String, Scope>();
        // make sure the MessageContext points back to this
        requestMsgCtx.setMEPContext(this);
    }
    
    public EndpointDescription getEndpointDesc() {
        if (responseMC != null) {
            return responseMC.getEndpointDescription();
        }
        return requestMC.getEndpointDescription();
    }

    public MessageContext getRequestMessageContext() {
        return requestMC;
    }
    
    public MessageContext getResponseMessageContext() {
        return responseMC;
    }
    
    public MessageContext getMessageContext() {
        if (responseMC != null) {
            return responseMC;
        }
        return requestMC;
    }
    
    public void setResponseMessageContext(MessageContext responseMC) {
        if(this.responseMC != null) {
            responseMC.setProperty(javax.xml.ws.handler.MessageContext.OUTBOUND_MESSAGE_ATTACHMENTS, 
                    this.responseMC.getProperty(javax.xml.ws.handler.MessageContext.OUTBOUND_MESSAGE_ATTACHMENTS));
        }
        // TODO does ApplicationAccessLocked mean anything here? -- method is protected, so probably not
        this.responseMC = responseMC;
        // if callers are being careful, the responseMC should not be set
        // until the engine is done invoking the endpoint, on both server and
        // client side.  At that point, we can start allowing callers access
        // to HANDLER scoped properties again.  Set the flag:
        ApplicationAccessLocked = false;
    }
    
    public void setMessage(Message msg) {
        if (responseMC != null) {
            responseMC.setMessage(msg);
        }
        else {
            requestMC.setMessage(msg);
        }
    }
    
    public Scope getScope(String s) {
        if (scopes.get(s) == null) {
            // JAX-WS default 9.4.1.  However, we try to set the scope for
            // every incoming property to HANDLER.  If a property is coming from
            // the axis2 AbstractContext properties bag, we want those to be
            // APPLICATION scoped.  Those properties may have been set by an
            // axis application handler, and may need to be accessible by 
            // a client app or endpoint.
            return Scope.APPLICATION;
        }
        return scopes.get(s);
    }

    public void setScope(String s, Scope scope) {
        // TODO review next two lines
        if (isApplicationAccessLocked()) {  // endpoints are not allowed to change property scope.  They should all be APPLICATION scoped anyway
            return;
        }
        scopes.put(s, scope);
    }

    //--------------------------------------------------
    // java.util.Map methods
    //--------------------------------------------------

    public void clear() {
        // TODO review
        if (isApplicationAccessLocked()) {  // endpoints are allowed to clear APPLICATION scoped properties only
            Map<String, Object> appScopedProps = getApplicationScopedProperties();
            for(Iterator it = appScopedProps.keySet().iterator(); it.hasNext();) {
                String key = (String)it.next();
                remove(key);
                // TODO also remove Scope setting for "key"?  How?
            }
            return;
        }
        // TODO: REVIEW
        // I don't think this will work if the message contexts have a copy
        // of the map
        if (responseMC != null) {
            responseMC.getProperties().clear();
        }
        synchronized (requestMC) {
            requestMC.getProperties().clear();
        }
    }

    public boolean containsKey(Object key) {
        if (isApplicationAccessLocked()) {
            return getApplicationScopedProperties().containsKey(key);
        }
        synchronized (requestMC) {
            if (responseMC != null) {
                boolean containsKey = responseMC.containsKey(key) || requestMC.containsKey(key);
                if ((getScope((String)key) == Scope.APPLICATION) || (!isApplicationAccessLocked())) {
                    return containsKey;
                }
            }
            if ((getScope((String)key) == Scope.APPLICATION) || (!isApplicationAccessLocked())) {
                return requestMC.containsKey(key);
            }
        }
        return false;
    }

    public boolean containsValue(Object value) {
        if (isApplicationAccessLocked()) {
            return getApplicationScopedProperties().containsValue(value);
        }
        if (responseMC != null) {

            if (responseMC.getProperties().containsValue(value)) {
                return true; 
            }
            synchronized (requestMC) {
                return requestMC.getProperties().containsValue(value);
            }
        }
        return requestMC.getProperties().containsValue(value);
    }

    public Set entrySet() {
        // TODO should check ApplicationAccessLocked flag
        // and return only APPLICATION scoped properties if true
        if (isApplicationAccessLocked()) {
            return getApplicationScopedProperties().entrySet();
        }
        HashMap tempProps = new HashMap();
        
        synchronized (requestMC) {
            tempProps.putAll(requestMC.getProperties());
        }
        if (responseMC != null) {
            tempProps.putAll(responseMC.getProperties());
        }
        return tempProps.entrySet();
    }

    public Object get(Object keyObject) {
        String key = (String) keyObject;
        if (responseMC != null) {
            if (responseMC.getProperty(key) != null) {
                if ((getScope((String)key) == Scope.APPLICATION) || (!isApplicationAccessLocked())) {
                    return responseMC.getProperty(key);
                }
            }
        }
        synchronized (requestMC) {
            if ((getScope((String)key) == Scope.APPLICATION) || (!isApplicationAccessLocked())) {
                return requestMC.getProperty(key);
            }
        }
        return null;
    }

    public boolean isEmpty() {
        if (isApplicationAccessLocked()) {
            return getApplicationScopedProperties().isEmpty();
        }
        synchronized (requestMC) {
            if (responseMC != null) {
                return requestMC.getProperties().isEmpty() && requestMC.getProperties().isEmpty();
            }
            return requestMC.getProperties().isEmpty();
        }
    }

    public Set keySet() {
        if (isApplicationAccessLocked()) {
            return getApplicationScopedProperties().keySet();
        }
        HashMap tempProps = new HashMap();
        synchronized (requestMC) {
            tempProps.putAll(requestMC.getProperties());
        }
        if (responseMC != null) {
            tempProps.putAll(responseMC.getProperties());
        }
        return tempProps.keySet();
    }

    public Object put(String key, Object value) {
        // TODO careful:  endpoints may overwrite pre-existing key/value pairs.
        // Those key/value pairs may already have a scope attached to them, which
        // means an endpoint could "put" a property that is wrongly scoped
        if (scopes.get(key) == null) {  // check the scopes object directly, not through getScope()!!
            setScope(key, Scope.HANDLER);
        }
        synchronized (requestMC) {
            if (requestMC.containsKey(key)) {
                return requestMC.setProperty(key, value);
            }
            if (responseMC != null) {
                return responseMC.setProperty(key, value);
            }
            return requestMC.setProperty(key, value);
        }
    }

    public void putAll(Map t) {
        // TODO similar problem as "put"
        for(Iterator it = t.entrySet().iterator(); it.hasNext();) {
            Entry<String, Object> entry = (Entry)it.next();
            if (getScope(entry.getKey()) == null) {
                setScope(entry.getKey(), Scope.HANDLER);
            }
        }
        if (responseMC != null) {
            responseMC.setProperties(t);
        }
        else {
            synchronized (requestMC) {
                requestMC.setProperties(t);
            }
        }
    }

    public Object remove(Object key) {
        // check ApplicationAccessLocked flag and prevent removal of HANDLER scoped props
        if (isApplicationAccessLocked()) {
            if (getScope((String)key).equals(Scope.HANDLER)) {
                return null;
            }
        }
        
        // yes, remove from both and return the right object
        // TODO This won't work because getProperties returns a temporary map
        Object retVal = null;
        if (responseMC != null) {
            retVal = responseMC.getProperties().remove(key);
        }
        synchronized (requestMC) {
            if (retVal == null) {
                return requestMC.getProperties().remove(key);
            }
            else {
                requestMC.getProperties().remove(key);
            }
        }
        return retVal;
    }

    public int size() {
        if (isApplicationAccessLocked()) {
            return getApplicationScopedProperties().size();
        }
        
        // The properties must be combined together because some
        // keys may be the same on the request and the response.
        HashMap tempProps = new HashMap();
        synchronized (requestMC) {
            tempProps.putAll(requestMC.getProperties());
        }
        if (responseMC != null) {
            tempProps.putAll(responseMC.getProperties());
        }
        return tempProps.size();
    }

    public Collection values() {
        if (isApplicationAccessLocked()) {
            return getApplicationScopedProperties().values();
        }
        HashMap tempProps = new HashMap();
        synchronized (requestMC) {
            tempProps.putAll(requestMC.getProperties());
        }
        if (responseMC != null) {
            tempProps.putAll(responseMC.getProperties());
        }
        return tempProps.values();
    }

    public Message getMessageObject() {
        // TODO does ApplicationAccessLocked apply here?
        if (responseMC != null) {
            return responseMC.getMessage();
        }
        return requestMC.getMessage();
    }
    
    public boolean isApplicationAccessLocked() {
        // since MEPContext is both a wrapper and a subclass, we need to be careful to set it only on the wrapper object:
        if (this == requestMC.getMEPContext()) {  // object compare, I am the wrapper object
            return ApplicationAccessLocked;
        }
        if (responseMC == null) {
            return requestMC.getMEPContext().isApplicationAccessLocked();
        }
        else {
            return responseMC.getMEPContext().isApplicationAccessLocked() || requestMC.getMEPContext().isApplicationAccessLocked();
        }
    }

    public void setApplicationAccessLocked(boolean applicationAccessLocked) {
        // since MEPContext is both a wrapper and a subclass, we need to be careful to set it only on the wrapper object:
        if (this == requestMC.getMEPContext()) {  // object compare, I am the wrapper object
            ApplicationAccessLocked = applicationAccessLocked;
        }
        else {
            requestMC.getMEPContext().setApplicationAccessLocked(applicationAccessLocked);
        }
            
    }
    
    /**
     * The returned tempMap should be used as a read-only map as changes to it will
     * not propogate into the requestMC or responseMC
     * 
     * Watch out for infinite loop if you call another method in this class that uses this method.
     * 
     * @return
     */
    public Map<String, Object> getApplicationScopedProperties() {
        Map<String, Object> tempMap = new HashMap<String, Object>();
        if (!scopes.containsValue(Scope.APPLICATION)) {
            return tempMap;
        }
        synchronized (requestMC) {
            for(Iterator it = requestMC.getProperties().entrySet().iterator(); it.hasNext();) {
                Entry entry = (Entry)it.next();
                if (getScope((String)entry.getKey()).equals(Scope.APPLICATION)) {
                    tempMap.put((String)entry.getKey(), entry.getValue());
                }
            }
        }
        if (responseMC != null) {
            for(Iterator it = responseMC.getProperties().entrySet().iterator(); it.hasNext();) {
                Entry entry = (Entry)it.next();
                if (getScope((String)entry.getKey()).equals(Scope.APPLICATION)) {
                    tempMap.put((String)entry.getKey(), entry.getValue());
                }
            }
        }
        return tempMap;
    }
    
}