#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 clientsock = -1;
char buffer[MAX_BUF_LEN] = {0};

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

int open_communication(){
  // fonction à implémenter qui permet d'entrer en communication via TCP
  // avec le gestionnaire de vols

  /* 0. Initialisation des variables */
  // struct hostent* host = NULL;
  struct sockaddr_in server;

  /* 1. Création de la socket */
  clientsock = socket(AF_INET, SOCK_STREAM, 0);

  /* 1bis. Gestion erreur socket */
  if( clientsock < 0 )
    return 0;

  /* 2. Hostname Lookup */
  // host = gethostbyname(SRV_HOST);

  // /* 2bis. Gestion erreur */
  // if( host == NULL )
  //   return 0;

  /* 3. Mise à jour des infos serveur */
  bzero(&server, sizeof(struct sockaddr_in));
  server.sin_family      = AF_INET;
  server.sin_port        = htons(SRV_PORT);
  server.sin_addr.s_addr = inet_addr(SRV_HOST);

  // // On récupère l'adresse serveur du lookup
  // memcpy(&server->sin_addr.s_addr, *(host->h_addr_list), host->h_length);

  /* 4. Connection */
  if( connect(clientsock, (struct sockaddr*) &server, sizeof(struct sockaddr_in)) < 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(){
  // fonction à implémenter qui envoie l'ensemble des caractéristiques
  // courantes de l'plane au gestionnaire de vols
}

/********************************
 ***  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
  unsigned int seed;
  time( (time_t*) &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();   
}