package io.jooby.netty;

import io.jooby.WebServer;
import io.jooby.Router;
import io.jooby.internal.netty.NettyConfigurer;
import io.jooby.internal.netty.NettyHandler;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.HttpServerExpectContinueHandler;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.util.SelfSignedCertificate;
import io.netty.util.concurrent.DefaultEventExecutorGroup;
import org.jooby.funzy.Throwing;

public class Netty implements WebServer {

  public static class Pipeline extends ChannelInitializer<SocketChannel> {

    private final SslContext sslCtx;
    private final NettyHandler handler;

    public Pipeline(SslContext sslCtx, DefaultEventExecutorGroup executor, Router router) {
      this.sslCtx = sslCtx;
      this.handler = new NettyHandler(executor, router);
    }

    @Override
    public void initChannel(SocketChannel ch) {
      ChannelPipeline p = ch.pipeline();
      if (sslCtx != null) {
        p.addLast(sslCtx.newHandler(ch.alloc()));
      }
      p.addLast(new HttpServerCodec());
      p.addLast(new HttpServerExpectContinueHandler());
      p.addLast(handler);
    }
  }

  private static boolean SSL = false;
  private EventLoopGroup accept;
  private EventLoopGroup worker;

  public void start(int port, Router router, boolean join) {
    // Configure SSL.
    final SslContext sslCtx;
    NettyConfigurer provider = NettyConfigurer.get();
    // Configure the server.
    this.accept = provider.group(1);
    this.worker = provider.group(0);
    try {
      if (SSL) {
        SelfSignedCertificate ssc = new SelfSignedCertificate();
        sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
      } else {
        sslCtx = null;
      }
      DefaultEventExecutorGroup executor = new DefaultEventExecutorGroup(32);
      ServerBootstrap bootstrap = new ServerBootstrap();
      bootstrap.option(ChannelOption.SO_BACKLOG, 1024);
      bootstrap.group(accept, worker)
          .channel(provider.channel())
          .handler(new LoggingHandler(LogLevel.DEBUG))
          .childHandler(new Pipeline(sslCtx, executor, router));

      Channel ch = bootstrap.bind(port).sync().channel();

      ChannelFuture future = ch.closeFuture();
      if (join) {
        future.sync();
      }
    } catch (Throwable x) {
      throw Throwing.sneakyThrow(x);
    }
  }

  @Override public void stop() {
    worker.shutdownGracefully();
    accept.shutdownGracefully();
  }
}