import java.net.*;
import java.util.*;
import java.io.*;

class packet		//denotes a TCP packet
{
	String mpack;

	public packet()
	{
		mpack = new String("");
	}

	public packet(String s)
	{
		mpack =s;
	}

	String padding(int arg,int plen)
	{
		String x = toBool(arg);
		String ans = new String("");
		for(int i=x.length();i<plen;i++)
			ans+="0";
		ans+=x;
		return ans;
	}

	String toBool(int x)
	{
		if(x==0)
			return "0";
		if(x==1)
			return "1";
		if(x==2)
			return "10";
		return toBool(x/2) + (new Integer(x%2)).toString();
	}

	int depad(String x)
	{
		if(debool(x)==0)
			return 0;
		while(x.charAt(0)=='0')
			x=x.substring(1,x.length());
		return debool(x);
	}

	int debool(String x)
	{
		if(x.length()==0)
			return 0;
		return (((x.charAt(0)=='0')?0:(int)Math.pow(2,x.length()-1)) + debool(x.substring(1,x.length())));
	}

	public void cPacket(int sport,int dport,int seq,int ack,int flags,int window, String data)
	{
		String header = new String("");
		header = padding(sport,16)+padding(dport,16);
		header+= padding(seq,32);
		header+= padding(ack,32);
		header+= padding(5,4)     +padding(0,4)      +padding(flags,8)+padding(window,16);
		header+= padding(0,32);
		header+= padding(0,32);
		mpack = header;
		mpack += data;
	}

	public int getwinsize()
	{
		return depad(mpack.substring(112,128));
	}
	public int findflag()
	{
		return depad(mpack.substring(104,112));
	}

	public int finddport()
	{
		return depad(mpack.substring(16,32));
	}

	public int findseqno()
	{
		return depad(mpack.substring(32,64));
	}

	public int findsport()
	{
		return depad(mpack.substring(0,16));
	}

	public int findackno()
	{
		return depad(mpack.substring(64,96));
	}

	public int size()
	{
	
		return mpack.length();
	}

	public String finddata()
	{
		return mpack;
	}
	
	public void showStrings(String s)
	{
		System.out.println(s+ ((Integer)findsport()).toString()+" "+ ((Integer)finddport()).toString() +" "+ ((Integer)findseqno()).toString() +" "+ ((Integer)findackno()).toString() +" " + ((Integer)findflag()).toString() +" "+ ((Integer)getwinsize()).toString());
	}
}

class glpack
{
	packet p;
	boolean[] mark;
	boolean sent;
	long timestamp;

	public long getts()
	{
		return timestamp;
	}
	public glpack()
	{
		mark = new boolean[3];
		p = null;
		Arrays.fill(mark,false);
		sent = false;
		timestamp = Long.MAX_VALUE;
	}

	public void set(packet z)
	{
		p=z;
		timestamp = System.currentTimeMillis();
	}

	public void marks(int i)
	{
		mark[i] = true;
	}

	public packet getpacket()
	{
		return p;
	}

	public boolean isunmark(int x)
	{
		return mark[x];
	}

	public int size()
	{
		return p.size();
	}

	public void sent()
	{
		sent = true;
	}

	public void unsent()
	{
		sent = false;
	}

	public boolean issent()
	{
		return sent;
	}

	public String getString()
	{
		return p.finddata();
	}
}

class myBuffers
{
	Map rBuffer;
	Map sBuffer;

	public myBuffers()
	{
		rBuffer = new HashMap();
		sBuffer = new HashMap();
	}
	
