// -*- mode: c++; c-basic-offset:4 -*-

// This file is part of libdap, A C++ implementation of the OPeNDAP Data

// Access Protocol.

// Copyright (c) 2002,2003 OPeNDAP, Inc.

// Author: James Gallagher <jgallagher@opendap.org>

//

// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Lesser General Public

// License as published by the Free Software Foundation; either

// version 2.1 of the License, or (at your option) any later version.

//

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

// Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

//

// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.

// (c) COPYRIGHT URI/MIT 1994-1999

// Please read the full copyright statement in the file COPYRIGHT_URI.

//

// Authors:

//      jhrg,jimg       James Gallagher <jgallagher@gso.uri.edu>

// Test the DAS class.

// Read attributes from one or more files, printing the resulting table to

// stdout. If a file is named `-' read from stdin for that file. The option

// `-d' causes new/delete run-time debugging to be turned on.

//

// jhrg 7/25/94

#include "config.h"

#include <cstdlib>

#include <string>

#include <GetOpt.h>

#define YYSTYPE char *

#include "DAS.h"

#include "das.tab.hh"

#include "Error.h"

using namespace libdap ;

void plain_driver(DAS &das, bool deref_alias);

void load_attr_table(AttrTable at);

void load_attr_table_ptr(AttrTable *atp);

void parser_driver(DAS &das, bool deref_alias, bool as_xml);

void test_scanner();

int daslex();

extern int dasdebug;

const char *prompt = "das-test: ";

const char *version = "version 1.19";

using namespace std;

void

usage(string name)

{

    fprintf( stderr, "usage: %s %s\n %s\n %s\n %s\n %s\n %s\n %s\n %s\n",

		     name.c_str(),

		     "[-v] [-s] [-d] [-c] [-p] [rx] {< in-file > out-file}",

		     "s: Test the DAS scanner.",

		     "p: Scan and parse from <in-file>; print to <out-file>.",

		     "c: Test building the DAS from C++ code.",

		     "v: Print the version of das-test and exit.",

		     "d: Print parser debugging information.",

		     "r: Print the DAS with aliases deReferenced.",

		     "x: Print as xml.") ;

}

int main(int argc, char *argv[])

{

    GetOpt getopt (argc, argv, "scpvdrx");

    int option_char;

    bool parser_test = false;

    bool scanner_test = false;

    bool code_test = false;

    bool deref_alias = false;

    bool as_xml = false;

    while ((option_char = getopt ()) != -1)

	switch (option_char)

	  {

	    case 'p':

	      parser_test = true;

	      break;

	    case 's':

	      scanner_test = true;

	      break;

	    case 'c':

	      code_test = true;

	      break;

	    case 'v':

	      fprintf( stderr, "%s: %s\n", argv[0], version ) ;

	      return 0;

	    case 'd':

	      dasdebug = 1;

	      break;

	    case 'r':

	      deref_alias = true;

	      break;

	    case 'x':

	        as_xml = true;

	        break;

	    case '?':

	    default:

	      usage(argv[0]);

              return 1;

	  }

    DAS das;

    if (!parser_test && !scanner_test && !code_test) {

	usage(argv[0]);

	return 1;

    }

    try {

      if (parser_test)

	parser_driver(das, deref_alias, as_xml);

      if (scanner_test)

	test_scanner();

      if (code_test)

	plain_driver(das, deref_alias);

    }

    catch (Error &e) {

	cerr << "Caught Error object:" << endl;

	cerr << e.get_error_message() << endl;

	return 1;

    }

    return 0;

}

void

test_scanner()

