/****** EJECUTABLE *************/

 

import java.io.*;

int id ;
DatagramPacket pEnvio;
DatagramPacket pRecibo;
MulticastSocket ms;
byte[] aEnvio;
byte[] aRecibo;
ContadorClicks miContador;
InetAddress ip;
int puerto ;

void setup(){
 id = 0;
 puerto  =3000; 
 if(id == 0){
   miContador  =new ContadorClicks();
   miContador.setIdTurno(id);
 }
 try{
     ip = InetAddress.getByName("239.1.1.1");
     ms = new MulticastSocket(puerto);
     ms.setSoTimeout(30);
     ms.joinGroup(ip); 
 }
 catch(UnknownHostException e){
   println(e);
 }
 catch(SocketException e){
   println(e);
 }
 catch(IOException e){
   println(e);
 } 
}

void draw(){
 background(0);
 //me pregunto si han pasado 10 segundos
 if (( frameCount % 300 )==0){
    println("enviando...");
    //enviar
    enviar();
 }
    
 //recibir  
  recibir();
  
  if (miContador != null)
    //println(miContador.getContador());
    text(miContador.getContador(), 10, 10);
  
}

void recibir(){
  ContadorClicks temp_Contador;
  
 try{
    aRecibo = new byte[4000];
    pRecibo  =new DatagramPacket(aRecibo, aRecibo.length);
    ms.receive(pRecibo);
    
    ByteArrayInputStream bis = new ByteArrayInputStream(aRecibo);
    ObjectInputStream ois = new ObjectInputStream(bis);
    temp_Contador = (ContadorClicks) ois.readObject();
    if (temp_Contador != null){
       if (temp_Contador.getIdTurno() == id){
          miContador = temp_Contador ;
       }
    }
 }
  catch (ClassNotFoundException e){
   // println(e);
  }  
  catch (IOException e){
 //   println(e);
  } 
}

void enviar(){
  
  try{
    if (miContador != null){
      miContador.setIdTurno(id+1);
      //traductor: pasa del objeto al arreglo de bytes
      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      //flujo donde debo escribir el objeto
      ObjectOutputStream oos = new ObjectOutputStream(bos);
      oos.writeObject(miContador);
      aEnvio = bos.toByteArray();
      
      pEnvio = new DatagramPacket(aEnvio, aEnvio.length, ip, puerto);
      ms.send(pEnvio);
      miContador=null;
    }
  }
  catch (IOException e){
 //   println(e);
  }
}

void mouseClicked(){
  if (miContador != null){
    if(miContador.getIdTurno() == id){
      miContador.setContador();
    }
   else{
    println("No es su turno");
   } 
 }
 else{
    println("No es su turno");
 } 
}

/*********************** CLASE, GUARDAR COMO .java ***************/

import java.io.*;

public class ContadorClicks implements Serializable{
  int idTurno;
  int contador;  
  
  public ContadorClicks(){
     idTurno  = -1;
     contador = 0; 
  }
  
  public int getIdTurno(){
   return this.idTurno; 
  }
  
  public void setIdTurno(int idTurno){
    this.idTurno = idTurno;
  }
  
  public int getContador(){
   return this.contador; 
  }
  
  public void setContador(){
    this.contador ++;
  }
    
}

/*
Utilizando flujos enviar y recibir un valor entero

Para enviar:

1. Crear el traductor para envio de bytes a traves de la red
2. Crear la conexion entre la fuente y el destino--> 
  inicializar flujo de datos de salida para envio del entero, utilizando el traductor
3. Escribir el dato en el flujo de salida.
4. Crear el arreglo de bytes y utilizar el traductor para pasar el valor entero a bytes
5.inicializar el datagrama con el arreglo, tamanho, ip, y puerto
6.enviar el datagrama con el multicast socket.

Para Recibir:

ejercicio en clase 10 minutos

*/

MulticastSocket ms;
DatagramPacket enviar;
DatagramPacket recibir;
InetAddress ip;

DataOutputStream dos;
DataInputStream dis;

int valorEnviar=101;
int valorRecibir=0;

