/* BEGIN_ICS_COPYRIGHT7 ****************************************

Copyright (c) 2015-2017, Intel Corporation

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,

      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

      notice, this list of conditions and the following disclaimer in the

      documentation and/or other materials provided with the distribution.

    * Neither the name of Intel Corporation nor the names of its contributors

      may be used to endorse or promote products derived from this software

      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE

FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

** END_ICS_COPYRIGHT7   ****************************************/

/* [ICS VERSION STRING: unknown] */

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

 *

 * File: opaxmlgenerate.c

 *

 * Description:

 *	This file implements the opaxmlgenerate program.  opaxmlgenerate takes

 *	CSV data as input and, with user-specified element names, generates

 *	sequences of XML containing the element values within start and end tag

 *	specifications.

 *

 *	opaxmlgenerate uses libXml to manage the XML generation state and for ouptut

 *	functions.  It calls the following functions:

 *	  IXmlInit()

 *	  IXmlOutputStartAttrTag()

 *	  IXmlOutputEndTag()

 *	  IXmlOutputStrLen()

 *

 *	opaxmlgenerate uses 3 types of element names specified by the user.  The

 *	types are distinguished by their command line option.  -g specifies an

 *	an element name that, along with a value from the CSV input file, will

 *	be used to generate XML of the form '<element_name>value</element_name>'.

 *	-h specifies an element name that will be used to generate an "enclosing"

 *	XML header start tag of the form '<element_name>'.  -e specifies an

 *	element name that will be used to generate an enclosing XML header end

 *	tag of the form '</element_name>'.  Enclosing elements do not contain

 *	a value, but serve to separate and organize the elements that do contain

 *	values.

 *

 *	The operation of opaxmlgenerate is further controlled by the following

 *	command line options:

 *	  -d delimiter - specifies the delimiter character that separates input

 *	                 values in the CSV input file; default is semicolon

 *	  -i indent - specifies the number of spaces to indent each level of

 *	              XML output; default is zero

 *	  -X input_file - input CSV data from input_file

 *	  -P param_file - input command line options (parameters) from param_file

 *	  -v - verbose output: output progress reports during generation

 *

 *	opaxmlgenerate generates sequences (fragments) of XML, as opposed to

 *	complete XML specifications.  It is intended that opaxmlgenerate be

 *	invoked from within a script (typically multiple times), using multiple

 *	input files (with possibly different CSV formats) to create the desired

 *	XML output.  The script would output any necessary XML header or trailer

 *	information (XML version or report information) as well as "glue" XML

 *	between fragments.

 *

 *	NOTES:

 *	Output of start and end tags for enclosing elements is controlled by

 *	the placement of command line options -h and -e respectively with

 *	respect to -g options.  No check for matching tags or proper nesting

 *	of tags is performed by opaxmlgenerate.

 */

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

 *

 * INCLUDES

 */

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <iba/ipublic.h>

#include <iba/public/datatypes.h>

#include <getopt.h>

#include "ixml.h"

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

 *

 * DEFINES

 */

#define OK  0

#define ERROR (-1)

#define NAME_PROG  "opaxmlgenerate"		// Program name

#define MAX_PARAMS_FILE  512			// Max number of param file parameters

#define MAX_ELEMENTS  100				// Max number of elements parsable

#define MAX_DELIMIT_CHARS  16			// Max size of delimiter string

#define MAX_INPUT_BUF  8192				// Max size of input buffer

#define MAX_PARAM_BUF  8192				// Max size of parameter file

#define MAX_FILENAME_CHARS  256			// Max size of file name

#define WHITE_SPACE  " \t\r\n"			// White space characters

#define OPTION_LEN 2			// string length of an option(eg. -P)

// Element table entry

typedef struct 

{

	int		lenName;					// Length of element name		

	char	*pName;						// Element name

	int		lenValue;					// Length of element value

	char	*pValue;					// Element value

	int		flags;						// Flags as:  xxxx xEHG

										//   E = 1 - End header

										//   H = 1 - Header

										//   G = 1 - Generate value

} ELEMENT_TABLE_ENTRY;

// Element table flags:

#define ELEM_GENERATE  0x01

#define ELEM_HEADER  0x02

#define ELEM_END  0x04

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

 *

 * GLOBAL VARIABLES

 */

int		g_exitstatus  = 0;

int		g_verbose  = 0;

int		g_quiet  = 0;

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

 *

 * LOCAL VARIABLES

 */

int  numElementsTable  = 0;				// Number of elements in tbElements[]

