/**
 *                                  Apache License
 *                            Version 2.0, January 2004
 *                         http://www.apache.org/licenses/
 *
 *    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 *
 *    1. Definitions.
 *
 *       "License" shall mean the terms and conditions for use, reproduction,
 *       and distribution as defined by Sections 1 through 9 of this document.
 *
 *       "Licensor" shall mean the copyright owner or entity authorized by
 *       the copyright owner that is granting the License.
 *
 *       "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.
 *
 *       "You" (or "Your") shall mean an individual or Legal Entity
 *       exercising permissions granted by this License.
 *
 *       "Source" form shall mean the preferred form for making modifications,
 *       including but not limited to software source code, documentation
 *       source, and configuration files.
 *
 *       "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.
 *
 *       "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).
 *
 *       "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.
 *
 *       "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."
 *
 *       "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.
 *
 *    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.
 *
 *    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.
 *
 *    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:
 *
 *       (a) You must give any other recipients of the Work or
 *           Derivative Works a copy of this License; and
 *
 *       (b) You must cause any modified files to carry prominent notices
 *           stating that You changed the files; and
 *
 *       (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
 *
 *       (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.
 *
 *       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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    END OF TERMS AND CONDITIONS
 *
 *    APPENDIX: How to apply the Apache License to your work.
 *
 *       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.
 *
 *    Copyright 2014 Edgar Espina
 *
 *    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
 *
 *        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.jooby;

import static java.util.Objects.requireNonNull;

import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.function.Consumer;
import java.util.function.Function;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
request logger

 *

 * Log all the matched incoming requested using the
 * NCSA format (a.k.a common log
 * format).
 *

 *
usage

 *
 *
{@code
 * {
 *   use("*", new RequestLogger());
 *
 *   ...
 * }
 * }

 *
 *

 * Output looks like:
 *

 *
 *

 * 127.0.0.1 - - [04/Oct/2016:17:51:42 +0000] "GET / HTTP/1.1" 200 2
 *

 *
 *

 * You probably want to configure the RequestLogger logger to save output into a new file:
 *

 *
 *

 * <appender name="ACCESS" class="ch.qos.logback.core.rolling.RollingFileAppender">
 *   <file>access.log</file>
 *   <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
 *     <fileNamePattern>access.%d{yyyy-MM-dd}.log</fileNamePattern>
 *   </rollingPolicy>
 *
 *   <encoder>
 *     <pattern>%msg%n</pattern>
 *   </encoder>
 * </appender>
 *
 * <logger name="org.jooby.RequestLogger" additivity="false">
 *   <appender-ref ref="ACCESS" />
 * </logger>
 *

 *
 *

 * Due that authentication is provided via module or custom filter, there is no concept of
 * logged/authenticated user. Still you can log the current user by setting an user id provider at
 * construction time:
 *

 *
 *
{@code
 * {
 *
 *   use("*", (req, rsp) -> {
 *     // authenticate user and set local attribute
 *     String userId = ...;
 *     req.set("userId", userId);
 *   });
 *
 *   use("*", new RequestLogger(req -> {
 *     return req.get("userId");
 *   }));
 * }
 * }

 *
 *

 * Here an application filter set an userId request attribute and then we provide that
 * userId to {@link RequestLogger}.
 *

 *
 *
custom log function

 *

 * By default it uses the underlying logging system: logback.
 * That's why we previously show how to configure the org.jooby.RequestLogger in
 * logback.xml.
 *

 *
 *

 * If you want to log somewhere else and/or use a different technology then:
 *

 *
 *
{@code
 * {
 *   use("*", new ResponseLogger()
 *     .log(line -> {
 *       System.out.println(line);
 *     }));
 * }
 * }

 *
 *

 * This is just an example but of course you can log the NCSA line to database, jms
 * queue, etc...
 *

 *
 *
latency

 *
 *
{@code
 * {
 *   use("*", new RequestLogger()
 *       .latency());
 * }
 * }

 *
 *

 * It add a new entry at the last of the NCSA output that represents the number of
 * ms it took to process the incoming release.
 *
 *
extended

 *

 * Extend the NCSA by adding the Referer and User-Agent
 * headers to the output.
 *

 *
 *
dateFormatter

 *
 *
{@code
 * {
 *   use("*", new RequestLogger()
 *       .dateFormatter(ts -> ...));
 *
 *   // OR
 *   use("*", new RequestLogger()
 *       .dateFormatter(DateTimeFormatter...));
 * }
 * }

 *
 *

 * Override, the default formatter for the request arrival time defined by:
 * {@link Request#timestamp()}. You can provide a function or an instance of
 * {@link DateTimeFormatter}.
 *

 *
 *

 * The default formatter use the default server time zone, provided by
 * {@link ZoneId#systemDefault()}. It's possible to just override the time zone (not the entirely
 * formatter) too:
 *

 *
 *
{@code
 * {
 *   use("*", new RequestLogger()
 *      .dateFormatter(ZoneId.of("UTC"));
 * }
 * }

 *
 * @author edgar
 * @since 1.0.0
 */
