/*
    * 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.discard;
  
  import io.netty5.buffer.api.Buffer;
  import io.netty5.channel.Channel;
  import io.netty5.channel.ChannelHandlerContext;
  import io.netty5.channel.SimpleChannelInboundHandler;
  import io.netty5.util.concurrent.FutureContextListener;
  
  /**
   * Handles a client-side channel.
   */
  public class DiscardClientHandler extends SimpleChannelInboundHandler<Object> {
  
      private Buffer content;
      private ChannelHandlerContext ctx;
  
      @Override
      public void channelActive(ChannelHandlerContext ctx) {
          this.ctx = ctx;
  
          // Initialize the message.
          content = ctx.bufferAllocator()
                       .allocate(DiscardClient.SIZE)
                       .writerOffset(DiscardClient.SIZE)
                       .fill((byte) 0)
                       .makeReadOnly();
  
          // Send the initial messages.
          generateTraffic();
      }
  
      @Override
      public void channelInactive(ChannelHandlerContext ctx) {
          content.close();
      }
  
      @Override
      public void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception {
          // Server is supposed to send nothing, but if it sends something, discard it.
      }
  
      @Override
      public void channelExceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
          // Close the connection when an exception is raised.
          cause.printStackTrace();
          ctx.close();
      }
  
      private void generateTraffic() {
          // Flush the outbound buffer to the socket.
          // Once flushed, generate the same amount of traffic again.
          ctx.writeAndFlush(content.copy(true)).addListener(ctx.channel(), trafficGenerator);
      }
  
      private final FutureContextListener<Channel, Void> trafficGenerator = (channel, future) -> {
          if (future.isSuccess()) {
              generateTraffic();
          } else {
              future.cause().printStackTrace();
              channel.close();
          }
      };
  }