/* 
 * This file is records.c.
 * 
 * This software and its documentation are in the public domain
 * and are furnished "as is."  The United States government,
 * its instrumentalities, officers, employees, and agents make
 * no warranty, express or implied, as to the usefulness of the
 * software and documentation for any purpose.  They assume no
 * responsibility (1) for the use of the software and
 * documentation; or (2) to provide technical support to users.
 * 
 * This file contains low level routines for manipulating the records 
 * of an EBUFR  file.
 */

#include "standard.h"
#include <malloc.h>
#include <stdio.h>
#include <errno.h>
#include "records.h"

   /* The following are provided as hooks for environments */
   /* where something must be done to delimit records.     */
#define startRecord(Out) ;
#define endRecord(Out)   ;

/* 
 * The following are hooks to report errors to the calling 
 * program.  None are expected to return. 
 * 
 * In order to create a program that uses the routines in records.c, A 
 * PROGRAMMER MUST CREATE THE FOLLOWING ROUTINES in her main program.  
 * This allows the programmer flexibility in deciding how to handle 
 * errors without being forced to check an error status after every 
 * call to one of the routines in this file.
 */
  
extern void reportBadRecord(/* char *s */) ;
extern void reportFatal(/* char *s */) ;
extern void reportIOError(/* char *s */) ;


      /* This buffer is used below to store up to one record's worth */
      /* of EBUFR input. */

static char EbufrBuffer[EBUFRMAXSIZE] ;



/*
 * The following 6 odd routines are written for use in programs that
 * wish to access an EBUFR file on  a record by record or entity by
 * entity basis.  `readHeader` reads the header of the next record
 * on the appropriate input stream.  Based on the contents of that
 * header one might want to copy the corresponding entity or record to
 * another file with `copyRecord` or `copyEntity`, or skip past the
 * corresponding record or entity with `skipRecord` or `skipEntity`.
 *
 * A note on terminology:  A record means an EBUFR record, which can
 * be up to EBUFRMAXSIZE bytes long.  An entity means (in the case of data
 * records at least) one complete observation, which may span more
 * than one record (however, a record never contains information from 
 * more than one entity.  See the comments in records.h for the format 
 * of multi-record entities.)
 */

/* 
 * ---------------------------------------------------------------------------
 * Name:  copyEntity
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to copy one entity (i.e., one BUFR message, sort of) from 
 * the input stream to the output stream.
 *
 * Description:  This routine examines the header given and copies the
 *    appropriate number of records.  The header must correspond to
 *    the first header of a (possibly multi-record) entity.
 *
 * Parameters:
 *    Header      --  Header of record read from In.
 *    In          --  Stream opened for reading an EBUFR file from
 *                    which Header has just been read.
 *    Out         --  Stream opened for writing an EBUFR file to.
 *
 * Return values:  (none)
 *
 * Dependencies:  In must be a stream opened for reading, from which
 *    Header has just been read; and Out must a stream opened for
 *    writing.
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
void
copyEntity(Header, In, Out)
     EBHeaderPacked_t Header;
     FILE *In ;
     FILE *Out ;
{
    int count, i ;
    Boolean contn ;
    EBHeaderPacked_t ContHdr ;

    count = 1+RecNumOf(Header) ;
    contn = IsContOf(Header) ;

    if (contn)
        reportBadRecord("first record of a series has continuation bit set.") ;
    else
    {
        copyRecord(Header, In, Out) ;
        for (i=2; i<=count; i++)
        {
            if (! readHeader(ContHdr, In))
                reportBadRecord("Missing continuation records.") ;
            if (!isEbufrCtn(Header, ContHdr, i))
                reportBadRecord("Mismatched continuation numbers.") ;
            copyRecord(ContHdr, In, Out) ;
        }
    }
    return ;
}

/* ---------------------------------------------------------------------------
 * Name:  skipEntity
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to skip one entity (i.e., one BUFR message, sort of) on
 * the input stream.
 *
 * Description:  This routine examines the header given and skips the
 *    appropriate number of records.  The header must correspond to
 *    the first header of a (possibly multi-record) entity.
 *
 * Parameters:
 *    Header      --  Header of record read from In.
 *    In          --  Stream opened for reading an EBUFR file from
 *                    which Header has just been read.
 *
 * Return values:  (none)
 *
 * Dependencies:  In must be a stream opened for reading, from which
 *    Header has just been read.
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
void
skipEntity(Header, In)
      EBHeaderPacked_t Header;
      FILE *In ;
{
    int count, i ;
    Boolean contn ;
    EBHeaderPacked_t ContHdr ;

    count = 1+RecNumOf(Header) ;
    contn = IsContOf(Header) ;

    if (contn)
        reportBadRecord("first record of a series has continuation bit set.") ;
    else
    {
        skipRecord(Header, In) ;
        for (i=2; i<=count; ++i)
        {
            if (! readHeader(ContHdr, In))
                reportBadRecord("Missing continuation records.") ;
            if (!isEbufrCtn(Header, ContHdr, i))
                reportBadRecord("Mismatched continuation numbers.") ;
            skipRecord(ContHdr, In) ;
        }
    }
    return ;
}


/* ---------------------------------------------------------------------------
 * Name:  copyRecord
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to copy one record from the input stream
 *    to the output stream.
 *
 * Description:  This routine examines the header given to determine the
 *    number of bytes to copy.  The header must correspond to
 *    that just read from the input stream.
 *
 * Parameters:
 *    Header      --  Header of record read from In.
 *    In          --  Stream opened for reading an EBUFR file from
 *                    which Header has just been read.
 *    Out         --  Stream opened for writing an EBUFR file to.
 *
 * Return values:  (none)
 *
 * Dependencies:  In must be a stream opened for reading, from which
 *    Header has just been read; and Out must a stream opened for
 *    writing.
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
void
copyRecord(Header, In, Out)
     EBHeaderPacked_t Header;
     FILE *In ;
     FILE *Out ;
{
    startRecord(Out) ;
    writeHeader(Header, Out) ;
    copyBytes((int) VSizeOf(Header), In, Out);
    endRecord(Out);
    return ;
}

/* ---------------------------------------------------------------------------
 * Name:  skipRecord
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to skip one EBUFR record on the input stream.
 *
 * Description:  This routine examines the header given and skips the
 *    appropriate number of bytes.  The header must have been the last
 *    item read from the input stream.
 *
 * Parameters:
 *    Header      --  Header of record read from In.
 *    In          --  Stream opened for reading an EBUFR file from
 *                    which Header has just been read.
 *
 * Return values:  (none)
 *
 * Dependencies:  In must be a stream opened for reading, from which
 *    Header has just been read.
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
void
skipRecord(Header, In)
     EBHeaderPacked_t Header;
     FILE *In ;
{
    skipBytes(VSizeOf(Header), In);
    return ;
}

/*
 * The following two routines are low-level routines that are used to
 * copy or skip the variable part of an EBUFR record.
 */

