/*
    * Copyright 2006 Outsource Cafe, Inc.
    *
    * 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.javagen.agile.core.context;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  /***
   * Holds a stack of ContextHolders (i.e. Contexts) allowing access as if it was a single
   * context.  Keys pushed on the stack will mask prior keys with identical names.
   * 
   * @author Richard Easterling
   */
  public class ContextHolderStack implements Context {
  
  	protected List<ContextHolder> contextHolderStack = new ArrayList<ContextHolder>();
  	
  	protected Context combinedContext;
  	
  	////////////////////////////////////////////////////////////////////////////
  	// Stack methods:
  	////////////////////////////////////////////////////////////////////////////
  	
  	public ContextHolder pop() {
  		combinedContext = null;
  		return contextHolderStack.isEmpty() ? null : contextHolderStack.remove(contextHolderStack.size()-1);
  	}
  	
  	public ContextHolder peek() {
  		return contextHolderStack.isEmpty() ? null : contextHolderStack.get(contextHolderStack.size()-1);
  	}
  	
  	public ContextHolderStack push(ContextHolder context) {
  		if (context!=null)
  			contextHolderStack.add(context);
  		combinedContext = null;
  		return this;
  	}
  	
  	////////////////////////////////////////////////////////////////////////////
  	// Map methods:
  	////////////////////////////////////////////////////////////////////////////
  
  	public Object get(Object key) {
  		if (contextHolderStack==null)
  			return null;
  		for(int i=contextHolderStack.size()-1; i>=0; i--) {
  			ContextHolder contextHolder = contextHolderStack.get(i);
  			Object value = contextHolder.getContext()==null ? null : contextHolder.getContext().get(key);
  			if (value!=null)
  				return value;
  		}
  		return null;
  	}
  	
  	public boolean containsKey(Object key) {
  		if (contextHolderStack==null)
  			return false;
  		for(int i=contextHolderStack.size()-1; i>=0; i--) {
  			ContextHolder contextHolder = contextHolderStack.get(i);
  			boolean value = contextHolder.getContext()==null ? false : contextHolder.getContext().containsKey(key);
  			if (value)
  				return value;
  		}
  		return false;
  	}
  
  	public Set<String> keySet() {
  		return combinedContext().keySet();
  	}
  	
  	public void clear() {
  		combinedContext = null;
  	}
  
  	public boolean containsValue(Object value) {
  		return combinedContext().containsValue(value);
  	}
  
  	public Set<Entry<String, Object>> entrySet() {
  		return combinedContext().entrySet();
  	}
  
 	public boolean equals(Object o) {
 		return combinedContext().equals(o);
 	}
 
 	public int hashCode() {
 		return combinedContext().hashCode();
 	}
 
 	public boolean isEmpty() {
 		return combinedContext().isEmpty();
 	}
 
 	public Object put(String key, Object value) {
 		throw new UnsupportedOperationException("ContextHolderStack supports read-only methods of java.util.Map");
 	}
 
 	public void putAll(Map<? extends String, ? extends Object> t) {
 		throw new UnsupportedOperationException("ContextHolderStack supports read-only methods of java.util.Map");
 	}
 
 	public Object remove(Object key) {
 		throw new UnsupportedOperationException("ContextHolderStack supports read-only methods of java.util.Map");
 	}
 
 	public int size() {
 		return combinedContext().size();
 	}
 
 	public Collection<Object> values() {
 		return combinedContext().values();
 	}
 	
 	////////////////////////////////////////////////////////////////////////////
 	// support methods:
 	////////////////////////////////////////////////////////////////////////////
 
 	public Context combinedContext() {
 		if (combinedContext==null) {
 			combinedContext = new DefaultContext();
 			for(ContextHolder contextHolder : contextHolderStack) {
 				Map<String, Object> context = contextHolder.getContext();
 				if (context!=null)
 					for(String key : context.keySet()) {
 						combinedContext.put(key, context.get(key));
 					}
 			}
 		}
 		return combinedContext;
 	}
 
 	
 }