/*
 * 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.juneau.rest.server.httppart;

import static org.apache.juneau.commons.httppart.HttpPartType.*;
import static org.apache.juneau.commons.utils.CollectionUtils.*;
import static org.apache.juneau.commons.utils.Shorts.*;
import static org.apache.juneau.commons.utils.StringUtils.*;

import java.util.*;
import java.util.stream.*;

import org.apache.juneau.commons.collections.*;
import org.apache.juneau.commons.lang.*;
import org.apache.juneau.commons.svl.*;
import org.apache.juneau.commons.utils.*;
import org.apache.juneau.http.*;
import org.apache.juneau.http.HttpPart;
import org.apache.juneau.http.header.*;
import org.apache.juneau.http.part.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.marshall.httppart.*;
import org.apache.juneau.rest.server.*;
import org.apache.juneau.rest.server.util.*;

import jakarta.servlet.http.Part;

/**
 * Represents the parsed form-data parameters in an HTTP request.
 *
 * <p>
 *    The {@link RequestFormParamList} object is the API for accessing the HTTP request content as form data.
 *    It can be accessed by passing it as a parameter on your REST Java method:
 * </p>
 * <p class='bjava'>
 *    <ja>@RestPost</ja>(...)
 *    <jk>public</jk> Object myMethod(RequestFormParamList <jv>formData</jv>) {...}
 * </p>
 *
 * <h5 class='figure'>Example:</h5>
 * <p class='bjava'>
 *    <ja>@RestPost</ja>(...)
 *    <jk>public</jk> Object myMethod(RequestFormParamList <jv>formData</jv>) {
 *
 *       <jc>// Get query parameters converted to various types.</jc>
 *       <jk>int</jk> <jv>p1</jv> = <jv>formData</jv>.get(<js>"p1"</js>).asInteger().orElse(0);
 *       String <jv>p2</jv> = <jv>formData</jv>.get(<js>"p2"</js>).orElse(<jk>null</jk>);
 *       UUID <jv>p3</jv> = <jv>formData</jv>.get(<js>"p3"</js>).as(UUID.<jk>class</jk>).orElse(<jk>null</jk>);
 *     }
 * </p>
 *
 * <p>
 *    Note that this object does NOT take GET parameters into account and only returns values found in the content of the request.
 * </p>
 *
 * <p>
 *    Some important methods on this class are:
 * </p>
 * <ul class='javatree'>
 *    <li class='jc'>{@link RequestFormParamList}
 *    <ul class='spaced-list'>
 *       <li>Methods for retrieving form data parameters:
 *       <ul class='javatreec'>
 *          <li class='jm'>{@link RequestFormParamList#contains(String) contains(String)}
 *          <li class='jm'>{@link RequestFormParamList#containsAny(String...) containsAny(String...)}
 *          <li class='jm'>{@link RequestFormParamList#get(Class) get(Class)}
 *          <li class='jm'>{@link RequestFormParamList#get(String) get(String)}
 *          <li class='jm'>{@link RequestFormParamList#getAll(String) getAll(String)}
 *          <li class='jm'>{@link RequestFormParamList#getFirst(String) getFirst(String)}
 *          <li class='jm'>{@link RequestFormParamList#getLast(String) getLast(String)}
 *       </ul>
 *       <li>Methods overridding form data parameters:
 *       <ul class='javatreec'>
 *          <li class='jm'>{@link RequestFormParamList#add(HttpPart...) add(HttpPart...)}
 *          <li class='jm'>{@link RequestFormParamList#add(Part) add(Part)}
 *          <li class='jm'>{@link RequestFormParamList#add(String,Object) add(String,Object)}
 *          <li class='jm'>{@link RequestFormParamList#addDefault(List) addDefault(List)}
 *          <li class='jm'>{@link RequestFormParamList#addDefault(HttpPart...) addDefault(HttpPart...)}
 *          <li class='jm'>{@link RequestFormParamList#addDefault(String,String) addDefault(String,String)}
 *          <li class='jm'>{@link RequestFormParamList#remove(String) remove(String)}
 *          <li class='jm'>{@link RequestFormParamList#set(HttpPart...) set(HttpPart...)}
 *          <li class='jm'>{@link RequestFormParamList#set(String,Object) set(String,Object)}
 *       </ul>
 *       <li>Other methods:
 *       <ul class='javatreec'>
 *          <li class='jm'>{@link RequestFormParamList#asQueryString() asQueryString()}
 *          <li class='jm'>{@link RequestFormParamList#copy() copy()}
 *          <li class='jm'>{@link RequestFormParamList#isEmpty() isEmpty()}
 *       </ul>
 *    </ul>
 * </ul>
 *
 * <h5 class='section'>See Also:</h5><ul>
 *    <li class='jc'>{@link RequestFormParam}
 *    <li class='ja'>{@link FormData}
 *    <li class='ja'>{@link HasFormData}
 *    <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/RestServerHttpParts">HTTP parts in REST servers</a>
 * </ul>
 */
