#include "../h/licasc.h"

/*
 =======================================================================

     ecrasc = ecriture ou mise a jour d'une serie dans un fichier
                   ascii.

     parametres =
        e       fdfic   = descripteur du fichier.
        e       rvalt   = tableau contenant les valeurs de la serie,
        e       kser    = cle de la serie ( 0 pour entete),
        e       iechd   = rang du premier echantillon,
        e       nvals   = nombre de valeurs dans la serie,
        e       nechs   = nombre d'echantillon maximum de la serie,
        e       nvecs   = nombre de vecteurs dans la serie,
        e       nech    = nombre d'echantillons a ecrire,
        e       zvalt   = commentaires associes a chaque echantillon,

     retourne =
            kerr        = indicateur d'erreur :
                           -3 = tentative d'ecriture d'une serie
                             deja existante,
                           -2 = tentative de mise a jour d'une serie
                             non existante,
                           -1 = rang du premier echantillon superieur au
                             nombre d'echantillons disponibles.
                            0 = absence d'erreur,


     generiques =
         err    = erreur
      P...      = pointeur
      S...      = structure
       ...t     = tableau

     auteur = marimai.henaff    iut.orsay
     version 1.1 du 02/01/95

 =======================================================================
*/

int ecrasc ( fdfic, rvalt, kser, iechd, nvals, nvecs, nechs, nech, zvalt)
FILE    *fdfic;
float   rvalt[];
int     *kser, *iechd, *nvals, *nvecs, *nechs, *nech;
char    *zvalt[];