	public String showBuffers()
	{
		try
		{
			int[] seq = null;
			Iterator keys = null;
			String output = new String("");
			synchronized(sBuffer)
			{
				seq = new int[sBuffer.size()];
				keys = sBuffer.keySet().iterator();
			}
			int nl =0;
			int i = 0;
			while(keys.hasNext())
			{
				seq[i++] = ((Integer)keys.next()).intValue();
			}

			output += "SBuffer:\n";
			output += "\tSport\tDport\tseq\tack\tflags\twindow\tmarks\tsent\ttimestamp\tlength\n";
			Arrays.sort(seq);
			for(int ii:seq)
			{
				glpack temp = (glpack)sBuffer.get(ii);
				packet p = null;
				try
				{
					p = temp.getpacket();
				}
				catch(Exception e)
				{
					System.out.println(ii);
				}
				output+= "\t"+p.findsport()+"\t"+p.finddport()+"\t"+p.findseqno()+"\t"+p.findackno()+"\t"+p.findflag()+"\t"+p.getwinsize()+"\t";
				for(int k=0;k<3;k++)
				{
					if(temp.isunmark(k))
						output+="1";
					else
						output+="0";
				}
				output+="\t"+((temp.issent())?"1":"0")+"\t"+temp.getts()+"\t"+p.finddata().length()+"\n";
			}

			nl+=2+seq.length;
			synchronized(rBuffer)
			{
				seq = new int[rBuffer.size()];
				keys = rBuffer.keySet().iterator();
			}
			
			i = 0;
			while(keys.hasNext())
			{
				seq[i++] = ((Integer)keys.next()).intValue();
			}

			output+= "RBuffer:\n";
			output+= "\tSport\tDport\tseq\tack\tflags\twindow\tmarks\tsent\ttimestamp\tlength\n";
			Arrays.sort(seq);
			for(int ii:seq)
			{
				glpack temp = (glpack)rBuffer.get(ii);
				packet p = temp.getpacket();
				output+= "\t"+p.findsport()+"\t"+p.finddport()+"\t"+p.findseqno()+"\t"+p.findackno()+"\t"+p.findflag()+"\t"+p.getwinsize()+"\t";
				for(int k=0;k<3;k++)
				{
					if(temp.isunmark(k))
						output+="1";
					else
						output+="0";
				}
				output+="\t"+((temp.issent())?"1":"0")+"\t"+temp.getts()+"\t"+p.finddata().length()+"\n";
			}
			nl+=4+seq.length;
			for(;nl<37;nl++)
				output+="\n";
			if(nl<37)
				output+="Wipe\n";
	// 		for(nl=0;nl<10;nl++)
	// 			output+="\n";
			return output;
		}
		catch(Exception e)
		{}
		return new String("");
	}
	
	public synchronized void writerBuff(packet p)
	{
		glpack neu = new glpack();
		glpack old = (glpack)rBuffer.get(p.findseqno());
		if(old==null)
		{
			neu.set(p);
			//System.out.println("Mywin" + pMaker.mywin + " psize "+p.size());
			pMaker.mywin = ((pMaker.mywin - p.size())>0)?(pMaker.mywin - p.size()):0;
			//System.out.println("Hippy "+ p.size());
		}
		else
			neu.set(p);
		synchronized(rBuffer)
		{
			rBuffer.remove(p.findseqno());
			rBuffer.put(p.findseqno(),neu);
		}
	}

	public synchronized void writesBuff(packet p)
	{
		if(p!=null)
		{
			glpack neu = new glpack();
			neu.set(p);
			synchronized(sBuffer)
			{
				sBuffer.put(p.findseqno(),neu);
			}
		}
	}

	public synchronized packet fetchrBuff(int x)
	{
		int[] seq =null;
		if(rBuffer.size()==0)
			return null;
		Iterator keys = null;
		synchronized(rBuffer)
		{
			keys= rBuffer.keySet().iterator();
			seq = new int[rBuffer.size()];
		}
		int i=0;
		while(keys.hasNext())
		{
			////System.out.println("Sequence" + i + "is" + xx + " seq size is " + seq.length);
			seq[i++] = ((Integer)keys.next()).intValue();
			////System.out.println("Reprinting" + seq[i-1]);
		}
		Arrays.sort(seq);
		i=seq[seq.length-1];
		glpack ans = (glpack)rBuffer.get(i);
		if(ans.isunmark(x))
			return null;
		for(int pp:seq)
		{
			int temp = pp;
			if(temp<=i)
			{
				glpack tempgl = (glpack)rBuffer.get(temp);
				tempgl.marks(x);
				synchronized(rBuffer)
				{
					rBuffer.remove(temp);
					rBuffer.put(temp,tempgl);
				}
			}
		}
		return ans.getpacket();
	}

