/**
 * Jooby https://jooby.io
 * Apache License Version 2.0 https://jooby.io/LICENSE.txt
 * Copyright 2014 Edgar Espina
 */
package io.jooby;

import static java.util.Collections.singletonList;

import java.io.EOFException;
import java.io.IOException;
import java.net.BindException;
import java.nio.channels.ClosedChannelException;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Predicate;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/**
 * Web server contract. Defines operations to start, join and stop a web server. Jooby comes
 * with three web server implementation: Jetty, Netty and Undertow.
 *
 * A web server is automatically discovered using the Java Service Loader API. All you need is to
 * add the server dependency to your project classpath.
 *
 * When service loader is not an option or do you want to manually bootstrap a server:
 *
 * <pre>{@code
 *
 * Server server = new Netty(); // or Jetty or Utow
 *
 * App app = new App();
 *
 * server.start(app);
 *
 * ...
 *
 * server.stop();
 *
 * }</pre>
 *
 * @author edgar
 * @since 2.0.0
 */
public interface Server {

  /**
   * Base class for server.
   */
  abstract class Base implements Server {

    private static final Predicate<Throwable> CONNECTION_LOST = cause -> {
      if (cause instanceof IOException) {
        String message = cause.getMessage();
        if (message != null) {
          String msg = message.toLowerCase();
          return msg.contains("reset by peer")
              || msg.contains("broken pipe")
              || msg.contains("forcibly closed")
              || msg.contains("connection reset");
        }
      }
      return (cause instanceof ClosedChannelException) || (cause instanceof EOFException);
    };

    private static final Predicate<Throwable> ADDRESS_IN_USE = cause ->
      (cause instanceof BindException)
          || (Optional.ofNullable(cause)
              .map(Throwable::getMessage)
              .map(String::toLowerCase)
              .filter(msg -> msg.contains("address already in use"))
              .isPresent()
          );

    private static final List<Predicate<Throwable>> connectionLostListeners =
        new CopyOnWriteArrayList<>(singletonList(CONNECTION_LOST));

    private static final List<Predicate<Throwable>> addressInUseListeners =
        new CopyOnWriteArrayList<>(singletonList(ADDRESS_IN_USE));

    private static final boolean useShutdownHook = Boolean
        .parseBoolean(System.getProperty("jooby.useShutdownHook", "true"));

    private AtomicBoolean stopping = new AtomicBoolean();

    protected void fireStart(@Nonnull List<Jooby> applications, @Nonnull Executor defaultWorker) {
      for (Jooby app : applications) {
        app.setDefaultWorker(defaultWorker).start(this);
      }
    }

    protected void fireReady(@Nonnull List<Jooby> applications) {
      for (Jooby app : applications) {
        app.ready(this);
      }
    }

    protected void fireStop(@Nonnull List<Jooby> applications) {
      if (stopping.compareAndSet(false, true)) {
        if (applications != null) {
          for (Jooby app : applications) {
            app.stop();
          }
        }
      }
    }

    protected void addShutdownHook() {
      if (useShutdownHook) {
        Runtime.getRuntime().addShutdownHook(new Thread(this::stop));
      }
    }
  }

  /**
   * Set server options.
   *
   * @param options Server options.
   * @return This server.
   */
  @Nonnull Server setOptions(@Nonnull ServerOptions options);

  /**
   * Get server options.
   *
   * @return Server options.
   */
  @Nonnull ServerOptions getOptions();

  /**
   * Start an application.
   *
   * @param application Application to start.
   * @return This server.
   */
  @Nonnull Server start(@Nonnull Jooby application);

  /**
   * Block current thread.
   *
   * @deprecated This method is planned to be removed in next major release (3.x)
   */
  @Deprecated
  @Nonnull default void join() {
    try {
      Thread.currentThread().join();
    } catch (InterruptedException x) {
      Thread.currentThread().interrupt();
    }
  }

  /**
   * Stop the server.
   *
   * @return Stop the server.
   */
  @Nonnull Server stop();

  /**
   * Add a connection lost predicate. On unexpected exception, this method allows to customize which
   * error are considered connection lost. If the error is considered a connection lost, no log
   * statement will be emitted by the application.
   *
   * @param predicate Customize connection lost error.
   */
  static void addConnectionLost(@Nonnull Predicate<Throwable> predicate) {
    Base.connectionLostListeners.add(predicate);
  }

  /**
   * Add an address in use predicate. On unexpected exception, this method allows to customize which
   * error are considered address in use. If the error is considered an address in use, no log
   * statement will be emitted by the application.
   *
   * @param predicate Customize connection lost error.
   */
  static void addAddressInUse(@Nonnull Predicate<Throwable> predicate) {
    Base.addressInUseListeners.add(predicate);
  }

  /**
   * Test whenever the given exception is a connection-lost. Connection-lost exceptions don't
   * generate log.error statements.
   *
   * @param cause Exception to check.
   * @return True for connection lost.
   */
  static boolean connectionLost(@Nullable Throwable cause) {
    for (Predicate<Throwable> connectionLost : Base.connectionLostListeners) {
      if (connectionLost.test(cause)) {
        return true;
      }
    }
    return false;
  }

  /**
   * Whenever the given exception is an address already in use. This probably won't work in none
   * English locale systems.
   *
   * @param cause Exception to check.
   * @return True address alaredy in use.
   */
  static boolean isAddressInUse(@Nullable Throwable cause) {
    for (Predicate<Throwable> addressInUse : Base.addressInUseListeners) {
      if (addressInUse.test(cause)) {
        return true;
      }
    }
    return false;
  }
}