/******************************************
 *
 *   Cedric Pradalier   2001
 *   mail : http://cedric.pradalier.free.fr/mail.html
 *
 *****************************************/



#include "output.h"
#include "lignes_gen.h"
#include <string.h>


/**********************************************

  Implementation des lignes contenant 
  des horaires generaux (un tram tous les 
   min) Deux differences :
   + Donnees de frequence de passage et de
    temps de trajet indicatif
   + Calcul particulier des horaires des 
    passages.

***********************************************/



CLignesGen::CLignesGen(char * rep,char * name,int i) :
    CLignes(rep,name,i)
{
    TempsIndic = NULL;
    Frequence = HNULL;
}


/* Affichage complementaire */
void CLignesGen::Print()
{
    CLignes::Print();
    sprintf(outbuf,"Frequences de passage : ");FlushBuffer();Frequence.Print();
        sprintf(outbuf,"\n");FlushBuffer();
    for (int i=0;i<nArretsRef-1;i++)
    {
        sprintf(outbuf," <- %i -> ",i);FlushBuffer();
        fflush(NULL);
        TempsIndic[i].Print();
    }
    sprintf(outbuf," <- %i ->\n",nArretsRef-1);FlushBuffer();
}



/* Chargement adapte des horaires */
void CLignesGen::LoadHoraires(TypeHoraire t,CBDArrets * liste)
{
    CLignes::LoadHoraires(t,liste);
    
    int Freqs[4];
    FILE * fp;
    char temp[127] = "horaires/\0";
    int i,n = 0;
    strcat(temp,mRep);
    n = strlen(temp) + 1;
    
    /* Recherche de la frequence de passage */
    strcat(temp,"/frequences");
    
    if ((fp = fopen(temp,"r")) == NULL)
    {   
        sprintf(outbuf,"Impossible d'ouvrir %s\n",temp);FlushBuffer();
        exit(1);
    }
    fscanf(fp,"BLANC = %d \n",&(Freqs[0]));
    fscanf(fp,"ORANGE = %d \n",&(Freqs[1]));
    fscanf(fp,"BLEU = %d \n",&(Freqs[2]));
    fscanf(fp,"VERT = %d \n",&(Freqs[3]));
    fclose(fp);
    Frequence = CHoraire(Freqs[t]);

    /* Lecture des temps de trajet indicatif */
    temp[n] = 0; /* oubli de la fin de la chaine */
    strcat(temp,"/temps.trajet");
    if ((fp = fopen(temp,"r")) == NULL)
    {   
        sprintf(outbuf,"Impossible d'ouvrir %s\n",temp);FlushBuffer();
        exit(1);
    }
    // on suppose que les references sont les memes que pour les horaires
    fscanf(fp,"#arrets = %d \n",&nArretsRef);
    TempsIndic = new CHoraire[nArretsRef-1];
    for (i=0;i<nArretsRef-1;i++)
    {
        fgets(temp,127,fp);/* on saute une ligne */
        fscanf(fp,"\t %d \n",&n);
        TempsIndic[i] = CHoraire(n);
    }
    fclose(fp);
}



/* Calcul le temps de trajet indicatif entre 2 arrets 
   a partir des temps de trajets indicatif
*/
CHoraire CLignesGen::GetTempsTrajet(int IndDepart,int IndArrivee)
{
    /* supposition : les 2 indices existent */
    /* IndDepart<IndArrivee : TypeHoraire */
    SensTrajet sens = (SensTrajet) (IndDepart>IndArrivee);
    InterPol dataD,dataA;
    /* ici le sens n'est pas important, quitte a 
    inverser depart et arrivee, on peut supposer
    que qu'on est dans le sens aller, la somme etant
    associative et commutative et tous les termes
    positif, le resultat ne change pas (faire un dessin)*/
    if (sens == s_aller)
    {
        dataD = DonneesInterpol[0][IndDepart];
        dataA = DonneesInterpol[0][IndArrivee];
    }
    else
    {
        dataD = DonneesInterpol[0][IndArrivee];
        dataA = DonneesInterpol[0][IndDepart];
    }
    CHoraire Res=CHoraire(0,0),h;
    int i;
    /* Res vaut 00:00 */
    for (i=dataD.NumArretRef;i<dataA.NumArretRef;i++)
    {
        Res = Res + TempsIndic[i];
    }
    h=CHoraire(0,0);
    if (dataA.NumArretInter != 0)
        Res = Res + h.Interpol(TempsIndic[dataA.NumArretRef],dataA.NumArretInter,dataA.NbArretsInter);
    if (dataD.NumArretInter != 0)
        Res = Res - h.Interpol(TempsIndic[dataD.NumArretRef],dataD.NumArretInter,dataD.NbArretsInter);
    return Res;
}



// Renvoie l'horaire de passage a l'arret 1
// Sachant qu'on veut etre a l'arret 2 avant
// l'horaire limite 
// renvoie HNULL en cas de Pb
CHoraire CLignesGen::Passage(CArrets * depart,CArrets * arrivee,CHoraire & limite)
{
    SensTrajet s;
    int trajet;
    int IndDepart,IndArrivee;
    CHoraire Passe;
//  sprintf(outbuf,"On entre dans le passage_gen (%s) ...\n",mName);FlushBuffer();
    if ((s=FindDirection(depart,arrivee)) == nonsens)
        return HNULL; // impossible de trouver depart ou arrivee
//  sprintf(outbuf,"Sens OK(%i) // cherchons le trajet...\n",s);FlushBuffer();
    if (((IndDepart = Indice(s,depart)) == -1) || ((IndArrivee = Indice(s,arrivee)) == -1))
        return HNULL;
//  sprintf(outbuf,"les arrets sont coherents.\n");FlushBuffer();
    if ((trajet = horaires[s].FindTrajet(IndArrivee,limite)) < 0)
        return HNULL; // arret introuvable ou pas d'horaire possible
//  sprintf(outbuf,"ce trajet (%i) est il possible ?\n",trajet);FlushBuffer();
    if ((trajet = horaires[s].FindFirstTrajetValid(trajet,IndDepart,IndArrivee)) < 0)
        return HNULL; // pas d'horaire possible
//  sprintf(outbuf,"Ya pus k interpoler le depart (%i)...\n",trajet);FlushBuffer();
    Passe = horaires[s].Interpol(trajet,IndDepart);
    if (Passe.IsGeneric())
    {
        CHoraire tmp = GetTempsTrajet(IndDepart,IndArrivee);
        /* Le Tram passe une fois toute les Frequence minute
        on sait donc que durant le temps de trajet indicatif
        plus cette Frequence, il passera au moins un Tram */
        Passe = (limite - tmp) - Frequence;
    }
    else
    {
        limite = horaires[s].Interpol(trajet,IndArrivee);
    }
    return Passe;
}