/*************************************************************************\
* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
* National Laboratory.
* Copyright (c) 2002 The Regents of the University of California, as
* Operator of Los Alamos National Laboratory.
* This file is distributed subject to a Software License Agreement found
* in the file LICENSE that is included with this distribution. 
\*************************************************************************/

/* program: sddsquery.c
 * purpose: read an SDDS file header and summarize it 
 * Michael Borland, 1993
 $Log: sddsquery.c,v $
 Revision 1.20  2009/07/02 19:38:24  soliday
 Fixed a bug listing the correct endianness on little endian computers.

 Revision 1.19  2005/11/07 21:48:11  soliday
 Updated to remove Linux compiler warnings.

 Revision 1.18  2002/08/14 17:12:52  soliday
 Added Open License

 Revision 1.17  2001/01/10 19:35:44  soliday
 Standardized usage message.

 Revision 1.16  2000/09/19 20:15:07  borland
 Now indicates whether binary file is big or little endian, if data is available.

 Revision 1.15  1999/11/09 19:08:01  borland
 Added -readAll option to force reading the entire file.  This prevents
 "broken pipe" errors and "child killed" errors on Solaris.

 Revision 1.14  1999/05/25 19:14:07  soliday
 Removed compiler warning on linux.

 Revision 1.13  1999/01/06 19:54:53  borland
 Fixed the version number in the usage message.

 Revision 1.12  1998/08/24 20:09:12  soliday
 Fixed bug with version option

 Revision 1.11  1996/06/11 22:10:41  borland
 Fixed bug for -pipe=in (was printing NULL filename).

 * Revision 1.10  1996/04/07  23:35:55  borland
 * Will now do sdds output to stdout.
 *
 * Revision 1.9  1996/03/21  15:30:43  borland
 * More conditional compilation for Solaris broken pipe problem.
 *
 * Revision 1.8  1996/03/12  04:56:34  borland
 * Added conditional compilation around SDDS_Terminate() call (for Solaris only).
 *
 * Revision 1.7  1996/01/24  20:44:49  borland
 * Added SDDS_Terminate call before exit to avoid "Broken Pipe" errors from
 * Solaris.
 *
 * Revision 1.6  1995/11/13  21:53:06  borland
 * Replaced ptr with ptr?ptr:NULL in all sprintf statements to avoid segmentation
 * faults under Solaris.
 *
 * Revision 1.5  1995/10/05  23:13:45  borland
 * Changed exit(1) to exit(0) for -column, -parameter, and -array normal
 * termination.
 *
 * Revision 1.4  1995/09/29  17:22:12  borland
 * Added -sddsOutput option and code to implement it.
 *
 * Revision 1.3  1995/09/06  14:57:01  saunders
 * First test release of SDDS1.5
 *
 */
#include "mdb.h"
#include "SDDS.h"
#include "scan.h"

#define SET_COLUMN_LIST 0
#define SET_PARAMETER_LIST 1
#define SET_ASSOCIATE_LIST 2
#define SET_ARRAY_LIST 3
#define SET_DELIMITER 4
#define SET_APPEND_UNITS 5
#define SET_VERSION 6
#define SET_PIPE 7
#define SET_SDDSOUTPUT 8
#define SET_READALL 9
#define N_OPTIONS 10

char *option[N_OPTIONS] = {
    "columnlist", "parameterlist", "associatelist", "arraylist", "delimiter",
    "appendunits", "version", "pipe", "sddsoutput", "readall",
    } ;


char *USAGE="sddsquery [-pipe[=input]] [<SDDSfilename>] [<SDDSfilename>...]\n\
[-sddsOutput[=<filename>]]\n\
[-arraylist | -associatelist | -columnlist | -parameterlist | -version]\n\
[-delimiter=<delimiting-string>] [-appendunits[=bare]] [-readAll]\n\n\
sddsquery accesses a series of SDDS files and summarizes the file header for each.  It also provides lists of arrays, columns,\
 parameters, or associates.\n\
Program by Michael Borland.  (This is version 5, November 1999.)\n";