@SuppressWarnings({
   "java:S1192", // Duplicated literals (argument/property names) read more clearly inline than as constants
   "resource" // Resource management handled externally
})
public class RequestFormParamList extends ArrayList<RequestFormParam> {

   private static final long serialVersionUID = 1L;

   private final transient RestRequest req;
   private boolean caseSensitive;
   private transient HttpPartParserSession parser;
   private final transient VarResolverSession vs;

   /**
    * Constructor.
    *
    * <p>
    * For a {@code multipart/form-data} request, the effective {@code @Rest(maxInput)} ceiling is enforced
    * against both the declared {@code Content-Length} (checked before the servlet container parses the body)
    * and the cumulative size of the parsed parts (checked afterward, as a backstop for a declared length that
    * was absent, chunked, or simply didn't match) &mdash; a request whose multipart body is too large is
    * rejected with a {@link PayloadTooLarge} (413) response rather than being handed off to the servlet
    * container's own (often much larger, or unset) multipart limits.
    *
    * @param req The request creating this bean.  Must not be <jk>null</jk>.
    * @param caseSensitive Whether case-sensitive name matching is enabled.
    * @throws Exception Any exception can be thrown.
    */
   
   @SuppressWarnings({
      "java:S112", // Generic exception thrown; acceptable for framework/lifecycle methods
      "java:S3776", // Cognitive complexity acceptable for this specific logic
      "null" // throws Exception intentional - callback/lifecycle method
   })
   public RequestFormParamList(RestRequest req, boolean caseSensitive) throws Exception {
      this.req = req;
      this.caseSensitive = caseSensitive;
      this.vs = req.getVarResolverSession();

      Map<String,String[]> m = null;
      Collection<Part> c = null;

      RequestContent content = req.getContent();
      if (content.isLoaded() || ! req.getHeader(ContentType.class).orElse(ContentType.NULL).equalsIgnoreCase("multipart/form-data")) {
         var listMap = RestUtils.parseQuery(content.getReader());
         m = map();
         for (var e : listMap.entrySet()) {
            if (e.getValue() == null)
               m.put(e.getKey(), null);
            else
               m.put(e.getKey(), array(e.getValue(), String.class));
         }
      } else {
         var maxInput = req.getOpContext().getMaxInput();
         checkMultipartLength(maxInput, req.getHttpServletRequest().getContentLengthLong());
         c = req.getHttpServletRequest().getParts();
         checkMultipartLength(maxInput, c);
         if (ie(c))
            m = req.getHttpServletRequest().getParameterMap();
      }

      if (nn(m)) {
         for (var e : m.entrySet()) {
            var name = e.getKey();

            var values = e.getValue();
            if (values == null)
               values = new String[0];

            // Fix for behavior difference between Tomcat and WAS.
            // getParameter("foo") on "&foo" in Tomcat returns "".
            // getParameter("foo") on "&foo" in WAS returns null.
            if (values.length == 1 && values[0] == null)
               values[0] = "";

            if (values.length == 0)
               values = a((String)null);

            for (var value : values)
               add(new RequestFormParam(req, name, value));
         }
      } else if (nn(c)) {
         c.forEach(this::add);
      }
   }

   /**
    * Rejects a {@code multipart/form-data} request outright when its declared {@code Content-Length} already
    * exceeds {@code maxInput}, before the servlet container is asked to parse (and potentially buffer to disk)
    * a body the resource has no intention of accepting.
    *
    * <p>
    * Package-private for direct unit-test coverage.
    *
    * @param maxInput The effective {@code @Rest(maxInput)} ceiling in bytes. Values {@code <= 0} disable the check.
    * @param declaredContentLength The request's declared {@code Content-Length}, as returned by
    *    {@code HttpServletRequest.getContentLengthLong()}. Values {@code < 0} (absent/unparsable) are ignored;
    *    the post-parse {@link #checkMultipartLength(long, Collection)} check still applies.
    * @throws PayloadTooLarge If {@code declaredContentLength} exceeds {@code maxInput}.
    */
   static void checkMultipartLength(long maxInput, long declaredContentLength) {
      if (maxInput > 0 && declaredContentLength > maxInput)
         throw new PayloadTooLarge("Multipart request content exceeds the maximum allowed input size of %d bytes.", maxInput);
   }

