/*
    * Created on Nov 5, 2003
    * 
    * Copyright neotechnologies.org
    */
   
   package org.neo.swarm.util.network.tcp;
   
   import java.net.InetAddress;
  
  import junit.framework.TestCase;
  
  import org.neo.swarm.util.network.tcp.ListenCallback;
  import org.neo.swarm.util.network.tcp.NIOTcpServer;
  import org.neo.swarm.util.network.tcp.TcpServiceAPI;
  import org.neo.swarm.util.network.tcp.client.TcpSender;
  import org.neo.swarm.util.network.tcp.client.TcpSenderFactory;
  import org.neo.swarm.util.threads.OswegoThreadPool;
  
  import EDU.oswego.cs.dl.util.concurrent.PooledExecutor;
  
  /***
   * Test client/server invocations between client and server using TCPIP.
   * 
   * @author neil.avery
   */
  public class TcpSocketsBehaviouralTest extends TestCase {
  
  	private static String PAD = "BytePaddingMessageThatDoesStuffXXXXYYYZZZAABBCCAADDEEFFQQWWEERRTTYY";
  	boolean verbose = false;
  	String host = "localhost";
  	int port = 8888;
  	int calls;
  	int threadpoolsize = 1;
  	int timeout = 1000; // 0 blocks indefinately (othewise time in ms)
  
  	TcpServiceAPI server;
  	int dataSize;
  	long startTime;
  	int numIterations;
  	int callbackCount;
  
  	protected void tearDown() throws Exception {
  		long endTime = System.currentTimeMillis();
  		double timeSecs = (endTime - startTime) / 1000.0;
  		double rate = numIterations / timeSecs;
  		double tp = rate * dataSize;
  		System.out.println("\nDone elapsed time:" + timeSecs + " pktSize:" + dataSize + " rate:" + rate
  						+ " throughput:" + tp / 1000.0 + "kb/s");
  		this.server.stopServer();
  	}
  
  	/***
  	 * This test shows a bug in the JDK nio socket libs - When sending large sets of data with pauses, then the
  	 * repeating select fails to trigger and pickup the following messages - resulting in them being ignored completely.
  	 * 
  	 * @throws Exception
  	 */
  	public void _testStaggeredClientServerWithManyMessages() throws Exception {
  		verbose = false;
  		MyListenerCallback cb = new MyListenerCallback();
  		// create the client and send a String.
  		TcpSender client = new TcpSenderFactory().getTcpSender(1024, InetAddress.getByName(host), port);
  
  		// create the tcp server which will callback on our object.
  		this.server = new NIOTcpServer(cb, 
                          new OswegoThreadPool(new PooledExecutor(), 1, 5), 1024, 
                          InetAddress.getByName(host), port, timeout);
  		this.server.startServer();
  
  		String expectedDataString = "0123456789";
  		byte[] expectedData = expectedDataString.getBytes();
  
  		//setup stats
  		this.numIterations = 100000;
  		this.callbackCount = 0;
  		this.startTime = System.currentTimeMillis();
  		this.dataSize = expectedData.length;
  		int stallPeriod = 1000;
  		int batchSize = 100;
  		int numBatchs = 10;
  
  		for (int j = 0; j < numBatchs; j++) {
  			for (int i = 0; i < batchSize; i++) {
  				client.send(new String(expectedDataString + ":" + i).getBytes());
  			}
  			System.out.println("stalling.... sent batch:" + j + " total msgs:" + batchSize * j);
  			Thread.sleep(stallPeriod);
  		}
  
  		System.out.println("sent all messages");
  
  		while (calls != numBatchs * batchSize) {
  			Thread.sleep(1000);
  		}
  		assertEquals(calls, numBatchs * batchSize);
  	}
  
  	/***
 	 * @throws Exception
 	 */
 	public void testThroughputWith10b() throws Exception {
 		sendDataOneWay(10, 10000);
 	}
 
 	public void _testThroughputWith512K() throws Exception {
 		sendDataOneWay(512, 5000);
 	}
 
 	public void _testThroughputWith1024K() throws Exception {
 		sendDataOneWay(1024, 2000);
 	}
 
 	public void testThroughputWith4024K() throws Exception {
 		sendDataOneWay(4 * 1024, 2000);
 	}
 
 	public void testTwoWayThroughputWith10() throws Exception {
 		sendDataTwoWay(10, 10000);
 	}
 
 	public void _testTwoWayThroughputWith1024() throws Exception {
 		sendDataTwoWay(1024, 2000);
 	}
 
 	public void testTwoWayThroughputWith4K() throws Exception {
 		sendDataTwoWay(4 * 1024, 200);
 	}
 
 	/*
 	 * Increment datasize until we pass or throw an exception.
 	 */
 	public void testMaxDataSetSize() throws Exception {
 		int size = 1024 * 2 * 2;
 		this.verbose = true;
 		for (int i = 0; i < 8; i++) {
 			calls = 0;
 			System.out.println("xxxxxxxxxxxxxxx testing size:" + size);
 			sendDataTwoWay(size, 10);
 			size *= 2;
 		}
 		this.verbose = false;
 	}
 
 	/***
 	 * Find largest amount of data possable
 	 */
 	private void sendDataOneWay(int size, int totalCalls) throws Exception {
 		;
 
 		verbose = false;
 		MyListenerCallback cb = new MyListenerCallback();
 
 		// setup the server and forget about it.
 		this.server = new NIOTcpServer(cb, new OswegoThreadPool(new PooledExecutor(), 1, 5), 4 * 1024, InetAddress
 						.getByName(host), port, timeout);
 		this.server.startServer();
 		// create the client and send a String.
 		TcpSender client = new TcpSenderFactory().getTcpSender(4 * 1024, InetAddress.getByName(host), port);
 
 		byte[] sendMessage = makeMessage(size);
 
 		//setup stats
 		this.numIterations = totalCalls;
 		this.callbackCount = 0;
 		this.startTime = System.currentTimeMillis();
 		this.dataSize = size;
 
 		calls = 0;
 
 		for (int j = 0; j < this.numIterations; j++) {
 			client.send(new String(j + ":" + new String(sendMessage)).getBytes());
 		}
 
 		// wait until the cb object has received the data
 		int wait = 0;
 		while (calls < this.numIterations && wait++ < 10) {
 			Thread.sleep(1000);
 		}
 		assertEquals(calls, this.numIterations);
 	}
 
 	private void sendDataTwoWay(int size, int totalCalls) throws Exception {
 		;
 
 		MyListenerCallbackWithReply cb = new MyListenerCallbackWithReply();
 
 		// setup the server and forget about it.
 		if (this.server == null) {
 
 			this.server = new NIOTcpServer(cb, new OswegoThreadPool(new PooledExecutor(), 1, 5), 4 * 1048, InetAddress
 							.getByName(host), port, timeout);
 			this.server.startServer();
 		}
 		// create the client and send a String.
 		TcpSender client = new TcpSenderFactory().getTcpSender(4 * 1048, InetAddress.getByName(host), port);
 
 		byte[] sendMessage = makeMessage(size);
 
 		//setup stats
 		this.numIterations = totalCalls;
 		this.callbackCount = 0;
 		this.startTime = System.currentTimeMillis();
 		this.dataSize = size;
 		calls = 0;
 
 		for (int j = 0; j < this.numIterations; j++) {
 			byte[] blah = client.sendAndReceiveMessage(new String(j + ":" + new String(sendMessage)).getBytes());
 		}
 
 		// wait until the cb object has received the data
 		int wait = 0;
 		while (calls < this.numIterations && wait++ < 5) {
 			Thread.sleep(1000);
 		}
 		assertEquals(calls, this.numIterations);
 	}
 
 	/***
 	 * Simple callback class that allows the server to call out onto use app.
 	 */
 	class MyListenerCallback implements ListenCallback {
 
 		public byte[] messageDataReceived(byte[] data) {
 
 			calls++;
 			if (verbose || (calls % 5000) == 0) {
 				System.out.println("cb:" + calls + " msgSize" + data.length);
 			}
 			return new byte[0];
 		}
 	}
 
 	/***
 	 * Simple callback class that allows the server to call out onto use app.
 	 */
 	class MyListenerCallbackWithReply implements ListenCallback {
 
 		public long expected = 0;
 
 		public byte[] messageDataReceived(byte[] data) {
 			calls++;
 			if (verbose || (calls % 5000) == 0) {
 				System.out.println("cb:" + calls + " msgSize" + data.length);
 			}
 
 			return "datacallbackreceived".getBytes();
 		}
 	}
 
 	private byte[] makeMessage(int size) throws Exception {
 		byte[] sendMessage = new byte[size];
 
 		byte[] padding = PAD.getBytes();
 
 		// fill the buffer
 		int pos = 0;
 		while (pos < size) {
 			sendMessage[pos] = padding[pos++ % padding.length];
 		}
 		return sendMessage;
 	}
 
 }