public class RequestLogger implements Route.Handler {

  private static final String USER_AGENT = "User-Agent";

  private static final String REFERER = "Referer";

  private static final String CONTENT_LENGTH = "Content-Length";

  private static final DateTimeFormatter FORMATTER = DateTimeFormatter
      .ofPattern("dd/MMM/yyyy:HH:mm:ss Z")
      .withZone(ZoneId.systemDefault());

  private static final String DASH = "-";
  private static final char SP = ' ';
  private static final char BL = '[';
  private static final char BR = ']';
  private static final char Q = '\"';
  private static final char QUERY = '?';

  private static Function<Request, String> ANNON = req -> DASH;

  /** The logging system. */
  private final Logger log = LoggerFactory.getLogger(getClass());

  private final Function<Request, String> userId;

  private Consumer<String> logRecord = log::info;

  private Function<Long, String> df;

  private boolean latency;

  private boolean queryString;

  private boolean extended;

  /**
   * Creates a new {@link RequestLogger} and use the given function and userId provider. Please
   * note, if the user isn't present this function is allowed to returns - (dash
   * character).
   *
   * @param userId User ID provider.
   */
  public RequestLogger(final Function<Request, String> userId) {
    this.userId = requireNonNull(userId, "User ID provider required.");
    dateFormatter(FORMATTER);
  }

  /**
   * Creates a new {@link RequestLogger} without user identifier.
   */
  public RequestLogger() {
    this(ANNON);
  }

  @Override
  public void handle(final Request req, final Response rsp) throws Throwable {
    /** Push complete callback . */
    rsp.complete((ereq, ersp, x) -> {
      StringBuilder sb = new StringBuilder(256);
      long timestamp = req.timestamp();
      sb.append(req.ip());
      sb.append(SP).append(DASH).append(SP);
      sb.append(userId.apply(req));
      sb.append(SP);
      sb.append(BL).append(df.apply(timestamp)).append(BR);
      sb.append(SP);
      sb.append(Q).append(req.method());
      sb.append(SP);
      sb.append(req.path());
      if (queryString) {
        req.queryString().ifPresent(s -> sb.append(QUERY).append(s));
      }
      sb.append(SP);
      sb.append(req.protocol());
      sb.append(Q).append(SP);
      int status = ersp.status().orElse(Status.OK).value();
      sb.append(status);
      sb.append(SP);
      sb.append(ersp.header(CONTENT_LENGTH).value(DASH));
      if (extended) {
        sb.append(SP);
        sb.append(Q).append(req.header(REFERER).value(DASH)).append(Q).append(SP);
        sb.append(Q).append(req.header(USER_AGENT).value(DASH)).append(Q);
      }
      if (latency) {
        long now = System.currentTimeMillis();
        sb.append(SP);
        sb.append(now - timestamp);
      }
      logRecord.accept(sb.toString());
    });
  }

  /**
   * Log an NCSA line to somewhere.
   *
   *
{@code
   *  {
   *    use("*", new RequestLogger()
   *        .log(System.out::println)
   *    );
   *  }
   * }

   *
   * @param log Log callback.
   * @return This instance.
   */
  public RequestLogger log(final Consumer<String> log) {
    this.logRecord = requireNonNull(log, "Logger required.");
    return this;
  }

  /**
   * Override the default date formatter.
   *
   * @param formatter New formatter to use.
   * @return This instance.
   */
  public RequestLogger dateFormatter(final DateTimeFormatter formatter) {
    requireNonNull(formatter, "Formatter required.");
    return dateFormatter(ts -> formatter.format(Instant.ofEpochMilli(ts)));
  }

  /**
   * Override the default date formatter.
   *
   * @param formatter New formatter to use.
   * @return This instance.
   */
  public RequestLogger dateFormatter(final Function<Long, String> formatter) {
    requireNonNull(formatter, "Formatter required.");
    this.df = formatter;
    return this;
  }

  /**
   * Keep the default formatter but use the provided timezone.
   *
   * @param zoneId Zone id.
   * @return This instance.
   */
  public RequestLogger dateFormatter(final ZoneId zoneId) {
    return dateFormatter(FORMATTER.withZone(zoneId));
  }

  /**
   * Log latency (how long does it takes to process an incoming request) at the end of the NCSA
   * line.
   *
   * @return This instance.
   */
  public RequestLogger latency() {
    this.latency = true;
    return this;
  }

