/*  Usefule things for the 'gram' module  */
  /*  FRED 0498 - Modif multi ML - 0399  */
  
  /*................................................................*/
  
  #include <libgram.h>
  
  /*................................................................*/
  
  /*  Declaration de la table de ML  */
  
  ty_ml Table_ML[NB_MAX_ML];
  
  /*  Nombre de ML present en memoire  */
  
  int NB_ML=0;
  
  /*................................................................*/
  
  /* Allocation d'un nouveau ML */
  
  ty_ml cons_ml(long nb1,long nb2,long nb3,int si_hash,int si_2g,int si_log10)
  {
  ty_ml pt;
  pt=(ty_ml)malloc(sizeof(struct type_ml));
  pt->pmc=NULL;
  pt->lexique=NULL;
  pt->NB1GRAM=nb1;
  pt->NB2GRAM=nb2;
  pt->NB3GRAM=nb3;
  pt->GRAM_SI_HASH=si_hash;
  pt->GRAM_SI_2G=si_2g;
  pt->GRAM_LOG10=si_log10;
  pt->TABL1GRAM=(type_1gram*)malloc(sizeof(type_1gram)*(pt->NB1GRAM+MARGE));
  if (pt->TABL1GRAM==NULL) return NULL;
  pt->TABL2GRAM=(type_2gram*)malloc(sizeof(type_2gram)*(pt->NB2GRAM+MARGE));
  if (pt->TABL2GRAM==NULL) return NULL;
  if (si_2g==0)
   {
   pt->TABL3GRAM=(type_3gram*)malloc(sizeof(type_3gram)*(pt->NB3GRAM+MARGE));
   if (pt->TABL3GRAM==NULL) return NULL;
   }
  else pt->TABL3GRAM=NULL;
  return pt;
  }
  
  /*................................................................*/
  
  /*  Egalite  */
  
  int H1compar(void *a ,void *b )
  {
  int n;
  type_1gram *i,*j;
  i=(type_1gram *)a;
  j=(type_1gram *)b;
  for(n=Nb1Byte-1;n>=0;n--)
   {
   if (i->cle[n]>j->cle[n]) return 1;
   if (i->cle[n]<j->cle[n]) return -1;
   }
  return 0;
  }
  
  int H2compar(void *a ,void *b )
  {
  int n;
  type_2gram *i,*j;
  i=(type_2gram *)a;
  j=(type_2gram *)b;
  for(n=Nb2Byte-1;n>=0;n--)
   {
   if (i->cle[n]>j->cle[n]) return 1;
   if (i->cle[n]<j->cle[n]) return -1;
   }
  return 0;
  }
  
  int H3compar(void *a ,void *b )
  {
  int n;
  type_3gram *i,*j;
  i=(type_3gram *)a;
  j=(type_3gram *)b;
  for(n=Nb3Byte-1;n>=0;n--)
   {
   if (i->cle[n]>j->cle[n]) return 1;
   if (i->cle[n]<j->cle[n]) return -1;
   }
  return 0;
  }
  
  int SiEgal1(wrd_index_t i_mot ,long indice ,ty_ml pt_ml)
  {
  return (pt_ml->TABL1GRAM[indice].cle[0]==BYTE1(i_mot)) &&
         (pt_ml->TABL1GRAM[indice].cle[1]==BYTE2(i_mot)) &&
         (pt_ml->TABL1GRAM[indice].cle[2]==BYTE3(i_mot))?1:0;
  }
  
  int SiEgal2(wrd_index_t i_mot1 ,wrd_index_t i_mot2 ,long indice ,ty_ml pt_ml)
  {
  return (pt_ml->TABL2GRAM[indice].cle[0]==BYTE1(i_mot1)) &&
         (pt_ml->TABL2GRAM[indice].cle[1]==BYTE2(i_mot1)) &&
         (pt_ml->TABL2GRAM[indice].cle[2]==BYTE3(i_mot1)) &&
  
         (pt_ml->TABL2GRAM[indice].cle[3]==BYTE1(i_mot2)) &&
         (pt_ml->TABL2GRAM[indice].cle[4]==BYTE2(i_mot2)) &&
         (pt_ml->TABL2GRAM[indice].cle[5]==BYTE3(i_mot2))?1:0;
  }
  
  int SiEgal3(wrd_index_t i_mot1 ,wrd_index_t i_mot2 ,wrd_index_t i_mot3 ,long indice ,ty_ml pt_ml)
  {
  return (pt_ml->TABL3GRAM[indice].cle[0]==BYTE1(i_mot1)) &&
         (pt_ml->TABL3GRAM[indice].cle[1]==BYTE2(i_mot1)) &&
         (pt_ml->TABL3GRAM[indice].cle[2]==BYTE3(i_mot1)) &&
  
         (pt_ml->TABL3GRAM[indice].cle[3]==BYTE1(i_mot2)) &&
         (pt_ml->TABL3GRAM[indice].cle[4]==BYTE2(i_mot2)) &&
         (pt_ml->TABL3GRAM[indice].cle[5]==BYTE3(i_mot2)) &&
  
         (pt_ml->TABL3GRAM[indice].cle[6]==BYTE1(i_mot3)) &&
         (pt_ml->TABL3GRAM[indice].cle[7]==BYTE2(i_mot3)) &&
         (pt_ml->TABL3GRAM[indice].cle[8]==BYTE3(i_mot3))?1:0;
  }
  
  /*................................................................*/
  
  /*  Gestion des 1.2.3-gram au format arpa  */
  /*  FRED 0398 - Modif multi ML - 0399  */
  
  /*................................................................*/
  
  /*  Lecture  */
  
  err_t gram_module_init(char *chfich ,int *num_ml, int n_gram , const err_t trace)
  {
  FILE *file;
  long nb1,nb2,nb3,nb4;
  int si_hash,si_log10;
  char ch[100];
  
  if ((n_gram!=2)&&(n_gram!=3))
   {
   fprintf(stderr,"Sorry, you can load only 2GRAM or 3GRAM models !!
  ");
   return SIR_RANGE_ERR;
   }
  
  *num_ml=NB_ML++;
  
  if (*num_ml>=NB_MAX_ML) return SIR_RANGE_ERR;
  
  if (trace & SIR_GRAM_TRACE)
   fprintf(stderr,"Loading of the n-gram model : number %d
  ",*num_ml);
  
  sprintf(ch,"%s.desc",chfich);
  if (!(file=fopen(ch,"r"))) return SIR_READ_OPEN_ERR;
  fgets(ch,100,file);
  sscanf(ch,"%ld %ld %ld",&nb1,&nb2,&nb3);
  fgets(ch,100,file);
  if (!strncmp(ch,"HASH",4)) si_hash=1; else si_hash=0;
  fgets(ch,100,file);
  if (trace & SIR_GRAM_TRACE)
   if (!strncmp(ch,"LOG_10",6))
    {
    si_log10=1;
    fprintf(stderr,"The logprob of the model are : LOG 10
  ");
    }
   else
    {
    si_log10=0;
    fprintf(stderr,"The logprob of the model are : LOG e
  ");
    }
  fgets(ch,100,file);
  if (!strncmp(ch,"TRIGRAMME",9))
   {
   if (n_gram==2)
    { if (trace & SIR_GRAM_TRACE) fprintf(stderr,"3GRAM model loaded as a 2GRAM
  "); }
   else
    { if (trace & SIR_GRAM_TRACE) fprintf(stderr,"3GRAM model
  "); }
   }
  else
   {
   if (n_gram==3)
    {
    fprintf(stderr,"Sorry, you can't load a 2GRAM model as a 3GRAM model !!!!
  ");
    return SIR_RANGE_ERR;
    }
   if (trace & SIR_GRAM_TRACE) fprintf(stderr,"2GRAM model
  ");
   }
  fclose(file);
  
  Table_ML[*num_ml]=cons_ml(nb1,nb2,nb3,si_hash,n_gram==2?1:0,si_log10);
  
  if (Table_ML[*num_ml]==NULL) return SIR_ALLOC_ERR;
  
  sprintf(ch,"%s.1g",chfich);
  if (!(file=fopen(ch,"rb"))) return SIR_READ_OPEN_ERR;
  if (!(fread(Table_ML[*num_ml]->TABL1GRAM,sizeof(type_1gram)*(nb1+MARGE),1,file)))
   return SIR_READ_ERR;
  fclose(file);
  
  sprintf(ch,"%s.2g",chfich);
  if (!(file=fopen(ch,"rb"))) return SIR_READ_OPEN_ERR;
  if (!(fread(Table_ML[*num_ml]->TABL2GRAM,sizeof(type_2gram)*(nb2+MARGE),1,file)))
   return SIR_READ_ERR;
  fclose(file);
  
  if (n_gram==3)
   {
   sprintf(ch,"%s.3g",chfich);
   if (!(file=fopen(ch,"rb"))) SIR_READ_OPEN_ERR;
   if (!(fread(Table_ML[*num_ml]->TABL3GRAM,sizeof(type_3gram)*(nb3+MARGE),1,file)))
    return SIR_READ_ERR;
   fclose(file);
   }
  return(CORRECT);
  }
  
  err_t gram_module_reset(const int num_ml,const err_t trace)
  {
  if (trace & SIR_GRAM_TRACE)
   fprintf(stderr,"Deletion of the n-gram model : number %d
  ",num_ml);
  if ((num_ml>NB_ML)||(Table_ML[num_ml]==NULL)) return SIR_FATAL_ERR;
  
  free(Table_ML[num_ml]->TABL1GRAM);
  free(Table_ML[num_ml]->TABL2GRAM);
  if (Table_ML[num_ml]->GRAM_SI_2G==0) free(Table_ML[num_ml]->TABL3GRAM);
  
  if (Table_ML[num_ml]->lexique) delete_lexique(Table_ML[num_ml]->lexique);
  
  return(CORRECT);
  }
  
  /*................................................................*/
  
  /*  Recherche des NGrams par HashCode  */
  
  int HashRecherche1Gram(wrd_index_t i_mot ,flogprob_t *lp ,flogprob_t *fr ,ty_ml pt_ml)
  {
  wrd_index_t essai,indice,valh1,valh2;
  if (i_mot<0) return 0;
  indice=valh1=H1Value(i_mot,pt_ml);
  valh2=Double1H(i_mot,pt_ml);
  for (essai=1;(essai<=pt_ml->NB1GRAM)&&(Case1Vide(indice,pt_ml)==0)&&
  	(!SiEgal1(i_mot,indice,pt_ml));essai++)
   indice=EssaiSuivant(valh1,valh2,essai,pt_ml->NB1GRAM);
  if ((essai<=pt_ml->NB1GRAM)&&(Case1Vide(indice,pt_ml)==0))
   {
   *lp=pt_ml->TABL1GRAM[indice].lp;
   *fr=pt_ml->TABL1GRAM[indice].fr;
   return 1;
   }
  return 0;
  }
  
  int HashRecherche2Gram(wrd_index_t i_mot1 ,wrd_index_t i_mot2 ,flogprob_t *lp ,flogprob_t *fr ,ty_ml pt_ml)
  {
  wrd_index_t essai,indice,valh1,valh2;
  if ((i_mot1<0)||(i_mot2<0)) return 0;
  indice=valh1=H2Value(i_mot1,i_mot2,pt_ml);
  valh2=Double2H(i_mot1,i_mot2,pt_ml);
  for (essai=1;(essai<=pt_ml->NB2GRAM)&&(Case2Vide(indice,pt_ml)==0)&&
  	(!SiEgal2(i_mot1,i_mot2,indice,pt_ml));essai++)
   indice=EssaiSuivant(valh1,valh2,essai,pt_ml->NB2GRAM);
  if ((essai<=pt_ml->NB2GRAM)&&(Case2Vide(indice,pt_ml)==0))
   {
   *lp=pt_ml->TABL2GRAM[indice].lp;
   *fr=pt_ml->TABL2GRAM[indice].fr;
   return 1;
   }
  return 0;
  }
  
  int HashRecherche3Gram(wrd_index_t i_mot1 ,wrd_index_t i_mot2 ,wrd_index_t i_mot3 ,flogprob_t *lp ,ty_ml pt_ml)
  {
  wrd_index_t essai,indice,valh1,valh2;
  if ((i_mot1<0)||(i_mot2<0)||(i_mot3<0)) return 0;
  indice=valh1=H3Value(i_mot1,i_mot2,i_mot3,pt_ml);
  valh2=Double3H(i_mot1,i_mot2,i_mot3,pt_ml);
  for (essai=1;(essai<=pt_ml->NB3GRAM)&&(Case3Vide(indice,pt_ml)==0)&&
  	(!SiEgal3(i_mot1,i_mot2,i_mot3,indice,pt_ml));essai++)
   indice=EssaiSuivant(valh1,valh2,essai,pt_ml->NB3GRAM);
  if ((essai<=pt_ml->NB3GRAM)&&(Case3Vide(indice,pt_ml)==0))
   {
   *lp=pt_ml->TABL3GRAM[indice].lp;
   return 1;
   }
  return 0;
  }
  
  /*................................................................*/
  
  /*  Recherche des NGrams par dichotomie  */
  
  int DichoRecherche1Gram(wrd_index_t i_mot , flogprob_t *lp ,flogprob_t *fr ,ty_ml pt_ml)
  {
  type_1gram *resu,key;
  key.cle[0]=BYTE1(i_mot); key.cle[1]=BYTE2(i_mot); key.cle[2]=BYTE3(i_mot);
  resu=(type_1gram*)bsearch((void*)(&key),pt_ml->TABL1GRAM,pt_ml->NB1GRAM+MARGE,
  	sizeof(type_1gram),H1compar);
  if (resu==NULL) return 0;
  *lp=resu->lp; *fr=resu->fr;
  return 1;
  }
  
  int DichoRecherche2Gram(wrd_index_t i_mot1 ,wrd_index_t i_mot2 ,flogprob_t *lp ,flogprob_t *fr ,ty_ml pt_ml)
  {
  type_2gram *resu,key;
  key.cle[0]=BYTE1(i_mot1); key.cle[1]=BYTE2(i_mot1); key.cle[2]=BYTE3(i_mot1);
  key.cle[3]=BYTE1(i_mot2); key.cle[4]=BYTE2(i_mot2); key.cle[5]=BYTE3(i_mot2);
  resu=(type_2gram*)bsearch((void*)(&key),pt_ml->TABL2GRAM,
  	pt_ml->NB2GRAM+MARGE,sizeof(type_2gram),H2compar);
  if (resu==NULL) return 0;
  *lp=resu->lp; *fr=resu->fr;
  return 1;
  }
  
  int DichoRecherche3Gram(wrd_index_t i_mot1 ,wrd_index_t i_mot2 ,wrd_index_t i_mot3 ,flogprob_t *lp ,ty_ml pt_ml)
  {
  type_3gram *resu,key;
  key.cle[0]=BYTE1(i_mot1); key.cle[1]=BYTE2(i_mot1); key.cle[2]=BYTE3(i_mot1);
  key.cle[3]=BYTE1(i_mot2); key.cle[4]=BYTE2(i_mot2); key.cle[5]=BYTE3(i_mot2);
  key.cle[6]=BYTE1(i_mot3); key.cle[7]=BYTE2(i_mot3); key.cle[8]=BYTE3(i_mot3);
  resu=(type_3gram*)bsearch((void*)(&key),pt_ml->TABL3GRAM,
  	pt_ml->NB3GRAM+MARGE,sizeof(type_3gram),H3compar);
  if (resu==NULL) return 0;
  *lp=resu->lp;
  return 1;
  }
  
  /*................................................................*/
  
  /*  Fonctions de recherche generiques  */
  
  int Recherche1Gram(wrd_index_t i_mot , flogprob_t *lp ,flogprob_t *fr ,ty_ml pt_ml)
  {
  if (pt_ml->GRAM_SI_HASH)
   return HashRecherche1Gram(i_mot,lp,fr,pt_ml);
  else
   return DichoRecherche1Gram(i_mot,lp,fr,pt_ml);
  }
  
  int Recherche2Gram(wrd_index_t i_mot1 ,wrd_index_t i_mot2 ,flogprob_t *lp ,flogprob_t *fr ,ty_ml pt_ml)
  {
  if (pt_ml->GRAM_SI_HASH)
   return HashRecherche2Gram(i_mot1,i_mot2,lp,fr,pt_ml);
  else
   return DichoRecherche2Gram(i_mot1,i_mot2,lp,fr,pt_ml);
  }
  
  int Recherche3Gram(wrd_index_t i_mot1 ,wrd_index_t i_mot2 ,wrd_index_t i_mot3 ,flogprob_t *lp ,ty_ml pt_ml)
  {
  if (pt_ml->GRAM_SI_HASH)
   return HashRecherche3Gram(i_mot1,i_mot2,i_mot3,lp,pt_ml);
  else
   return DichoRecherche3Gram(i_mot1,i_mot2,i_mot3,lp,pt_ml);
  }
  
  /*................................................................*/
  
  /*  Fonction renvoyant la proba d'un 3-gram selon la formule :
  
  p(wd3|wd1,wd2)= if(trigram exists)           p_3(wd1,wd2,wd3)
  		else if(bigram w1,w2 exists) bo_wt_2(w1,w2)*p(wd3|wd2)
  		else                         p(wd3|w2)
  
  p(wd2|wd1)= if(bigram exists) p_2(wd1,wd2)
  	    else              bo_wt_1(wd1)*p_1(wd2)
  */
  
  err_t gram_proba_to_bigram(logprob_t *proba,const wrd_index_t wrd1,
  			 const wrd_index_t wrd2,const int num_ml, const err_t trace)
  {
  flogprob_t lp,fr,lp1,fr1,lp2,fr2;
  
  if ((num_ml>NB_ML)||(Table_ML[num_ml]==NULL))
   {
   fprintf(stderr,"Le ML numero:%d n'existe pas .... NB_ML=%d
  ",num_ml,NB_ML);
   exit(0);
   }
  
  if (trace & SIR_GRAM_TRACE)
   fprintf(stderr,"GRAM : P(%d,%d)
  ",wrd1,wrd2);
  
  if (Recherche2Gram(wrd1,wrd2,&lp,&fr,Table_ML[num_ml]))
   {
   if (trace & SIR_GRAM_TRACE)
    {
    fprintf(stderr,"J'ai trouve le bigramme : %ld %ld
  ",wrd1,wrd2);
    fprintf(stderr,"  avec : lp=%f et fr=%f
  ",lp,fr);
    }
   *proba=(logprob_t)lp;
   return CORRECT;
   }
  else
   {
   if (trace & SIR_GRAM_TRACE)
    fprintf(stderr,"Je n'ai pas trouve le bigramme : %ld %ld
  ",wrd1,wrd2);
   if (!Recherche1Gram(wrd1,&lp1,&fr1,Table_ML[num_ml]))
    {
    if (trace & SIR_GRAM_TRACE) fprintf(stderr,"(hash) je ne trouve pas : %d
  ",wrd1);
    return GRAM_CODE_UNKNOWN;
    }
   if (!Recherche1Gram(wrd2,&lp2,&fr2,Table_ML[num_ml]))
    {
    if (trace & SIR_GRAM_TRACE) fprintf(stderr,"(hash) je ne trouve pas : %d
  ",wrd2);
    return GRAM_CODE_UNKNOWN;
    }
   if (trace & SIR_GRAM_TRACE)
    fprintf(stderr,"Backoff sur l'unigramme avec : P(%ld)=%f et FR(%ld)=%f d'ou lp=%f
  ",
  	wrd2,lp2,wrd1,fr1,fr1+lp2);
   *proba=(logprob_t)(fr1+lp2);
   return CORRECT;
   }
  }
  
  err_t gram_proba_to_trigram(logprob_t *proba,const wrd_index_t wrd1,const wrd_index_t wrd2,
  	const wrd_index_t wrd3,const int num_ml,const err_t trace)
  {
  flogprob_t lp,fr,lp1,fr1,fr2;
  logprob_t lp2;
  err_t reto;
  
  if ((num_ml>NB_ML)||(Table_ML[num_ml]==NULL))
   {
   fprintf(stderr,"Le ML numero:%d n'existe pas .... NB_ML=%d
  ",num_ml,NB_ML);
   exit(0);
   }
  
  if (Table_ML[num_ml]->GRAM_SI_2G==1) return SIR_FATAL_ERR;
  
  if (trace & SIR_GRAM_TRACE)
   fprintf(stderr,"GRAM : P(%d,%d,%d)
  ",wrd1,wrd2,wrd3);
  
  if (Recherche3Gram(wrd1,wrd2,wrd3,&lp,Table_ML[num_ml]))
   { *proba=(logprob_t)lp; return CORRECT; }
  else
   {
   if (!Recherche2Gram(wrd1,wrd2,&lp1,&fr1,Table_ML[num_ml]))
    {
    if (trace & SIR_GRAM_TRACE)
     fprintf(stderr,"(hash) je ne trouve pas : %d %d
  ",wrd1,wrd2);
    fr1=0;
    }
   reto=gram_proba_to_bigram(&lp2,wrd2,wrd3,num_ml,trace);
   if (reto!=CORRECT) return reto;
   *proba=(logprob_t)fr1+lp2;
  
   return CORRECT;
   }
  }
  
  /*................................................................*/