long InitializeSDDSHeaderOutput(SDDS_DATASET *outSet, char *filename);
long MakeSDDSHeaderSummary(SDDS_DATASET *outSet, SDDS_DATASET *inSet, long listRequest, char *inputFile);
long MakeColumnHeaderSummary(SDDS_DATASET *outSet, SDDS_DATASET *inSet, char *inputFile);
long MakeParameterHeaderSummary(SDDS_DATASET *outSet, SDDS_DATASET *inSet, char *inputFile);
long MakeArrayHeaderSummary(SDDS_DATASET *outSet, SDDS_DATASET *inSet, char *inputFile);

int main(int argc, char **argv)
{
  SDDS_DATASET SDDS_dataset, SDDSout;
  SDDS_LAYOUT *layout;
  COLUMN_DEFINITION *coldef;
  PARAMETER_DEFINITION *pardef;
  ARRAY_DEFINITION *arraydef;
  long list_request;
  char s[SDDS_MAXLINE];
  char **filename, *ptr, *sddsOutputFile;
  long i, i_arg, filenames, file, append_units, sddsOutput;
  SCANNED_ARG *s_arg;
  char *text, *contents, *delimiter, *unitsTemplate;
  FILE *fp;
  unsigned long pipeFlags;
  long readAll;
  
  list_request = -1;
  filename = NULL;
  sddsOutput = 0;
  filenames = append_units = 0;
  delimiter = sddsOutputFile = unitsTemplate = NULL;
  pipeFlags = 0;
  readAll = 0;
  
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&s_arg, argc, argv);

  for (i_arg=1; i_arg<argc; i_arg++) {
    if (s_arg[i_arg].arg_type==OPTION) {
      delete_chars(s_arg[i_arg].list[0], "_");
      switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
      case SET_COLUMN_LIST:
        list_request = SET_COLUMN_LIST;
        break;
      case SET_PARAMETER_LIST:
        list_request = SET_PARAMETER_LIST;
        break;
      case SET_ASSOCIATE_LIST:
        list_request = SET_ASSOCIATE_LIST;
        break;
      case SET_ARRAY_LIST:
        list_request = SET_ARRAY_LIST;
        break;
      case SET_VERSION:
        list_request = SET_VERSION;
        break;
      case SET_DELIMITER:
        if (s_arg[i_arg].n_items<2)
          SDDS_Bomb("invalid -delimiter syntax");
        delimiter = s_arg[i_arg].list[1];
        break;
      case SET_APPEND_UNITS:
        append_units = 1;
        if (s_arg[i_arg].n_items==2) {
          if (strncmp(s_arg[i_arg].list[1], "bare", strlen(s_arg[i_arg].list[1]))==0)
            unitsTemplate = " %s";
          else
            SDDS_Bomb("invalid -appendUnits syntax");
        }
        else if (s_arg[i_arg].n_items>2) 
          SDDS_Bomb("invalid -appendUnits syntax");
        else
          unitsTemplate = " (%s)";
        break;
      case SET_PIPE:
        if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags))
          SDDS_Bomb("invalid -pipe syntax");
        break;
      case SET_SDDSOUTPUT:
        sddsOutput = 1;
        sddsOutputFile = NULL;
        if ((s_arg[i_arg].n_items!=1 && s_arg[i_arg].n_items!=2) ||
            (s_arg[i_arg].n_items==2 &&
             SDDS_StringIsBlank(sddsOutputFile=s_arg[i_arg].list[1])))
          SDDS_Bomb("invalid -sddsOutput syntax");
        break;
      case SET_READALL:
        readAll = 1;
        break;
      default:
        bomb("unknown switch", USAGE);
        break;
      }
    }
    else {
      filename = trealloc(filename, sizeof(*filename)*(filenames+1));
      filename[filenames++] = s_arg[i_arg].list[0];
    }
  }


  if (!filenames && !(pipeFlags&USE_STDIN))
    bomb(NULL, USAGE);
  if (pipeFlags&USE_STDIN) {
    char **filename1;
    filename1 = tmalloc(sizeof(*filename1)*(filenames+1));
    filename1[0] = NULL;
    for (file=0; file<filenames; file++)
      filename1[file+1] = filename[file];
    if (filename)
      free(filename);
    filename = filename1;
    filenames++;
  }
