#include <stdio.h>
#include <stdlib.h>
#include <string.h>


/*Initialisation des structure*/
char* villes[100];
int nb_villes=0;
int distance_villes[100][100];
char* possibleActual[4]={"personnes","villes","abonnements","distances"};
int ind_actual=0;
int tab_distances_personnes[]={0,-1,-1,-1,-1,-1,-1}; 


typedef struct Personne{
    char* nom;
    char* ville;
    struct Chaine{
        struct Personne* actu;
        struct Chaine* suivant;
    } * abonnement;
    struct Chaine * suivi_par;
    
} Personne;
int nb_personne=0;
Personne* tab_personne[100];


/*ajoute une personne*/
void ajoute_personne(char* nom, char* ville)
{
    Personne* nouv=malloc(sizeof(Personne*));
    nouv->nom=nom;
    nouv->ville=ville;
    tab_personne[nb_personne]=nouv;
    nb_personne++;
}

/*cherche une personne dans le tableau de personne*/
Personne* get_personne(char* nom)
{
    int i;
    for (i=0;i<nb_personne;i++)
    {
        if (strcmp(nom,tab_personne[i]->nom)==0)
        {
            return tab_personne[i];
        }
    }
    printf("La personne %s n'a pas était trouvé!\n",nom);
    return NULL;
}

int getInd_personne(char* nom){
  int i;
    for (i=0;i<nb_personne;i++)
    {
        if (strcmp(nom,tab_personne[i]->nom)==0)
        {
            return i;
        }
    }
    printf("La personne %s n'a pas était trouvé!\n",nom);
    return -1;

}

/*ajoute un abonné a une personne : ,ne gère pas si une personne n'existe pas..*/
void ajoute_abo(Personne* p1, Personne* p2)
{
    struct Chaine* abo=p1->abonnement;
    struct Chaine* nouv=malloc(sizeof(struct Chaine*));
    nouv->actu=p2;
    nouv->suivant=p1->abonnement;
    p1->abonnement=nouv;
}

void enleve_abo(Personne* p1,Personne* p2){
  struct Chaine* actuel=p1->abonnement;

  if(actuel!=NULL){
    if(actuel->actu==p2){
      p1->abonnement=actuel->suivant;
    }
    while(actuel!=NULL){
      if(actuel->suivant!=NULL){
        if(actuel->suivant->actu==p2){
          actuel->suivant=(actuel->suivant)->suivant;
        }
      }
      actuel=actuel->suivant;
    }
  }
}

void ajoute_suivi_par(Personne * p1,Personne *p2){
  struct Chaine* nouv=malloc(sizeof(struct Chaine));
  nouv->actu=p2;
  nouv->suivant=p1->suivi_par;
  p1->suivi_par=nouv;

}

void setVille_personne(Personne* p1,char* ville){
  char* cpy_ville=malloc(50*sizeof(char));
  strcpy(cpy_ville,ville);
  p1->ville=cpy_ville;
}



/*fonctions utilitaires*/
void affAbo(Personne* p)
{
    struct Chaine* abo=p->abonnement;
    printf("[");
    while(abo!=NULL)
    {
        if (abo->suivant==NULL)
        {
            printf("%s",abo->actu->nom);
        }
        else{
            printf("%s,",abo->actu->nom);
        }
        abo=abo->suivant;
        printf("%d",abo==NULL);
    }
    printf("]\n");
}

void affSuivi_par(Personne *p){
  struct Chaine* abo=p->suivi_par;
  printf("[");
  while(abo!=NULL)
  {
      if (abo->suivant==NULL)
      {
          printf("%s",abo->actu->nom);
      }
      else{
          printf("%s,",abo->actu->nom);
      }
      abo=abo->suivant;
  }
  printf("]\n");
}


void affPersonne(void){
    for (int i=0;i<nb_personne;i++)
    {
        printf("%s | ",tab_personne[i]->nom);
        printf(" [%s] |",tab_personne[i]->ville);
        affAbo(tab_personne[i]);
    }
}

void affUnePersonne(Personne* p1){
  printf("%s | [%s] | ",p1->nom,p1->ville);
  affAbo(p1);
}


void afficheVilles(void){
  printf("[%s",villes[0]);

  for(int i=1;i!=nb_villes;i++){
    printf(",%s",villes[i]);
  }
  printf("]\n");
}

