
/*
 *  Name:           main
 *  Input:          command-line arguments (argc, argv)
 *  Output:         integer success or error code
 *  Return:         DIS_DATA_MANAGEMENT_SUCCESS, or
 *                  DIS_DATA_MANAGEMENT_ERROR
 *  Description:    The is the main() routine for the DIS Data Management 
 *                  Benchmark baseline application.  The application reads a 
 *                  data set from the specified input (default=stdin), displays 
 *                  the query command response to the specified output 
 *                  (default=stdout), and calculates and displays a set of 
 *                  metric calculations (default=stderr).  The format for the 
 *                  input and output files is given in the DIS Benchmark Suite 
 *                  specification document.  The application is made up of three
 *                  modules: Database, Input & Output, and Metrics.  A complete 
 *                  description of the modules and supporting routines are 
 *                  provided in the DIS Data Management Software Design document
 *                  provided with the baseline source code.  The routine has 
 *                  three main sections:
 *
 *                  (1) Initialization
 *                      The three modules are initialized by opening files, 
 *                      creating the first root node, reading the fan from the 
 *                      input, and starting the metric timing.
 *                  (2) Main Loop
 *                      The main loop consists of the input data set being 
 *                      processed line by line where a single line represents a 
 *                      command to the database.  The command is process as 
 *                      either an INSERT, QUERY, or DELETE.  If no commands are 
 *                      left in the database, then a value of NONE is specified 
 *                      by the getNextCommandCode() routine and the main loop 
 *                      exits.
 *
 *                  (3) Exit
 *                      The application exits by stopping the metric timing, 
 *                      calculating and displaying the statistical values, 
 *                      removing the memory allocated for the database index, 
 *                      and closing all files.
 *
 *  Calls:          clearLine()
 *                  closeFiles()
 *                  createIndexNode()
 *                  delete();
 *                  deleteIndexNode()
 *                  errorMessage()
 *                  flushErrorMessage()
 *                  flushOutputBuffer()
 *                  getDeleteCommand()
 *                  getInitCommand()
 *                  getInsertCommand()
 *                  getNextCommandCode()
 *                  getQueryCommand()
 *                  getTime()
 *                  initMetricsData()
 *                  insert()
 *                  openFiles()
 *                  outputMetricsData()
 *                  setMetricsData()
 *                  query()
 *                  updateMetricsData()
 *      System:     free()
 *  Author:         M.L.Rivas
 *
 *  Revision History:
 *
 *  Date    Name            Revision
 *  ------- --------------- ------------------------------
 *  28May99 Matthew Rivas   Created
 *  06Jul99 Matthew Rivas   Modified return check for openFiles() routine to 
 *                          handle a usage request or error
 *  12Jul99 Matthew Rivas   Initialized input, output, and metric pointers
 *                          to NULL before passing to openFiles() routine to
 *                          prevent incorrect assertion
 *
 *	Copyright 1999, Atlantic Aerospace Electronics Corp.
 */

#include <stdlib.h>             /*  for free() and NULL definitions           */
#include "dataObject.h"         /*  for DataObject definitions                */
#include "dataManagement.h"     /*  for primitive type definitions            */
#include "delete.h"             /*  for delete() and return codes             */
#include "errorMessage.h"       /*  for errorMessage() definitions            */
#include "index.h"              /*  for IndexNode definition                  */
#include "insert.h"             /*  for insert() and return codes             */
#include "getNextCommandCode.h" /*  for getNextCommandCode definitions        */
#include "getInitCommand.h"     /*  for getInitCommand() and return codes     */
#include "getInsertCommand.h"   /*  for getInsertCommand() and return codes   */
#include "getDeleteCommand.h"   /*  for getDeleteCommand() and return codes   */
#include "getQueryCommand.h"    /*  for getQueryCommand() and return codes    */
#include "metrics.h"            /*  for Metrics definition                    */
#include "openFiles.h"          /*  for openFiles() and return codes          */
#include "query.h"              /*  for query() and return codes              */

/*
 *  Exit status definitions
 */
#define DIS_DATA_MANAGEMENT_SUCCESS  0
#define DIS_DATA_MANAGEMENT_ERROR   -1

/*
 *  Function prototypes
 */
extern void clearLine( FILE *file );
extern void closeFiles( FILE *input, FILE *output, FILE *metrics );
extern void flushOutputBuffer( void );
extern void outputQuery( DataObject *dataObject );
extern void initMetricsData( Metrics *metrics );
extern void setMetricsData( Metrics *metrics, CommandType command );
extern void updateMetricsData( Metrics *metrics );
extern void outputMetricsData( FILE *file, Metrics *metrics );
extern Time getTime( void );