/* 
 * ---------------------------------------------------------------------------
 * Name:  copyBytes
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to copy the variable part size of an EBUFR record from
 *    one stream to another.
 *
 * Description:
 * 
 * Parameters:
 *    n           --  number of bytes to copy.
 *    In          --  stream from which to copy the bytes.
 *    Out         --  stream to which to copy the bytes.
 *
 * Return values:  (none)
 *
 * Dependencies:  In, Out must be appropriately opened streams.
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
void copyBytes(n, In, Out)
     unsigned int n ;
     FILE *In ;
     FILE *Out ;
{
    int m ;

    if (n>(EBUFRMAXSIZE-EBHsize))
        reportFatal("bad record size noticed in copyBytes.") ;

    m = fread(EbufrBuffer, (int) n, 1, In) ;
    if (m != 1)
    {
        if (ferror(In))
            reportIOError("I/O error encountered while reading EBUFR file.");
        else
            reportBadRecord("Unexpected EOF (bad record length)");
    }
    m = fwrite(EbufrBuffer, n, 1, Out) ;
    if (m != 1)
    {
        reportIOError("I/O error encountered while writing EBUFR file.");
    }
    return ;
}

/* 
 * ---------------------------------------------------------------------------
 * Name:  skipBytes
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to skip the variable part size of an EBUFR record from
 *    one stream to another.
 *    
 * Description:
 *
 * Parameters:
 *    n           --  number of bytes to skip.
 *    In          --  stream from which to skip the bytes.
 *    Out         --  stream to which to skip the bytes.
 *
 * Return values:  (none)
 *
 * Dependencies:  In, Out must be appropriately opened streams.
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
#if 0
   /* 
    * The following code has problems because of the interaction
    * of fseek with the fbuffer mechanism.  The following code is UNIX 
    * specific, because it relies on lseek working in numbers of bytes.
    */
#include <sys/types.h>
#include <unistd.h>

void skipBytes(n, In)
     unsigned int n ;
     FILE *In ;
{
  int m ;
  Boolean CantSeek ;

  if (n>(EBUFRMAXSIZE-EBHsize))
    reportFatal("bad record size noticed in skipBytes.") ;

  CantSeek = False ;

  while (n>0)
  {
      m = (n<In->_cnt) ? n : In->_cnt ;
      In->_cnt -= m ;
      In->_ptr += m ;
      n        -= m ;
      if (0==n)
          break ;
      if (!CantSeek)
      {
          m = lseek(fileno(In), (long) n, SEEK_CUR) ;
          if (m>0)
              n = 0 ;
          else
          {
              CantSeek = True ;
              if (ESPIPE != errno)
                  reportIOError("unusual error while attempting to lseek") ;
          }
      }
      else /* CantSeek */
      {
          (void) getc(In) ;
          n-- ;
      }
  }
  return ;
}

