// -*- 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,2013 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//

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

// Test the DMR parser

#include "config.h"

#include <stdint.h>

#include <cstring>

#include <fstream>

#include <memory>

#include "crc.h"

#include <GetOpt.h>

#include "BaseType.h"

#include "Array.h"

#include "D4Enum.h"

#include "DMR.h"

#include "D4Group.h"

#include "D4StreamUnMarshaller.h"

#include "chunked_ostream.h"

#include "chunked_istream.h"

#include "util.h"

#include "InternalErr.h"

#include "Error.h"

#include "D4ResponseBuilder.h"

#include "ConstraintEvaluator.h"

#include "D4ParserSax2.h"

#include "D4TestTypeFactory.h"

#include "TestCommon.h"

#include "D4ConstraintEvaluator.h"

#include "D4FunctionEvaluator.h"

#include "ServerFunctionsList.h"

#include "D4TestFunction.h"

#include "D4RValue.h"

#include "util.h"

#include "mime_util.h"

#include "debug.h"

int test_variable_sleep_interval = 0;   // Used in Test* classes for testing timeouts.

using namespace libdap;

/**

 * Open the named XML file and parse it, assuming that it contains a DMR.

 * @param name The name of the DMR XML file (or '-' for stdin)

 * @param debug True if the debug mode of the parse should be used

 * @param print Once parsed, should the DMR object be printed?

 * @return true if the parse worked, false otherwise

 */

DMR *

test_dap4_parser(const string &name, bool debug, bool print)

{

    D4TestTypeFactory *factory = new D4TestTypeFactory;

    DMR *dataset = new DMR(factory, path_to_filename(name));

    try {

        D4ParserSax2 parser;

        if (name == "-") {

            parser.intern(cin, dataset, debug);

        }

        else {

            fstream in(name.c_str(), ios_base::in);

            parser.intern(in, dataset, debug);

        }

    }

    catch(...) {

        delete factory;

        delete dataset;

        throw;

    }

    cout << "Parse successful" << endl;

    if (print) {

        XMLWriter xml("    ");

        dataset->print_dap4(xml, false);

        cout << xml.get_doc() << endl;

    }

    delete factory;

    dataset->set_factory(0);

    return dataset;

}

/**

 * Should the changing values - meant to mimic the DTS - be used?

 * @param dmr Set for this DMR

 * @param state True to use the DTS-like values, false otherwise

 */

void

set_series_values(DMR *dmr, bool state)

{

	if (state == true)

		dmr->root()->set_read_p(false);

	TestCommon *tc = dynamic_cast<TestCommon*>(dmr->root());

	if (tc)

		tc->set_series_values(state);

	else

		cerr << "Could not cast root group to TestCommon (" << dmr->root()->type_name() << ", " << dmr->root()->name() << ")" << endl;

}

/**

 * Call the parser and then serialize the resulting DMR after applying the

 * constraint. The persistent representation is written to a file. The file

 * is name '<name>_data.bin'.

 *

 * @param dataset

 * @param constraint

 * @param series_values

 * @return The name of the file that hods the response.

 */

string

send_data(DMR *dataset, const string &constraint, const string &function, bool series_values, bool ce_parser_debug)

{

    set_series_values(dataset, series_values);

    // This will be used by the DMR that holds the results of running the functions.

    // It's declared at this scope because we (may) need it for the code beyond the

    // function parse/eval code that immediately follows. jhrg 3/12/14

    D4TestTypeFactory d4_factory;

    auto_ptr<DMR> function_result(new DMR(&d4_factory, "function_results"));

	// The Function Parser

	if (!function.empty()) {

		ServerFunctionsList *sf_list = ServerFunctionsList::TheList();

		ServerFunction *scale = new D4TestFunction;

		sf_list->add_function(scale);

		D4FunctionEvaluator parser(dataset, sf_list);

		if (ce_parser_debug) parser.set_trace_parsing(true);

		bool parse_ok = parser.parse(function);

		if (!parse_ok)

			Error("Function Expression failed to parse.");

		else {

			if (ce_parser_debug) cerr << "Function Parse OK" << endl;

			parser.eval(function_result.get());

			// Now use the results of running the functions for the remainder of the

			// send_data operation.

			dataset = function_result.release();

		}

	}

    D4ResponseBuilder rb;

    rb.set_dataset_name(dataset->name());

    string file_name = dataset->name() + "_data.bin";

    ofstream out(file_name.c_str(), ios::out|ios::trunc|ios::binary);

	if (!constraint.empty()) {

		D4ConstraintEvaluator parser(dataset);

		if (ce_parser_debug)

		    parser.set_trace_parsing(true);

		bool parse_ok = parser.parse(constraint);

		if (!parse_ok)

			throw Error("Constraint Expression failed to parse.");

		else if (ce_parser_debug)

		    cerr << "CE Parse OK" << endl;

	}

    else {

    	dataset->root()->set_send_p(true);

    }

    rb.send_dap(out, *dataset, /*with mime headers*/ true, !constraint.empty());

    out.close();

    return file_name;

}

