/*
    * 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.logging.log4j.spi;
  
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  
  import org.apache.logging.log4j.util.PropertiesUtil;
  
  /**
   * The actual ThreadContext Map. A new ThreadContext Map is created each time it is updated and the Map stored
   * is always immutable. This means the Map can be passed to other threads without concern that it will be updated.
   * Since it is expected that the Map will be passed to many more log events than the number of keys it contains
   * the performance should be much better than if the Map was copied for each event.
   */
  public class DefaultThreadContextMap implements ThreadContextMap {
      /** 
       * Property name ({@value}) for selecting {@code InheritableThreadLocal} (value "true")
       * or plain {@code ThreadLocal} (value is not "true") in the implementation.
       */
      public static final String INHERITABLE_MAP = "isThreadContextMapInheritable";
  
      private final boolean useMap;
      private final ThreadLocal<Map<String, String>> localMap;
  
      public DefaultThreadContextMap(final boolean useMap) {
          this.useMap = useMap;
          this.localMap = createThreadLocalMap(useMap);
      }
      
      // LOG4J2-479: by default, use a plain ThreadLocal, only use InheritableThreadLocal if configured.
      // (This method is package protected for JUnit tests.)
      static ThreadLocal<Map<String, String>> createThreadLocalMap(final boolean isMapEnabled) {
          final PropertiesUtil managerProps = PropertiesUtil.getProperties();
          final boolean inheritable = managerProps.getBooleanProperty(INHERITABLE_MAP);
          if (inheritable) {
              return new InheritableThreadLocal<Map<String, String>>() {
                  @Override
                  protected Map<String, String> childValue(final Map<String, String> parentValue) {
                      return parentValue != null && isMapEnabled //
                              ? Collections.unmodifiableMap(new HashMap<String, String>(parentValue)) //
                              : null;
                  }
              };
          }
          // if not inheritable, return plain ThreadLocal with null as initial value
          return new ThreadLocal<Map<String, String>>();
      }
  
      /**
       * Put a context value (the <code>o</code> parameter) as identified
       * with the <code>key</code> parameter into the current thread's
       * context map.
       * <p/>
       * <p>If the current thread does not have a context map it is
       * created as a side effect.
       * @param key The key name.
       * @param value The key value.
       */
      @Override
      public void put(final String key, final String value) {
          if (!useMap) {
              return;
          }
          Map<String, String> map = localMap.get();
          map = map == null ? new HashMap<String, String>() : new HashMap<String, String>(map);
          map.put(key, value);
          localMap.set(Collections.unmodifiableMap(map));
      }
  
      /**
       * Get the context identified by the <code>key</code> parameter.
       * <p/>
       * <p>This method has no side effects.
       * @param key The key to locate.
       * @return The value associated with the key or null.
       */
      @Override
      public String get(final String key) {
          final Map<String, String> map = localMap.get();
          return map == null ? null : map.get(key);
      }
  
      /**
      * Remove the the context identified by the <code>key</code>
      * parameter.
      * @param key The key to remove.
      */
     @Override
     public void remove(final String key) {
         final Map<String, String> map = localMap.get();
         if (map != null) {
             final Map<String, String> copy = new HashMap<String, String>(map);
             copy.remove(key);
             localMap.set(Collections.unmodifiableMap(copy));
         }
     }
 
     /**
      * Clear the context.
      */
     @Override
     public void clear() {
         localMap.remove();
     }
 
     /**
      * Determine if the key is in the context.
      * @param key The key to locate.
      * @return True if the key is in the context, false otherwise.
      */
     @Override
     public boolean containsKey(final String key) {
         final Map<String, String> map = localMap.get();
         return map != null && map.containsKey(key);
     }
 
     /**
      * Returns a non-{@code null} mutable copy of the ThreadContext Map.
      * @return a non-{@code null} mutable copy of the context.
      */
     @Override
     public Map<String, String> getCopy() {
         final Map<String, String> map = localMap.get();
         return map == null ? new HashMap<String, String>() : new HashMap<String, String>(map);
     }
 
     /**
      * Returns either {@code null} or an immutable view of the context Map.
      * @return the Context Map.
      */
     @Override
     public Map<String, String> getImmutableMapOrNull() {
         return localMap.get();
     }
 
     /**
      * Returns true if the Map is empty.
      * @return true if the Map is empty, false otherwise.
      */
     @Override
     public boolean isEmpty() {
         final Map<String, String> map = localMap.get();
         return map == null || map.size() == 0;
     }
 
     @Override
     public String toString() {
         final Map<String, String> map = localMap.get();
         return map == null ? "{}" : map.toString();
     }
 
     @Override
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         final Map<String, String> map = this.localMap.get();
         result = prime * result + ((map == null) ? 0 : map.hashCode());
         result = prime * result + (this.useMap ? 1231 : 1237);
         return result;
     }
 
     @Override
     public boolean equals(final Object obj) {
         if (this == obj) {
             return true;
         }
         if (obj == null) {
             return false;
         }
         if (obj instanceof DefaultThreadContextMap) {
             final DefaultThreadContextMap other = (DefaultThreadContextMap) obj;
             if (this.useMap != other.useMap) {
                 return false;
             }
         }
         if (!(obj instanceof ThreadContextMap)) {
             return false;
         }
         final ThreadContextMap other = (ThreadContextMap) obj;
         final Map<String, String> map = this.localMap.get();
         final Map<String, String> otherMap = other.getImmutableMapOrNull(); 
         if (map == null) {
             if (otherMap != null) {
                 return false;
             }
         } else if (!map.equals(otherMap)) {
             return false;
         }
         return true;
     }
 }