#else
    /* Alternative code, till I fix the fseek problem */

void skipBytes(n, In)
     unsigned int n ;
     FILE *In ;
{
  int m ;

  if (n>(EBUFRMAXSIZE-EBHsize))
    reportFatal("bad record size noticed in skipBytes.") ;

  m = fread(EbufrBuffer, (int) n, 1, In) ;
  if (m != 1)
    {
      if (ferror(In))
          reportIOError("IO error reading EBUFR file");
      else
          reportBadRecord("Unexpected EOF (bad record length)");
    }
  return ;
}
#endif

/* 
 * ---------------------------------------------------------------------------
 * Name:  readHeader
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to read the header of an EBUFR record.
 *
 * Parameters:
 *    h           --  Header array into which to copy the header.
 *    In          --  Stream from which to read the header.
 *
 * Description:
 * 
 * Return values:
 *    True   if header was read
 *    False  if EOF detected on input stream.
 *
 * Dependencies:  In must be an appropriately opened stream.
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
Boolean readHeader(h, In)
     EBHeaderPacked_t h ;
     FILE *In ;
{
  int m ;

  m = fread(h, (int) EBHsize, (int) 1, In);

#ifdef DEBUG
  {
    int i ;
    fprintf(stderr, "header:");
    for (i=0;i<VSizeLoc;i++)
      fprintf(stderr, " %d", h[i]) ;
    fprintf(stderr, "%c%c%c%c :\n",
            h[VSizeLoc],
            h[VSizeLoc+1],
            h[VSizeLoc+2],
            h[VSizeLoc+3]) ;
  }
#endif
  if ((0 == m) && feof(In))
    {
      return False;
    }
  else if (m != 1)
    {
      if (ferror(In))
          reportIOError("Error reading EBUFR file");
      else
          reportFatal("This can\'t happen.");
    }
  return True;
}

/* 
 * ---------------------------------------------------------------------------
 * Name:  writeHeader
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to read the header of an EBUFR record.
 * 
 * Description:
 *
 * Parameters:
 *    h           --  Header array from which to copy the header.
 *    Out         --  Stream onto which to write the header.
 *
 * Return values:  (none)
 *
 * Dependencies:  Out must be an appropriately opened stream.
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
void writeHeader(h, Out)
     EBHeaderPacked_t h ;
     FILE *Out ;
{
  int m ;

  m = fwrite(h, EBHsize, 1, Out);
  if (m != 1)
      reportIOError("Error writing EBUFR file");
  return ;
}


/* ---------------------------------------------------------------------------
 * Name:  isEbufrCtn
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to check the consistency of a continuation record header.
 *
 * Description:  This function checks to see that the continuation bit of a
 *    continuation record is set, and that the record number is
 *    appropriate.  It also compares the beginning of the header with
 *    that of the first record in the entity to make sure that it agrees.
 *
 * Parameters:
 *    h1          --  header of the first record in an entity.
 *    h2          --  header of the current record in an entity (the
 *                    header to be checked for consistency).
 *    recno       --  sequence number of the record in the entity
 *                    (first record of the entity = 1, etc.)
 *
 * Return values:
 *    True   if h2 is an appropriate header record for the `recno`th
 *           record of an entity beginning with header h1.
 *    False  otherwise.
 *
 * Dependencies:  (none)
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
Boolean
isEbufrCtn(h1, h2, recno)
     EBHeaderPacked_t h1 ;
     EBHeaderPacked_t h2 ;
     int recno ;
{
    int i ;

    if (recno > 1+RecNumOf(h1))
        return False ;

    for(i=0; i<RecNumLoc; i++)
    {
        if (h1[i] != h2[i])
            return False ;
    }

    return (IsContOf(h2)) && (RecNumOf(h2) == recno-2) ;
}

/* ---------------------------------------------------------------------------
 * Name:  readEntity
 *
 * Author:  David Casperson (4 Nov 1991)
 *
 * Purpose:  to read one entity from an EBUFR file into dynamically
 *    allocated storage.
 *
 * Description:
 *
 * Parameters:
 *   Header       --  array into which to read the header of the next
 *                    entity from stream In.
 *   VPart        --  pointer to string.  On return the string pointed
 *                    to will be dynamically allocated storage
 *                    containing the variable part of the EBUFR entity
 *                    read. 
 *   VSize        --  pointer to integer.  On return the integer
 *                    pointed to will contain the size of VPart (in bytes).
 *   In           --  stream from which to read the entity.
 *
 * Return values:  (none)
 *
 * Dependencies:  In must be an appropriately opened stream.
 *
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
void
readEntity(Header, VPart, VSize, In)
     EBHeaderPacked_t Header ;
     char **VPart ;
     int *VSize ;
     FILE *In ;
{
  int NumRecs, RecNo, RecordSize, TotalSize, MaxSize ;
  EBHeaderPacked_t HeadCont ;
  char *s ;

  readHeader(Header, In) ;

  NumRecs = 1 + RecNumOf(Header)  ;

  MaxSize = (NumRecs > 1) ? NumRecs*EBUFRMAXSIZE : VSizeOf(Header) ;
  TotalSize = 0 ;

  s = *VPart = (char *) malloc(MaxSize) ;

  RecordSize = VSizeOf(Header) ;
  fread(s, RecordSize, 1, In) ;
  TotalSize += RecordSize ;
  s += RecordSize;

  /* Now read the continuation records */

  for (RecNo=2; RecNo<=NumRecs; ++RecNo)
  {
      readHeader(HeadCont, In) ;
      if (!isEbufrCtn(Header, HeadCont, RecNo))
      {
          free(*VPart) ;
          reportBadRecord("Bad continuation record in multi-record entity.") ;
      }
      RecordSize = VSizeOf(HeadCont) ;
      fread(s, RecordSize, 1, In) ;
      s += RecordSize ;
      TotalSize += RecordSize ;
  }

  if (TotalSize != MaxSize)
      *VPart = realloc(*VPart, TotalSize) ;
  *VSize = TotalSize ;
  return ;
}