void

intern_data(DMR *dataset, /*const string &constraint,*/ bool series_values)

{

    set_series_values(dataset, series_values);

    // Mark all variables to be sent in their entirety. No CEs are used

    // when 'interning' variables' data.

    dataset->root()->set_send_p(true);

#if 0

    Crc32 checksum;

#endif

    dataset->root()->intern_data(/*checksum, *dataset, eval*/);

}

DMR *

read_data_plain(const string &file_name, bool debug)

{

    D4BaseTypeFactory *factory = new D4BaseTypeFactory;

    DMR *dmr = new DMR(factory, "Test_data");

    fstream in(file_name.c_str(), ios::in|ios::binary);

    // Gobble up the response's initial set of MIME headers. Normally

    // a client would extract information from these headers.

    remove_mime_header(in);

    chunked_istream cis(in, CHUNK_SIZE);

    // parse the DMR, stopping when the boundary is found.

    try {

        // force chunk read

        // get chunk size

        int chunk_size = cis.read_next_chunk();

        // get chunk

        char chunk[chunk_size];

        cis.read(chunk, chunk_size);

        // parse char * with given size

    	D4ParserSax2 parser;

    	// Mirror the behavior in D4Connect where we are permissive with DAP4

    	// data responses' parsing, as per Hyrax-98 in Jira. jhrg 4/13/16

    	parser.set_strict(false);

    	// '-2' to discard the CRLF pair

        parser.intern(chunk, chunk_size-2, dmr, debug);

    }

    catch(Error &e) {

    	delete factory;

    	delete dmr;

    	cerr << "Exception: " << e.get_error_message() << endl;

    	return 0;

    }

    catch(std::exception &e) {

    	delete factory;

    	delete dmr;

    	cerr << "Exception: " << e.what() << endl;

    	return 0;

    }

    catch(...) {

    	delete factory;

    	delete dmr;

    	cerr << "Exception: unknown error" << endl;

    	return 0;

    }

    D4StreamUnMarshaller um(cis, cis.twiddle_bytes());

    dmr->root()->deserialize(um, *dmr);

    delete factory;

    dmr->set_factory(0);

    return dmr;

}

static void usage()

{

    cerr << "Usage: dmr-test -p|s|t|i <file> [-c <expr>] [-f <function expression>] [-d -x -e]" << endl

            << "p: Parse a file (use \"-\" for stdin; if a ce or a function is passed those are parsed too)" << endl

            << "s: Send: parse and then 'send' a response to a file" << endl

            << "t: Transmit: parse, send and then read the response file" << endl

            << "i: Intern values (ce and function will be ignored by this)" << endl

            << "c: Constraint expression " << endl

            << "f: Function expression" << endl

            << "d: turn on detailed xml parser debugging" << endl

            << "D: turn on detailed ce parser debugging" << endl

            << "x: print the binary object(s) built by the parse, send, trans or intern operations." << endl

            << "e: use sEries values." << endl;

}

int

main(int argc, char *argv[])