uint32  numIndentChars  = 0;		// Num of chars per indent level

FILE  * hFileInput  = NULL;				// Input file handle (default stdin)

										// Input file name (default stdin)

char  nameFileInput[MAX_FILENAME_CHARS + 1]  = "stdin";

FILE  * hFileOutput  = NULL;			// Output file handle (default stdout)

char  nameFileOutput[MAX_FILENAME_CHARS]  = "stdout";  // Output file name (default stdout)

uint32  fvDebugProg  = 0;			// Debug/Trace variable as:

										//  0MMM MMMM NNNN NNNN  SSSS 21RC SIEB SNEB

// Command line option table, each has a short and long flag name

struct option tbOptions[] =

{

	// Basic controls

	{ "verbose", no_argument, NULL, 'v' },

	{ "generate", required_argument, NULL, 'g' },

	{ "header", required_argument, NULL, 'h' },

	{ "end", required_argument, NULL, 'e' },

	{ "infile", required_argument, NULL, 'X' },

	{ "pfile", required_argument, NULL, 'P' },

	{ "delimit", required_argument, NULL, 'd' },

	{ "indent", required_argument, NULL, 'i' },

	{ "debug", required_argument, NULL, 'Z' },

	{ 0 }

};

// Element table; contains information about each element of interest.

//  Elements are contained in the table (0 - numElementsTable-1) in the

//	order they appear on the command line.

ELEMENT_TABLE_ENTRY  tbElements[MAX_ELEMENTS];

// IXml Output State

IXmlOutputState_t state;

// Delimiter string buffer

char  bfDelimit[MAX_DELIMIT_CHARS + 1] = ";";

// Input buffer

char  bfInput[MAX_INPUT_BUF];

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

 *

 * LOCAL FUNCTION PROTOTYPES

 */

void dispElementRecord(ELEMENT_TABLE_ENTRY * pElement, const char * pValue);

void errUsage(void);

int findElement(const char *pElement);

void getRecu_opt( int argc, char ** argv, const char *pOptShort,

	struct option tbOptLong[] );

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

 *

 * dispElementRecord()

 *

 * Description:

 *	Display (output) an element, either generate (with value) or header (Start

 *	or End).

 *

 * Inputs:

 *	pElement - Pointer to tbElement to output

 *	  pValue - Pointer to value string to output (NULL means no value)

 *

 * Outputs:

 *	none

 */

void dispElementRecord(ELEMENT_TABLE_ENTRY * pElement, const char * pValue)

{

	// Output header element name (as Start tag or End tag)

	if (pElement->flags & ELEM_HEADER)

		IXmlOutputStartAttrTag(&state, pElement->pName, NULL, NULL);

	else if (pElement->flags & ELEM_END)

		IXmlOutputEndTag(&state, pElement->pName);

	// Output generate element name and value

	else if ((pElement->flags & ELEM_GENERATE) && pValue)

		IXmlOutputStrLen(&state, pElement->pName, pValue, strlen(pValue));

}	// End of dispElementRecord()

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

 *

 * errUsage()

 *

 * Description:

 *	Output information about program usage and parameters.

 *

 * Inputs:

 *	none

 *

 * Outputs:

 *	none

 */

void errUsage(void)

{

	fprintf(stderr, "Usage: " NAME_PROG " [-v][-d delimiter][-i number][-g element][-h element]\n");

	fprintf(stderr, "                         [-e element][-X input_file][-P param_file]\n");

	fprintf(stderr, "  At least 1 element must be specified\n");

	fprintf(stderr, "  -g/--generate element     - name of XML element to generate\n");

	fprintf(stderr, "                              can be used multiple times\n");

	fprintf(stderr, "                              values assigned to elements in order xxx ... \n");

	fprintf(stderr, "  -h/--header element       - name of XML element in which to enclose generated\n");

	fprintf(stderr, "                              XML elements\n");

	fprintf(stderr, "  -e/--end element          - name of header XML element to end (close)\n");

	fprintf(stderr, "  -d/--delimit delimiter    - delimiter char input between element values\n");

	fprintf(stderr, "                              default is semicolon\n");

	fprintf(stderr, "  -i/--indent number        - number of spaces to indent each level of XML\n");

	fprintf(stderr, "                              output; default is zero\n");

	fprintf(stderr, "  -X/--infile input_file    - generate XML from CSV in input_file\n");

	fprintf(stderr, "  -P/--pfile param_file     - read command parameters from param_file\n");

	fprintf(stderr, "  -v/--verbose              - verbose output: progress reports during generation\n");

	if (hFileInput && (hFileInput != stdin))

		fclose(hFileInput);

	exit(2);

}	// End of errUsage()

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

 *

 * findElement()

 *

 * Description:

 *	Find specified element in element table.

 *

 * Inputs:

 *	pElement - Pointer to element name

 *

 * Outputs:

 *	Index of element table containing element name, else

 *	-1 - Element name not found

 */