	public synchronized packet fetchrBuffmod(int x)
	{
		int[] seq =null;
		if(rBuffer.size()==0)
			return null;
		Iterator keys = null;
		synchronized(rBuffer)
		{
			keys= rBuffer.keySet().iterator();
			seq = new int[rBuffer.size()];
		}
		int i=0;
		while(keys.hasNext())
		{
			seq[i++] = ((Integer)keys.next());
			////System.out.println("Sequence" + i + "is" + xx + " seq size is " + seq.length);
			////System.out.println("Reprinting" + seq[i-1]);
		}
		Arrays.sort(seq);
		for(int pp:seq)
		{
			glpack tempgl = (glpack)rBuffer.get(pp);
			if(!(tempgl.isunmark(x)))
			{
				tempgl.marks(x);
				synchronized(rBuffer)
				{
					rBuffer.remove(pp);
					rBuffer.put(pp,tempgl);
				}
				return tempgl.getpacket();
			}
		}
		return null;
	}
	
	public synchronized packet fetchrBuffseq(int x)
	{
		//System.out.print("");		//Donot remove this
		if(rBuffer.size()==0)
			return null;
		int[] seq =null;
		int i=0;
		Iterator keys = null;
		synchronized(rBuffer)
		{
			keys= rBuffer.keySet().iterator();
			seq = new int[rBuffer.size()];
		}
		while(keys.hasNext())
		{
			seq[i++] = ((Integer)keys.next());
			////System.out.println("Sequence" + i + "is" + xx + " seq size is " + seq.length);
			////System.out.println("Reprinting" + seq[i-1]);
		}
		glpack ans = null;
		Arrays.sort(seq);
		for(int y : seq)
		{
			if((y==pMaker.nextexp)||(pMaker.nextexp==0))
			{
				
				ans = (glpack)rBuffer.get(y);
				ans.marks(x);
				synchronized(rBuffer)
				{
					rBuffer.remove(y);
					rBuffer.put(y,ans);
				}
				if(pMaker.nextexp==0)
					pMaker.nextexp = y;	
				pMaker.nextexp++;
			}
		}
		//System.out.println("Next expecting "+ pMaker.nextexp);
		if(ans!=null)
		{
			return ans.getpacket();
		}
		return null;
	}

	public synchronized int fetchunmarksBuff(packet p, int x)
	{
		if(p==null)
			return 0;
		int sizes = 0;
		int numbr = 0;
		int[] seq =null;
		int i=0;
		Iterator keys = null;
		synchronized(sBuffer)
		{
			keys= sBuffer.keySet().iterator();
			seq = new int[sBuffer.size()];
		}
		while(keys.hasNext())
		{
			seq[i++] = ((Integer)keys.next());
			////System.out.println("Sequence" + i + "is" + xx + " seq size is " + seq.length);
			////System.out.println("Reprinting" + seq[i-1]);
		}
		Arrays.sort(seq);
		for(int pp:seq)
		{
			int temp = pp;
			if(temp<p.findackno())
			{
				glpack tempack = (glpack)sBuffer.get(temp);
				if(!tempack.isunmark(x))
				{
					tempack.marks(x);
					sizes +=tempack.size();
					numbr ++;
					synchronized(sBuffer)
					{
						sBuffer.remove(temp);
						sBuffer.put(temp,tempack);
					}
				}
			}
		}
		return (x==1)?sizes:numbr;
	}

	public synchronized boolean tosBuff()
	{
		int i=0;
		int[] seq = null;
		Iterator keys = null;
		boolean flag = false;
		synchronized(sBuffer)
		{
			seq = new int[sBuffer.size()];
			keys = sBuffer.keySet().iterator();
		}
		while(keys.hasNext())
		{
			seq[i++] = ((Integer)keys.next());
					
		}
		Arrays.sort(seq);

		for(int ii:seq)
		{
			glpack temp = (glpack)sBuffer.get(ii);
			if(!temp.isunmark(2))
			{
				if((System.currentTimeMillis()-temp.getts())>((long)10000))
				{
					temp.unsent();
					flag = true;
					/*synchronized(sBuffer)
					{
						sBuffer.remove(ii);
						sBuffer.put(ii,temp);
					}*/
				}
			}
			
		}
		return flag;
	}

