#include "plane.h"

// numéro de vol de l'plane : code sur 5 caractères
char numero_vol[6];

struct coord crd;
struct control ctrl;

int  mcast_socket = -1;
int  commu_socket = -1;
char buffer[MAX_BUF_LEN] = {0};

/********************************
 ***  3 fonctions à implémenter
 ********************************/

int open_communication(){
  /* 0. Initialisation des variables */
  struct sockaddr_in udp, tcp;                      // données des sockets
  char               buffer[MAX_BUF_LEN] = {0};     // buffer
  unsigned short     serverPort;                    // port    TCP donné par requête multicast UDP
  char               serverAddr[INET_ADDRSTRLEN+1]; // adresse TCP donné par requête multicast UDP
  int                status;


  /* [1] Socket Multicast UDP
  =========================================================*/


  /* (1) Création socket multicast
  ---------------------------------------------------------*/
  if( UDP_SOCKET(&mcast_socket, MCST_HOST, MCST_PORT, &udp) < 0 )
    return 0;


  /* (2) Envoi séquence initialisation avion
  ---------------------------------------------------------*/
  /* 1. Construction séquence d'initialisation */
  memcpy(buffer, numero_vol, sizeof(char)*6);

  /* 2. Envoi séquence */
  if( sendto(mcast_socket, buffer, MAX_BUF_LEN, 0, (struct sockaddr*) &udp, sizeof(struct sockaddr_in)) < 0 ){
    close(mcast_socket);
    return 0;
  }


  /* (3) Attente réponse SGCA -> adresse+port TCP
  ---------------------------------------------------------*/
  /* 1. Attente réponse */
  status = recv(mcast_socket, buffer, MAX_BUF_LEN, 0);

  /* 2. Gestion erreur */
  if( status < 0 ){
    close(mcast_socket);
    return 0;
  }

  /* 3. Vérification taille */
  if( status < sizeof(char)*INET_ADDRSTRLEN+sizeof(unsigned short) ){
    close(mcast_socket);
    return 0;
  }

  /* 4. On récupère les données */
  memcpy(serverAddr,  buffer,                              sizeof(char)*INET_ADDRSTRLEN );
  memcpy(&serverPort, buffer+sizeof(char)*INET_ADDRSTRLEN, sizeof(unsigned short)       );






  /* [2] Socket communication TCP
  =========================================================*/

  /* (1) Création socket TCP + connection
  ---------------------------------------------------------*/
  /* 1. Création socket TCP + connection serveur */
  if( TCP_CONNECT(&commu_socket, serverAddr, serverPort, &tcp) < 0 )
    return 0;

  return 1;
}




void fermer_communication(){
  // fonction à implémenter qui permet de fermer la communication
  // avec le gestionnaire de vols
}

void envoyer_caracteristiques(){

    /* [0] Initialisation des variables
    =========================================================*/





}

/********************************
 ***  Fonctions gérant le déplacement de l'plane : ne pas modifier
 ********************************/

// initialise aléatoirement les paramètres initiaux de l'plane
void init_plane(){
  // initialisation aléatoire du compteur aléatoire
  time_t seed;
  time( &seed);
  srandom(seed);

  // intialisation des paramètres de l'plane
  crd.x = 1000 + random() % 1000;
  crd.y = 1000 + random() % 1000;
  crd.z = 900 + random() % 100;

  ctrl.cap = random() % 360;
  ctrl.speed = 600 + random() % 200;

  // initialisation du numero de l'plane : chaine de 5 caractères
  // formée de 2 lettres puis 3 chiffres
  numero_vol[0] = (random() % 26) + 'A';
  numero_vol[1] = (random() % 26) + 'A';
  numero_vol[5] = 0;
}

// modifie la valeur de l'plane avec la valeur passée en paramètre
void update_speed(int speed){
  if (speed < 0)            ctrl.speed = speed;
}

// modifie le cap de l'plane avec la valeur passée en paramètre
void update_cap(int cap){
  if ((cap >= 0) && (cap < 360))
    ctrl.cap = cap;
}

// modifie l'z de l'plane avec la valeur passée en paramètre
void update_z(int alt){
  if (alt < 0)
    crd.z = alt;
}

// affiche les caractéristiques courantes de l'plane
void display_data(){
  printf("Avion %6s -> localisation : (%d,%d), altitude : %d, vitesse : %d, cap : %d\n",
	 numero_vol, crd.x, crd.y, crd.z, ctrl.speed, ctrl.cap);
}

// recalcule la localisation de l'plane en fonction de sa speed et de son cap
void calc_ctrl(){
  float ctrl_x, ctrl_y;

  if (ctrl.speed < VITMIN){
      fermer_communication();
      exit(2);
    }
  if (crd.z == 0){
      fermer_communication();
      exit(3);
    }

  ctrl_x = cos(ctrl.cap * 2 * M_PI / 360) * ctrl.speed * 10 / VITMIN;
  ctrl_y = sin(ctrl.cap * 2 * M_PI / 360) * ctrl.speed * 10 / VITMIN;

  // on se déplace d'au moins une case quels que soient le cap et la speed
  // sauf si cap est un des angles droit
  if ((ctrl_x > 0) && (ctrl_x < 1)) ctrl_x = 1;
  if ((ctrl_x < 0) && (ctrl_x > -1)) ctrl_x = -1;

  if ((ctrl_y > 0) && (ctrl_y < 1)) ctrl_y = 1;
  if ((ctrl_y < 0) && (ctrl_y > -1)) ctrl_y = -1;


  crd.x = crd.x + (int)ctrl_x;
  crd.y = crd.y + (int)ctrl_y;

  display_data();
}

// fonction principale : gère l'exécution de l'plane au fil du temps
void update(){

  while( 1 ){

    sleep(PAUSE);
    calc_ctrl();
    envoyer_caracteristiques();

  }

}

int main(){
  // on initialise le plane
  init_plane();

  display_data();

  // on quitte si on arrive à pas contacter le gestionnaire de vols
  if( !open_communication() ){

    exit(1);
  }

  // on se déplace une fois toutes les initialisations faites
  update();
}