int findElement(const char *pElement)

{

	int		ix;

	int		length;

	length = strlen(pElement);

	for (ix = 0; ix < numElementsTable; ix++)

	{

		if ((tbElements[ix].lenName - 1) == length)

			if (!strcmp(pElement, tbElements[ix].pName))

				return (ix);

	}

	return (ERROR);

}	// End of findElement()

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

 *

 * getRecu_opt()

 *

 * Description:

 *	Get command line options (recursively).  Parses command line options

 *	using short and long option (parameter) definitions.  Parameters (global

 *	variables) are updated appropriately.  The parameter '-P param_file' which

 *	takes command line options from a file is also handled.  The -P parameter

 *	can be used within a parameter file; in such cases the function will call

 *	itself recursively.

 *

 * Inputs:

 *	     argc - Number of input parameters

 *	     argv - Array of pointers to input parameters

 *	pOptShort - Pointer to string of short option definitions

 *	tbOptLong - Array of long option definitions

 * 

 * Outputs:

 *	none

 */

void getRecu_opt( int argc, char ** argv, const char *pOptShort,

	struct option tbOptLong[] )

{

	int		ix;

    int		cOpt;						// Option parsing char                         

	int		ixOpt;						// Option parsing index

	int		lenStr;						// String length

	int		argc_recu;					// Recursive argc

	char	*argv_recu[MAX_PARAMS_FILE];  // Recursive argv

	int		optind_recu;				// Recursive optind

	char	*optarg_recu;				// Recursive optarg

	int		ctCharParam;				// Parameter file char count

	FILE	*hFileParam = NULL;			// Parameter file handle

	char	nameFileParam[MAX_FILENAME_CHARS +1];  // Parameter file name

	char	bfParam[MAX_PARAM_BUF + 1];

	// Input command line arguments

	while ((cOpt = getopt_long(argc, argv, pOptShort, tbOptLong, &ixOpt)) != -1)