#ifdef DEBUG
  fprintf(stderr, "files: ");
  for (file=0; file<filenames; file++)
    fprintf(stderr, "%s ", filename[file]?filename[file]:"NULL");
  fprintf(stderr, "\n");
#endif

  if (sddsOutput && !InitializeSDDSHeaderOutput(&SDDSout, sddsOutputFile)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(1);
  }

  for (file=0; file<filenames; file++) {
#ifdef DEBUG
    fprintf(stderr, "working on file %ld\n", file);
#endif
    if (list_request!=SET_VERSION &&
        !SDDS_InitializeInput(&SDDS_dataset, filename[file])) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      exit(1);
    }
#ifdef DEBUG
    fprintf(stderr, "file initialized\n");
#endif
    if (sddsOutput) {
#ifdef DEBUG
      fprintf(stderr, "Making SDDS header summary\n");
#endif
      if (!MakeSDDSHeaderSummary(&SDDSout, &SDDS_dataset, list_request, filename[file])) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        exit(1);
      }
#ifdef SOLARIS
      if (!SDDS_Terminate(&SDDS_dataset)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        exit(1);
      }
#endif
      continue;
    }
    layout = &SDDS_dataset.layout;
    if (list_request>=0) {
      switch (list_request) {
      case SET_COLUMN_LIST:
#ifdef DEBUG
        fprintf(stderr, "printing column info\n");
#endif
        for (i=0; i<layout->n_columns; i++) {
          fputs(layout->column_definition[i].name, stdout);
          if (append_units && layout->column_definition[i].units &&
              !SDDS_StringIsBlank(layout->column_definition[i].units)) 
            fprintf(stdout, unitsTemplate, layout->column_definition[i].units);
          fputs(delimiter?delimiter:"\n", stdout);
        }
        break;
      case SET_PARAMETER_LIST:
#ifdef DEBUG
        fprintf(stderr, "printing parameter info\n");
#endif
        for (i=0; i<layout->n_parameters; i++) {
          fputs(layout->parameter_definition[i].name, stdout);
          if (append_units && layout->parameter_definition[i].units &&
              !SDDS_StringIsBlank(layout->parameter_definition[i].units)) 
            fprintf(stdout, unitsTemplate, layout->parameter_definition[i].units);
          fputs(delimiter?delimiter:"\n", stdout);
        }
        break;
      case SET_ASSOCIATE_LIST:
#ifdef DEBUG
        fprintf(stderr, "printing associate info\n");
#endif
        for (i=0; i<layout->n_associates; i++) {
          fputs(layout->associate_definition[i].filename, stdout);
          fputs(delimiter?delimiter:"\n", stdout);
        }
        break;
      case SET_ARRAY_LIST:
#ifdef DEBUG
        fprintf(stderr, "printing array info\n");
#endif
        for (i=0; i<layout->n_arrays; i++) {
          fputs(layout->array_definition[i].name, stdout);
          if (append_units && layout->array_definition[i].units &&
              !SDDS_StringIsBlank(layout->array_definition[i].units)) 
            fprintf(stdout, unitsTemplate, layout->array_definition[i].units);
          fputs(delimiter?delimiter:"\n", stdout);
        }
        break;
      case SET_VERSION:
#ifdef DEBUG
        fprintf(stderr, "printing version info\n");
#endif
        s[0] = 0;
        if (!(fp = fopen(filename[file], "r")) || !fgets(s, SDDS_MAXLINE, fp)) {
          puts("-1");
          exit(1);
        }
        if (strncmp(s, "SDDS", 4)!=0)
          puts("0");
        else {
          if (!(ptr=strchr(s, '\n')))
            puts("0");
          else {
            *ptr = 0;
            puts(s+4);
          }
        }
        fclose(fp);
        break;
      default:
        SDDS_Bomb("something impossible happned!");
        break;
      }
      if (readAll) {
        while (SDDS_ReadPageSparse(&SDDS_dataset, 0, 1000, 0)>0)
          ;
      }
#ifdef SOLARIS
      if (list_request!=SET_VERSION && !SDDS_Terminate(&SDDS_dataset)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        exit(1);
      }
#endif
      exit(0);
    }
    
    fprintf(stdout, "\nfile %s is in SDDS protocol version %" PRId32 "\n", 
            filename[file]?filename[file]:"stdin", layout->version);
    if (!SDDS_GetDescription(&SDDS_dataset, &text, &contents)) 
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
    if (text)
      fprintf(stdout, "description: %s\n", text);
    if (contents)
      fprintf(stdout, "contents: %s\n", contents);
    if (layout->data_mode.mode==SDDS_ASCII) {
      fprintf(stdout, "\ndata is ASCII with %" PRId32 " lines per row and %" PRId32 " additional header lines expected.\n",
              layout->data_mode.lines_per_row, layout->data_mode.additional_header_lines);
      fprintf(stdout, "row counts: %s\n",
              layout->data_mode.no_row_counts?"no":"yes");
    }
    else {
      if (!SDDS_dataset.layout.byteOrderDeclared)
        fprintf(stdout, "data is binary (no byte order declared)\n");
      else if (SDDS_IsBigEndianMachine()) {
        if (SDDS_dataset.swapByteOrder)
          fprintf(stdout, "data is little-endian binary\n");
        else
          fprintf(stdout, "data is big-endian binary\n");
      } else {
        if (SDDS_dataset.swapByteOrder)
          fprintf(stdout, "data is big-endian binary\n");
        else
          fprintf(stdout, "data is little-endian binary\n");
      }
    }
    
    if (layout->n_columns) {
      fprintf(stdout, "\n%" PRId32 " columns of data:\n", layout->n_columns);
      fprintf(stdout, "NAME            UNITS           SYMBOL          FORMAT          TYPE    FIELD  DESCRIPTION\n");
      fprintf(stdout, "                                                                        LENGTH\n");
      for (i=0; i<layout->n_columns; i++) {
        coldef = layout->column_definition+i;
        fprintf(stdout, "%-15s %-15s %-15s %-15s %-7s %-7" PRId32 " %s\n",
                coldef->name?coldef->name:"NULL", 
                coldef->units?coldef->units:"NULL", 
                coldef->symbol?coldef->symbol:"NULL",
                coldef->format_string?coldef->format_string:"NULL", 
                SDDS_type_name[coldef->type-1]?SDDS_type_name[coldef->type-1]:"NULL", 
                coldef->field_length,
                coldef->description?coldef->description:"NULL");
      }
    }
    
    if (layout->n_parameters) {
      fprintf(stdout, "\n%" PRId32 " parameters:\n", layout->n_parameters);
      fprintf(stdout, "NAME                UNITS               SYMBOL              TYPE                DESCRIPTION\n");
      for (i=0; i<layout->n_parameters; i++) {
        pardef = layout->parameter_definition+i;
        fprintf(stdout, "%-19s %-19s %-19s %-19s %s\n",
                pardef->name?pardef->name:"NULL", 
                pardef->units?pardef->units:"NULL", 
                pardef->symbol?pardef->symbol:"NULL", 
                SDDS_type_name[pardef->type-1]?SDDS_type_name[pardef->type-1]:"NULL", 
                pardef->description?pardef->description:"NULL");
      }
    }
    
    if (layout->n_arrays) {
      fprintf(stdout, "\n%" PRId32 " arrays of data:\n", layout->n_arrays);
      fprintf(stdout, "NAME            UNITS           SYMBOL          FORMAT  TYPE            FIELD   GROUP           DESCRIPTION\n");
      fprintf(stdout, "                                                                        LENGTH  NAME\n");
      for (i=0; i<layout->n_arrays; i++) {
        arraydef = layout->array_definition+i;
        fprintf(stdout, "%-15s %-15s %-15s %-7s %-8s*^%-5" PRId32 " %-7" PRId32 " %-15s %s\n",
                arraydef->name?arraydef->name:"NULL", 
                arraydef->units?arraydef->units:"NULL", 
                arraydef->symbol?arraydef->symbol:"NULL",
                arraydef->format_string?arraydef->format_string:"NULL", 
                SDDS_type_name[arraydef->type-1],
                arraydef->dimensions,
                arraydef->field_length,
                arraydef->group_name?arraydef->group_name:"NULL", 
                arraydef->description?arraydef->description:"NULL");
      }
    }
    
    if (layout->n_associates) {
      fprintf(stdout, "\n%" PRId32 " associates:\n", layout->n_associates);
      fprintf(stdout, "SDDS  FILENAME            PATH                          CONTENTS            DESCRIPTION\n");
      for (i=0; i<layout->n_associates; i++)
        fprintf(stdout, "%-5s %-19s %-29s %-19s %s\n",
                layout->associate_definition[i].sdds?"yes":"no",
                layout->associate_definition[i].filename?layout->associate_definition[i].filename:"NULL", 
                layout->associate_definition[i].path?layout->associate_definition[i].path:"NULL",
                layout->associate_definition[i].contents?layout->associate_definition[i].contents:"NULL", 
                layout->associate_definition[i].description?layout->associate_definition[i].description:"NULL");
    }
    fflush(stdout);
    if (readAll) {
      while (SDDS_ReadPageSparse(&SDDS_dataset, 0, 1000, 0)>0)
        ;
    }
    if (!SDDS_Terminate(&SDDS_dataset)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      exit(1);
    }
  }
  return(0);
}