int getInd_villes(char* ville){
  int i=0;
  for(int i=0;i<nb_villes;i++){
    if(strcmp(villes[i],ville)==0){
      return i;
    }
  }
  printf("Aucune ville au nom de <%s> \n",ville);
  return -1;

}
void ajoute_sesAbonnements(Personne * p1,char* abonnements){
  const char* separators="[],";
  char* strToken6=strtok(abonnements,separators); 
  while(strToken6!=NULL){
    ajoute_abo(p1,get_personne(strToken6));
    strToken6 = strtok (NULL,separators);
  } 
}

void parsePersonnesInfos(char* personnes){

  const char* separators="[], ";
  char* strToken5=strtok(personnes,separators);
  char* nom=malloc(50*sizeof(char));
  while(strToken5!=NULL){
    nom=malloc(50*sizeof(char));
    strcpy(nom,strToken5);
    ajoute_personne(nom,NULL);
    strToken5 = strtok (NULL,separators);
  }
}

void parseVillesInfos(char* personnes){

  const char* separators="[], ";
  char* strToken4=strtok(personnes,separators);
  char* ville;
  while(strToken4!=NULL){
    ville=malloc(50*sizeof(char));
    strcpy(ville,strToken4);
    villes[nb_villes]=ville;
    nb_villes++;
    strToken4 = strtok (NULL,separators);
  }
}
void parsePersonne(char* chaine){
  char* separators=": ";
  char personne[50];
  char abonnements[50];
  char ville[50];
  char* strToken2=strtok(chaine,separators);
  strcpy(personne,strToken2);
  strToken2=strtok(NULL,separators);
  separators="{} ";
  strToken2=strtok(strToken2,separators);
  separators="[] ";
  strToken2=strtok(strToken2,separators);
  strcpy(abonnements,strToken2);
  separators=", ";
  strToken2=strtok(NULL,separators);
  strcpy(ville,strToken2);
  ajoute_sesAbonnements(get_personne(personne),abonnements);
  setVille_personne(get_personne(personne),ville);
}

void parseVille(char* chaine){
  char* separators="(), ";
  int ind_ville1;
  int ind_ville2;
  int distance;
  char* strToken3=strtok(chaine,separators);
  ind_ville1=getInd_villes(strToken3);
  strToken3 = strtok (NULL,separators);
  distance=atoi(strToken3);
  strToken3 = strtok (NULL,separators);
  ind_ville2=getInd_villes(strToken3);
  distance_villes[ind_ville1][ind_ville2]=distance;
}

void analyseLigne(char* ligne,char* actual){

  if(strcmp(actual,"personnes")==0){
    parsePersonnesInfos(ligne);
    ind_actual++;
  }
  else if(strcmp(actual,"villes")==0){
    parseVillesInfos(ligne);
    afficheVilles();
  }
  else if(strcmp(actual,"abonnements")==0){
    parsePersonne(ligne);
  }
  else if(strcmp(actual,"distances")==0){
    parseVille(ligne);
  }

}

void analyseFile(char* ligne){
    if(strcmp(ligne,"[")==0){
      ind_actual++;
    }
    else if(strcmp(ligne,"]")==0 || strcmp(ligne,"],")==0 || strcmp(ligne,"{")==0){
      printf("\n");
    }
    else if(strcmp(ligne,"}")==0){
      printf("Fin de lecture du fichier en question");
    }
    else{
      analyseLigne(ligne,possibleActual[ind_actual]);
    }

}

char* enleve_espaces_chaine(char* chaine){
    char *NewPhrase;
    int i, j = 0;
    int a= strlen(chaine);

    NewPhrase = malloc(a*sizeof(char)+1);

    if(NewPhrase == NULL)
    {
        exit(0);
     }

    for(i=0;i<a;i++){
        if(chaine[i]!=' ' && chaine[i]!='\n')
        {
           NewPhrase[j++] = chaine[i];
        }
 
    }
    return NewPhrase;
}



