#include <stdio.h>
  #include <time.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <string.h>
  #include <dirent.h>
  #include <sys/types.h>
  
  #define MAX_NODES       128
  #define MAX_SENSORS     8
  #define MAX_BUFFER      1024
  #define USERNAME        "antoine"

  #define FILES_PATH      "/home/antoine/PFE_DEMO/files/"
  #define TOFLASH_PATH    "/home/antoine/PFE_DEMO/toflash/"
  #define PLAYBOOK_PATH	"/home/antoine/PFE_DEMO/ansible.yml"

  
  typedef struct node {
      char *ip;
      char *sensors[MAX_SENSORS];
      int n_sensors;
  } Node;
  
  typedef struct experiment {
      int exp_id;
      int n_nodes;
      char *date;
      char *file;
      char *duration;
      char *name;
      char *arch;
      char *dir;

  	char *exp_name;

      Node nodes[MAX_NODES];
  } Experiment;
  
  void process_line(char *line, Experiment *experiment) {
      char *key;
      char *value;
      char *save_ptr;
      key = strtok_r(line, ":", &save_ptr);
      if(!strcmp(key, "date")) {
          value = strtok_r(NULL, "\n", &save_ptr);
          experiment->date = strdup(value + 1);
      }
      else if(!strcmp(key, "name")) {
          value = strtok_r(NULL, "\n", &save_ptr);
          experiment->name = strdup(value + 1);       
      }
      else if(!strcmp(key, "dir")) {
          value = strtok_r(NULL, "\n", &save_ptr);
          experiment->dir = strdup(value + 1);       
      }
      else if(!strcmp(key, "arch")) {
          value = strtok_r(NULL, "\n", &save_ptr);
          experiment->arch = strdup(value + 1);       
      }
      else if(!strcmp(key, "exp_id")) {
          value = strtok_r(NULL, "\n", &save_ptr);
          experiment->exp_id = atoi(value + 1);   
      }
      else if(!strcmp(key, "time")) {
          value = strtok_r(NULL, "\n", &save_ptr);
          experiment->duration = strdup(value + 1);
      }        
      else if(!strcmp(key, "file")) {
          value = strtok_r(NULL, "\n", &save_ptr);
          experiment->file = strdup(value + 1);
      }
      else if(!strcmp(key, "nodes")) {
          value = strtok_r(NULL, "\n", &save_ptr) + 2;
          char *nodes_list = strtok_r(value, "]", &save_ptr);
          char *node;
          char *save_ptr_node;
          int present = 0;
  
          node = strtok_r(nodes_list, ",", &save_ptr);
  
          while(node != NULL) {
              char *sensor = strtok_r(node, "@", &save_ptr_node);
              char *ip = strtok_r(NULL, "@", &save_ptr_node);
  
              if(experiment->n_nodes == 0) {
                  Node n;
                  n.n_sensors = 1;
                  n.ip = strdup(ip);
                  n.sensors[0] = strdup(sensor);
                  experiment->nodes[0] = n;
                  experiment->n_nodes++;
              }
  
              else {
                  for(int i = 0; i < experiment->n_nodes; i++) {
                      if(!strcmp(experiment->nodes[i].ip, ip)) {
                          int nb = experiment->nodes[i].n_sensors;
                          experiment->nodes[i].sensors[nb] = strdup(sensor);
                          experiment->nodes[i].n_sensors++;
                          present = 1;
                      }
                  }
                  if(!present) {
                      Node n;
                      n.n_sensors = 1;
                      n.ip = strdup(ip);
                      n.sensors[0] = strdup(sensor);
                      experiment->nodes[experiment->n_nodes] = n;
                      experiment->n_nodes++;
                  }
                  present = 0;
              }
  
              node = strtok_r(NULL, ",", &save_ptr);
              if(node != NULL && *node == ' ') {
                  node++;
              }
          }
      }
  }
  
  Experiment *read_file(char *file_name) {
      char ch;
      char buffer[MAX_BUFFER];
      FILE *fp;
      Experiment *experiment = (Experiment*) malloc(sizeof(Experiment));
      experiment->n_nodes = 0;
  
      fp = fopen(file_name, "r");
  
      if(fp == NULL) {
          perror("Error while opening the file.\n");
          exit(EXIT_FAILURE);
      }
  
      while(fgets(buffer, MAX_BUFFER, fp) != NULL) {
          process_line(buffer, experiment);
      }
  
      fclose(fp);
      return experiment;
  }
  
  int check_date(Experiment *experiment) {
      time_t now;
      time(&now);

      struct tm tm = { 0 };

      strptime(experiment->date, "%Y-%m-%dT%H:%M", &tm);

      time_t t = mktime(&tm);
  
      if(t <= now) {
          printf("Starting deployment of \"[%d] %s\" ...\n", experiment->exp_id, experiment->name);
          return 0;
      }
      return 1;
  }
  
  int process_time(Experiment *experiment) {
      char duration[8];
      strcpy(duration, experiment->duration);
      char *hour;
      char *min;
      hour = strtok(duration, ":");
      min = strtok(NULL, "\0");
      return atoi(hour) * 3600 + atoi(min) * 60;
  }
  
  int binary_not_present(Experiment *experiment) {
      char path[512];
      strcpy(path, FILES_PATH);
      strcat(path, experiment->dir);
      strcat(path, "/out.bin");
      FILE *file;
      if(file = fopen(path, "r")) {
          fclose(file);
          return 0;
      }
      return 1;
  }
  
  int process_exp(Experiment *experiment) {
      if(check_date(experiment)) {
          return 1;
      }
  
      char docker_cmd[1024];
  
      if(!strcmp(experiment->arch, "arm")) {
          if(binary_not_present(experiment)) {
              sprintf(docker_cmd, "docker run --rm -v %s:/exp -e SRC_NAME=\"%s\" -e SRC_DIR=\"%s\" arm_compiler",
                  FILES_PATH,
                  experiment->file,
                  experiment->dir
              );
              exec_prog(docker_cmd);
          }
      }
  
      int time_sec = process_time(experiment);
      char cmd1[1024];
      char cmd2[1024];
      char sensors_list[512];
      strcpy(sensors_list, "");
      for(int i = 0; i < experiment->n_nodes; i++) {
          for(int j = 0; j < experiment->nodes[i].n_sensors; j++) {
              strcat(sensors_list, experiment->nodes[i].sensors[j]);
              if(j < experiment->nodes[i].n_sensors - 1) {
                  strcat(sensors_list, "\n");
              }
          }
          sprintf(cmd2, "mkdir ~/exp_%d", experiment->exp_id);

          sprintf(cmd1, "runuser -l %s -c \'echo \"%s\" | ssh pi@%s \"%s && cat > ~/exp_%d/config_experimentation.txt\"\'", 

              USERNAME,
              sensors_list, 
              experiment->nodes[i].ip, 
              cmd2, 
              experiment->exp_id);
          exec_prog(cmd1);
      }
  
      char hosts_filename[64];
      sprintf(hosts_filename, "/etc/ansible/exp_%d.hosts", experiment->exp_id);
      FILE *hosts_fp = fopen(hosts_filename, "w");
      fprintf(hosts_fp, "[exp_%d]\n", experiment->exp_id);
      for(int i = 0; i < experiment->n_nodes; i++) {
          fprintf(hosts_fp, "%s ansible_user=pi\n", experiment->nodes[i].ip);
      }
      fclose(hosts_fp);
  
      char ansible_command[512];

      sprintf(ansible_command, "runuser -l %s -c \'ansible-playbook %s -i %s -e \"servernames=exp_%d exp_duration=%d binary_dir=%s exp_name=%s\"\'",

          USERNAME,

  	PLAYBOOK_PATH,

          hosts_filename,
          experiment->exp_id,
          time_sec,

          experiment->dir,
  		experiment->exp_name);

      exec_prog_background(ansible_command);
  
      return 0;
  }
  
  void print_exp(Experiment *experiment) {
      printf("== EXP[%d] : %s ==\n%s during %s with the file %s (%s) on the %d nodes :\n",
          experiment->exp_id,

          experiment->exp_name,

          experiment->date,
          experiment->duration,
          experiment->file,
          experiment->arch,
          experiment->n_nodes);
      for(int i = 0; i < experiment->n_nodes; i++) {
          printf("* %s\n", experiment->nodes[i].ip);
          for(int j = 0; j < experiment->nodes[i].n_sensors; j++) {
              printf("    - %s\n", experiment->nodes[i].sensors[j]);
          }
      }
  }
  
  void free_exp(Experiment *experiment) {
      free(experiment->date);
      free(experiment->duration);
      free(experiment->file);
      free(experiment->arch);
      free(experiment->dir);
      free(experiment->name);

  	free(experiment->exp_name);

      for(int i = 0; i < experiment->n_nodes; i++) {
          for(int j = 0; j < experiment->nodes[i].n_sensors; j++) {
              free(experiment->nodes[i].sensors[j]);
          }
          free(experiment->nodes[i].ip);
      }
      free(experiment);
  }
  
  void check_files() {
      DIR *dir;
      struct dirent *dirent;
      dir = opendir(TOFLASH_PATH);
  
      if(dir != NULL) {
          while(dirent = readdir(dir)) {

              if((dirent->d_type == DT_REG) && (strstr(dirent->d_name, ".started") == NULL)) {

                  char file_name[128];

  				char new_file_name[128];

                  strcpy(file_name, TOFLASH_PATH);
                  strcat(file_name, dirent->d_name);
                  Experiment *experiment = read_file(file_name);

  				experiment->exp_name = strdup(dirent->d_name);

  #ifdef DEBUG                
                  print_exp(experiment);
  #endif
                  if(!process_exp(experiment)) {

  					strcpy(new_file_name, file_name);
  					strcat(new_file_name, ".started");
                      rename(file_name, new_file_name);

                  }
                  free_exp(experiment);
              }
          }
          closedir(dir);
      }
      else {
          perror("Dossier toflash non trouvable");
          exit(EXIT_FAILURE);
      }
  
      return;
  }
  
  int exec_prog(char *cmd) {
      if(system(cmd) == -1) {
          return 1;
      }
      return 0;
  }
  
  int exec_prog_background(char *cmd) {
      if(!fork()) {
          system(cmd);
          return 0;
      }
      return 1;
  }
  
  int main(int argc, char **argv) {
      while(1) {
          check_files();
          sleep(10);
      }
      return 0;

  }