{

/* ... variables globales ... */

extern  char    *Pzcomsert[NCOMM];

        /* ... variables locales ... */

        int     kerr;
        int     bmaj, bins, bser ;
        int     iech, icom, ivec, ilig, ival, icar;

        long    lposd, lposf, lposs, lpos;

        char    zser[LLIGM], zsers[LLIGM], zvec[LLIGM] ;
        char    zlig[LLIGM], zligw[LLIGM] ;

        FILE    *fdtmp;

        /* ... initialisations ...................................... */

        kerr = 0 ;
        iech = 0 ;
        ivec = 1 ;
        icom = 0 ;
        bins = 0 ;
        bmaj = 0 ;
        bser = 0 ;
        lposs = 0 ;
        lposf = 0 ;
        lposd = 0 ;

        if ( *kser) {
           sprintf ( zser, "%s%d", ZCLESER, *kser ) ;
        }
        else {
           sprintf ( zser, "%s", ZCLEENT) ;
        }

        /* ... debut du traitement .................................. */

        fseek ( fdfic, 0, 0) ;

        /* .......................................................... */
        /* ...1er passage: boucle d'analyse du contenu du fichier ... */
        /* .......................................................... */

        while ( ( !bins ) && ( !feof ( fdfic)) ) {

           fgets ( zlig, LLIGM, fdfic) ;

           if ( bser == 0) {

              /* ... detection de la cle serie ... */

              if ( strncmp ( zlig, zser, strlen(zser)) == 0) {

                 bser = 1 ;

                 if ( *iechd == 0) {
                    /*...erreur:ecriture d'une serie deja existante...*/
                    return ( -3) ;
                 }
                 else {
                    bmaj = 1 ;
                 }
              }
           }
           else {

              /* ... detection d'un echantillon ... */

              if ( strncmp ( zlig, ZCLECOM, strlen(ZCLECOM)) != 0) {

                 if ( ( strncmp ( zlig, ZCLE, strlen(ZCLE)) != 0) &&
                    ( ! ligspc ( zlig, LLIGM)) ) {
                    iech++ ;

                    /* ... rang du premier echantillon atteint ... */

                    if ( iech == *iechd) {
                       lposd = lpos  ;
                    }

                    /* ... rang du dernier echantillon atteint ... */

                    if (iech == *iechd + *nech - 1) {
                          lposf = lpos ;
                    }

                 }

              }
              else {

                 if ( !lposs) lposs = lpos ;
              }

           }

           /* ... detection d'une nouvelle cle serie ... */

           if ( strncmp ( zlig, ZCLESER, strlen(ZCLESER)) == 0) {
              icar = 0 ;
              while ( isgraph ( zlig[icar])) icar++ ;
              strncpy ( zsers, zlig, icar) ;
              if ( strncmp ( zsers, zser, icar) > 0) {
                 if ( !lposs) lposs = lpos ;
                 bins = 1 ;
              }
           }
           else {
              if ( strncmp ( zlig, ZCLECOM, strlen(ZCLECOM)) == 0) {
                 if ( !lposs) lposs =lpos ;
              }
              else {
                 if ( ! ligspc ( zlig, LLIGM)) lposs = 0 ;
              }
           }

           lpos = ftell ( fdfic) ;


        } /* fin boucle analyse */

        /* ... erreur: maj d'une serie non existante ... */

        if ( ( *iechd) && ( !bmaj)) {
           return ( -2) ;
        }

        /* ... rang du premier echantillon superieur au nombre ... */
        /* ... d'echantillons disponibles ........................ */

        if ( bser && !lposd) {
           kerr = -1 ;
        }


        /* ........................................................ */
        /* ... 2eme passage : recopie dans fichier tmp et insertion */
        /* ........................................................ */

        if ( bins) {

           /* ... ouverture d'un fichier temporaire ... */

           fdtmp = tmpfile() ;

           /* ... place le pointeur en debut de fichier d'entree ... */

           fseek ( fdfic, 0, 0) ;

           /* ... recopie le fichier jusqu'a la serie ... */

           if ( !bmaj) lposd = lposs ;

            while ( ftell ( fdfic) < lposd ) {
               fgets ( zlig, LLIGM, fdfic);
               fputs ( zlig, fdtmp);
           }

           /* ... si la serie est creee, on recopie l'entete ... */

           if ( !bmaj) {

              for( icom = 0; icom < NCOMM; icom++) {
                 fputs ( Pzcomsert[icom], fdtmp) ;
                 fputc ( '\n', fdtmp) ;
              }
              fputs ( zser, fdtmp) ;
              fputc ( '\n', fdtmp) ;

              sprintf ( zvec, "%s%s1", ZCLE, ZCLEVEC) ;
              fputs ( zvec, fdtmp) ;
              for ( ivec = 2; ivec <= *nvecs; ivec++) {
                 sprintf ( zvec, ",%s%d", ZCLEVEC,ivec) ;
                 fputs ( zvec, fdtmp) ;
              }
              fputc ( '\n', fdtmp) ;
           }

           /* ... ecriture des commentaires et echantillons ... */

           for ( iech = 0; iech < *nech; iech++) {
              fputs ( zvalt[iech], fdtmp) ;
              for ( ivec = 0; ivec < *nvecs; ivec++) {
                 ival = (ivec * *nechs) + iech;
                 sprintf ( zlig, "\t%f", rvalt[ival]) ;
                 fputs ( zlig, fdtmp) ;
              }
              fputc ( '\n', fdtmp) ;
           }

           /* ... si il y a maj, on place le pointeur apres le ... */
           /* ... dernier echantillon a modifier ... */

           if ( bmaj) {
              if (!lposf)  {
                 lposf = lposs ;
              }
              else {
                 lposs = -1 ;
              }
              fseek ( fdfic, lposf, 0) ;
           }

           /* ... recopie le reste du fichier .. */

           if ( lposs == -1) fgets ( zlig, LLIGM, fdfic) ;

           while ( !feof ( fdfic)) {
              fgets ( zlig, LLIGM, fdfic) ;
              fputs ( zlig, fdtmp) ;
           }

           /* ... recopie le fichier temporaire dans ... */
           /* ... l'ancien fichier ...*/

           fseek ( fdtmp, 0, 0) ;
           fseek ( fdfic, 0, 0) ;
           fgets ( zlig, LLIGM, fdtmp) ;
           fgets ( zligw, LLIGM, fdtmp) ;

           while ( !feof ( fdtmp) ) {
              fputs ( zlig, fdfic) ;
              strcpy ( zlig, zligw) ;
              fgets ( zligw, LLIGM, fdtmp) ;
           }

        }

        /* ... si la serie doit etre ecrite en fin de fichier ... */

        else {

           /* ... place le pointeur en fin de fichier ... */

           if ( bmaj) {
              if ( lposd) {
                 fseek ( fdfic, lposd, 0) ;
              }
              else {
                 if ( lposs) {
                    fseek ( fdfic, lposs, 0) ;
                 }
                 else {
                    fseek ( fdfic, 0, 2) ;
                 }
              }
           }
           else {
              fseek ( fdfic, 0, 2) ;

              /* ... si la serie est creee, on recopie l'entete ... */

              for( icom = 0; icom < NCOMM; icom++) {
                 fputs ( Pzcomsert[icom], fdfic) ;
                 fputc ( '\n', fdfic) ;
              }

              fputs ( zser, fdfic) ;
              fputc ( '\n', fdfic) ;

              sprintf ( zvec, "%s%s1", ZCLE, ZCLEVEC) ;
              fputs ( zvec, fdfic) ;
              for ( ivec = 2; ivec <= *nvecs; ivec++) {
                 sprintf ( zvec, ",%s%d", ZCLEVEC,ivec) ;
                 fputs ( zvec, fdfic) ;
              }
              fputc ( '\n', fdfic) ;

           }

           /* ... ecriture des commentaires et echantillons ... */

           for ( iech = 0; iech < *nech; iech++) {
              fputs ( zvalt[iech], fdfic) ;
              for ( ivec = 0; ivec < *nvecs; ivec++) {
                 ival = (ivec * *nechs) + iech ;
                 sprintf ( zlig, "\t%f", rvalt[ival] ) ;
                 fputs ( zlig, fdfic) ;
              }
              fputc ( '\n', fdfic) ;
           }

        }

        /* ... fin du traitement .................................... */

        return ( kerr) ;

}