   /**
    * Rejects a {@code multipart/form-data} request once the cumulative size of its parsed parts exceeds
    * {@code maxInput}, as a backstop for the case where the declared {@code Content-Length} was absent,
    * chunked, or simply didn't match what the container actually buffered.
    *
    * <p>
    * Package-private for direct unit-test coverage.
    *
    * @param maxInput The effective {@code @Rest(maxInput)} ceiling in bytes. Values {@code <= 0} disable the check.
    * @param parts The parts already parsed by the servlet container. Can be <jk>null</jk> or empty (no-op).
    * @throws PayloadTooLarge If the cumulative {@link Part#getSize()} across {@code parts} exceeds {@code maxInput}.
    */
   static void checkMultipartLength(long maxInput, Collection<Part> parts) {
      if (maxInput <= 0 || ie(parts))
         return;
      var total = 0L;
      for (var p : parts) {
         total += p.getSize();
         if (total > maxInput)
            throw new PayloadTooLarge("Multipart request content exceeds the maximum allowed input size of %d bytes.", maxInput);
      }
   }

   /**
    * Copy constructor.
    */
   private RequestFormParamList(RequestFormParamList copyFrom) {
      req = copyFrom.req;
      caseSensitive = copyFrom.caseSensitive;
      parser = copyFrom.parser;
      addAll(copyFrom);
      vs = copyFrom.vs;
   }

   /**
    * Subset constructor.
    */
   private RequestFormParamList(RequestFormParamList copyFrom, String...names) {
      this.req = copyFrom.req;
      caseSensitive = copyFrom.caseSensitive;
      parser = copyFrom.parser;
      vs = copyFrom.vs;
      for (var n : names)
         copyFrom.stream().filter(x -> eq(x.getName(), n)).forEach(this::add);
   }

   /**
    * Adds request parameter values.
    *
    * <p>
    * Parameters are added to the end.
    * <br>Existing parameters with the same name are not changed.
    *
    * @param parameters The parameter objects.  Must not be <jk>null</jk>.
    * @return This object.
    */
   public RequestFormParamList add(HttpPart...parameters) {
      reqnn("parameters", parameters);
      for (var p : parameters)
         if (nn(p))
            add(p.getName(), p.getValue());
      return this;
   }

   /**
    * Adds a parameter value.
    *
    * <p>
    * Parameter is added to the end.
    * <br>Existing parameter with the same name are not changed.
    *
    * @param part The parameter part.  Must not be <jk>null</jk>.
    * @return This object.
    */
   public RequestFormParamList add(Part part) {
      reqnn("part", part);
      add(new RequestFormParam(req, part).parser(parser));
      return this;
   }

   /**
    * Adds a parameter value.
    *
    * <p>
    * Parameter is added to the end.
    * <br>Existing parameter with the same name are not changed.
    *
    * @param name The parameter name.  Must not be <jk>null</jk>.
    * @param value The parameter value.
    * @return This object.
    */
   public RequestFormParamList add(String name, Object value) {
      reqnn("name", name);
      add(new RequestFormParam(req, name, s(value)).parser(parser));
      return this;
   }

   /**
    * Adds default entries to these parameters.
    *
    * <p>
    * Similar to {@link #set(String, Object)} but doesn't override existing values.
    *
    * @param pairs
    *    The default entries.
    *    <br>Can be <jk>null</jk> (no-op).
    * @return This object.
    */
   public RequestFormParamList addDefault(List<? extends HttpPart> pairs) {
      if (pairs == null)
         return this;
      for (var p : pairs) {
         var name = p.getName();
         var l = stream(name);
         var hasAllBlanks = l.allMatch(x -> Shorts.ie(x.getValue()));  // NOAI
         if (hasAllBlanks) {
            removeAll(getAll(name));
            add(new RequestFormParam(req, name, vs.resolve(p.getValue())));
         }
      }
      return this;
   }