    {

		lenStr = 0;

        switch (cOpt)

        {

		// Verbose

		case 'v':

			g_verbose = 1;

			break;

		// Generate element name specification

		case 'g':

		// Header element name specification

		case 'h':

		// End (header) element name specification

		case 'e':

			if (numElementsTable == MAX_ELEMENTS)

			{

				fprintf(stderr, NAME_PROG ": Too many Element Names\n");

				errUsage();

			}

			else if (!optarg || ((lenStr = strlen(optarg) + 1) == 1))

			{

				fprintf(stderr, NAME_PROG ": Invalid Element Name: %s\n", optarg ? optarg:"");

				errUsage();

			}

			else

			{

				if ( (tbElements[numElementsTable].pName = malloc(lenStr)) )

				{

					strcpy(tbElements[numElementsTable].pName, optarg);

					tbElements[numElementsTable].lenName = lenStr;

				}

				else

				{

					fprintf(stderr, NAME_PROG ": Unable to Allocate Name Memory\n");

					errUsage();

				}

				if (cOpt == 'g')

					tbElements[numElementsTable++].flags |= ELEM_GENERATE;

				else if (cOpt == 'h')

					tbElements[numElementsTable++].flags |= ELEM_HEADER;

				else if (cOpt == 'e')

					tbElements[numElementsTable++].flags |= ELEM_END;

			}

			break;

		// Delimiter string specification

		case 'd':

			if ( !optarg || ((lenStr = strlen(optarg)) == 0) ||

					(lenStr > MAX_DELIMIT_CHARS) )

			{

				fprintf(stderr, NAME_PROG ": Invalid delimiter size: %d\n", lenStr);

				errUsage();

			}

			strncpy(bfDelimit, optarg, MAX_DELIMIT_CHARS);

			bfDelimit[MAX_DELIMIT_CHARS]=0; // Ensure null terminated

			break;

		// Indent chars specification

		case 'i':

			if (FSUCCESS != StringToUint32(&numIndentChars, optarg, NULL, 0, TRUE)) {

				fprintf(stderr, NAME_PROG ": Invalid indent parameter size: %d\n", lenStr);

				errUsage();

			}

			break;

		// Input file specification

		case 'X':

			if ( !optarg || ((lenStr = strlen(optarg)) == 0) ||

					(lenStr > MAX_FILENAME_CHARS) )

			{

				fprintf(stderr, NAME_PROG ": Invalid Input File Name: %s\n", optarg ? optarg:"");

				errUsage();

			}

			else if (hFileInput != stdin)

			{

				fprintf( stderr, NAME_PROG ": Multiple Input Files: %s and %s\n",

					nameFileInput, optarg );

				errUsage();

			}

			if (strcmp(optarg, "-"))

			{

				strncpy(nameFileInput, optarg, MAX_FILENAME_CHARS);

				nameFileInput[MAX_FILENAME_CHARS]=0; // Ensure null terminated

				hFileInput = fopen(nameFileInput, "r");

				if (!hFileInput)

				{

					fprintf( stderr, NAME_PROG ": Unable to Open Input File: %s\n",

						nameFileInput );

					perror("");

					errUsage();

				}

			}

			break;

		// Parameter file specification

		case 'P':

			if (!optarg || ((lenStr = strlen(optarg)) == 0) ||

					(lenStr > MAX_FILENAME_CHARS) )

			{

				fprintf(stderr, NAME_PROG ": Invalid Parameter File Name: %s\n", optarg ? optarg:"");

				errUsage();

			}

			// Open parameter file

			strncpy(nameFileParam, optarg,MAX_FILENAME_CHARS);

			nameFileParam[MAX_FILENAME_CHARS]=0; // Ensure null terminated.

			hFileParam = fopen(nameFileParam, "r");

			if (!hFileParam)

			{

				fprintf( stderr, NAME_PROG ": Unable to Open Parameter File: %s\n",

					nameFileParam );

				perror("");

				errUsage();

			}

			// Read parameter file

			if (g_verbose)

				fprintf(stderr, NAME_PROG ": Reading Param File: %s\n", nameFileParam);

			ctCharParam = (int)fread(bfParam, 1, MAX_PARAM_BUF, hFileParam);

			bfParam[MAX_PARAM_BUF-1]=0;

			if (ferror(hFileParam))

			{

				fclose(hFileParam);

				fprintf(stderr, NAME_PROG ": Read Error: %s\n", nameFileParam);

				errUsage();

			}

			if ((ctCharParam == MAX_PARAM_BUF) && !feof(hFileParam))

			{

				fclose(hFileParam);

				fprintf( stderr, NAME_PROG ": Parameter file (%s) too large (> %d bytes)\n",

					nameFileParam, MAX_PARAM_BUF );

				errUsage();

			}

			fclose(hFileParam);

			if (ctCharParam > 0)

			{

				// Parse parameter file into tokens

				argc_recu = 2;

				argv_recu[0] = nameFileParam;

				for (ix = 1; ; ix++, argc_recu++)

				{

					if (ix == MAX_PARAMS_FILE)

					{

						fprintf( stderr, NAME_PROG ": Parameter file (%s) has too many parameters (> %d)\n",

										nameFileParam, MAX_PARAMS_FILE );

						errUsage();

					}

					if ( (argv_recu[ix] = strtok((ix == 1) ? bfParam : NULL, WHITE_SPACE))

							== NULL )

					{

						argc_recu--;

						break;

					}

					if (!strncmp(argv_recu[ix], "-P", OPTION_LEN))

					{

						fprintf( stderr, NAME_PROG ": Parameter file (%s) cannot contain -P option\n", nameFileParam);

						errUsage();

					}

					if ( (argv_recu[ix] - bfParam + strlen(argv_recu[ix]) + 1) ==

							ctCharParam )

						break;

				}

				// Process parameter file parameters

				if (argc_recu > 1)

				{

					optind_recu = optind;	// Save optind & optarg

					optarg_recu = optarg;

					optind = 1;   			// Init optind & optarg

					optarg = NULL;

					getRecu_opt(argc_recu, argv_recu, pOptShort, tbOptLong);

					optind = optind_recu;	// Restore optind & optarg

					optarg = optarg_recu;

				}

			}	// End of if (ctCharParam > 0)

			break;

		// Debug trace specification

		case 'Z':

			if (FSUCCESS != StringToUint32(&fvDebugProg, optarg, NULL, 0, TRUE)) {

				fprintf(stderr, NAME_PROG ": Invalid Debug Setting: %s\n", optarg);

				errUsage();

			}

			break;

		default:

			fprintf(stderr, NAME_PROG ": Invalid Option -<%c>\n", cOpt);

			errUsage();

			break;

        }	// End of switch (cOpt)

    }	// End of while ((cOpt = getopt_long(argc, argv,

