/*
    * 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.netty5.example.proxy;
  
  import io.netty5.bootstrap.Bootstrap;
  import io.netty5.channel.Channel;
  import io.netty5.channel.ChannelFutureListeners;
  import io.netty5.channel.ChannelHandler;
  import io.netty5.channel.ChannelHandlerContext;
  import io.netty5.channel.ChannelInitializer;
  import io.netty5.channel.ChannelOption;
  
  public class HexDumpProxyFrontendHandler implements ChannelHandler {
  
      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.executor())
           .channel(ctx.channel().getClass())
           .handler(new ChannelInitializer<>() {
               @Override
               protected void initChannel(Channel ch) throws Exception {
                   outboundChannel = ch;
                   ch.pipeline().addLast(new HexDumpProxyBackendHandler(inboundChannel));
               }
           })
           .option(ChannelOption.AUTO_READ, false)
           .connect(remoteHost, remotePort)
           .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(outboundChannel, (outbound, future) -> {
                  if (future.isSuccess()) {
                      // was able to flush out data, start to read the next chunk
                      ctx.channel().read();
                  } else {
                      outbound.close();
                  }
              });
          }
      }
  
      @Override
      public void channelInactive(ChannelHandlerContext ctx) {
          if (outboundChannel != null) {
              closeOnFlush(outboundChannel);
          }
      }
  
      @Override
      public void channelExceptionCaught(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(ch.bufferAllocator().allocate(0)).addListener(ch, ChannelFutureListeners.CLOSE);
         }
     }
 }