  /**
   * Log full path of the request including query string.
   *
   * @return This instance.
   */
  public RequestLogger queryString() {
    this.queryString = true;
    return this;
  }

  /**
   * Append Referer and User-Agent entries to the NCSA line.
   *
   * @return This instance.
   */
  public RequestLogger extended() {
    this.extended = true;
    return this;
  }

}


/**
 *                                  Apache License
 *                            Version 2.0, January 2004
 *                         http://www.apache.org/licenses/
 *
 *    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 *
 *    1. Definitions.
 *
 *       "License" shall mean the terms and conditions for use, reproduction,
 *       and distribution as defined by Sections 1 through 9 of this document.
 *
 *       "Licensor" shall mean the copyright owner or entity authorized by
 *       the copyright owner that is granting the License.
 *
 *       "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.
 *
 *       "You" (or "Your") shall mean an individual or Legal Entity
 *       exercising permissions granted by this License.
 *
 *       "Source" form shall mean the preferred form for making modifications,
 *       including but not limited to software source code, documentation
 *       source, and configuration files.
 *
 *       "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.
 *
 *       "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).
 *
 *       "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.
 *
 *       "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."
 *
 *       "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.
 *
 *    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.
 *
 *    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.
 *
 *    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:
 *
 *       (a) You must give any other recipients of the Work or
 *           Derivative Works a copy of this License; and
 *
 *       (b) You must cause any modified files to carry prominent notices
 *           stating that You changed the files; and
 *
 *       (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
 *
 *       (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.
 *
 *       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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    END OF TERMS AND CONDITIONS
 *
 *    APPENDIX: How to apply the Apache License to your work.
 *
 *       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.
 *
 *    Copyright 2014 Edgar Espina
 *
 *    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
 *
 *        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.jooby.hbv;

import static java.util.Objects.requireNonNull;
import static javax.validation.Validation.byProvider;

import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Predicate;

import javax.validation.ConstraintValidatorFactory;
import javax.validation.ConstraintViolationException;
import javax.validation.ValidationException;
import javax.validation.Validator;

import org.hibernate.validator.HibernateValidator;
import org.hibernate.validator.HibernateValidatorConfiguration;
import org.jooby.Env;
import org.jooby.Jooby;
import org.jooby.Parser;
import org.jooby.Request;

import com.google.inject.Binder;
import com.google.inject.TypeLiteral;
import com.google.inject.multibindings.Multibinder;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import com.typesafe.config.ConfigValueFactory;

/**
 * Bean validation via Hibernate Validator.
 *
 *
exposes

 *

 *
a {@link Validator},

 *
a {@link HibernateValidatorConfiguration} and

 *
a {@link Parser}

 *

 *
 *
usage

 *
 *

 * {
 *   use(new Hbv());
 *
 *   get("/", req {@literal ->} {
 *     Validator validator = req.require(Validator.class);
 *     Car car = req.params().to(Car.class);
 *     Set<ConstraintViolation> violations = validator.validate(car);
 *     if (violations.size() {@literal >} 0) {
 *       // handle errors
 *       ...
 *     }
 *   });
 * }
 *

 *
 *
automatic validations of HTTP params and body

 *
 * Previous example demonstrate how to manually validate a bean created via:
 * {@link Request#params()} or {@link Request#body()}. The boilerplate code can be avoided if you
 * explicitly tell the validation module which classes require validation.
 *
 * The previous example can be rewritten as:
 *
 *

 * {
 *    use(new Hbv(Car.class));
 *
 *    get("/", () {@literal ->} {
 *      Car car = req.params().to(Car.class);
 *      // a valid car is here
 *      ...
 *    });
 * }
 *

 *
 * Here a {@link Parser} will do the boilerplate part and throws
 * a {@link ConstraintViolationException}.
 *
 *
rendering a ConstraintViolationException

 *
 * The default err handler will render the {@link ConstraintViolationException} without problem, but
 * suppose we have a JavaScript client and want to display the errors in a friendly way.
 *
 *

 * {
 *   use(new Jackson()); // JSON renderer
 *
 *   use(new Hbv(Car.class)); // Validate Car objects
 *
 *   err((req, rsp, err) {@literal ->} {
 *     Throwable cause = err.getCause();
 *     if (cause instanceof ConstraintViolationException) {
 *       Set<ConstraintViolation<?>> constraints =
 *           ((ConstraintViolationException) cause) .getConstraintViolations();
 *
 *       Map<Path, String> errors = constraints.stream()
 *          .collect(Collectors.toMap(
 *              ConstraintViolation::getPropertyPath,
 *              ConstraintViolation::getMessage
 *           ));
 *       rsp.send(errors);
 *     }
 *   });
 *
 *   get("/", () {@literal ->} {
 *     Car car = req.params().to(Car.class);
 *     // a valid car is here
 *     ...
 *   });
 * }
 *

 *
 * The call to rsp.send(errors); will be rendered by ```Jackson``` (or any other that
 * applies) and will produces a more friendly response, here it will be a JavaScript object with the
 * errors.
 *
 *
constraint validator factory

 *
 * {@link ConstraintValidatorFactory} is the extension point for customizing how constraint
 * validators are instantiated and released.
 *
 * In Jooby, a {@link ConstraintValidatorFactory} is powered by Guice.
 *
 *
configuration

 *
 * Any property defined at hibernate.validator will be add it automatically:
 *
 * application.conf:
 *
 *

 * hibernate.validator.fail_fast = true
 *

 *
 * Or programmatically:
 *
 *

 * {
 *   use(new Hbv().doWith(config {@literal ->} {
 *     config.failFast(true);
 *   }));
 * }
 *

 *
 * @author edgar
 * @since 0.6.0
 */