{

    int tok;

    fprintf( stdout, "%s", prompt ) ; // first prompt

    fflush( stdout ) ;

    while ((tok = daslex())) {

	switch (tok) {

	  case SCAN_ATTR:

	    fprintf( stdout, "ATTR\n" ) ;

	    break;

	  case SCAN_ALIAS:

	    fprintf( stdout, "ALIAS\n" ) ;

	    break;

	  case SCAN_WORD:

	    fprintf( stdout, "WORD=%s\n", daslval ) ;

	    break;

	  case SCAN_BYTE:

	    fprintf( stdout, "BYTE\n" ) ;

	    break;

	  case SCAN_INT16:

	    fprintf( stdout, "INT16\n" ) ;

	    break;

	  case SCAN_UINT16:

	    fprintf( stdout, "UINT16\n" ) ;

	    break;

	  case SCAN_INT32:

	    fprintf( stdout, "INT32\n" ) ;

	    break;

	  case SCAN_UINT32:

	    fprintf( stdout, "UINT32\n" ) ;

	    break;

	  case SCAN_FLOAT32:

	    fprintf( stdout, "FLOAT32\n" ) ;

	    break;

	  case SCAN_FLOAT64:

	    fprintf( stdout, "FLOAT64\n" ) ;

	    break;

	  case SCAN_STRING:

	    fprintf( stdout, "STRING\n" ) ;

	    break;

          case SCAN_URL:

            fprintf( stdout, "URL\n" ) ;

            break;

          case SCAN_XML:

            fprintf( stdout, "OtherXML\n" ) ;

            break;

	  case '{':

	    fprintf( stdout, "Left Brace\n" ) ;

	    break;

	  case '}':

	    fprintf( stdout, "Right Brace\n" ) ;

	    break;

	  case ';':

	    fprintf( stdout, "Semicolon\n" ) ;

	    break;

	  case ',':

	    fprintf( stdout, "Comma\n" ) ;

	    break;

	  default:

	    fprintf( stdout, "Error: Unrecognized input\n" ) ;

	    break;

	}

	fprintf( stdout, "%s", prompt ) ; // print prompt after output

	fflush( stdout ) ;

    }

}

void

parser_driver(DAS &das, bool deref_alias, bool as_xml)

{

    das.parse();

    if (as_xml) {

        das.get_top_level_attributes()->print_xml(stdout, "    ");

    }

    else

        das.print(stdout, deref_alias);

}

// Given a DAS, add some stuff to it.

void

plain_driver(DAS &das, bool deref_alias)

{

    string name = "test";

    AttrTable *atp = new AttrTable;

    load_attr_table_ptr(atp);

#if 0

    AttrTable *dummy = das.get_table(name);

#endif

    das.add_table(name, atp);

    name = "test2";

    atp = new AttrTable;

    load_attr_table_ptr(atp);

    das.add_table(name, atp);

    das.print(stdout, deref_alias);

}

// stuff an AttrTable full of values. Also, print it out.

void

load_attr_table(AttrTable at)