/* ---------------------------------------------------------------------------
 * Name:  writeEntity
 * 
 * Author:  David Casperson (4 Nov 1991)
 * 
 * Purpose:  to write one entity defined by a header and a variable 
 *    part to an output stream.
 *    
 * Description:
 * 
 * Parameters:  
 *    Header      --  Standard EBUFR header to use in creating headers 
 *                    for the records of the entity to be written.  
 *                    (The last five bytes are ignored and replaced by 
 *                    appropriate values.)
 *    Body        --  pointer to an array of charaters containing the 
 *                    variable part of the EBUFR entity to be written.
 *    Size        --  Number of bytes in Body.
 *    Out         --  Stream on which to write the entity.
 *                    
 * Return values:  (none)
 * 
 * Dependencies:  Out must be an appropriately opened and positioned 
 *     stream.  If special record blocking is required on output, the 
 *     routines startRecord and endRecord must be appropriately declared.
 *    
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
void
writeEntity(Header, Body, Size, Out)
     EBHeaderPacked_t Header ;
     char *Body ;
     int Size ;
     FILE *Out ;
{
    int NumRecs, RecNo ;
    char *s, *bufptr ;
    char V[6] ;
    int NLeft ;
    int length ;

    NumRecs = Size / (EBUFRMAXSIZE-EBHsize) ;
    if (NumRecs*(EBUFRMAXSIZE-EBHsize)<Size)
        ++NumRecs;

    NLeft = Size ;
    s = Body ;

    for (RecNo=1; RecNo<=NumRecs; ++RecNo)
    {
        /* Create a new record in EbufrBuffer */

        /* First, copy the fixed part of the header */
        bufptr = EbufrBuffer ;
        memcpy(bufptr, Header, EBHsize-5) ;
        bufptr += (EBHsize-5) ;

        /* Next, the continuation, rec number byte */
        *bufptr++ = ((1==RecNo) ? (NumRecs-1) : (0x80 | (RecNo-2))) ;

        /* Now compute the length of this record, and copy the VSize field*/
        length = (RecNo==NumRecs) ? NLeft : (EBUFRMAXSIZE-EBHsize) ;
        sprintf(bufptr, "%04.4d", length) ;
        bufptr += 4 ;
        
        /* Finally, copy the promised number bytes in the variable part */
        memcpy(bufptr, s, length) ;
        bufptr += length ;

        /* Write the record */
        startRecord(Out) ;
        fwrite(EbufrBuffer, bufptr-EbufrBuffer, 1, Out) ;
        endRecord(Out) ;

        /* and update the pointers to the rest of the variable part */
        s += length ;
        NLeft -= length ;
    }
    return ;
}

/* 
 * ---------------------------------------------------------------------------
 * Name:  nextRecordType
 * 
 * Author:  David Casperson (4 Nov 1991)
 * 
 * Purpose:  to find out what type of record is next on the input stream.
 *
 * Description:
 * 
 * Parameters:  
 *    In          --  stream opened for reading on an EBUFR file.
 *                    
 * Return values:  type of next record or EOF if stream is at end of file.
 *
 * Dependencies:  In must be a stream with buffering for this routine 
 *    to work correctly.
 *  
 * Modification:  (none)
 * ---------------------------------------------------------------------------
 */
int nextRecordType(In)
     FILE *In ;
{
    register int n ;

    n = getc(In) ;
    if (EOF != n)
        ungetc(n, In) ;

    return n ;
}