
#include "Comunicacio_Robot.h"
#include "Interficie_Mart.h"
#include "Simulador_Mart.h"

#define NUM_CLIENTS_MART 2

extern Simulador_Mart *simulador_mart;
extern Visualitzador_Mart *visor_mart;


Comunicacio_Robot::Comunicacio_Robot(Logica_Robot *logica_robot)
{
   logica = logica_robot;
   robot_en_funcionament = 0;
}   

void Comunicacio_Robot::establir_dades_inicials(char *ipTerra, int portTerra)
{
   ip_terra = ipTerra;
   port_terra = portTerra;
}   

void Comunicacio_Robot::tractar_Emergencia(char *emergencia)
{
   logica -> desactivar_moviment();
   // En cas de no poder realitzar moviment simplement
   // es notifica a la Terra. En cas contrari, quan
   // la bateria es baixa o no es detecta comunicacio,
   // es para el funcionament a mes a mes.
   if (!strcmp(emergencia,"moviment_impossible") == 0) {
      robot_en_funcionament = 0;      
   }
   Thread_Client_Mart *client_emergencia;
   client_emergencia = new Thread_Client_Mart(ip_terra,port_terra,"emergencia",emergencia);
   client_emergencia -> start();
}

Logica_Robot *Comunicacio_Robot::get_Logica_Robot()
{
   return logica;
}   

void Comunicacio_Robot::activar_robot()
{
   robot_en_funcionament = 1;
   // Inici dels threads clients
   client_mart[0] = new Thread_Client_Mart(ip_terra,port_terra,"comprovar_comunicacio","");
   client_mart[1] = new Thread_Client_Mart(ip_terra,port_terra,"informe_dades_robot","");   
   for (int i = 0; i < NUM_CLIENTS_MART; i++) {
      client_mart[i] -> start();
   }
   // Inici del thread controlador de temperatura
   thread_termic = new Thread_Control_Termic(logica);
   thread_termic -> start();   
   // Inici del thread controlador de bateria
   thread_bateria = new Thread_Control_Bateries(logica);
   thread_bateria -> start(); 
   // Inici del thread que recopila periodicament informes de mart 
   thread_informes = new Thread_Servidor_Informes();
   thread_informes -> start(); 
}   

void Comunicacio_Robot::desactivar_robot()
{
   std::cout << "COMUNICACIO-ROBOT -> DESACTIVAR-ROBOT\n";
   robot_en_funcionament = 0;
}   

void Comunicacio_Robot::iniciar_moviment()
{
   logica -> activar_moviment();
   thread_moviment = new Thread_Moviment_Robot(logica);
   thread_moviment -> start();
}   

void Comunicacio_Robot::finalitzar_moviment()
{
   logica -> desactivar_moviment();
}   

int Comunicacio_Robot::get_Funcionament()
{
   return robot_en_funcionament;
}   

int Comunicacio_Robot::get_moviment()
{
   return logica -> get_moviment();
}   

void Comunicacio_Robot::girar_robot(int graus)
{
   logica -> girar_robot(graus);
}   

void Comunicacio_Robot::girar_cameres(int graus)
{
   logica -> posicionar_cap(graus);
}   

void Comunicacio_Robot::canviar_camara_activa(int num_camara)
{
   visor_mart -> set_camera_activa(num_camara);
}   

void Comunicacio_Robot::capturar_fotografia(int actiu, int num_camera, unsigned char *imatge)
{
   visor_mart -> set_captura_fotografia(actiu,num_camera,imatge);
   while(visor_mart -> get_captura_fotografia());
}

/*void *Comunicacio_Robot::realitzar_fotografia(int camera, unsigned char *imatge)
{
   visor_mart -> capturar_pantalla(camera,imatge);
}*/

void Comunicacio_Robot::get_posicio_actual(struct TPosicio *posicio_actual)
{
   logica -> get_posicio_actual(posicio_actual);
}   

int Comunicacio_Robot::analitzar_material()
{
   struct TPosicio posicio_actual;
   logica -> get_posicio_actual(&posicio_actual);
   return simulador_mart -> get_material((int)posicio_actual.x,(int)posicio_actual.z);
}   

float Comunicacio_Robot::analitzar_ferro()
{
   struct TPosicio posicio_actual;
   logica -> get_posicio_actual(&posicio_actual);
   return simulador_mart -> get_ferro((int)posicio_actual.x,(int)posicio_actual.z);
}   

float Comunicacio_Robot::get_nivell_llum_actual()
{
   struct TPosicio posicio_actual;
   logica -> get_posicio_actual(&posicio_actual);
   return simulador_mart -> get_llum((int)posicio_actual.x,(int)posicio_actual.z);   
}   

float Comunicacio_Robot::get_temperatura_actual()
{
   struct TPosicio posicio_actual;
   logica -> get_posicio_actual(&posicio_actual);
   return simulador_mart -> get_temperatura((int)posicio_actual.x,(int)posicio_actual.z);
}   

int Comunicacio_Robot::get_carrega_bateria()
{
   return logica -> get_nivell_bateria();
}   

float Comunicacio_Robot::analitzar_xray()
{
   struct TPosicio posicio_actual;
   logica -> get_posicio_actual(&posicio_actual);
   return simulador_mart -> get_xray((int)posicio_actual.x,(int)posicio_actual.z);
}

int Comunicacio_Robot::get_amplada_imatge()
{
   return visor_mart -> get_amplada_imatge();
}   

int Comunicacio_Robot::get_altura_imatge()
{
   return visor_mart -> get_altura_imatge();   
}

void Comunicacio_Robot::get_ip_terra(int *ip)
{
   ip[0] = atoi(strtok(ip_terra,"."));
   ip[1] = atoi(strtok(NULL,"."));
   ip[2] = atoi(strtok(NULL,"."));
   ip[3] = atoi(strtok(NULL,"."));
}   

int Comunicacio_Robot::get_port_terra()
{
   return port_terra;
}   

void Comunicacio_Robot::conversio_a_cadena(int amplada, char *ampladaStr)
{
   sprintf(ampladaStr,"%d",amplada);
}   