	public synchronized String server()
	{
		int i=0;
		int[] keyvals =null;
		Iterator keys = null;
		synchronized(sBuffer)
		{
			keyvals = new int[sBuffer.size()];
			keys = sBuffer.keySet().iterator();
		}
		while(keys.hasNext())
		{
			keyvals[i++] = ((Integer)keys.next());
					
		}
		Arrays.sort(keyvals);
		
		for(int x:keyvals)
		{
			glpack temp = (glpack)sBuffer.get(x);
			if(!temp.issent())
			{
				temp.sent();
				synchronized(sBuffer)
				{
					sBuffer.remove(x);
					sBuffer.put(x,temp);
				}
				return temp.getString();
			}
		}
		return null;
	}

	public synchronized void cleansBuff()
	{
		int i=0;
		int[] seq = null;
		Iterator keys = null;
		synchronized(sBuffer)
		{
			seq = new int[sBuffer.size()];
			keys = sBuffer.keySet().iterator();
		}
		while(keys.hasNext())
		{
			seq[i++] = ((Integer)keys.next());
					
		}
		Arrays.sort(seq);

		for(int x:seq)
		{
			glpack temp = (glpack)sBuffer.get(x);
			if(temp.isunmark(1)&&temp.isunmark(2))
			{
				synchronized(sBuffer)
				{
					sBuffer.remove(x);
				}
			}
		}
	}

	public synchronized void cleanrBuff()
	{
		int i=0;
		int[] seq = null;
		Iterator keys = null;
		synchronized(sBuffer)
		{
			seq = new int[rBuffer.size()];
			keys = rBuffer.keySet().iterator();
		}
		while(keys.hasNext())
		{
			seq[i++] = ((Integer)keys.next());
					
		}

		Arrays.sort(seq);
		for(int x:seq)
		{
			glpack temp = (glpack)rBuffer.get(x);
			if(temp.isunmark(0)&&temp.isunmark(1)&&temp.isunmark(2))
			{
				synchronized(sBuffer)
				{
					int freed = temp.getpacket().size();
					rBuffer.remove(x);
					pMaker.mywin+=freed;
				}
			}
		}
	}
}

class server extends Thread
{
	myBuffers mBuffer;

	public server(myBuffers getit)
	{
		mBuffer = getit;
	}
	
	public void run()
	{
			DatagramSocket sSocket =null;
			try
			{
				sSocket = new DatagramSocket(4994);
			}
			catch(Exception e)
			{
				//System.out.println("Cant open socket");
			}
			byte[] rData = new byte[1500];
			packet mpack = null;
			DatagramPacket rPacket = null;
			while(true)
			{
				//Arrays.fill(rData,null);
				try
				{
					rPacket = new DatagramPacket(rData,rData.length);
					sSocket.receive(rPacket); 
					controller.IP = (rPacket.getAddress()).getHostAddress();
				}
				catch(Exception e)
				{
					//System.out.println("Fuxxing errors");
				}
				controller.condition = true;
				byte[] answer = new byte[rPacket.getLength()];
				for(int i=0;i<answer.length;i++)
					answer[i]=rData[i];
				mpack = new packet(new String(answer));
				//System.out.println("Recieved packet of type " + mpack.findflag());
				//mpack.showString();
				////System.out.println("Writing to Buffer");
				mBuffer.writerBuff(mpack);
				////System.out.println("Written to Buffer");
			}
		
	}
}

class pMaker extends Thread
{
	int winsize;
	int mode;
	static int mywin;
	static int nextexp;
	static int spacksize;
	static int conjested;
	int seqNumber;
	int ano;
	myBuffers mBuffer;
	boolean sar;
	int offset;
	boolean closing_seq = false;
	