public class Hbv implements Jooby.Module {

  private final Predicate<TypeLiteral<?>> predicate;

  private BiConsumer<HibernateValidatorConfiguration, Config> configurer;

  /**
   * Creates a new {@link Hbv} module.
   *
   * @param predicate A predicate to test if a class require validation or not.
   */
  public Hbv(final Predicate<TypeLiteral<?>> predicate) {
    this.predicate = requireNonNull(predicate, "Predicate is required.");
  }

  /**
   * Creates a new {@link Hbv} module.
   *
   * @param classes List of classes that require validation.
   */
  public Hbv(final Class<?>... classes) {
    this(typeIs(classes));
  }

  /**
   * Creates a new {@link Hbv} module. No automatic validation is applied.
   */
  public Hbv() {
    this(none());
  }

  /**
   * Setup a configurer callback.
   *
   * @param configurer Configurer callback.
   * @return This module.
   */
  public Hbv doWith(final Consumer<HibernateValidatorConfiguration> configurer) {
    requireNonNull(configurer, "Configurer callback is required.");
    this.configurer = (hvc, conf) -> configurer.accept(hvc);
    return this;
  }

  /**
   * Setup a configurer callback.
   *
   * @param configurer Configurer callback.
   * @return This module.
   */
  public Hbv doWith(final BiConsumer<HibernateValidatorConfiguration, Config> configurer) {
    this.configurer = requireNonNull(configurer, "Configurer callback is required.");
    return this;
  }

  @Override
  public void configure(final Env env, final Config config, final Binder binder) {
    HibernateValidatorConfiguration configuration = byProvider(HibernateValidator.class)
        .configure();

    if (config.hasPath("hibernate.validator")) {
      config.getConfig("hibernate.validator").root().forEach((k, v) -> configuration.addProperty("hibernate.validator." + k, v.unwrapped().toString()));
    }

    if (configurer != null) {
      configurer.accept(configuration, config);
    }

    binder.bind(HibernateValidatorConfiguration.class).toInstance(configuration);

    binder.bind(Validator.class).toProvider(HbvFactory.class).asEagerSingleton();

    env.lifeCycle(HbvFactory.class);

    Multibinder.newSetBinder(binder, Parser.class).addBinding()
        .toInstance(new HbvParser(predicate));
  }

  @Override
  public Config config() {
    return ConfigFactory.empty(Hbv.class.getName())
        .withValue("err." + ValidationException.class.getName(),
            ConfigValueFactory.fromAnyRef(400));
  }

  static Predicate<TypeLiteral<?>> typeIs(final Class<?>[] classes) {
    return type -> {
      Class<?> it = type.getRawType();
      for (Class<?> klass : classes) {
        if (it.isAssignableFrom(klass)) {
          return true;
        }
      }
      return false;
    };
  }

  static Predicate<TypeLiteral<?>> none() {
    return type -> false;
  }

}