/*
 *  System Test Debug Prototypes
 */
extern Int countDataObjects( IndexNode *node );

/*
 *  Main program
 */
int main( int argc, Char *argv[] )
{   /*  begin main()    */
    Int         returnCode; /*  generic return code for error processing    */
    CommandType command;    /*  current command read/processing             */
    FILE        *input;     /*  input file                                  */
    FILE        *output;    /*  output file                                 */
    FILE        *metric;    /*  metrics file                                */
    Metrics     metrics;    /*  metrics data structure                      */
    IndexNode   *root;      /*  root node of index                          */
    Int         fan;        /*  fan or order of index - read from input     */
    Time        tempTime;   /*  time for keeping I/O timing statistics      */ 

    /*
     *                  Initialize Application
     *
     *      (1) Initialize the Metrics module: this consists of calling the 
     *          initMetricsData() routine to initialize the Metrics structure.  
     *      (2) Initialize the Input & Output module: this consists of calling 
     *          the openFiles() routine which opens the three files: input, 
     *          output, and metrics and also calls the initOutputBuffer() 
     *          routine to pass the output FILE ptr to the output buffer.  If an
     *          error occurred for any of the files, notify user and exit.  Note
     *          that the command-line arguments are passed directly to 
     *          openFiles() for default overrides on the file names.
     *      (3) Initialize the Database module:  this consists of creating the 
     *          initial root node and reading the INIT command from the input 
     *          file.  If the root node can't be created or an error occurred 
     *          during the reading of the INIT command, notify user and exit.
     */

    initMetricsData( &metrics ); /* (1) */

    input  = NULL;
    output = NULL;
    metric = NULL;
    returnCode = openFiles( argc, argv, &input, &output, &metric ); /* (2) */
    if ( returnCode != OPEN_FILES_SUCCESS ) {
        /*
         *  Check for a usage request, i.e., "-h" in the command-line and
         *  exit successfully if so. Otherwise, flush error message and return
         *  with error.
         */
        if ( returnCode == OPEN_FILES_USAGE_REQUEST ) {
            return ( DIS_DATA_MANAGEMENT_SUCCESS );        
        }   /*  end of returnCode == OPEN_FILES_USAGE_REQUEST */
        else {
            /*
             *  FATAL ERROR: can't proceed if unable to open files or incorrect 
             *               usage
             */
            errorMessage( argv[ 0 ], PREPEND );
            flushErrorMessage();

            return ( DIS_DATA_MANAGEMENT_ERROR );        
        }   /*  end of else */
    }

    root = createIndexNode( LEAF ); /* (3) */
    if ( root == NULL ) {
        /*
         *  FATAL ERROR: can't proceed if unable to create root node
         */
        errorMessage( "root node", PREPEND );
        errorMessage( argv[ 0 ], PREPEND );
        flushErrorMessage();

        return ( DIS_DATA_MANAGEMENT_ERROR );
    }

    returnCode = getNextCommandCode( input, &command );
    if ( returnCode == GET_NEXT_COMMAND_CODE_SUCCESS ) {
        if ( command == INIT ) {

            tempTime = getTime(); /* start I/O timing of command */
            returnCode = getInitCommand( input, &fan );
            metrics.inputTime += ( getTime() - tempTime );
            
            if ( returnCode != GET_INIT_SUCCESS ) { 
                errorMessage( "Can't read first command (INIT)", PREPEND );
                errorMessage( argv[ 0 ], PREPEND );
                flushErrorMessage();

                /*
                 *  FATAL ERROR: must have fan parameter to continue
                 */
                return ( DIS_DATA_MANAGEMENT_ERROR );
            }   /*  end error checks for getInitCommand */
        }   /*  end if command == INIT  */
        else {
            errorMessage( "First command is not INIT command", REPLACE );
            errorMessage( argv[ 0 ], PREPEND );
            flushErrorMessage();

            /*
             *  FATAL ERROR: must have fan parameter to continue
             */
            return ( DIS_DATA_MANAGEMENT_ERROR );
        }   /*  end command != INIT     */
    }   /*  end if returnCode == GET_NEXT_COMMAND_CODE_SUCCESS */
    else if ( returnCode == GET_NEXT_COMMAND_CODE_IO_ERROR ||
              returnCode == GET_NEXT_COMMAND_CODE_INVALID_COMMAND ) {
        errorMessage( "Can't read first command (INIT)", PREPEND );
        errorMessage( argv[ 0 ], PREPEND );
        flushErrorMessage();

        /*
         *  FATAL ERROR: must have fan parameter to continue
         */
        return ( DIS_DATA_MANAGEMENT_ERROR );
    }   /*  end return check for getNextCommandCode */
    clearLine( input );
    
    /*
     *                  Main Loop
     *
     *    The main loop of the DIS Data Management benchmark baseline
     *    application consists of getting the next command from the 
     *    input stream and processing the command.  Metric timing is
     *    done for each command processed.  The query command response
     *    is also display/flushed through each loop.  Extensive error
     *    checking is made during the loop.  The following is a
     *    description of the main loop actions:
     *
     *      (1) Get next command code from input stream
     *      (2) Start metric timing of command
     *      (3) Switch on command code
     *          (A) Insert
     *              (a) Get insert command from input stream: the
     *                  insert command consists of a new data object
     *                  to add to index.
     *              (b) Insert new data object into index: this may
     *                  cause tree "growth", so the root node may be
     *                  replaced or "updated" after call to insert(). 
     *                  There is no response for the insert command.
     *          (B) Query 
     *              (a) Get query command from input stream: the 
     *                  command consists of an index key and a list of
     *                  non-key DataAttribute's.  The memory for the
     *                  non-key character strings will need to be 
     *                  freed after the query() call (see 3.B.c)
     *              (b) Query current index placing responses
     *                  into output buffer via outputQuery()
     *                  routine. 
     *              (c) Free non-key DataAttribute character strings
     *                  allocated during the getQueryCommand() call.
     *          (C) Delete 
     *              (a) Get delete command from input stream: the 
     *                  command consists of an index key and a list of
     *                  non-key DataAttribute's.  The memory for the
     *                  non-key character strings will need to be 
     *                  freed after the delete() call (see 3.C.c)
     *              (b) Delete entries in current index which are 
     *                  consistent with input search values.  There is
     *                  no response to the delete command. 
     *              (c) Free non-key DataAttribute character strings
     *                  allocated during the getDeleteCommand() call.
     *      (3) Stop metric timing for command 
     *      (4) Flush output buffer of any query response
     */

	/*** VERSABENCH START ***/
	while ( command != NONE ) {
        returnCode = getNextCommandCode( input, &command );
        if ( returnCode == GET_NEXT_COMMAND_CODE_SUCCESS ) {
            setMetricsData( &metrics, command ); /* start timing */

            if ( command == INSERT ) {
                DataObject  *dataObject;

                tempTime = getTime(); /* start I/O timing of command */
                returnCode = getInsertCommand( input, &dataObject );
                metrics.inputTime += ( getTime() - tempTime );

                if ( returnCode == GET_INSERT_SUCCESS ) {
                    returnCode = insert( &root, dataObject, fan );
                    if ( returnCode == INSERT_INSERT_ENTRY_FAILURE_FATAL ){
                        errorMessage( argv[ 0 ], PREPEND );
                        flushErrorMessage();

                        /*
                         *  FATAL ERROR:
                         */
                        return ( DIS_DATA_MANAGEMENT_ERROR );
                    }   /*  end code == INSERT_INSERT_ENTRY_FAILURE_FATAL */
                    else if (returnCode==INSERT_INSERT_ENTRY_FAILURE_NON_FATAL){
                        errorMessage( argv[ 0 ], PREPEND );
                        flushErrorMessage();
                    }   /*  end code == INSERT_INSERT_ENTRY_FAILURE_NON_FATAL */
                    else if ( returnCode == INSERT_ALLOCATION_FAILURE ) {
                        errorMessage( argv[ 0 ], PREPEND );
                        flushErrorMessage();

                        /*
                         *  FATAL ERROR:
                         */
                        return ( DIS_DATA_MANAGEMENT_ERROR );
                    }   /*  end of if returnCode == INSERT_ALLOCATION_FAILURE */
                }   /*  end of if ( returnCode == GET_INSERT_SUCCESS )  */
                else {
                    errorMessage( argv[ 0 ], PREPEND );
                    flushErrorMessage();
                }   /*  end of returnCode != GET_INSERT_SUCCESS */
            }   /*  end command == INSERT   */
            else if ( command == QUERY ) {
                IndexKey        searchKey;
                DataAttribute   *searchNonKey;
                DataAttribute   *temp;

                tempTime = getTime(); /* start I/O timing of command */
                returnCode = getQueryCommand( input, &searchKey, &searchNonKey);
                metrics.inputTime += ( getTime() - tempTime );

                if ( returnCode == GET_QUERY_SUCCESS ) {

                    returnCode = query( root, &searchKey, searchNonKey, TRUE, 
                                        outputQuery );
                    if ( returnCode == QUERY_INVALID_KEY_SEARCH_VALUE ||
                         returnCode == QUERY_INVALID_NON_KEY_SEARCH_VALUE ) {
                        errorMessage( argv[ 0 ], PREPEND );
                        flushErrorMessage();
                    } /* end of if returnCode != QUERY_SUCCESS */
                }   /*  end of if ( returnCode == GET_QUERY_SUCCESS )  */
                else {
                    errorMessage( argv[ 0 ], PREPEND );
                    flushErrorMessage();
                }   /*  end of returnCode != GET_QUERY_SUCCESS */

                /*
                 *  Clean-up memory: the non-key search values read for the
                 *  QUERY command allocates memory for each value.  This memory
                 *  needs to be deallocated before the list leaves scope.
                 */
                temp = searchNonKey;
                while ( temp != NULL ) {
                    DataAttribute *next;
                    
                    next = temp->next;
                    free( temp->attribute.value.nonKey );
                    free( temp );
                    temp = next;                    
                }  /*  end of loop over searchNonKey list using temp */
            }   /*  end command == QUERY    */
            else if ( command == DELETE ) {
                IndexKey        searchKey;
                DataAttribute   *searchNonKey;
                DataAttribute   *temp;

                tempTime = getTime(); /* start I/O timing of command */
                returnCode = getDeleteCommand( input,&searchKey, &searchNonKey);
                metrics.inputTime += ( getTime() - tempTime );

                if ( returnCode == GET_DELETE_SUCCESS ) {
                    returnCode = delete( &root, &searchKey, searchNonKey );
                    if ( returnCode == DELETE_INVALID_KEY_SEARCH_VALUE ||
                         returnCode == DELETE_INVALID_NON_KEY_SEARCH_VALUE ) {
                        errorMessage( argv[ 0 ], PREPEND );
                        flushErrorMessage();
                   }  /* end of returnCode != DELETE_SUCCESS */
                }   /*  end of if ( returnCode == GET_INSERT_SUCCESS )  */
                else {
                    errorMessage( argv[ 0 ], PREPEND );
                    flushErrorMessage();
                }   /*  end of returnCode != GET_DELETE_SUCCESS */

                /*
                 *  Clean-up memory: the non-key search values read for the
                 *  DELETE command allocates memory for each value.  This memory
                 *  needs to be deallocated before the list leaves scope.
                 */
                temp = searchNonKey;
                while ( temp != NULL ) {
                    DataAttribute *next;
                    
                    next = temp->next;
                    free( temp->attribute.value.nonKey );
                    free( temp );
                    temp = next;                    
                }  /*  end of loop over searchNonKey list using temp */
            }   /*  end command == DELETE   */
            else if ( command == INIT ) {
                errorMessage( "Additional INIT command read", REPLACE );
                errorMessage( argv[ 0 ], PREPEND );
                flushErrorMessage();
            }   /*  end command == INIT     */
            else if ( command == INVALID ) {
                errorMessage( argv[ 0 ], PREPEND );
                flushErrorMessage();
            }   /*  end command == INVALID  */

            updateMetricsData( &metrics ); /* stop timing */

            tempTime = getTime(); /* start output timing of command */
            flushOutputBuffer();
            metrics.outputTime += ( getTime() - tempTime );

        }   /*  end of returnCode == GET_NEXT_COMMAND_CODE_SUCCESS */
        else if ( returnCode == GET_NEXT_COMMAND_CODE_IO_ERROR ) {
            errorMessage( argv[ 0 ], PREPEND );
            flushErrorMessage();
            return ( DIS_DATA_MANAGEMENT_ERROR );
        }   /*  else low-level I/O error for getNextCommandCode */
        else if ( returnCode == GET_NEXT_COMMAND_CODE_INVALID_COMMAND ) {
            errorMessage( argv[ 0 ], PREPEND );
            flushErrorMessage();
        }   /*  end return check for getNextCommandCode */

        clearLine( input );
    }   /*  end main loop   */

	/*** VERSABENCH END ***/
	
    /*
     *                  Exit Application
     *
     *      (1) Exit the Metrics module: this consists of calling the 
     *          outputMetricsData() routine to calculate and display the
     *          statistical metric values.
     *      (2) Exit the Database module:  this consists of deleting the
     *          index root node which will recursively delete all nodes,
     *          entries, and data objects currently in the index. 
     *      (3) Exit the Input & Output module: this consists of closing
     *          the three files used during the program execution.  Note
     *          that the three files may point to stdin, stdout, and 
     *          stderr, but no error occurs for closing these files. 
     */
	/*    outputMetricsData( metric, &metrics ); */

    deleteIndexNode( root );

    closeFiles( input, output, metric );

    exit ( DIS_DATA_MANAGEMENT_SUCCESS );
}   /*  end of main()   */