	public pMaker(myBuffers b)
	{
		offset = 0;
		mBuffer  = b;
		mode =1;
		winsize = Integer.MIN_VALUE;
		mywin = 20000;
		nextexp = 0;
		Random generator = new Random();
		seqNumber = Math.abs(generator.nextInt()%2000);
		spacksize = 0;
		ano = 0;
		sar = true;
	}

	pMaker(int modes, myBuffers b)
	{
		offset = 0;
		winsize = Integer.MAX_VALUE;
		mywin = 20000;
		mode = 0;
		nextexp = 0;
		Random generator = new Random();
		seqNumber = Math.abs(generator.nextInt()%2000);
		spacksize = 0;
		ano = 0;
		mBuffer  = b;
		sar = false;
	}

	packet makepacket(packet s, int value) throws IOException
	{
		//look at the packet (use the packet accessing methods from class packet)
		//create a new packet based on that packet
		//basically lots of if-else or use a switch
		//i need to start my own seq number too..
		//don't miss this... set the flag when closing conection starts
		BufferedReader br;
		char[] tempBuffer;
		String data;
		packet gpack = new packet();
		
		if(value >= 192)
		{
			//s.showString("Source: ");
			switch (s.findflag())
			{
			case 0:
					//received data, send ACK
				data = "";
				//System.out.println("received data, return ACK");
				ano = s.findseqno();
				gpack.cPacket(s.finddport(), s.findsport(), s.findackno(), ++ano, 16, mywin, data);
				seqNumber = s.findackno()+1; //changed all ack, to accomodate the multiple ACK issue
				break;
			case 1:
				//received FIN, return ACK
				data = "";
				//System.out.println("received FIN, return ACK");
				closing_seq = true; // probably correct
				ano = s.findseqno();
				gpack.cPacket(s.finddport(), s.findsport(), (s.findackno()+1), ++ano, 16, mywin, data);
				seqNumber = s.findackno()+1;
				break;
			case 2:
				//received SYN, return SYN+ACK
				//System.out.println("received SYN, return SYN+ACK");
				data = "";
				ano = s.findseqno();
				gpack.cPacket(s.finddport(), s.findsport(), seqNumber++, ++ano, 18, mywin, data);
				break;
			case 18:
				//received SYN+ACK, return ACK, done by client
				if(!sar)
				{
					data = "handshake";
					ano = s.findseqno();
					gpack.cPacket(s.finddport(), s.findsport(), seqNumber++, ++ano, 16, mywin, data);
					//System.out.println("MADE");
					seqNumber = s.findackno()+1;
					sar = true;
					//System.out.println("received SYN+ACK, return ACK of type" + gpack.findflag());
				}
				else
				{
					br = new BufferedReader(new FileReader("send.txt"));
					tempBuffer = new char[value-192];
					try
					{
						br.read(tempBuffer, offset, value-192); //read byte by byte
					}
					catch(IOException e)
					{
						//System.out.println("IOException, It's normal as file is over");
					}
					offset = offset + value-192; //update the start pointer, is it the correct 	place, or put it in try block?
						
					data = new String(tempBuffer); // data from file
						////System.out.println("received ACK, send next packet");
					if(ano<s.findseqno())
						ano=s.findseqno();
					gpack.cPacket(s.finddport(), s.findsport(), seqNumber++, ++ano, 0, mywin, data);
				}
				break;
			case 16:
				//client side received ACK, prepare next packet!!, if it is not closing sequence and not handshake ACK
				//server side received ACK, and it's handshake, do nothing
				if(!closing_seq || !(s.finddata().equalsIgnoreCase("handshake")))
				{
						//cPacket creates only the header?
					//System.out.println("here");
					br = new BufferedReader(new FileReader("send.txt"));
					tempBuffer = new char[value-192];
// 					try
// 					{
// 						br.read(tempBuffer, offset, value-192); //read byte by byte
// 					}
// 					catch(IOException e)
// 					{
// 						System.out.println("IOException, It's normal as file is over");
// 					}
					Arrays.fill(tempBuffer,'A');
					//System.out.println("here2");
					offset = offset + value-192; //update the start pointer, is it the correct 	place, or put it in try block?
						
					data = new String(tempBuffer); // data from file
					//System.out.println("received ACK, send next packet");
					if(ano<s.findseqno())
						ano=s.findseqno();
					gpack.cPacket(s.finddport(), s.findsport(), seqNumber++, ++ano, 0, mywin, data);
//						received SYN+ACK, return ACK
				}
				else
					System.out.println("looks like closing sequence, now what?");
					//else what?
				break;
			case 17:
				//received FIN+ACK, return ACK
				data = "";
				//System.out.println("received FIN+ACK, return ACK");
				ano = s.findseqno();
				gpack.cPacket(s.finddport(), s.findsport(), (s.findackno()+1), ++ano, 16, mywin, data);
				seqNumber = s.findackno()+1;
				break;
			/*case 18:
				//received SYN+ACK, return ACK, done by client
				data = "handshake";
				ano = s.findseqno();
				//System.out.println("received SYN+ACK, return ACK");
				s.cPacket(s.finddport(), s.findsport(), (s.findackno()+1), ++ano, 16, mywin, data);
				seqNumber = s.findackno()+1;
				break;*/
			}
			//gpack.showString("");
			return gpack;
		}
		else
			return null;
	}