static long indexName, indexUnits, indexSymbol, indexFormat, indexType, indexDescription, indexGroup;

long InitializeSDDSHeaderOutput(SDDS_DATASET *outSet, char *filename)
{
  if (!SDDS_InitializeOutput(outSet, SDDS_BINARY, 0, NULL, NULL, filename))
    return 0;
  if (0>(indexName=SDDS_DefineColumn(outSet, "Name", NULL, NULL, NULL, NULL, SDDS_STRING, 0)) ||
      0>(indexUnits=SDDS_DefineColumn(outSet, "Units", NULL, NULL, NULL, NULL, SDDS_STRING, 0)) ||
      0>(indexSymbol=SDDS_DefineColumn(outSet, "Symbol", NULL, NULL, NULL, NULL, SDDS_STRING, 0)) ||
      0>(indexFormat=SDDS_DefineColumn(outSet, "Format", NULL, NULL, NULL, NULL, SDDS_STRING, 0)) ||
      0>(indexType=SDDS_DefineColumn(outSet, "Type", NULL, NULL, NULL, NULL, SDDS_STRING, 0)) ||
      0>(indexDescription=SDDS_DefineColumn(outSet, "Description", NULL, NULL, NULL, NULL, SDDS_STRING, 0)) ||
      0>(indexGroup=SDDS_DefineColumn(outSet, "Group", NULL, NULL, NULL, NULL, SDDS_STRING, 0)))
    return 0;
  if (0>SDDS_DefineParameter(outSet, "Class", NULL, NULL, NULL, NULL, SDDS_STRING, 0) ||
      0>SDDS_DefineParameter(outSet, "Filename", NULL, NULL, NULL, NULL, SDDS_STRING, 0))
    return 0;
  if (!SDDS_WriteLayout(outSet))
    return 0;
  return 1;
}