int distances_personnes(Personne * p1,Personne * p2,int distance){


  if(distance==(nb_personne+1)){
    printf("analyse terminée");
    return distance;
  }

  struct Chaine* abo=p1->abonnement;
  while(abo!=NULL)
  {
      if(abo->actu==p2){
        tab_distances_personnes[getInd_personne(abo->actu->nom)]=distance;
        printf("Nous avons trouvé la personne %s a la distance %d",p2->nom,tab_distances_personnes[getInd_personne(p2->nom)]);
        return 1;
      }
      else if (abo->suivant==NULL)
      {
        if(tab_distances_personnes[getInd_personne(abo->actu->nom)]==-1){
          tab_distances_personnes[getInd_personne(abo->actu->nom)]=distance;
          return distances_personnes(abo->actu,p2,distance++);
        }
        else{
          return 1;
        }
      }
      else{
        if(tab_distances_personnes[getInd_personne(abo->actu->nom)]==-1){
          tab_distances_personnes[getInd_personne(abo->actu->nom)]=distance;
          return distances_personnes(abo->actu,p2,distance++);
        }
        else{
          return 1;
        }
      }
      abo=abo->suivant;
  }

}

/*Une version de calcul de distance entre deux personnes dont je ne suis pas sur du tout car elle possède pas mal de bug,notamment sur les appels recursifs de trois personnes (karim appel alice qui appel kevin qui appel karim qui appel alice...sans fin)*/
int distances_personnes2(Personne* p1,Personne *p2,Personne* pere,int distance,int* min)
{
    struct Chaine* abo=p1->abonnement;
    if(distance>nb_personne+1){
      return distance;
    }
    while(abo!=NULL)
    {
        if(tab_distances_personnes[getInd_personne(abo->actu->nom)]==-1){
          tab_distances_personnes[getInd_personne(abo->actu->nom)]=distance;
        }
        if(abo!=NULL){
          if(pere!=abo->actu){
            distances_personnes2(abo->actu,p2,p1,distance++,min);
          }
          else{
            return distance;
          }
        }
        abo=abo->suivant;
    }
}
/*main*/
int main(void)
{
    /*ajoute_personne("Michel","Lens");
    ajoute_personne("Bernard","Arras");
    ajoute_personne("Roger","Avion");
    ajoute_personne("Denis","Lille");
    ajoute_abo(get_personne("Michel"),get_personne("Bernard"));
    ajoute_abo(get_personne("Roger"),get_personne("Michel"));
    ajoute_abo(get_personne("Michel"),get_personne("Denis"));
    enleve_abo(get_personne("Michel"),get_personne("Denis"));
    enleve_abo(get_personne("Michel"),get_personne("Bernard"));
    enleve_abo(get_personne("Michel"),get_personne("Denis"));*/
    /*char liste[]="   [kevin,karim,alice,paul,charlotte,gabriel,dalila],";
    char villagers[]="      [lille,lens,arras,douai,carvin,seclin],";
    char phrase[]="     kevin:{[dalila,charlotte,gabriel,paul],lille},";
    char villedistance[]="    (lille,22,lens),";
    parsePersonnesInfos(liste);
    parseVillesInfos(villagers);
    parsePersonne(phrase);
    parseVille(villedistance);
    affPersonne();
    afficheVilles();*/

    /*Changer le reseau ici*/
    char* reseau="reseau2.txt";
    FILE* file=fopen(reseau,"r");
    char fichier[4500];
    char ligne[300];
    if(file!=NULL){
      while(fgets(ligne,300,file)!=NULL){
        strcpy(ligne,enleve_espaces_chaine(ligne));
        analyseFile(ligne);
      }

      fclose(file);
    }
    else{
      printf("Le fichier a mal était ouvert\n");
    }
    int min=50;
    distances_personnes2(get_personne("gabriel"),get_personne("paul"),NULL,1,&min);
    printf("On utilise le %s\n",reseau);
    printf("Personne | [VILLE] | [SES ABONNEMENTS]\n");
    printf("--------------------------------------\n");
    affPersonne();
    printf("--------------------------------------\n");
    printf("LISTES DES VILLES\n");
    printf("--------------------------------------\n");
    afficheVilles();
    printf("--------------------------------------\n");

    printf("\n la distance entre gabriel et paul a était trouvé le plus court a %d\n",tab_distances_personnes[getInd_personne("charlotte")]);
    ajoute_suivi_par(get_personne("kevin"),get_personne("dalila"));
    ajoute_suivi_par(get_personne("kevin"),get_personne("gabriel"));
    ajoute_suivi_par(get_personne("kevin"),get_personne("karim"));
    affSuivi_par(get_personne("kevin"));
    return 0;
}