	public int min(int a , int b)
	{
		if(a>b)
			return b;
		return a;
	}

	public void run()
	{
		packet last = null;
		switch(mode)
		{
		case 0:
			packet mpack = null;
			
			while(true)
			{
				packet s = null;
				//System.out.println("Sending syn ");
				mpack = new packet();
				mpack.cPacket(1337,4994,seqNumber++,0,2,mywin,"");
				//mpack.showStrings("");
				mBuffer.writesBuff(mpack);
				while(true)
				{
					s=null;
					while(s==null)
					{
						//System.out.println("Waiting");
						try
						{
							Thread.sleep(100);
						}
						catch(Exception e){}
						s =mBuffer.fetchrBuff(0);
					}
					////System.out.println("Wait Over" + s);
					if(last == null)
						last = s;
					if(s.findseqno()<last.findseqno())
						continue;
					winsize = s.getwinsize();
					//int xxx=5;
					int nbr = 0;
					while(true)
					{
						if(nbr>=conjested)
						{
							//System.out.println("Conjested");
							try
							{
								Thread.sleep(500);
							}
							catch(Exception e){}
							break;
						}
						int value = min(winsize - spacksize,1000);
						
						//xxx++;
						packet p = null;
						try
						{
							////System.out.println()
							//System.out.print("Attempting to create on ");
							//s.showStrings("");
							p = makepacket(s,value);
							////System.out.println("made syn/data "+xxx);
						}
						catch(Exception e)
						{
							//System.out.println(e.getMessage());
						}
						if(p!=null)
						{
							spacksize+=p.size();
							mBuffer.writesBuff(p);
							nbr++;
						}
						else
						{
							//System.out.println("Failed creating " + value);
							s=null;
							break;
						}
					}
				}
			}
		case 1:
			while(true)
			{
				packet s = null;
				while(s==null)
				{
					try
					{
						Thread.sleep(100);
					}
					catch(Exception e){}
					//System.out.println("Awaiting");
					s = mBuffer.fetchrBuffseq(0);
				}
// 				if(last!=null)
// 					if(s.findseqno()<last.findseqno())
// 						s=last;
// 				last = s;
				winsize = s.getwinsize();
				int value = min (winsize - spacksize, 1000);
				packet p = null;
				try
				{
					p = makepacket(s,value);
				}
				catch(Exception e)
				{
					////System.out.println("blablablala");
				}
				mBuffer.writesBuff(p);
				//System.out.println("written");
				spacksize+=value;
			}
		}
	}

	
}

class preciever extends Thread
{
	int p;
	myBuffers mBuffer;
	
	public preciever(myBuffers b)
	{
		mBuffer = b;
	}

	public void run()
	{
		packet z = null;
		while(true)
		{
			p=0;
			z=null;
			while(z==null)
			{
				z = mBuffer.fetchrBuffmod(1);
			}
			p=mBuffer.fetchunmarksBuff(z,1);
			pMaker.spacksize -= p;
		}
	}
}

