/**
 * Apache License
 * Version 2.0, January 2004
 * http://www.apache.org/licenses/
 * <p>
 * TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 * <p>
 * 1. Definitions.
 * <p>
 * "License" shall mean the terms and conditions for use, reproduction,
 * and distribution as defined by Sections 1 through 9 of this document.
 * <p>
 * "Licensor" shall mean the copyright owner or entity authorized by
 * the copyright owner that is granting the License.
 * <p>
 * "Legal Entity" shall mean the union of the acting entity and all
 * other entities that control, are controlled by, or are under common
 * control with that entity. For the purposes of this definition,
 * "control" means (i) the power, direct or indirect, to cause the
 * direction or management of such entity, whether by contract or
 * otherwise, or (ii) ownership of fifty percent (50%) or more of the
 * outstanding shares, or (iii) beneficial ownership of such entity.
 * <p>
 * "You" (or "Your") shall mean an individual or Legal Entity
 * exercising permissions granted by this License.
 * <p>
 * "Source" form shall mean the preferred form for making modifications,
 * including but not limited to software source code, documentation
 * source, and configuration files.
 * <p>
 * "Object" form shall mean any form resulting from mechanical
 * transformation or translation of a Source form, including but
 * not limited to compiled object code, generated documentation,
 * and conversions to other media types.
 * <p>
 * "Work" shall mean the work of authorship, whether in Source or
 * Object form, made available under the License, as indicated by a
 * copyright notice that is included in or attached to the work
 * (an example is provided in the Appendix below).
 * <p>
 * "Derivative Works" shall mean any work, whether in Source or Object
 * form, that is based on (or derived from) the Work and for which the
 * editorial revisions, annotations, elaborations, or other modifications
 * represent, as a whole, an original work of authorship. For the purposes
 * of this License, Derivative Works shall not include works that remain
 * separable from, or merely link (or bind by name) to the interfaces of,
 * the Work and Derivative Works thereof.
 * <p>
 * "Contribution" shall mean any work of authorship, including
 * the original version of the Work and any modifications or additions
 * to that Work or Derivative Works thereof, that is intentionally
 * submitted to Licensor for inclusion in the Work by the copyright owner
 * or by an individual or Legal Entity authorized to submit on behalf of
 * the copyright owner. For the purposes of this definition, "submitted"
 * means any form of electronic, verbal, or written communication sent
 * to the Licensor or its representatives, including but not limited to
 * communication on electronic mailing lists, source code control systems,
 * and issue tracking systems that are managed by, or on behalf of, the
 * Licensor for the purpose of discussing and improving the Work, but
 * excluding communication that is conspicuously marked or otherwise
 * designated in writing by the copyright owner as "Not a Contribution."
 * <p>
 * "Contributor" shall mean Licensor and any individual or Legal Entity
 * on behalf of whom a Contribution has been received by Licensor and
 * subsequently incorporated within the Work.
 * <p>
 * 2. Grant of Copyright License. Subject to the terms and conditions of
 * this License, each Contributor hereby grants to You a perpetual,
 * worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 * copyright license to reproduce, prepare Derivative Works of,
 * publicly display, publicly perform, sublicense, and distribute the
 * Work and such Derivative Works in Source or Object form.
 * <p>
 * 3. Grant of Patent License. Subject to the terms and conditions of
 * this License, each Contributor hereby grants to You a perpetual,
 * worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 * (except as stated in this section) patent license to make, have made,
 * use, offer to sell, sell, import, and otherwise transfer the Work,
 * where such license applies only to those patent claims licensable
 * by such Contributor that are necessarily infringed by their
 * Contribution(s) alone or by combination of their Contribution(s)
 * with the Work to which such Contribution(s) was submitted. If You
 * institute patent litigation against any entity (including a
 * cross-claim or counterclaim in a lawsuit) alleging that the Work
 * or a Contribution incorporated within the Work constitutes direct
 * or contributory patent infringement, then any patent licenses
 * granted to You under this License for that Work shall terminate
 * as of the date such litigation is filed.
 * <p>
 * 4. Redistribution. You may reproduce and distribute copies of the
 * Work or Derivative Works thereof in any medium, with or without
 * modifications, and in Source or Object form, provided that You
 * meet the following conditions:
 * <p>
 * (a) You must give any other recipients of the Work or
 * Derivative Works a copy of this License; and
 * <p>
 * (b) You must cause any modified files to carry prominent notices
 * stating that You changed the files; and
 * <p>
 * (c) You must retain, in the Source form of any Derivative Works
 * that You distribute, all copyright, patent, trademark, and
 * attribution notices from the Source form of the Work,
 * excluding those notices that do not pertain to any part of
 * the Derivative Works; and
 * <p>
 * (d) If the Work includes a "NOTICE" text file as part of its
 * distribution, then any Derivative Works that You distribute must
 * include a readable copy of the attribution notices contained
 * within such NOTICE file, excluding those notices that do not
 * pertain to any part of the Derivative Works, in at least one
 * of the following places: within a NOTICE text file distributed
 * as part of the Derivative Works; within the Source form or
 * documentation, if provided along with the Derivative Works; or,
 * within a display generated by the Derivative Works, if and
 * wherever such third-party notices normally appear. The contents
 * of the NOTICE file are for informational purposes only and
 * do not modify the License. You may add Your own attribution
 * notices within Derivative Works that You distribute, alongside
 * or as an addendum to the NOTICE text from the Work, provided
 * that such additional attribution notices cannot be construed
 * as modifying the License.
 * <p>
 * You may add Your own copyright statement to Your modifications and
 * may provide additional or different license terms and conditions
 * for use, reproduction, or distribution of Your modifications, or
 * for any such Derivative Works as a whole, provided Your use,
 * reproduction, and distribution of the Work otherwise complies with
 * the conditions stated in this License.
 * <p>
 * 5. Submission of Contributions. Unless You explicitly state otherwise,
 * any Contribution intentionally submitted for inclusion in the Work
 * by You to the Licensor shall be under the terms and conditions of
 * this License, without any additional terms or conditions.
 * Notwithstanding the above, nothing herein shall supersede or modify
 * the terms of any separate license agreement you may have executed
 * with Licensor regarding such Contributions.
 * <p>
 * 6. Trademarks. This License does not grant permission to use the trade
 * names, trademarks, service marks, or product names of the Licensor,
 * except as required for reasonable and customary use in describing the
 * origin of the Work and reproducing the content of the NOTICE file.
 * <p>
 * 7. Disclaimer of Warranty. Unless required by applicable law or
 * agreed to in writing, Licensor provides the Work (and each
 * Contributor provides its Contributions) on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied, including, without limitation, any warranties or conditions
 * of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
 * PARTICULAR PURPOSE. You are solely responsible for determining the
 * appropriateness of using or redistributing the Work and assume any
 * risks associated with Your exercise of permissions under this License.
 * <p>
 * 8. Limitation of Liability. In no event and under no legal theory,
 * whether in tort (including negligence), contract, or otherwise,
 * unless required by applicable law (such as deliberate and grossly
 * negligent acts) or agreed to in writing, shall any Contributor be
 * liable to You for damages, including any direct, indirect, special,
 * incidental, or consequential damages of any character arising as a
 * result of this License or out of the use or inability to use the
 * Work (including but not limited to damages for loss of goodwill,
 * work stoppage, computer failure or malfunction, or any and all
 * other commercial damages or losses), even if such Contributor
 * has been advised of the possibility of such damages.
 * <p>
 * 9. Accepting Warranty or Additional Liability. While redistributing
 * the Work or Derivative Works thereof, You may choose to offer,
 * and charge a fee for, acceptance of support, warranty, indemnity,
 * or other liability obligations and/or rights consistent with this
 * License. However, in accepting such obligations, You may act only
 * on Your own behalf and on Your sole responsibility, not on behalf
 * of any other Contributor, and only if You agree to indemnify,
 * defend, and hold each Contributor harmless for any liability
 * incurred by, or claims asserted against, such Contributor by reason
 * of your accepting any such warranty or additional liability.
 * <p>
 * END OF TERMS AND CONDITIONS
 * <p>
 * APPENDIX: How to apply the Apache License to your work.
 * <p>
 * To apply the Apache License to your work, attach the following
 * boilerplate notice, with the fields enclosed by brackets "{}"
 * replaced with your own identifying information. (Don't include
 * the brackets!)  The text should be enclosed in the appropriate
 * comment syntax for the file format. We also recommend that a
 * file or class name and description of purpose be included on the
 * same "printed page" as the copyright notice for easier
 * identification within third-party archives.
 * <p>
 * Copyright 2014 Edgar Espina
 * <p>
 * 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
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * 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.jooby.internal.undertow;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.URLDecoder;
import java.util.*;
import java.util.concurrent.Executor;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

import io.undertow.server.handlers.form.*;
import org.jooby.Cookie;
import org.jooby.MediaType;
import org.jooby.Router;
import org.jooby.Sse;
import org.jooby.spi.NativePushPromise;
import org.jooby.spi.NativeRequest;
import org.jooby.spi.NativeUpload;
import org.jooby.spi.NativeWebSocket;

import com.google.common.base.Supplier;
import com.google.common.base.Suppliers;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import com.typesafe.config.Config;

import io.undertow.server.BlockingHttpExchange;
import io.undertow.server.HttpServerExchange;
import io.undertow.server.handlers.form.FormData.FormValue;
import io.undertow.util.AttachmentKey;
import io.undertow.util.HeaderValues;
import io.undertow.util.HttpString;

public class UndertowRequest implements NativeRequest {

  public static final AttachmentKey<NativeWebSocket> SOCKET = AttachmentKey
      .create(NativeWebSocket.class);

  private static final FormData NO_FORM = new FormData(0);

  private final HttpServerExchange exchange;

  private final Config conf;

  private FormData form;

  private final String path;

  private final Supplier<BlockingHttpExchange> blocking;

  public UndertowRequest(final HttpServerExchange exchange, final Config conf) throws IOException {
    this.exchange = exchange;
    this.blocking = Suppliers.memoize(() -> this.exchange.startBlocking());
    this.conf = conf;
    this.path = Router.decode(exchange.getRequestPath());
  }

  @Override
  public Optional<String> queryString() {
    String q = exchange.getQueryString();
    return q.length() == 0 ? Optional.empty() : Optional.of(q);
  }

  @Override
  public String method() {
    return exchange.getRequestMethod().toString();
  }

  @Override
  public String path() {
    return path;
  }

  @Override
  public String rawPath() {
    return exchange.getRequestURI();
  }

  @Override
  public List<String> paramNames() {
    ImmutableList.Builder<String> builder = ImmutableList.builder();
    builder.addAll(exchange.getQueryParameters().keySet());
    FormData formdata = parseForm();
    formdata.forEach(v -> {
      // excludes upload from param names.
      if (!formdata.getFirst(v).isFile()) {
        builder.add(v);
      }
    });
    return builder.build();
  }

  @Override
  public List<String> params(final String name) {
    Builder<String> builder = ImmutableList.builder();
    // query params
    Deque<String> query = exchange.getQueryParameters().get(name);
    if (query != null) {
      query.forEach(builder::add);
    }
    // form params
    Optional.ofNullable(parseForm().get(name)).ifPresent(values -> values.forEach(value -> {
      if (!value.isFile()) {
        builder.add(value.getValue());
      }
    }));
    return builder.build();
  }

  @Override
  public Optional<String> header(final String name) {
    return Optional.ofNullable(exchange.getRequestHeaders().getFirst(name));
  }

  @Override
  public List<String> headers(final String name) {
    HeaderValues values = exchange.getRequestHeaders().get(name);
    return values == null ? Collections.emptyList() : values;
  }

  @Override
  public List<String> headerNames() {
    return exchange.getRequestHeaders().getHeaderNames()
        .stream()
        .map(HttpString::toString)
        .collect(Collectors.toList());
  }

  @Override
  public List<Cookie> cookies() {
    return exchange.getRequestCookies().values().stream()
        .map(UndertowRequest::cookie)
        .collect(Collectors.toList());
  }

  @Override
  public List<NativeUpload> files(final String name) {
    Builder<NativeUpload> builder = ImmutableList.builder();
    Deque<FormValue> values = parseForm().get(name);
    if (values != null) {
      values.forEach(value -> {
        if (value.isFile()) {
          builder.add(new UndertowUpload(value));
        }
      });
    }
    return builder.build();
  }

  @Override
  public List<NativeUpload> files() throws IOException {
    FormData formData = parseForm();
    Iterator<String> keyIterator = formData.iterator();
    Iterable<String> iterableKeys = () -> keyIterator;
    List<NativeUpload> retVal = StreamSupport.stream(iterableKeys.spliterator(), true)
            .map(formData::get)
            .filter(formValues -> formValues.peekFirst().isFileItem())
            .flatMap(Collection::stream)
            .map(UndertowUpload::new)
            .collect(Collectors.toList());

    return Collections.unmodifiableList(retVal);
  }

  @Override
  public InputStream in() {
    blocking.get();
    return exchange.getInputStream();
  }

  @Override
  public String ip() {
    return Optional.ofNullable(exchange.getSourceAddress())
        .map(src -> Optional.ofNullable(src.getAddress())
            .map(InetAddress::getHostAddress)
            .orElse(""))
        .orElse("");
  }

  @Override
  public String protocol() {
    return exchange.getProtocol().toString();
  }

  @Override
  public boolean secure() {
    return exchange.getRequestScheme().equalsIgnoreCase("https");
  }

  @Override
  @SuppressWarnings("unchecked")
  public <T> T upgrade(final Class<T> type) throws Exception {
    if (type == NativeWebSocket.class) {
      UndertowWebSocket ws = new UndertowWebSocket(conf);
      exchange.putAttachment(SOCKET, ws);
      return (T) ws;
    }
    if (type == Sse.class) {
      return (T) new UndertowSse(exchange);
    }
    if (type == NativePushPromise.class) {
      return (T) new UndertowPush(exchange);
    }
    throw new UnsupportedOperationException("Not Supported: " + type);
  }

  @Override
  public void startAsync(final Executor executor, final Runnable runnable) {
    exchange.dispatch(executor, runnable);
  }

  private FormData parseForm() {
    if (form == null) {
      form = NO_FORM;
      try {
        String tmpdir = conf.getString("application.tmpdir");
        String charset = conf.getString("application.charset");

        FormEncodedDataDefinition encodedParser = new FormEncodedDataDefinition().setDefaultEncoding(charset);
        MultiPartParserDefinition multiPartParser = new MultiPartParserDefinition()
                .setTempFileLocation(new File(tmpdir).toPath())
                .setDefaultEncoding(charset);
        blocking.get();
        FormDataParser parser = FormParserFactory
                .builder(false)
                .addParser(encodedParser)
                .addParser(multiPartParser)
                .build()
                .createParser(exchange);

        form = parser != null ? parser.parseBlocking() : NO_FORM;
      } catch (IOException iox) {
        throw new IllegalArgumentException("Bad Request...", iox);
      }
    }
    return form;
  }

  private static Cookie cookie(final io.undertow.server.handlers.Cookie c) {
    Cookie.Definition cookie = new Cookie.Definition(c.getName(), c.getValue());
    Optional.ofNullable(c.getComment()).ifPresent(cookie::comment);
    Optional.ofNullable(c.getDomain()).ifPresent(cookie::domain);
    Optional.ofNullable(c.getPath()).ifPresent(cookie::path);

    return cookie.toCookie();
  }

}
