/**
    * Logback: the reliable, generic, fast and flexible logging framework. Copyright (C) 1999-2015, QOS.ch. All rights
    * reserved.
    *
    * This program and the accompanying materials are dual-licensed under either the terms of the Eclipse Public License
    * v1.0 as published by the Eclipse Foundation
    *
    * or (per the licensee's choosing)
    *
   * under the terms of the GNU Lesser General Public License version 2.1 as published by the Free Software Foundation.
   */
  package ch.qos.logback.access.common.spi;
  
  import ch.qos.logback.access.common.AccessConstants;
  import ch.qos.logback.access.common.pattern.AccessConverter;
  import ch.qos.logback.access.common.servlet.Util;
  import ch.qos.logback.core.Context;
  import ch.qos.logback.core.spi.SequenceNumberGenerator;
  
  import jakarta.servlet.http.Cookie;
  import jakarta.servlet.http.HttpServletRequest;
  import jakarta.servlet.http.HttpServletResponse;
  import jakarta.servlet.http.HttpSession;
  
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.TreeMap;
  import java.util.Vector;
  
  // Contributors:  Joern Huxhorn (see also bug #110)
  
  /**
   * <p>This class is the implementation of the {@link IAccessEvent} interface.</p>
   *
   * <p>Much of the processing done by the logack-access project revolves around this class.</p>
   *
   * @author Ceki G&uuml;lc&uuml;
   * @author S&eacute;bastien Pennec
   */
  public class AccessEvent implements Serializable, IAccessEvent {
  
      private static final String[] NA_STRING_ARRAY = new String[] { NA };
  
      private static final long serialVersionUID = 866718993618836343L;
  
      private static final String EMPTY = "";
  
      private transient final HttpServletRequest httpRequest;
      private transient final HttpServletResponse httpResponse;
  
      String queryString;
      String requestURI;
      String requestURL;
      String remoteHost;
      String remoteUser;
      String remoteAddr;
      String threadName;
      String protocol;
      String method;
      String serverName;
      String requestContent;
      String responseContent;
      String sessionID;
      long elapsedTime;
  
      Map<String, String> requestHeaderMap;
      Map<String, String[]> requestParameterMap;
      Map<String, String> responseHeaderMap;
      Map<String, Object> attributeMap;
  
      List<Cookie> cookieList;
  
      long contentLength = SENTINEL;
      int statusCode = SENTINEL;
      int localPort = SENTINEL;
  
      transient ServerAdapter serverAdapter;
  
      /**
       * The number of milliseconds elapsed from 1/1/1970 until logging event was created.
       */
      private long timeStamp = 0;
  
      private long sequenceNumber = 0;
  
      public AccessEvent(Context context, HttpServletRequest httpRequest, HttpServletResponse httpResponse,
              ServerAdapter adapter) {
          this.httpRequest = httpRequest;
          this.httpResponse = httpResponse;
          this.timeStamp = System.currentTimeMillis();
  
          SequenceNumberGenerator sng = context.getSequenceNumberGenerator();
          if (sng != null) {
              this.sequenceNumber = sng.nextSequenceNumber();
         }
         this.serverAdapter = adapter;
         this.elapsedTime = calculateElapsedTime();
     }
 
     /**
      * Returns the underlying HttpServletRequest. After serialization the returned value will be null.
      *
      * @return
      */
     @Override
     public HttpServletRequest getRequest() {
         return httpRequest;
     }
 
     /**
      * Returns the underlying HttpServletResponse. After serialization the returned value will be null.
      *
      * @return
      */
     @Override
     public HttpServletResponse getResponse() {
         return httpResponse;
     }
 
     @Override
     public long getTimeStamp() {
         return timeStamp;
     }
 
     public void setTimeStamp(long timeStamp) {
         this.timeStamp = timeStamp;
     }
 
     public long getSequenceNumber() {
         return sequenceNumber;
     }
 
     public void setSequenceNumber(long sequenceNumber) {
         this.sequenceNumber = sequenceNumber;
     }
 
     /**
      * @param threadName The threadName to set.
      */
     public void setThreadName(String threadName) {
         this.threadName = threadName;
     }
 
     @Override
     public String getThreadName() {
         return threadName == null ? NA : threadName;
     }
 
     @Override
     public String getRequestURI() {
         if (requestURI == null) {
             if (httpRequest != null) {
                 requestURI = httpRequest.getRequestURI();
             } else {
                 requestURI = NA;
             }
         }
         return requestURI;
     }
 
     @Override
     public String getQueryString() {
         if (queryString == null) {
             if (httpRequest != null) {
                 StringBuilder buf = new StringBuilder();
                 final String qStr = httpRequest.getQueryString();
                 if (qStr != null) {
                     buf.append(AccessConverter.QUESTION_CHAR);
                     buf.append(qStr);
                 }
                 queryString = buf.toString();
             } else {
                 queryString = NA;
             }
         }
         return queryString;
     }
 
     /**
      * The first line of the request.
      */
     @Override
     public String getRequestURL() {
         if(requestURL != null)
             return requestURL;
 
         if (httpRequest != null) {
             StringBuilder buf = new StringBuilder();
             buf.append(getMethod());
             buf.append(AccessConverter.SPACE_CHAR);
             buf.append(getRequestURI());
             buf.append(getQueryString());
             buf.append(AccessConverter.SPACE_CHAR);
             buf.append(getProtocol());
             requestURL = buf.toString();
         } else {
             requestURL = NA;
         }
         return requestURL;
     }
 
     @Override
     public String getRemoteHost() {
         if (remoteHost == null) {
             if (httpRequest != null) {
                 // the underlying implementation of HttpServletRequest will
                 // determine if remote lookup will be performed
                 remoteHost = httpRequest.getRemoteHost();
             } else {
                 remoteHost = NA;
             }
         }
         return remoteHost;
     }
 
     @Override
     public String getRemoteUser() {
         if (remoteUser == null) {
             if (httpRequest != null) {
                 remoteUser = httpRequest.getRemoteUser();
             } else {
                 remoteUser = NA;
             }
         }
         return remoteUser;
     }
 
     @Override
     public String getProtocol() {
         if (protocol == null) {
             if (httpRequest != null) {
                 protocol = httpRequest.getProtocol();
             } else {
                 protocol = NA;
             }
         }
         return protocol;
     }
 
     @Override
     public String getMethod() {
         if (method == null) {
             if (httpRequest != null) {
                 method = httpRequest.getMethod();
             } else {
                 method = NA;
             }
         }
         return method;
     }
 
     @Override
     public String getSessionID() {
         if (sessionID == null) {
             if (httpRequest != null) {
                 if (httpRequest instanceof WrappedHttpRequest) {
                     WrappedHttpRequest wrappedHttpRequest = (WrappedHttpRequest) httpRequest;
                     sessionID = wrappedHttpRequest.getSessionID();
                 } else {
                     final HttpSession session = httpRequest.getSession(false);
                     if (session != null) {
                         sessionID = session.getId();
                     }
                 }
             } else {
                 sessionID = NA;
             }
         }
         return sessionID;
     }
 
     @Override
     public String getServerName() {
         if (serverName == null) {
             if (httpRequest != null) {
                 serverName = httpRequest.getServerName();
             } else {
                 serverName = NA;
             }
         }
         return serverName;
     }
 
     @Override
     public String getRemoteAddr() {
         if (remoteAddr == null) {
             if (httpRequest != null) {
                 remoteAddr = httpRequest.getRemoteAddr();
             } else {
                 remoteAddr = NA;
             }
         }
         return remoteAddr;
     }
 
     @Override
     public String getRequestHeader(String key) {
         String result = null;
         key = key.toLowerCase();
         if (requestHeaderMap == null) {
             if (httpRequest != null) {
                 buildRequestHeaderMap();
                 result = requestHeaderMap.get(key);
             }
         } else {
             result = requestHeaderMap.get(key);
         }
 
         if (result != null) {
             return result;
         } else {
             return NA;
         }
     }
 
     @Override
     public Enumeration<String> getRequestHeaderNames() {
         // post-serialization
         if (httpRequest == null) {
             Vector<String> list = new Vector<String>(getRequestHeaderMap().keySet());
             return list.elements();
         }
         return httpRequest.getHeaderNames();
     }
 
     @Override
     public Map<String, String> getRequestHeaderMap() {
         if (requestHeaderMap == null) {
             buildRequestHeaderMap();
         }
         return requestHeaderMap;
     }
 
     public void buildRequestHeaderMap() {
         if (httpRequest instanceof WrappedHttpRequest) {
             WrappedHttpRequest whr = (WrappedHttpRequest) httpRequest;
             requestHeaderMap = whr.buildRequestHeaderMap();
         } else {
 
             // according to RFC 2616 header names are case-insensitive
             // latest versions of Tomcat return header names in lower-case
             requestHeaderMap = new TreeMap<String, String>(String.CASE_INSENSITIVE_ORDER);
             Enumeration<String> e = httpRequest.getHeaderNames();
             if (e == null) {
                 return;
             }
             while (e.hasMoreElements()) {
                 String key = e.nextElement();
                 requestHeaderMap.put(key, httpRequest.getHeader(key));
             }
         }
     }
 
     public void buildRequestParameterMap() {
         if (httpRequest instanceof WrappedHttpRequest) {
             WrappedHttpRequest whr = (WrappedHttpRequest) httpRequest;
             requestParameterMap = whr.buildRequestParameterMap();
         } else {
 
             requestParameterMap = new HashMap<String, String[]>();
             try {
                 Enumeration<String> e = httpRequest.getParameterNames();
                 if (e == null) {
                     return;
                 }
                 while (e.hasMoreElements()) {
                     String key = e.nextElement();
                     requestParameterMap.put(key, httpRequest.getParameterValues(key));
                 }
             } catch (Throwable t) {
                 // The use of HttpServletRequest.getParameterNames() can cause
                 // a READ of the Request body content.  This can fail with various
                 // Throwable failures depending on the state of the Request
                 // at the time this method is called.
                 // We don't want to fail the logging due to these types of requests
                 t.printStackTrace();
             }
         }
     }
 
     @Override
     public Map<String, String[]> getRequestParameterMap() {
         if (requestParameterMap == null) {
             buildRequestParameterMap();
         }
         return requestParameterMap;
     }
 
     @Override
     public String getAttribute(String key) {
         Object value = null;
         if (attributeMap != null) {
             // Event was prepared for deferred processing so we have a copy of attribute map
             // and must use that copy
             value = attributeMap.get(key);
         } else if (httpRequest != null) {
             // We have original request so take attribute from it
             value = httpRequest.getAttribute(key);
         }
 
         return value != null ? value.toString() : NA;
     }
 
     private void copyAttributeMap() {
 
         if (httpRequest == null) {
             return;
         }
 
         // attributeMap has been copied already. See also LOGBACK-1189
         if (attributeMap != null) {
             return;
         }
 
         attributeMap = new HashMap<String, Object>();
 
         Enumeration<String> names = httpRequest.getAttributeNames();
         while (names.hasMoreElements()) {
             String name = names.nextElement();
 
             Object value = httpRequest.getAttribute(name);
             if (shouldCopyAttribute(name, value)) {
                 attributeMap.put(name, value);
             }
         }
     }
 
     private boolean shouldCopyAttribute(String name, Object value) {
         if (AccessConstants.LB_INPUT_BUFFER.equals(name) || AccessConstants.LB_OUTPUT_BUFFER.equals(name)) {
             // Do not copy attributes used by logback internally - these are available via
             // other getters anyway
             return false;
         } else if (value == null) {
             // No reasons to copy nulls - Map.get() will return null for missing keys and
             // the list of attribute
             // names is not available through IAccessEvent
             return false;
         } else {
             // Only copy what is serializable
             return value instanceof Serializable;
         }
     }
 
     @Override
     public String[] getRequestParameter(String key) {
         String[] value = null;
 
         if (requestParameterMap != null) {
             value = requestParameterMap.get(key);
         } else if (httpRequest != null) {
             value = httpRequest.getParameterValues(key);
         }
 
         return (value != null) ? value : NA_STRING_ARRAY;
     }
 
     /**
      * Return the list of cookies in the httpRequest. The list is created if it did not exist previously.
      *
      * @return a list of cookies in the httpRequest, the returned list can be empty but not null
      * @since version 2.0.2
      */
     public List<Cookie> getCookies() {
 
         if (cookieList != null)
             return cookieList;
 
         if (httpRequest == null) {
             cookieList = List.of();
             return cookieList;
         }
 
         Cookie[] cookieArray = httpRequest.getCookies();
         this.cookieList = (cookieArray != null ? List.of(cookieArray) : List.of());
         return this.cookieList;
     }
 
     @Override
     public String getCookie(String key) {
         List<Cookie> cookies = getCookies();
         Cookie matchingCookie = cookies.stream().filter(c -> c.getName().equals(key)).findFirst().orElse(null);
         return matchingCookie != null ? matchingCookie.getValue() : NA;
     }
 
     @Override
     public long getContentLength() {
         if (contentLength == SENTINEL) {
             if (httpResponse != null) {
                 contentLength = serverAdapter.getContentLength();
                 return contentLength;
             }
         }
         return contentLength;
     }
 
     public int getStatusCode() {
         if (statusCode == SENTINEL) {
             if (httpResponse != null) {
                 statusCode = serverAdapter.getStatusCode();
             }
         }
         return statusCode;
     }
 
     public long getElapsedSeconds() {
         return elapsedTime < 0 ? elapsedTime : elapsedTime / 1000;
     }
 
     public long getElapsedTime() {
         return elapsedTime;
     }
 
     private long calculateElapsedTime() {
         if (serverAdapter.getRequestTimestamp() < 0) {
             return -1;
         }
         return getTimeStamp() - serverAdapter.getRequestTimestamp();
     }
 
     public String getRequestContent() {
         if (requestContent != null) {
             return requestContent;
         }
 
         if (Util.isFormUrlEncoded(httpRequest)) {
             StringBuilder buf = new StringBuilder();
 
             try {
                 Enumeration<String> pramEnumeration = httpRequest.getParameterNames();
 
                 // example: id=1234&user=cgu
                 // number=1233&x=1
                 int count = 0;
                 while (pramEnumeration.hasMoreElements()) {
 
                     String key = pramEnumeration.nextElement();
                     if (count++ != 0) {
                         buf.append("&");
                     }
                     buf.append(key);
                     buf.append("=");
                     String val = httpRequest.getParameter(key);
                     if (val != null) {
                         buf.append(val);
                     } else {
                         buf.append("");
                     }
                 }
             } catch (Throwable t) {
                 // The use of HttpServletRequest.getParameterNames() and
                 // HttpServletRequest.getParameter(String) can cause
                 // a READ of the Request body content.  This can fail with various
                 // Throwable failures depending on the state of the Request
                 // at the time this method is called.
                 // We don't want to fail the logging due to these types of requests
                 t.printStackTrace();
             }
             requestContent = buf.toString();
         } else {
             // retrieve the byte array placed by TeeFilter
             byte[] inputBuffer = (byte[]) httpRequest.getAttribute(AccessConstants.LB_INPUT_BUFFER);
 
             if (inputBuffer != null) {
                 requestContent = new String(inputBuffer);
             }
 
             if (requestContent == null || requestContent.length() == 0) {
                 requestContent = EMPTY;
             }
         }
 
         return requestContent;
     }
 
     public String getResponseContent() {
         if (responseContent != null) {
             return responseContent;
         }
 
         if (Util.isImageResponse(httpResponse)) {
             responseContent = "[IMAGE CONTENTS SUPPRESSED]";
         } else {
 
             // retrieve the byte array previously placed by TeeFilter
             byte[] outputBuffer = (byte[]) httpRequest.getAttribute(AccessConstants.LB_OUTPUT_BUFFER);
 
             if (outputBuffer != null) {
                 responseContent = new String(outputBuffer);
             }
             if (responseContent == null || responseContent.length() == 0) {
                 responseContent = EMPTY;
             }
         }
 
         return responseContent;
     }
 
     public int getLocalPort() {
         if (localPort == SENTINEL) {
             if (httpRequest != null) {
                 localPort = httpRequest.getLocalPort();
             }
 
         }
         return localPort;
     }
 
     public ServerAdapter getServerAdapter() {
         return serverAdapter;
     }
 
     public String getResponseHeader(String key) {
         buildResponseHeaderMap();
         return responseHeaderMap.get(key);
     }
 
     void buildResponseHeaderMap() {
         if (responseHeaderMap == null) {
             responseHeaderMap = serverAdapter.buildResponseHeaderMap();
         }
     }
 
     public Map<String, String> getResponseHeaderMap() {
         buildResponseHeaderMap();
         return responseHeaderMap;
     }
 
     public List<String> getResponseHeaderNameList() {
         buildResponseHeaderMap();
         return new ArrayList<String>(responseHeaderMap.keySet());
     }
 
     public void prepareForDeferredProcessing() {
         getRequestHeaderMap();
         getRequestParameterMap();
         getResponseHeaderMap();
         getLocalPort();
         getMethod();
         getProtocol();
         getRemoteAddr();
         getRemoteHost();
         getRemoteUser();
         getRequestURI();
         getRequestURL();
         getServerName();
         getTimeStamp();
         getElapsedTime();
 
         getCookies();
 
         getStatusCode();
         getContentLength();
         getRequestContent();
         getResponseContent();
 
         copyAttributeMap();
     }
 }