/**
 * @Communicator.java
 * 
 * Sköter kommunikationen för Drawapplikationen
 * Skickar och tar emot via UDP.
 * Ändrad version av communicator från ip4.2.1
 * Så den kan användas för worm spelet.
 * Skickar och tar Emot Direction instanser istället för Point.
 *
 * @Author: Karl-Adam karlsson
 * 
 * @version 1.0 06/10/17
 *
 *
 */

 import java.util.LinkedList;
 import java.io.*;
 import java.net.*;
import java.awt.*;
import java.util.*;
 
 public class Communicator implements Runnable{
 	 private int port;
 	 private int remotePort;
 	 InetAddress remAddress;
 	 private Paper myPaper;
     public DatagramSocket sendSock = null;
     public DatagramSocket getSock = null;
     private InetAddress server = null;
     public Gamehandler myGame;
     private Thread gameThread;
     public boolean run;
    // private Draw someDraw;
 	 
 	 /*
 	  * Konstruktor, fixar iordning sockets och allt som behövs för att UDP:a
 	  * @param String host, the Name of the host.
 	  * @param int aPort, The port on which to communicate
 	  * @param Draw aDrawApp An instance of the Draw application.
 	  * @param int starter, Will be one if you initiated the game, 2 if not.
 	  *
 	  */
 	 public Communicator(int aPort, Paper apaper, String remHost, int remPort, int starter, Thread someThread,Draw aDraw){
 	 	//someDraw = null;
 	 	run = true;
 	 	remotePort = remPort;
 	 	port = aPort;
 	 	myPaper = apaper;
 	 	myGame = new Gamehandler(starter,myPaper,someThread, aDraw,this);
 	 	gameThread = new Thread(myGame);
 	 	
 	 	
 	 	// Skapar sockets, en för send och end för receive.
 	 	try {
      		remAddress = InetAddress.getByName(remHost);
      		sendSock = new DatagramSocket();
    	}
    		catch (IOException exE) {
     		//System.err.println(exE);
      		//System.exit(1);
      		System.out.println("EXCEPTION CREATING GAME CONNECTION. IF YOU ARE ALREADY RUNNING A GAME,");
    		System.out.println("TRY LATER, YOU MAY ONLY PLAY ONE GAME AT A TIME.");
    	}
    	////
    	try {
      		getSock = new DatagramSocket(aPort);
      		getSock.setSoTimeout(50);
      		gameThread.start();
    	}
    		catch (IOException ex) {
     		//System.err.println(ex);
      		//System.exit(1);
      		System.out.println("EXCEPTION CREATING GAME CONNECTION. IF YOU ARE ALREADY RUNNING A GAME,");
    		System.out.println("TRY LATER, YOU MAY ONLY PLAY ONE GAME AT A TIME.");
    	}
    
 	 }//End of Constructor
 	 
 	 /*
 	  * Skapar ett DataGramPacket av en Point p
 	  * och skickar iväg det hela.
 	  * @param Point p pointen som skall skickas
 	  */
 	 public void packAndsend(Direction p){
 	 	ByteArrayOutputStream byteStream = new ByteArrayOutputStream(1024);
 	 	//System.out.println("SENDING");
 	 	
 	 	try {
      		ObjectOutputStream outS = new ObjectOutputStream(new BufferedOutputStream(byteStream));
        	outS.flush();
      		outS.writeObject(p);
      		outS.flush();
        	//Fixar byte array
       		byte[] sendBuffer = byteStream.toByteArray();
        	DatagramPacket aPacket = new DatagramPacket(sendBuffer, sendBuffer.length, remAddress, remotePort);  
        	sendSock.send(aPacket);
      		
    	}
    	catch (IOException ioex) {
     		System.err.println(ioex);
    	}
 	 }
 	 
 	 // japp, stänger helt enkelt.
 	 public void closeSockets(){
 	 	sendSock.close();
 	 	getSock.close();
 	 	sendSock.disconnect();
 	 	getSock.disconnect();
 	 }
 	 
 	// sets run
 	public void setRun(boolean b/*, Draw aDraw*/){
 		run = b;
 		//someDraw = aDraw;
 	}
 	//getter
 	public boolean getRun(){
 		return this.run;
 	}
 	
 	
 	
 	/*
 	 * Run,
 	 * tar emot ett DataGramPacket via getSock , gör om
 	 * till Direction och ändrar fiendens direction
 	 * Sover 50ms varje loop.
 	 *
 	 * När loopen e slut stängs sockets.
 	 * Sätter också run för mygame till false, så den tråden lugnar ned sig.
 	 */
 public void run(){
 	DatagramPacket incoming;
 	//gameThread.run();
 	
    while ( this.getRun()==true ) {
    	byte[] buffer = new byte[1024]; 
    	incoming = new DatagramPacket(buffer, buffer.length);
    	
    	
      try {
        incoming.setLength(buffer.length);
        
        
        if(!getSock.isClosed() ){
        	
	        getSock.receive(incoming);
            int byteCount = incoming.getLength();
            
            }
      		ByteArrayInputStream byteStr = new ByteArrayInputStream(buffer);
        ObjectInputStream is = new ObjectInputStream(new BufferedInputStream(byteStr));
        try{
        	Object o = is.readObject();
        	 is.close();
        	 
        	myGame.setEnemyDir((Direction)o);
        }catch(ClassNotFoundException cE){System.err.println(cE);}
       
      }catch (SocketTimeoutException ex) {
        //KOMMER ATT HÄNDA DÅ OCH DÅ.
        //SÅ INGEN IDE ATT SKRIVA UT NGT
        // DET SKA FAKTISKT HÄNDA.
      }
      catch (IOException ex) {
        System.err.println("Exception:  " + ex);
      				ex.printStackTrace();
      }
      try{
	      Thread.sleep(100);
	      }catch(InterruptedException iEX){System.err.println(iEX);}
    }
    
    //SLUT PÅ WHILE RUN
    //System.out.println("STÄNGER OSS NU!!!!!!!!!!!!");
    myGame.run = false;
    closeSockets();
 	//someDraw.dispose();
 	//System.out.println("END OF RUN");

   }
}