/**
 *                                  Apache License
 *                            Version 2.0, January 2004
 *                         http://www.apache.org/licenses/
 *
 *    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 *
 *    1. Definitions.
 *
 *       "License" shall mean the terms and conditions for use, reproduction,
 *       and distribution as defined by Sections 1 through 9 of this document.
 *
 *       "Licensor" shall mean the copyright owner or entity authorized by
 *       the copyright owner that is granting the License.
 *
 *       "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.
 *
 *       "You" (or "Your") shall mean an individual or Legal Entity
 *       exercising permissions granted by this License.
 *
 *       "Source" form shall mean the preferred form for making modifications,
 *       including but not limited to software source code, documentation
 *       source, and configuration files.
 *
 *       "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.
 *
 *       "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).
 *
 *       "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.
 *
 *       "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."
 *
 *       "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.
 *
 *    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.
 *
 *    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.
 *
 *    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:
 *
 *       (a) You must give any other recipients of the Work or
 *           Derivative Works a copy of this License; and
 *
 *       (b) You must cause any modified files to carry prominent notices
 *           stating that You changed the files; and
 *
 *       (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
 *
 *       (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.
 *
 *       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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    END OF TERMS AND CONDITIONS
 *
 *    APPENDIX: How to apply the Apache License to your work.
 *
 *       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.
 *
 *    Copyright 2014 Edgar Espina
 *
 *    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
 *
 *        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.jooby.internal;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;

/**
 * {@link InputStream} implementation that reads a character stream from a {@link Reader} and
 * transforms it to a byte stream using a specified charset encoding. The stream
 * is transformed using a {@link CharsetEncoder} object, guaranteeing that all charset
 * encodings supported by the JRE are handled correctly. In particular for charsets such as
 * UTF-16, the implementation ensures that one and only one byte order marker
 * is produced.
 *

 * Since in general it is not possible to predict the number of characters to be read from the
 * {@link Reader} to satisfy a read request on the {@link ReaderInputStream}, all reads from the
 * {@link Reader} are buffered. There is therefore no well defined correlation between the current
 * position of the {@link Reader} and that of the {@link ReaderInputStream}. This also implies that
 * in general there is no need to wrap the underlying {@link Reader} in a
 * {@link java.io.BufferedReader}.
 *

 * {@link ReaderInputStream} implements the inverse transformation of
 * {@link java.io.InputStreamReader}; in the following example, reading from <tt>in2</tt> would
 * return the same byte sequence as reading from <tt>in</tt> (provided that the initial byte
 * sequence is legal with respect to the charset encoding):
 *
 *

 * InputStream in = ...
 * Charset cs = ...
 * InputStreamReader reader = new InputStreamReader(in, cs);
 * ReaderInputStream in2 = new ReaderInputStream(reader, cs);

 * {@link ReaderInputStream} implements the same transformation as
 * {@link java.io.OutputStreamWriter}, except that the control flow is reversed: both classes
 * transform a character stream into a byte stream, but {@link java.io.OutputStreamWriter} pushes
 * data to the underlying stream, while {@link ReaderInputStream} pulls it from the underlying
 * stream.
 *

 * Note that while there are use cases where there is no alternative to using this class, very often
 * the need to use this class is an indication of a flaw in the design of the code. This class is
 * typically used in situations where an existing API only accepts an {@link InputStream}, but where
 * the most natural way to produce the data is as a character stream, i.e. by providing a
 * {@link Reader} instance. An example of a situation where this problem may appear is when
 * implementing the {@link javax.activation.DataSource} interface from the Java Activation
 * Framework.
 *

 * Given the fact that the {@link Reader} class doesn't provide any way to predict whether the next
 * read operation will block or not, it is not possible to provide a meaningful implementation of
 * the {@link InputStream#available()} method. A call to this method will always return 0. Also,
 * this class doesn't support {@link InputStream#mark(int)}.
 *

 * Instances of {@link ReaderInputStream} are not thread safe.
 *
 * @author Andreas Veithen
 * @since Commons IO 2.0
 */
public class ReaderInputStream extends InputStream {
  private static final int DEFAULT_BUFFER_SIZE = 1024;

  private final Reader reader;
  private final CharsetEncoder encoder;

  /**
   * CharBuffer used as input for the decoder. It should be reasonably
   * large as we read data from the underlying Reader into this buffer.
   */
  private final CharBuffer encoderIn;

  /**
   * ByteBuffer used as output for the decoder. This buffer can be small
   * as it is only used to transfer data from the decoder to the
   * buffer provided by the caller.
   */
  private final ByteBuffer encoderOut = ByteBuffer.allocate(128);

  private CoderResult lastCoderResult;

  private boolean endOfInput;

  /**
   * Construct a new {@link ReaderInputStream}.
   *
   * @param reader the target {@link Reader}
   * @param charset the charset encoding
   * @param bufferSize the size of the input buffer in number of characters
   */
  private ReaderInputStream(final Reader reader, final Charset charset, final int bufferSize) {
    this.reader = reader;
    encoder = charset.newEncoder();
    encoderIn = CharBuffer.allocate(bufferSize);
    encoderIn.flip();
  }

  /**
   * Construct a new {@link ReaderInputStream} with a default input buffer size of
   * 1024 characters.
   *
   * @param reader the target {@link Reader}
   * @param charset the charset encoding
   */
  public ReaderInputStream(final Reader reader, final Charset charset) {
    this(reader, charset, DEFAULT_BUFFER_SIZE);
  }