long MakeSDDSHeaderSummary(SDDS_DATASET *outSet, SDDS_DATASET *inSet, long listRequest, char *inputFile)
{
  switch (listRequest) {
  case SET_COLUMN_LIST:
    if (!MakeColumnHeaderSummary(outSet, inSet, inputFile))
      return 0;
    break;
  case SET_PARAMETER_LIST:
    if (!MakeParameterHeaderSummary(outSet, inSet, inputFile))
      return 0;
    break;
  case SET_ARRAY_LIST:
    if (!MakeArrayHeaderSummary(outSet, inSet, inputFile))
      return 0;
    break;
  default:
    if (!MakeColumnHeaderSummary(outSet, inSet, inputFile) ||
        !MakeParameterHeaderSummary(outSet, inSet, inputFile) ||
        !MakeArrayHeaderSummary(outSet, inSet, inputFile))
      return 0;
    break;
  }
  return 1;
}

long MakeColumnHeaderSummary(SDDS_DATASET *outSet, SDDS_DATASET *inSet, char *inputFile)
{
  SDDS_LAYOUT *layout;
  COLUMN_DEFINITION *coldef;
  long i;

  layout = &inSet->layout;
  if (!layout->n_columns)
    return 1;
  if (!SDDS_StartPage(outSet, layout->n_columns))
    return 0;
  for (i=0; i<layout->n_columns; i++) { 
    coldef = layout->column_definition+i;
    if (!SDDS_SetRowValues(outSet, SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE, i,
                           indexName, coldef->name,
                           indexUnits, coldef->units,
                           indexSymbol, coldef->symbol,
                           indexFormat, coldef->format_string,
                           indexType, SDDS_type_name[coldef->type-1],
                           indexDescription, coldef->description,
                           indexGroup, NULL, -1))
      return 0;
  }
  if (!SDDS_SetParameters(outSet, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE,
                          "Class", "column", "Filename", inputFile, NULL))
    return 0;
  if (!SDDS_WritePage(outSet))
    return 0;
  return 1;
}

