/*
    * Copyright 2012 The Netty Project
    *
    * The Netty Project licenses this file to you under the Apache License,
    * version 2.0 (the "License"); you may not use this file except in compliance
    * with the License. You may obtain a copy of the License at:
    *
    *   https://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 io.netty.example.proxy;
  
  import io.netty.bootstrap.Bootstrap;
  import io.netty.buffer.Unpooled;
  import io.netty.channel.Channel;
  import io.netty.channel.ChannelFuture;
  import io.netty.channel.ChannelFutureListener;
  import io.netty.channel.ChannelHandlerContext;
  import io.netty.channel.ChannelInboundHandlerAdapter;
  import io.netty.channel.ChannelOption;
  
  public class HexDumpProxyFrontendHandler extends ChannelInboundHandlerAdapter {
  
      private final String remoteHost;
      private final int remotePort;
  
      // As we use inboundChannel.eventLoop() when building the Bootstrap this does not need to be volatile as
      // the outboundChannel will use the same EventLoop (and therefore Thread) as the inboundChannel.
      private Channel outboundChannel;
  
      public HexDumpProxyFrontendHandler(String remoteHost, int remotePort) {
          this.remoteHost = remoteHost;
          this.remotePort = remotePort;
      }
  
      @Override
      public void channelActive(ChannelHandlerContext ctx) {
          final Channel inboundChannel = ctx.channel();
  
          // Start the connection attempt.
          Bootstrap b = new Bootstrap();
          b.group(inboundChannel.eventLoop())
           .channel(ctx.channel().getClass())
           .handler(new HexDumpProxyBackendHandler(inboundChannel))
           .option(ChannelOption.AUTO_READ, false);
          ChannelFuture f = b.connect(remoteHost, remotePort);
          outboundChannel = f.channel();
          f.addListener(future -> {
              if (future.isSuccess()) {
                  // connection complete start to read first data
                  inboundChannel.read();
              } else {
                  // Close the connection if the connection attempt has failed.
                  inboundChannel.close();
              }
          });
      }
  
      @Override
      public void channelRead(final ChannelHandlerContext ctx, Object msg) {
          if (outboundChannel.isActive()) {
              outboundChannel.writeAndFlush(msg).addListener(future -> {
                  if (future.isSuccess()) {
                      // was able to flush out data, start to read the next chunk
                      ctx.read();
                  } else {
                      ctx.close();
                  }
              });
          }
      }
  
      @Override
      public void channelInactive(ChannelHandlerContext ctx) {
          if (outboundChannel != null) {
              closeOnFlush(outboundChannel);
          }
      }
  
      @Override
      public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
          cause.printStackTrace();
          closeOnFlush(ctx.channel());
      }
  
      /**
       * Closes the specified channel after all queued write requests are flushed.
       */
      static void closeOnFlush(Channel ch) {
          if (ch.isActive()) {
              ch.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
          }
      }
  }