	// Validate command line arguments

	if (optind < argc)

	{

		fprintf(stderr, "%s: invalid argument %s\n", NAME_PROG, argv[optind]);

		errUsage();

	}

}	// End of getRecu_opt()

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

 *

 * main()

 *

 * Description:

 *	main function for program.

 *

 * Inputs:

 *	argc - Number of input parameters

 *	argv - Array of pointers to input parameters

 *

 * Outputs:

 *	Exit status 0 - no errors

 *	Exit status 2 - error (input parameter, resources, file I/O, XML parsing)

 */

int main(int argc, char ** argv)

{

	int		ix;							// Loop index

	int		ctCharInput = 0;			// Input file char count

	char	*pValue = NULL;				// Pointer to current input value

	char	*pValueNext = bfInput + MAX_INPUT_BUF;  // Ptr to next input value

	// Initialize for generation

	hFileInput = stdin;

	hFileOutput = stdout;

	for (ix = 0; ix < MAX_ELEMENTS; ix++)

	{

		tbElements[ix].lenName = 0;

		tbElements[ix].pName = NULL;

		tbElements[ix].lenValue = 0;

		tbElements[ix].pValue = NULL;

		tbElements[ix].flags = 0;

	}

	// Get and validate command line arguments

	getRecu_opt(argc, argv, "vg:h:e:X:P:d:i:Z:", tbOptions);

	if (numElementsTable <= 0)

	{

		fprintf(stderr, NAME_PROG ": No Elements Specified\n");

		errUsage();

	}

	IXmlInit(&state, hFileOutput, numIndentChars, IXML_OUTPUT_FLAG_NONE, NULL);

	// Output Report

	strcat(bfDelimit, "\n");			// Append New Line to bfDelimit

	for (ix = 0; ; )

	{

		// Generate element

		if (tbElements[ix].flags & ELEM_GENERATE)

		{

			// Check for end of bfInput

			if ( ((pValueNext - bfInput) > (MAX_INPUT_BUF >> 1)) &&

					!feof(hFileInput) )

			{

				// Shift bfInput[] and read input file

				memmove(bfInput, pValueNext, MAX_INPUT_BUF + bfInput - pValueNext);

				if (g_verbose)

					fprintf( stderr, NAME_PROG ": Reading Input File: %s\n",

						nameFileInput );

				ctCharInput = MAX_INPUT_BUF + bfInput - pValueNext +

                    (int)fread( bfInput + MAX_INPUT_BUF - pValueNext + bfInput,

                    1, pValueNext - bfInput, hFileInput );

				pValueNext = bfInput;

				if (ferror(hFileInput))

				{

					fprintf(stderr, NAME_PROG ": Read Error: %s\n", nameFileInput);

					errUsage();

				}

			}

			// Check for end of input file

			if ((pValueNext - bfInput) >= ctCharInput)

			{

				fprintf( stderr,

			NAME_PROG ": WARNING End of Input file (%s) before End of Element List (%d items)\n",

						nameFileInput, numElementsTable );

				g_exitstatus = 2;

				break;

			}

			/* strtok() skips over multiple consecutive delimiters as a group;

			   the following causes a NULL element value to be processed if 2

			   consecutive delimiters are encountered.

			*/

			if (!strchr(bfDelimit, *pValueNext))

			{

				pValue = strtok(pValueNext, bfDelimit);

				if (!pValue) 

				{

					fprintf( stderr,

						NAME_PROG ": WARNING Malformed Input file (%s) strtok() error.\n",

						nameFileInput);

					break;

				}

				dispElementRecord(&tbElements[ix++], pValue);

				pValueNext = pValue + strlen(pValue) + 1;

			}

			else

			{

				dispElementRecord(&tbElements[ix++], NULL);

				pValueNext += 1;

			}

		}

		// Header or Header End element

		else

			dispElementRecord(&tbElements[ix++], NULL);

		// Check for end of tbElements[]

		if (ix >= numElementsTable)

		{

			if ((pValueNext - bfInput) < ctCharInput)

				ix = 0;					// Wrap to beg of tbElements[]

			else						// End of report

				break;

		}

	}	// End of for (ix = 0; ; )

	if (hFileInput && (hFileInput != stdin))

		fclose(hFileInput);

	return (g_exitstatus);

}	// End of main()

// End of file