   /**
    * Adds default entries to these parameters.
    *
    * <p>
    * Similar to {@link #set(String, Object)} but doesn't override existing values.
    *
    * @param pairs
    *    The default entries.
    *    <br>Can be <jk>null</jk> (no-op).
    * @return This object.
    */
   public RequestFormParamList addDefault(HttpPart...pairs) {
      return addDefault(l(pairs));
   }

   /**
    * Adds a default entry to the form data parameters.
    *
    * @param name The name.
    * @param value The value.
    * @return This object.
    */
   public RequestFormParamList addDefault(String name, String value) {
      return addDefault(HttpStringPart.of(name, value));
   }

   /**
    * Converts this object to a query string.
    *
    * <p>
    * Returned query string does not start with <js>'?'</js>.
    *
    * @return A new query string, or an empty string if this object is empty.
    */
   public String asQueryString() {
      var sb = new StringBuilder();
      for (var e : this) {
         if (!sb.isEmpty())
            sb.append("&");
         sb.append(urlEncode(e.getName())).append('=').append(urlEncode(e.getValue()));
      }
      return sb.toString();
   }

   /**
    * Sets case sensitivity for names in this list.
    *
    * @param value The new value for this setting.
    * @return This object (for method chaining).
    */
   public RequestFormParamList caseSensitive(boolean value) {
      caseSensitive = value;
      return this;
   }

   /**
    * Returns <jk>true</jk> if the parameters with the specified names are present.
    *
    * @param name The parameter name.  Must not be <jk>null</jk>.
    * @return <jk>true</jk> if the parameters with the specified names are present.
    */
   public boolean contains(String name) {
      return stream(name).findAny().isPresent();
   }

   /**
    * Returns <jk>true</jk> if the parameter with any of the specified names are present.
    *
    * @param names The parameter names.  Must not be <jk>null</jk>.
    * @return <jk>true</jk> if the parameter with any of the specified names are present.
    */
   public boolean containsAny(String...names) {
      reqnn("names", names);
      for (var n : names)
         if (stream(n).findAny().isPresent())
            return true;
      return false;
   }

   /**
    * Makes a copy of these parameters.
    *
    * @return A new parameters object.
    */
   public RequestFormParamList copy() {
      return new RequestFormParamList(this);
   }

   /**
    * Returns the form data parameter as the specified bean type.
    *
    * <p>
    * Type must have a name specified via the {@link FormData} annotation
    * and a public constructor that takes in either <c>value</c> or <c>name,value</c> as strings.
    *
    * @param <T> The bean type to create.
    * @param type The bean type to create.
    * @return The bean, or {@link Optional#empty()} if the parameter is not present.
    */
   public <T> Optional<T> get(Class<T> type) {
      var cm = req.getMarshallingSession().getClassMeta(type);
      var name = HttpParts.getName(FORMDATA, cm).orElseThrow(() -> rex("@FormData(name) not found on class %s", cn(type)));
      return get(name).as(type);
   }

   /**
    * Returns the condensed parameter with the specified name.
    *
    * <p>
    * If multiple parameters are present, they will be combined into a single comma-delimited list.
    *
    * @param name The parameter name.
    * @return The parameter, never <jk>null</jk>.
    */
   public RequestFormParam get(String name) {
      List<RequestFormParam> l = getAll(name);
      if (l.isEmpty())
         return new RequestFormParam(req, name, null).parser(parser);
      if (l.size() == 1)
         return l.get(0);
      var sb = new StringBuilder(128);
      for (var i = 0; i < l.size(); i++) {
         if (i > 0)
            sb.append(", ");
         sb.append(l.get(i).getValue());
      }
      return new RequestFormParam(req, name, sb.toString()).parser(parser);
   }

   /**
    * Returns all the parameters with the specified name.
    *
    * @param name The parameter name.
    * @return The list of all parameters with the specified name, or an empty list if none are found.
    */
   public List<RequestFormParam> getAll(String name) {
      return stream(name).toList();
   }

   /**
    * Returns the first parameter with the specified name.
    *
    * <p>
    * Note that this method never returns <jk>null</jk> and that {@link RequestFormParam#isPresent()} can be used
    * to test for the existence of the parameter.
    *
    * @param name The parameter name.
    * @return The parameter.  Never <jk>null</jk>.
    */
   public RequestFormParam getFirst(String name) {
      reqnn("name", name);
      return stream(name).findFirst().orElseGet(() -> new RequestFormParam(req, name, null).parser(parser));
   }