  /**
   * Read the specified number of bytes into an array.
   *
   * @param b the byte array to read into
   * @param off the offset to start reading bytes into
   * @param len the number of bytes to read
   * @return the number of bytes read or -1 if the end of the stream has been reached
   * @throws IOException if an I/O error occurs
   */
  @Override
  public int read(final byte[] b, int off, int len) throws IOException {
    int read = 0;
    while (len > 0) {
      if (encoderOut.position() > 0) {
        encoderOut.flip();
        int c = Math.min(encoderOut.remaining(), len);
        encoderOut.get(b, off, c);
        off += c;
        len -= c;
        read += c;
        encoderOut.compact();
      } else {
        if (!endOfInput && (lastCoderResult == null || lastCoderResult.isUnderflow())) {
          encoderIn.compact();
          int position = encoderIn.position();
          // We don't use Reader#read(CharBuffer) here because it is more efficient
          // to write directly to the underlying char array (the default implementation
          // copies data to a temporary char array).
          int c = reader.read(encoderIn.array(), position, encoderIn.remaining());
          if (c == -1) {
            endOfInput = true;
          } else {
            encoderIn.position(position + c);
          }
          encoderIn.flip();
        }
        lastCoderResult = encoder.encode(encoderIn, encoderOut, endOfInput);
        if (endOfInput && encoderOut.position() == 0) {
          break;
        }
      }
    }
    return read == 0 && endOfInput ? -1 : read;
  }

  /**
   * Read the specified number of bytes into an array.
   *
   * @param b the byte array to read into
   * @return the number of bytes read or -1 if the end of the stream has been reached
   * @throws IOException if an I/O error occurs
   */
  @Override
  public int read(final byte[] b) throws IOException {
    return read(b, 0, b.length);
  }

  /**
   * Read a single byte.
   *
   * @return either the byte read or -1 if the end of the stream
   *         has been reached
   * @throws IOException if an I/O error occurs
   */
  @Override
  public int read() throws IOException {
    byte[] b = new byte[1];
    return read(b) == -1 ? -1 : b[0] & 0xFF;
  }

  /**
   * Close the stream. This method will cause the underlying {@link Reader} to be closed.
   *
   * @throws IOException if an I/O error occurs
   */
  @Override
  public void close() throws IOException {
    reader.close();
  }
}