long MakeParameterHeaderSummary(SDDS_DATASET *outSet, SDDS_DATASET *inSet, char *inputFile)
{
  SDDS_LAYOUT *layout;
  PARAMETER_DEFINITION *pardef;
  long i;

  layout = &inSet->layout;
  if (!layout->n_parameters)
    return 1;
  if (!SDDS_StartPage(outSet, layout->n_parameters))
    return 0;
  for (i=0; i<layout->n_parameters; i++) { 
    pardef = layout->parameter_definition+i;
    if (!SDDS_SetRowValues(outSet, SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE, i,
                           indexName, pardef->name,
                           indexUnits, pardef->units,
                           indexSymbol, pardef->symbol,
                           indexFormat, pardef->format_string,
                           indexType, SDDS_type_name[pardef->type-1],
                           indexDescription, pardef->description,
                           indexGroup, NULL, -1))
      return 0;
  }
  if (!SDDS_SetParameters(outSet, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE,
                          "Class", "parameter", "Filename", inputFile, NULL))
    return 0;
  if (!SDDS_WritePage(outSet))
    return 0;
  return 1;
}

long MakeArrayHeaderSummary(SDDS_DATASET *outSet, SDDS_DATASET *inSet, char *inputFile)
{
  SDDS_LAYOUT *layout;
  ARRAY_DEFINITION *arrdef;
  long i;

  layout = &inSet->layout;
  if (!layout->n_arrays)
    return 1;
  if (!SDDS_StartPage(outSet, layout->n_arrays))
    return 0;
  for (i=0; i<layout->n_arrays; i++) { 
    arrdef = layout->array_definition+i;
    if (!SDDS_SetRowValues(outSet, SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE, i,
                           indexName, arrdef->name,
                           indexUnits, arrdef->units,
                           indexSymbol, arrdef->symbol,
                           indexFormat, arrdef->format_string,
                           indexType, SDDS_type_name[arrdef->type-1],
                           indexDescription, arrdef->description,
                           indexGroup, arrdef->group_name, -1))
      return 0;
  }
  if (!SDDS_SetParameters(outSet, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE,
                          "Class", "array", "Filename", inputFile, NULL))
    return 0;
  if (!SDDS_WritePage(outSet))
    return 0;
  return 1;
}