{

    at.append_attr("month", "String", "Feb");

    at.append_attr("month", "String", "Feb");

    at.append_attr("month_a", "String", "Jan");

    at.append_attr("month_a", "String", "Feb");

    at.append_attr("month_a", "String", "Mar");

    at.append_attr("Date", "Int32", "12345");

    at.append_attr("day", "Int32", "01");

    at.append_attr("Time", "Float64", "3.1415");

    fprintf( stdout, "Using the iterator:\n" ) ;

    for (AttrTable::Attr_iter p2 = at.attr_begin(); p2 != at.attr_end(); p2++)

    {

		fprintf( stdout, "%s %s ", at.get_name(p2).c_str(),

			at.get_type(p2).c_str() ) ;

		for (unsigned i = 0; i < at.get_attr_num(p2); ++i)

			fprintf( stdout, "%s ", at.get_attr(p2, i).c_str() ) ;

		fprintf( stdout, "\n" ) ;

    }

    string name = "month";

    fprintf( stdout, "Using String: %s %s %s\n",

		     at.get_type(name).c_str(),

		     at.get_attr(name, 0).c_str(),

		     at.get_attr(name, 1).c_str()) ;

    fprintf( stdout, "Using char *: %s %s %s\n",

		     at.get_type("month").c_str(),

		     at.get_attr("month", 0).c_str(),

		     at.get_attr("month", 1).c_str() ) ;

    at.del_attr("month");

    fprintf( stdout, "After deletion:\n" ) ;

    for (AttrTable::Attr_iter p3 = at.attr_begin(); p3 != at.attr_end(); p3++)

    {

		fprintf( stdout, "%s %s ", at.get_name(p3).c_str(),

			at.get_type(p3).c_str() ) ;

		for (unsigned i = 0; i < at.get_attr_num(p3); ++i)

			fprintf( stdout, "%s ", at.get_attr(p3, i).c_str() ) ;

		fprintf( stdout, "\n" ) ;

    }

    at.print(stdout);

    fprintf( stdout, "After print:\n" ) ;

    for (AttrTable::Attr_iter p4 = at.attr_begin(); p4 != at.attr_end(); p4++)

    {

	fprintf( stdout, "%s %s ", at.get_name(p4).c_str(),

		at.get_type(p4).c_str() ) ;

	for (unsigned i = 0; i < at.get_attr_num(p4); ++i)

	     fprintf( stdout, "%s ", at.get_attr(p4, i).c_str() ) ;

	fprintf( stdout, "\n" ) ;

    }

}

// OK, now try it with a dymanic AttrTable

void

load_attr_table_ptr(AttrTable *at)

{

    at->append_attr("month", "String", "Feb");

    at->append_attr("month", "String", "Feb");

    at->append_attr("month_a", "String", "Jan");

    at->append_attr("month_a", "String", "Feb");

    at->append_attr("month_a", "String", "Mar");

    at->append_attr("Date", "Int32", "12345");

    at->append_attr("day", "Int32", "01");

    at->append_attr("Time", "Float64", "3.1415");

    fprintf( stdout, "Using the iterator:\n" ) ;

    for (AttrTable::Attr_iter p2 = at->attr_begin(); p2 != at->attr_end(); p2++)

    {

		fprintf( stdout, "%s %s ", at->get_name(p2).c_str(),

			at->get_type(p2).c_str() ) ;

		for (unsigned i = 0; i < at->get_attr_num(p2); ++i)

			fprintf( stdout, "%s ", at->get_attr(p2, i).c_str() ) ;

		fprintf( stdout, "\n" ) ;

    }

    string name = "month";

    fprintf( stdout, "Using String: %s %s %s\n",

		     at->get_type(name).c_str(),

		     at->get_attr(name, 0).c_str(),

		     at->get_attr(name, 1).c_str() ) ;

    fprintf( stdout, "Using char *: %s %s %s\n",

		     at->get_type("month").c_str(),

		     at->get_attr("month", 0).c_str(),

		     at->get_attr("month", 1).c_str() ) ;

    at->del_attr("month");

    fprintf( stdout, "After deletion:\n" ) ;

    for (AttrTable::Attr_iter p3 = at->attr_begin(); p3 != at->attr_end(); p3++)

    {

		fprintf( stdout, "%s %s ", at->get_name(p3).c_str(),

			at->get_type(p3).c_str() ) ;

		for (unsigned i = 0; i < at->get_attr_num(p3); ++i)

			fprintf( stdout, "%s ", at->get_attr(p3, i).c_str() ) ;

		fprintf( stdout, "\n" ) ;

    }

    at->print(stdout);

    fprintf( stdout, "After print:\n" ) ;

    for (AttrTable::Attr_iter p4 = at->attr_begin(); p4 !=at->attr_end(); p4++)

    {

		fprintf( stdout, "%s %s ", at->get_name(p4).c_str(),

			at->get_type(p4).c_str() ) ;

		for (unsigned i = 0; i < at->get_attr_num(p4); ++i)

			fprintf( stdout, "%s ", at->get_attr(p4, i).c_str() ) ;

		fprintf( stdout, "\n" ) ;

    }

}