/**
 *                                  Apache License
 *                            Version 2.0, January 2004
 *                         http://www.apache.org/licenses/
 *
 *    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 *
 *    1. Definitions.
 *
 *       "License" shall mean the terms and conditions for use, reproduction,
 *       and distribution as defined by Sections 1 through 9 of this document.
 *
 *       "Licensor" shall mean the copyright owner or entity authorized by
 *       the copyright owner that is granting the License.
 *
 *       "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.
 *
 *       "You" (or "Your") shall mean an individual or Legal Entity
 *       exercising permissions granted by this License.
 *
 *       "Source" form shall mean the preferred form for making modifications,
 *       including but not limited to software source code, documentation
 *       source, and configuration files.
 *
 *       "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.
 *
 *       "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).
 *
 *       "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.
 *
 *       "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."
 *
 *       "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.
 *
 *    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.
 *
 *    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.
 *
 *    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:
 *
 *       (a) You must give any other recipients of the Work or
 *           Derivative Works a copy of this License; and
 *
 *       (b) You must cause any modified files to carry prominent notices
 *           stating that You changed the files; and
 *
 *       (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
 *
 *       (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.
 *
 *       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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    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.
 *
 *    END OF TERMS AND CONDITIONS
 *
 *    APPENDIX: How to apply the Apache License to your work.
 *
 *       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.
 *
 *    Copyright 2014 Edgar Espina
 *
 *    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
 *
 *        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.jooby.filewatcher;

import com.google.common.collect.ImmutableList;
import com.google.inject.Binder;
import com.google.inject.multibindings.Multibinder;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;
import org.jooby.Env;
import org.jooby.Jooby.Module;
import org.jooby.funzy.Throwing;
import org.jooby.spi.WatchEventModifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardWatchEventKinds;
import java.nio.file.WatchService;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 *
file watcher

 *

 * Watches for file system changes or event. It uses a watch service to monitor a directory for
 * changes so that it can update its display of the list of files when files are created or deleted.
 *

 *
 *
usage

 *

 * Watch mydir and listen for create, modify or delete event on all files under it:
 *

 *
 *
{@code
 * {
 *   use(new FileWatcher()
 *     .register(Paths.get("mydir"), (kind, path) -> {
 *       log.info("found {} on {}", kind, path);
 *     });
 *   );
 * }
 * }

 *
 *
file handler

 *

 * You can specify a {@link FileEventHandler} instance or class while registering a path:
 *

 *
 *

 * Instance:
 *

 *
{@code
 * {
 *   use(new FileWatcher()
 *     .register(Paths.get("mydir"), (kind, path) -> {
 *       log.info("found {} on {}", kind, path);
 *     });
 *   );
 * }
 * }

 *
 *

 * Class reference:
 *

 *
 *
{@code
 * {
 *   use(new FileWatcher()
 *     .register(Paths.get("mydir"), MyFileEventHandler.class)
 *   );
 * }
 * }

 *
 *

 * Worth to mention that MyFileEventHandler will be provided by Guice.
 *

 *
 *
options

 *

 * You can specify a couple of options at registration time:
 *

 *
{@code
 * {
 *   use(new FileWatcher(
 *     .register(Paths.get("mydir"), MyFileEventHandler.class, options -> {
 *       options.kind(StandardWatchEventKinds.ENTRY_MODIFY)
 *              .recursive(false)
 *              .includes("*.java");
 *     });
 *   ));
 * }
 * }

 *
 *

 * 1. Here we listen for {@link StandardWatchEventKinds#ENTRY_MODIFY} (we don't care about create or
 * delete).
 *

 *

 * 2. We turn off recursive watching, only direct files are detected.
 *

 *

 * 3. We want .java files and we ignore any other files.
 *

 *
 *
configuration file

 *

 * In addition to do it programmatically, you can do it via configuration properties:
 *

 *
 *
{@code
 * {
 *   use(new FileWatcher()
 *     .register("mydirproperty", MyEventHandler.class)
 *   );
 * }
 * }

 *
 *

 * The mydirproperty property must be present in your .conf file.
 *

 *
 *

 * But of course, you can entirely register paths from .conf file:
 *

 *
 *
{@code
 * filewatcher {
 *   register {
 *     path: "mydir"
 *     handler: "org.example.MyFileEventHandler"
 *     kind: "ENTRY_MODIFY"
 *     includes: "*.java"
 *     recursive: false
 *   }
 * }
 * }

 *
 *

 * Multiple paths are supported using array notation:
 *

 *
 *
{@code
 * filewatcher {
 *   register: [{
 *     path: "mydir1"
 *     handler: "org.example.MyFileEventHandler"
 *   }, {
 *     path: "mydir2"
 *     handler: "org.example.MyFileEventHandler"
 *   }]
 * }
 * }

 *
 *

 * Now use the module:
 *

 *
{@code
 * {
 *   use(new FileWatcher());
 * }
 * }

 *
 *

 * The {@link FileWatcher} module read the filewatcher.register property and setup
 * everything.
 *

 *
 * @author edgar
 */
public class FileWatcher implements Module {
  private static final Consumer<FileEventOptions> EMPTY = it -> {
  };

  /**
   * The logging system.
   */
  private final Logger log = LoggerFactory.getLogger(getClass());

  private final List<Throwing.Function2<Config, Binder, FileEventOptions>> bindings = new ArrayList<>();

  private WatchService watcher;

  /**
   * Register the given directory tree and execute the given handler whenever a file/folder has been
   * created, modified or delete.
   *
   * @param path Directory to register.
   * @param handler Handler to execute.
   * @return This module.
   */
  public FileWatcher register(final Path path, final Class<? extends FileEventHandler> handler) {
    return register(path, handler, EMPTY);
  }

  /**
   * Register the given directory tree and execute the given handler whenever a file/folder has been
   * created, modified or delete. The configurer callback allow you to customize default event
   * kinds, filter specific file types and restrict the watch scope lookup to direct files.
   *
   * @param path Directory to register.
   * @param handler Handler to execute.
   * @param configurer Configurer callback.
   * @return This module.
   * @see FileEventOptions
   */
  public FileWatcher register(final Path path, final Class<? extends FileEventHandler> handler,
      final Consumer<FileEventOptions> configurer) {
    return register(c -> path, p -> new FileEventOptions(p, handler), configurer);
  }

  /**
   * Register the given directory tree and execute the given handler whenever a file/folder has been
   * created, modified or delete.
   *
   * @param path Directory to register.
   * @param handler Handler to execute.
   * @return This module.
   */
  public FileWatcher register(final Path path, final FileEventHandler handler) {
    return register(c -> path, p -> new FileEventOptions(p, handler), EMPTY);
  }

  /**
   * Register the given directory tree and execute the given handler whenever a file/folder has been
   * created, modified or delete. The configurer callback allow you to customize default event
   * kinds, filter specific file types and restrict the watch scope lookup to direct files.
   *
   * @param path Directory to register.
   * @param handler Handler to execute.
   * @param configurer Configurer callback.
   * @return This module.
   * @see FileEventOptions
   */
  public FileWatcher register(final Path path, final FileEventHandler handler,
      final Consumer<FileEventOptions> configurer) {
    return register(c -> path, p -> new FileEventOptions(p, handler), configurer);
  }