void setup() {
  try {
    ip=InetAddress.getByName("239.0.0.1");
    ms=new MulticastSocket(5000);
    ms.joinGroup(ip);
    ms.setSoTimeout(500);
  }
  catch(UnknownHostException ex) {
    println(ex);
  }
  catch(IOException ex) {
  }
}

void draw() {
  enviar();
  recibir();
}

void enviar() {
  try {
    ByteArrayOutputStream bos =
        new ByteArrayOutputStream();
    dos = new DataOutputStream(bos);
    dos.writeInt(valorEnviar);
    dos.flush();
    byte[] datos = bos.toByteArray();
    enviar = new DatagramPacket(datos, 
                datos.length, ip, 5000);
    ms.send(enviar);
  }
  catch(IOException ex) {
    println("error en envio " + ex);
  }
}

void recibir(){
 try{
   byte datosRecibe[] = new byte[5000];
   recibir=new DatagramPacket(datosRecibe, datosRecibe.length);
   ms.receive(recibir);
   
   ByteArrayInputStream bis = new ByteArrayInputStream(datosRecibe);
   dis = new DataInputStream(bis);
   valorRecibir =dis.readInt();
   println(valorRecibir);
  
 }
catch(IOException ex){
 println("error en recibo " + ex);
} 
}

/**** CLIENTE ****/

DatagramPacket dpEnviar;
DatagramPacket dpRecibe;
InetAddress ipServidor;
DatagramSocket ds;
byte[] benviar;
byte[] brecibo;
int puerto;

float posX=0;
float posY;
String lugar="c";
String posiciones="";

void setup(){
 size(350,200); 
 posY=height/2; 
 posiciones = posX +"_" + posY + "_" + lugar;
 try{
    ipServidor = InetAddress.getLocalHost();
    puerto=4000;
    ds = new DatagramSocket();

 }
  catch(UnknownHostException ex){
   println("Cliente: "+ ex);
 } 
 catch(SocketException ex){
    println("Cliente: "+ ex);
 }
}

void draw(){
  background(5);
  smooth();
  
 
  try{
    benviar=posiciones.getBytes();
    dpEnviar =new DatagramPacket(benviar, benviar.length, ipServidor, puerto);
    ds.send(dpEnviar);
  }
  catch(IOException ex){
   println( "Cliente: "+ ex);
  }
    lugar=(posiciones.split("_"))[2];
    if(lugar.equals("c"))
      ellipse(posX,posY, 70,70);
  
}

void keyPressed(){

  if ((key == CODED) ) {
    if (keyCode == LEFT) {
      posX-=5;
    } else if (keyCode == RIGHT) {
      posX+=5;
    }

    if (posX >= width)
      lugar="s";
    else
      lugar="c";
  }     
  posiciones = posX +"_" + posY + "_" + lugar;
   
}

 

 

/***** SERVIDOR ****/

DatagramPacket dpEnviar;
DatagramPacket dpRecibe;
DatagramSocket ds;
byte[] benviar;
byte[] brecibo=new byte[250];
int puerto;

float posX=0;
float posY;
String lugar="";
InetAddress ipCliente;

String posiciones;

void setup(){
 size(350,200); 
 posY=height/2; 
 posiciones="";
 try{
    puerto=4000;
    ds = new DatagramSocket(puerto);
    ds.setSoTimeout(50);
 }
 catch(SocketException ex){
    println("Servidor: "+ ex);
 }
}

void draw(){
  background(5);
  smooth();
  try{
        dpRecibe=new DatagramPacket(brecibo,brecibo.length);
        ds.receive(dpRecibe);
        posiciones =new String(brecibo);    
      }
      catch(IOException ex){
       println("Servidor: "+ ex); 
      }
  if ((trim((posiciones.split("_"))[2]).equals("s"))){
    lugar=trim((posiciones.split("_"))[2]);
    posX =Float.parseFloat((posiciones.split("_"))[0]);
    posY =Float.parseFloat((posiciones.split("_"))[1]);

    ellipse(posX-width,posY, 70,70);
  }

}