class concontrol extends Thread
{
	myBuffers mBuffer;

	public concontrol(myBuffers b)
	{
		pMaker.conjested = 2;
		mBuffer = b;
	}
	
	public void run()
	{
		while(true)
		{
			try
			{
				Thread.sleep(1000);
			}
			catch(Exception e){}
			
			packet p = mBuffer.fetchrBuffmod(2);
			if(p!=null)
			{
				int n = mBuffer.fetchunmarksBuff(p,2);
				pMaker.conjested = pMaker.conjested + 2*n;
			}
			else
			{
				if(mBuffer.tosBuff())
					pMaker.conjested=(pMaker.conjested/2)+1;
			}
		}
	}
}

class cleaner extends Thread
{
	myBuffers mBuffer;
	String output;

	public cleaner(myBuffers b)
	{
		mBuffer = b;
		output = new String("");
	}

	public void run()
	{
		while(true)
		{
// 			try
// 			{
// 				Thread.sleep(100);
// 			}
// 			catch(Exception e)
// 			{
// 			}
			String s = mBuffer.showBuffers();
			if(!(s.equalsIgnoreCase(output)))
			{
				System.out.println(s);
				output =s;
			}
			mBuffer.cleansBuff();
			mBuffer.cleanrBuff();
		}
	}
}

class client extends Thread
{
	myBuffers mBuffer;

	public client(myBuffers b)
	{
		mBuffer = b;
	}
	public void run()
	{
		while(controller.IP.length()==0)
		{
			try
			{
				Thread.sleep(100);
			}
			catch(Exception e){}
		}

		////System.out.println(controller.IP);
		DatagramSocket socket = null;
		DatagramPacket packet = null;
		try
		{
			socket = new DatagramSocket();
		}
		catch(Exception e)
		{
			////System.out.println("Abhishek");
		}
		byte[] tosend = null;
		String s = null;
		////System.out.println("Scanning for sending");
		while(true)
		{
			tosend =null;
			while(tosend==null)
			{
// 				try
// 				{
// 					Thread.sleep(500);
// 				}
// 				catch(Exception e)
// 				{
// 				}
				s= mBuffer.server();
				if(s!=null)
					tosend = s.getBytes();
			}
			try
			{
				////System.out.println("Tosend length " + tosend.length);
				packet = new DatagramPacket(tosend,tosend.length,InetAddress.getByName(controller.IP),4994);
				////System.out.println(controller.IP);
				//System.out.println("Sending packet of type " +(new packet(s)).findflag());
				socket.send(packet);
				////System.out.println("sent");
			}
			catch(Exception e)
			{
				//System.out.println(tosend);
			}
		}
	}
}

class showBuffer extends Thread
{
	myBuffers mBuffer = new myBuffers();
	String output;

	public showBuffer(myBuffers b)
	{
		mBuffer = b;
		output = new String("");
	}

	public void run()
	{
		while(true)
		{
			String s = mBuffer.showBuffers();
			if(s.equalsIgnoreCase(output))
			{
				try
				{
					Thread.sleep(100);
				}
				catch(Exception e)
				{}
			}
			else
			{
				System.out.println(s);
				output =s;
			}
		}
	}
}

public class controller
{
	public static String IP;
	public static boolean condition;
	public static void main(String[] args)
	{
		IP = new String("");
		condition = false;
		myBuffers bfr = new myBuffers();
		pMaker mypMaker;
		if(args.length>0)
		{
			IP = args[0];
			mypMaker= new pMaker(1,bfr);
		}
		else
			mypMaker= new pMaker(bfr);
		server myserver = new server(bfr);
		client myclient = new client(bfr);
		cleaner mycleaner = new cleaner(bfr);
		preciever mypreciever = new preciever(bfr);
		concontrol myconcontrol = new concontrol(bfr);
 		//showBuffer displays = new showBuffer(bfr);
		//displays.start();
		mypMaker.start();
		myserver.start();
		myclient.start();
		mycleaner.start();
		mypreciever.start();
		myconcontrol.start();
	}
}