  /**
   * Register the given directory tree and execute the given handler whenever a file/folder has been
   * created, modified or delete.
   *
   * @param property Directory to register.
   * @param handler Handler to execute.
   * @return This module.
   */
  public FileWatcher register(final String property, final FileEventHandler handler) {
    return register(c -> Paths.get(c.getString(property)), p -> new FileEventOptions(p, handler),
        EMPTY);
  }

  /**
   * Register the given directory tree and execute the given handler whenever a file/folder has been
   * created, modified or delete. The configurer callback allow you to customize default event
   * kinds, filter specific file types and restrict the watch scope lookup to direct files.
   *
   * @param property Directory to register.
   * @param handler Handler to execute.
   * @param configurer Configurer callback.
   * @return This module.
   * @see FileEventOptions
   */
  public FileWatcher register(final String property, final FileEventHandler handler,
      final Consumer<FileEventOptions> configurer) {
    return register(c -> Paths.get(c.getString(property)), p -> new FileEventOptions(p, handler),
        configurer);
  }

  /**
   * Register the given directory tree and execute the given handler whenever a file/folder has been
   * created, modified or delete.
   *
   * @param property Directory to register.
   * @param handler Handler to execute.
   * @return This module.
   */
  public FileWatcher register(final String property,
      final Class<? extends FileEventHandler> handler) {
    return register(property, handler, EMPTY);
  }

  /**
   * Register the given directory tree and execute the given handler whenever a file/folder has been
   * created, modified or delete. The configurer callback allow you to customize default event
   * kinds, filter specific file types and restrict the watch scope lookup to direct files.
   *
   * @param property Directory to register.
   * @param handler Handler to execute.
   * @param configurer Configurer callback.
   * @return This module.
   * @see FileEventOptions
   */
  public FileWatcher register(final String property,
      final Class<? extends FileEventHandler> handler,
      final Consumer<FileEventOptions> configurer) {
    return register(c -> Paths.get(c.getString(property)),
        path -> new FileEventOptions(path, handler), configurer);
  }

  private FileWatcher register(final Function<Config, Path> provider,
      final Throwing.Function<Path, FileEventOptions> handler,
      final Consumer<FileEventOptions> configurer) {
    bindings.add((conf, binder) -> {
      Path path = provider.apply(conf);
      FileEventOptions options = handler.apply(path);
      configurer.accept(options);
      return register(binder, options);
    });
    return this;
  }

  private FileEventOptions register(final Binder binder, final FileEventOptions options) {
    Multibinder.newSetBinder(binder, FileEventOptions.class)
        .addBinding()
        .toInstance(options);
    return options;
  }

  @Override
  public void configure(final Env env, final Config conf, final Binder binder) throws Throwable {
    this.watcher = FileSystems.getDefault().newWatchService();
    binder.bind(WatchService.class).toInstance(watcher);
    List<FileEventOptions> paths = new ArrayList<>();
    paths(env.getClass().getClassLoader(), conf, "filewatcher.register", options -> paths.add(register(binder, options)));
    for (Throwing.Function2<Config, Binder, FileEventOptions> binding : bindings) {
      paths.add(binding.apply(conf, binder));
    }
    binder.bind(FileMonitor.class).asEagerSingleton();
    paths.forEach(it -> log.info("Watching: {}", it));
  }

  protected boolean empty() {
    return bindings.isEmpty();
  }

  @SuppressWarnings({"unchecked", "rawtypes"})
  private void paths(final ClassLoader loader, final Config conf, final String name,
      final Consumer<FileEventOptions> callback) {
    list(conf, name, value -> {
      Config coptions = ConfigFactory.parseMap((Map) value);
      Class handler = loader.loadClass(coptions.getString("handler"));
      Path path = Paths.get(coptions.getString("path"));
      FileEventOptions options = new FileEventOptions(path, handler);
      list(coptions, "kind", it -> options.kind(new WatchEventKind(it.toString())));
      list(coptions, "modifier", it -> options.modifier(WatchEventModifier.modifier(it.toString())));
      list(coptions, "includes", it -> options.includes(it.toString()));
      list(coptions, "recursive", it -> options.recursive(Boolean.valueOf(it.toString())));
      callback.accept(options);
    });
  }

  @SuppressWarnings("rawtypes")
  private void list(final Config conf, final String name, final Throwing.Consumer<Object> callback) {
    if (conf.hasPath(name)) {
      Object value = conf.getAnyRef(name);
      List values = value instanceof List ? (List) value : ImmutableList.of(value);
      for (Object it : values) {
        callback.accept(it);
      }
    }
  }

}