/**
    * This file Copyright (c) 2017-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.context;
  
  import info.magnolia.cms.beans.runtime.MultipartForm;
  import info.magnolia.cms.core.AggregationState;
  import info.magnolia.cms.core.HTMLEscapingAggregationState;
  import info.magnolia.cms.i18n.Messages;
  import info.magnolia.cms.security.AccessManager;
  import info.magnolia.cms.security.User;
  import info.magnolia.objectfactory.Components;
  
  import java.io.IOException;
  import java.io.Writer;
  import java.util.Collection;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  import java.util.function.BiConsumer;
  import java.util.function.BiFunction;
  import java.util.function.Function;
  
  import javax.jcr.LoginException;
  import javax.jcr.RepositoryException;
  import javax.jcr.Session;
  import javax.security.auth.Subject;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  /**
   * A wrapper around {@link WebContext} which will return an escaped {@link AggregationState}.
   *
   * @see HTMLEscapingAggregationState
   * @see #getAggregationState()
   */
  public class HTMLEscapingWebContextWrapper implements WebContext {
  
      private WebContext original;
  
      public HTMLEscapingWebContextWrapper(WebContext original) {
          this.original = original;
      }
  
      /**
       * @return the unwrapped/original {@link WebContext}
       */
      public WebContext unwrap() {
          return original;
      }
  
      @Override
      public void init(HttpServletRequest request, HttpServletResponse response, ServletContext servletContext) {
          original.init(request, response, servletContext);
      }
  
      /**
       * @return AggregationState wrapped as {@link HTMLEscapingAggregationState}.
       */
      @Override
      public AggregationState getAggregationState() {
          return Components.getComponent(HTMLEscapingAggregationState.class);
      }
  
      @Override
      public void resetAggregationState() {
          original.resetAggregationState();
     }
 
     @Override
     public MultipartForm getPostedForm() {
         return original.getPostedForm();
     }
 
     @Override
     public String getParameter(String name) {
         return original.getParameter(name);
     }
 
     @Override
     public Map<String, String> getParameters() {
         return original.getParameters();
     }
 
     @Override
     public String getContextPath() {
         return original.getContextPath();
     }
 
     @Override
     public HttpServletRequest getRequest() {
         return original.getRequest();
     }
 
     @Override
     public HttpServletResponse getResponse() {
         return original.getResponse();
     }
 
     @Override
     public User getUser() {
         return original.getUser();
     }
 
     @Override
     public Subject getSubject() {
         return original.getSubject();
     }
 
     @Override
     public void setLocale(Locale locale) {
         original.setLocale(locale);
     }
 
     @Override
     public ServletContext getServletContext() {
         return original.getServletContext();
     }
 
     @Override
     public Locale getLocale() {
         return original.getLocale();
     }
 
     @Override
     public Session getJCRSession(String workspaceName) throws LoginException, RepositoryException {
         return original.getJCRSession(workspaceName);
     }
 
     @Override
     public void include(String path, Writer out) throws ServletException, IOException {
         original.include(path, out);
     }
 
     @Override
     public AccessManager getAccessManager(String name) {
         return original.getAccessManager(name);
     }
 
     @Override
     public void push(HttpServletRequest request, HttpServletResponse response) {
         original.push(request, response);
     }
 
     @Override
     public void pop() {
         original.pop();
     }
 
     @Override
     public void setAttribute(String name, Object value, int scope) {
         original.setAttribute(name, value, scope);
     }
 
     @Override
     public String[] getParameterValues(String name) {
         return original.getParameterValues(name);
     }
 
     @Override
     public <T> T getAttribute(String name, int scope) {
         return original.getAttribute(name, scope);
     }
 
     @Override
     public <T> T getAttribute(String name) {
         return original.getAttribute(name);
     }
 
     @Override
     public Map<String, Object> getAttributes(int scope) {
         return original.getAttributes(scope);
     }
 
     @Override
     public void removeAttribute(String name, int scope) {
         original.removeAttribute(name, scope);
     }
 
     @Override
     public Map<String, Object> getAttributes() {
         return original.getAttributes();
     }
 
     @Override
     public Messages getMessages() {
         return original.getMessages();
     }
 
     @Override
     public Messages getMessages(String basename) {
         return original.getMessages(basename);
     }
 
     @Override
     public void release() {
         original.release();
     }
 
     @Override
     public int size() {
         return original.size();
     }
 
     @Override
     public boolean isEmpty() {
         return original.isEmpty();
     }
 
     @Override
     public boolean containsKey(Object key) {
         return original.containsKey(key);
     }
 
     @Override
     public boolean containsValue(Object value) {
         return original.containsValue(value);
     }
 
     @Override
     public Object get(Object key) {
         return original.get(key);
     }
 
     @Override
     public Object put(Object key, Object value) {
         return original.put(key, value);
     }
 
     @Override
     public Object remove(Object key) {
         return original.remove(key);
     }
 
     @Override
     public void putAll(Map m) {
         original.putAll(m);
     }
 
     @Override
     public void clear() {
         original.clear();
     }
 
     @Override
     public Set keySet() {
         return original.keySet();
     }
 
     @Override
     public Collection values() {
         return original.values();
     }
 
     @Override
     public Set<Entry> entrySet() {
         return original.entrySet();
     }
 
     @Override
     public boolean equals(Object o) {
         return original.equals(o);
     }
 
     @Override
     public int hashCode() {
         return original.hashCode();
     }
 
     @Override
     public Object getOrDefault(Object key, Object defaultValue) {
         return original.getOrDefault(key, defaultValue);
     }
 
     @Override
     public void forEach(BiConsumer action) {
         original.forEach(action);
     }
 
     @Override
     public void replaceAll(BiFunction function) {
         original.replaceAll(function);
     }
 
     @Override
     public Object putIfAbsent(Object key, Object value) {
         return original.putIfAbsent(key, value);
     }
 
     @Override
     public boolean remove(Object key, Object value) {
         return original.remove(key, value);
     }
 
     @Override
     public boolean replace(Object key, Object oldValue, Object newValue) {
         return original.replace(key, oldValue, newValue);
     }
 
     @Override
     public Object replace(Object key, Object value) {
         return original.replace(key, value);
     }
 
     @Override
     public Object computeIfAbsent(Object key, Function mappingFunction) {
         return original.computeIfAbsent(key, mappingFunction);
     }
 
     @Override
     public Object computeIfPresent(Object key, BiFunction remappingFunction) {
         return original.computeIfPresent(key, remappingFunction);
     }
 
     @Override
     public Object compute(Object key, BiFunction remappingFunction) {
         return original.compute(key, remappingFunction);
     }
 
     @Override
     public Object merge(Object key, Object value, BiFunction remappingFunction) {
         return original.merge(key, value, remappingFunction);
     }
 }