/*
    * 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:
    *
    *   http://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.
   */
  //The MIT License
  //
  //Copyright (c) 2009 Carl Bystršm
  //
  //Permission is hereby granted, free of charge, to any person obtaining a copy
  //of this software and associated documentation files (the "Software"), to deal
  //in the Software without restriction, including without limitation the rights
  //to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  //copies of the Software, and to permit persons to whom the Software is
  //furnished to do so, subject to the following conditions:
  //
  //The above copyright notice and this permission notice shall be included in
  //all copies or substantial portions of the Software.
  //
  //THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  //IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  //FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  //AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  //LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  //OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  //THE SOFTWARE.
  package org.jboss.netty.example.http.websocketx.client;
  
  import org.jboss.netty.bootstrap.ClientBootstrap;
  import org.jboss.netty.buffer.ChannelBuffers;
  import org.jboss.netty.channel.Channel;
  import org.jboss.netty.channel.ChannelFuture;
  import org.jboss.netty.channel.ChannelPipeline;
  import org.jboss.netty.channel.ChannelPipelineFactory;
  import org.jboss.netty.channel.Channels;
  import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;
  import org.jboss.netty.handler.codec.http.HttpRequestEncoder;
  import org.jboss.netty.handler.codec.http.HttpResponseDecoder;
  import org.jboss.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
  import org.jboss.netty.handler.codec.http.websocketx.PingWebSocketFrame;
  import org.jboss.netty.handler.codec.http.websocketx.TextWebSocketFrame;
  import org.jboss.netty.handler.codec.http.websocketx.WebSocketClientHandshaker;
  import org.jboss.netty.handler.codec.http.websocketx.WebSocketClientHandshakerFactory;
  import org.jboss.netty.handler.codec.http.websocketx.WebSocketVersion;
  import org.jboss.netty.handler.ssl.SslContext;
  import org.jboss.netty.handler.ssl.util.SelfSignedCertificate;
  
  import java.net.InetSocketAddress;
  import java.net.URI;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.concurrent.Executors;
  
  public final class WebSocketClient {
  
      static final String URL = System.getProperty("url", "ws://127.0.0.1:8080/websocket");
  
      public static void main(String[] args) throws Exception {
          URI uri = new URI(URL);
          String scheme = uri.getScheme() == null? "http" : uri.getScheme();
          final String host = uri.getHost() == null? "127.0.0.1" : uri.getHost();
          final int port;
          if (uri.getPort() == -1) {
              if ("http".equalsIgnoreCase(scheme)) {
                  port = 80;
              } else if ("https".equalsIgnoreCase(scheme)) {
                  port = 443;
              } else {
                  port = -1;
              }
          } else {
              port = uri.getPort();
          }
  
          if (!"ws".equalsIgnoreCase(scheme) && !"wss".equalsIgnoreCase(scheme)) {
              System.err.println("Only WS(S) is supported.");
              return;
          }
  
          final boolean ssl = "wss".equalsIgnoreCase(scheme);
          final SslContext sslCtx;
          if (ssl) {
              SelfSignedCertificate ssc = new SelfSignedCertificate();
              sslCtx = SslContext.newServerContext(ssc.certificate(), ssc.privateKey());
          } else {
              sslCtx = null;
          }
  
          Map<String, String> customHeaders = new HashMap<String, String>();
         customHeaders.put("MyHeader", "MyValue");
 
         ClientBootstrap bootstrap =
                 new ClientBootstrap(
                         new NioClientSocketChannelFactory(
                                 Executors.newCachedThreadPool(),
                                 Executors.newCachedThreadPool()));
 
         Channel ch = null;
         try {
             // Connect with V13 (RFC 6455 aka HyBi-17). You can change it to V08 or V00.
             // If you change it to V00, ping is not supported and remember to change
             // HttpResponseDecoder to WebSocketHttpResponseDecoder in the pipeline.
             final WebSocketClientHandshaker handshaker =
                     new WebSocketClientHandshakerFactory().newHandshaker(
                             uri, WebSocketVersion.V13, null, false, customHeaders);
 
             bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
                 public ChannelPipeline getPipeline() {
                     ChannelPipeline pipeline = Channels.pipeline();
 
                     if (sslCtx != null) {
                         pipeline.addLast("ssl", sslCtx.newHandler(host, port));
                     }
                     pipeline.addLast("decoder", new HttpResponseDecoder());
                     pipeline.addLast("encoder", new HttpRequestEncoder());
                     pipeline.addLast("ws-handler", new WebSocketClientHandler(handshaker));
                     return pipeline;
                 }
             });
 
             // Connect.
             ChannelFuture future = bootstrap.connect(new InetSocketAddress(host, port));
             ch = future.sync().getChannel();
 
             handshaker.handshake(ch).sync();
 
             // Send 10 messages and wait for responses
             for (int i = 0; i < 1000; i++) {
                 ch.write(new TextWebSocketFrame("Message #" + i));
             }
 
             // Ping
             ch.write(new PingWebSocketFrame(ChannelBuffers.wrappedBuffer(new byte[] { 1, 2, 3, 4, 5, 6 })));
 
             // Close
             ch.write(new CloseWebSocketFrame());
 
             // WebSocketClientHandler will close the connection when the server
             // responds to the CloseWebSocketFrame.
             ch.getCloseFuture().sync();
         } finally {
             if (ch != null) {
                 ch.close();
             }
             bootstrap.releaseExternalResources();
         }
     }
 }