   /**
    * Returns the last parameter with the specified name.
    *
    * <p>
    * Note that this method never returns <jk>null</jk> and that {@link RequestFormParam#isPresent()} can be used
    * to test for the existence of the parameter.
    *
    * @param name The parameter name.
    * @return The parameter.  Never <jk>null</jk>.
    */
   public RequestFormParam getLast(String name) {
      reqnn("name", name);
      var v = Holder.<RequestFormParam>empty();
      stream(name).forEach(v::set);
      return v.orElseGet(() -> new RequestFormParam(req, name, null).parser(parser));
   }

   /**
    * Returns all the unique header names in this list.
    * @return The list of all unique header names in this list.
    */
   public List<String> getNames() { return stream().map(RequestFormParam::getName).map(x -> caseSensitive ? x : lcr(x)).distinct().toList(); }

   /**
    * Returns all headers in sorted order.
    *
    * @return The stream of all headers in sorted order.
    */
   public Stream<RequestFormParam> getSorted() {
      Comparator<RequestFormParam> x;
      if (caseSensitive)
         x = Comparator.comparing(RequestFormParam::getName);
      else
         x = (x1, x2) -> String.CASE_INSENSITIVE_ORDER.compare(x1.getName(), x2.getName());
      return stream().sorted(x);
   }

   /**
    * Sets the parser to use for part values.
    *
    * @param value The new value for this setting.
    * @return This object.
    */
   public RequestFormParamList parser(HttpPartParserSession value) {
      parser = value;
      forEach(x -> x.parser(parser));
      return this;
   }

   /**
    * Remove parameters.
    *
    * @param name The parameter names.  Must not be <jk>null</jk>.
    * @return This object.
    */
   public RequestFormParamList remove(String name) {
      reqnn("name", name);
      removeIf(x -> eq(x.getName(), name));
      return this;
   }

   /**
    * Sets request header values.
    *
    * <p>
    * Parameters are added to the end of the headers.
    * <br>Any previous parameters with the same name are removed.
    *
    * @param parameters The parameters to set.  Must not be <jk>null</jk> or contain <jk>null</jk>.
    * @return This object.
    */
   public RequestFormParamList set(HttpPart...parameters) {
      reqnn("headers", parameters);
      for (var p : parameters)
         remove(p.getName());
      for (var p : parameters)
         add(p);
      return this;
   }

   /**
    * Sets a parameter value.
    *
    * <p>
    * Parameter is added to the end.
    * <br>Any previous parameters with the same name are removed.
    *
    * @param name The parameter name.  Must not be <jk>null</jk>.
    * @param value
    *    The parameter value.
    *    <br>Converted to a string using {@link Object#toString()}.
    *    <br>Can be <jk>null</jk> (the parameter is set with a <jk>null</jk> value).
    * @return This object.
    */
   public RequestFormParamList set(String name, Object value) {
      reqnn("name", name);
      set(new RequestFormParam(req, name, s(value)).parser(parser));
      return this;
   }

   /**
    * Returns all headers with the specified name.
    *
    * @param name The header name.
    * @return The stream of all headers with matching names.  Never <jk>null</jk>.
    */
   public Stream<RequestFormParam> stream(String name) {
      return stream().filter(x -> eq(x.getName(), name));
   }

   /**
    * Returns a copy of this object but only with the specified param names copied.
    *
    * @param names The list to include in the copy.
    * @return A new list object.
    */
   public RequestFormParamList subset(String...names) {
      return new RequestFormParamList(this, names);
   }

   protected FluentMap<String,Object> properties() {
      // @formatter:off
      var m = filteredBeanPropertyMap();
      for (var n : getNames())
         m.a(n, get(n).asString().orElse(null));
      return m;
      // @formatter:on
   }

   @Override
   public boolean equals(Object o) {
      return this == o || (o instanceof RequestFormParamList o2 && super.equals(o2));
   }

   @Override
   public int hashCode() {
      return super.hashCode();
   }

   @Override /* Overridden from Object */
   public String toString() {
      return r(properties());
   }

   private boolean eq(String s1, String s2) {
      return Shorts.eq(! caseSensitive, s1, s2);  // NOAI
   }
}