{

    GetOpt getopt(argc, argv, "p:s:t:i:c:f:xdDeh?");

    int option_char;

    bool parse = false;

    bool debug = false;

    bool print = false;

    bool send = false;

    bool trans = false;

    bool intern = false;

    bool series_values = false;

    bool constrained = false;

    bool functional = false;

    bool ce_parser_debug = false;

    string name = "";

    string ce = "";

    string function = "";

    // process options

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

        switch (option_char) {

        case 'p':

            parse = true;

            name = getopt.optarg;

            break;

        case 's':

        	send = true;

        	name = getopt.optarg;

        	break;

        case 't':

        	trans = true;

        	name = getopt.optarg;

        	break;

        case 'i':

        	intern = true;

        	name = getopt.optarg;

        	break;

        case 'c':

        	constrained = true;

        	ce = getopt.optarg;

        	break;

        case 'f':

        	functional = true;

        	function = getopt.optarg;

        	break;

        case 'd':

            debug = true;

            break;

        case 'D':

            ce_parser_debug = true;

            break;

        case 'x':

            print = true;

            break;

        case 'e':

        	series_values = true;

        	break;

        case '?':

        case 'h':

            usage();

            return 0;

        default:

            cerr << "Error: ";

            usage();

            return 1;

        }

    if (! (parse || send || trans || intern)) {

        cerr << "Error: ";

        usage();

        return 1;

    }

    try {

		if (parse) {

			DMR *dmr = test_dap4_parser(name, debug, print);

			// The CE Parser

			if (!ce.empty()) {

				try {

					D4ConstraintEvaluator parser(dmr);

					if (ce_parser_debug) parser.set_trace_parsing(true);

					bool parse_ok = parser.parse(ce);

					if (!parse_ok)

						cout << "CE Parse Failed" << endl;

					else

						cout << "CE Parse OK" << endl;

				}

				catch (Error &e) {

					cerr << "CE Parse error: " << e.get_error_message() << endl;

				}

				catch (...) {

					cerr << "Ce Parse error: Unknown exception thrown by parser" << endl;

				}

			}

			// The Function Parser

			if (!function.empty()) {

				try {

					ServerFunctionsList *sf_list = ServerFunctionsList::TheList();

				    ServerFunction *scale = new D4TestFunction;

				    sf_list->add_function(scale);

					D4FunctionEvaluator parser(dmr, sf_list);

					if (ce_parser_debug) parser.set_trace_parsing(true);

					bool parse_ok = parser.parse(function);

					if (!parse_ok)

						cout << "Function Parse Failed" << endl;

					else

						cout << "Function Parse OK" << endl;

				}

				catch (Error &e) {

					cerr << "Function Parse error: " << e.get_error_message() << endl;

				}

				catch (...) {

					cerr << "Function Parse error: Unknown exception thrown by parser" << endl;

				}

			}

			delete dmr;

		}

		if (send) {

        	DMR *dmr = test_dap4_parser(name, debug, print);

        	string file_name = send_data(dmr, ce, function, series_values, ce_parser_debug);

        	if (print)

        		cout << "Response file: " << file_name << endl;

        	delete dmr;

        }

        if (trans) {

        	DMR *dmr = test_dap4_parser(name, debug, print);

        	string file_name = send_data(dmr, ce, function, series_values, ce_parser_debug);

         	delete dmr;

        	DMR *client = read_data_plain(file_name, debug);

        	if (print) {

        		XMLWriter xml;

        		// received data never have send_p set; don't set 'constrained'

        		client->print_dap4(xml, false /* constrained */);

        		cout << xml.get_doc() << endl;

				cout << "The data:" << endl;

        	}

        	// if trans is used, the data are printed regardless of print's value

    		client->root()->print_val(cout, "", false);

    		cout << endl;

        	delete client;

        }

        if (intern) {

        	DMR *dmr = test_dap4_parser(name, debug, print);

        	intern_data(dmr, /*ce,*/ series_values);

        	if (print) {

        		XMLWriter xml;

        		dmr->print_dap4(xml, false /*constrained*/);

        		cout << xml.get_doc() << endl;

				cout << "The data:" << endl;

        	}

        	// if trans is used, the data are printed regardless of print's value

    		dmr->root()->print_val(cout, /*space*/"", false);

    		cout << endl;

        	delete dmr;

        }

    }

    catch (Error &e) {

        cerr << "Error: " << e.get_error_message() << endl;

        return 1;

    }

    return 0;

}