// -*- 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 1997-1999

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

//

// Authors:

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

// This is the source to `getdap'; a simple tool to exercise the Connect

// class. It can be used to get naked URLs as well as the DAP2 DAS and DDS

// objects.  jhrg.

#include "config.h"

#ifdef WIN32

#include <io.h>

#include <fcntl.h>

#endif

#include <cstring>

#include <string>

#include <sstream>

#include "GetOpt.h"

#include "DMR.h"

#include "XMLWriter.h"

#include "D4BaseTypeFactory.h"

#include "D4Group.h"

#include "D4Sequence.h"

#include "D4Connect.h"

#include "StdinResponse.h"

#include "HTTPConnect.h"

#include "RCReader.h"

using namespace std;

using namespace libdap ;

const char *version = CVER " (" DVR " DAP/" DAP_PROTOCOL_VERSION ")";

#if 0

extern int libdap::dods_keep_temps;     // defined in HTTPResponse.h

extern int libdap::www_trace;

#endif

static void usage(const string &name)

{

	cerr << "Usage: " << name << endl;

	cerr << " [dD vVikmzstM][-c <expr>][-m <num>] <url> [<url> ...] | <file> [<file> ...]" << endl;

	cerr << endl;

	cerr << "In the first form of the command, dereference the URL and" << endl;

	cerr << "perform the requested operations. This includes routing" << endl;

	cerr << "the returned information through the DAP processing" << endl;

	cerr << "library (parsing the returned objects, et c.). If none" << endl;

	cerr << "of a, d, or D are used with a URL, then the DAP library" << endl;

	cerr << "routines are NOT used and the URLs contents are dumped" << endl;

	cerr << "to standard output." << endl;

	cerr << "Note: If the URL contains a query string the query string" << endl;

	cerr << "will be preserved in the request. However, if the query " << endl;

	cerr << "string contains DAP4 keys they may interfere with the" << endl;

	cerr << "operation of " << name << ". A warning will be" << endl;

	cerr << "written to stderr when "<< name << " identifies" << endl;

	cerr << "the presence of a DAP4 query key in the submitted" << endl;

	cerr << "URL's query string." << endl;

	cerr << endl;

	cerr << "In the second form of the command, assume the files are" << endl;

	cerr << "DataDDS objects (stored in files or read from pipes)" << endl;

	cerr << "and process them as if -D were given. In this case the" << endl;

	cerr << "information *must* contain valid MIME header in order" << endl;

	cerr << "to be processed." << endl;

	cerr << endl;

	cerr << "Options:" << endl;

	cerr << "        d: For each URL, get the (DAP4) DMR object. Does not get data." << endl;

	cerr << "        D: For each URL, get the DAP4 Data response." << endl;

	cerr << endl;

	cerr << "        v: Verbose output." << endl;

	cerr << "        V: Version of this client; see 'i' for server version." << endl;

	cerr << "        i: For each URL, get the server version." << endl;

	cerr << "        k: Keep temporary files created by libdap." << endl;

	cerr << "        m: Request the same URL <num> times." << endl;

	cerr << "        z: Ask the server to compress data." << endl;

	cerr << "        s: Print Sequences using numbered rows." << endl;

	cerr << "        t: Trace www accesses." << endl;

	cerr << "        M: Assume data read from a file has no MIME headers; use only with files" << endl;

	cerr << endl;

	cerr << "        c: <expr> is a constraint expression. Used with -d/D" << endl;

	cerr << "           NB: You can use a `?' for the CE also." << endl;

}

// Used for raw http access/transfer

bool read_data(FILE * fp)

{

    if (!fp) {

        fprintf(stderr, "getdap4: Whoa!!! Null stream pointer.\n");

        return false;

    }

    // Changed from a loop that used getc() to one that uses fread(). getc()

    // worked fine for transfers of text information, but *not* for binary

    // transfers. fread() will handle both.

    char c;

    while (fp && !feof(fp) && fread(&c, 1, 1, fp))

        printf("%c", c);        // stick with stdio

    return true;

}

static void read_response_from_file(D4Connect *url, DMR &dmr, Response &r, bool mime_headers, bool get_dap4_data, bool get_dmr)

{

    if (mime_headers) {

    	if (get_dap4_data)

    		url->read_data(dmr, r);

    	else if (get_dmr)

    		url->read_dmr(dmr, r);

    	else

    		throw Error("Only supports Data or DMR responses");

    }

    else {

    	if (get_dap4_data)

    		url->read_data_no_mime(dmr, r);

    	else if (get_dmr)

    		url->read_dmr_no_mime(dmr, r);

    	else

    		throw Error("Only supports Data or DMR responses");

    }

}

static void print_group_data(D4Group *g, bool print_rows = false)

{

    for (Constructor::Vars_iter i = g->var_begin(), e = g->var_end(); i != e; i++) {

        if (print_rows && (*i)->type() == dods_sequence_c)

            dynamic_cast<D4Sequence &>(**i).print_val_by_rows(cout);

        else

            (*i)->print_val(cout);

    }

    for (D4Group::groupsIter gi = g->grp_begin(), ge = g->grp_end(); gi != ge; ++gi) {

        print_group_data(*gi, print_rows);

    }

}

static void print_data(DMR &dmr, bool print_rows = false)

{

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

    D4Group *g = dmr.root();

    print_group_data(g, print_rows);

    cout << endl << flush;

}

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

{

    GetOpt getopt(argc, argv, "[dDvVikrm:Mzstc:]");

    int option_char;

    bool get_dmr = false;

    bool get_dap4_data = false;

    bool get_version = false;

    bool cexpr = false;

    bool verbose = false;

    bool multi = false;

    bool accept_deflate = false;

    bool print_rows = false;

    bool mime_headers = true;

    bool report_errors = false;

    int times = 1;

    int dap_client_major = 4;

    int dap_client_minor = 0;

    string expr = "";

#ifdef WIN32

    _setmode(_fileno(stdout), _O_BINARY);

#endif

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

        switch (option_char) {

        case 'd':

            get_dmr = true;

            break;

        case 'D':

            get_dap4_data = true;

            break;

        case 'v':

            verbose = true;

            break;

        case 'V':

        	cerr << "getdap4 version: " << version << endl;

            exit(0);

        case 'i':

            get_version = true;

            break;

#if 0

        case 'k':

            dods_keep_temps = 1;

            break;              // keep_temp is in Connect.cc

#endif

        case 'r':

        	report_errors = true;

        	break;

        case 'm':

            multi = true;

            times = atoi(getopt.optarg);

            break;

        case 'z':

            accept_deflate = true;

            break;

        case 's':

            print_rows = true;

            break;

        case 'M':

            mime_headers = false;

            break;

#if 0

        case 't':

            www_trace = 1;

            break;

#endif

        case 'c':

            cexpr = true;

            expr = getopt.optarg;

            break;

        case 'h':

        case '?':

        default:

            usage(argv[0]);

            exit(1);

            break;

        }

    try {

        // If after processing all the command line options there is nothing

        // left (no URL or file) assume that we should read from stdin.

        for (int i = getopt.optind; i < argc; ++i) {

            if (verbose)

                cerr << "Fetching: " << argv[i] << endl;

            string name = argv[i];

            D4Connect *url = 0;

            // auto_ptr? jhrg 10/19/15

            url = new D4Connect(name);

            // This overrides the value set in the .dodsrc file.

            if (accept_deflate)

                url->set_accept_deflate(accept_deflate);

            if (dap_client_major > 2)

                url->set_xdap_protocol(dap_client_major, dap_client_minor);

            if (url->is_local()) {

                if (verbose)

                    cerr << "Assuming " << argv[i] << " is a file that contains a response object; decoding." << endl;

                try {

                    D4BaseTypeFactory factory;

                    DMR dmr(&factory);

                    if (strcmp(argv[i], "-") == 0) {

                        StdinResponse r(cin);

                        if (!r.get_cpp_stream())

                            throw Error("Could not open standard input.");

                        read_response_from_file(url, dmr, r, mime_headers, get_dap4_data, get_dmr);

                    }

                    else {

                    	fstream f(argv[i], std::ios_base::in);

                    	if (!f.is_open() || f.bad() || f.eof())

                    		throw Error((string)"Could not open: " + argv[i]);

                    	Response r(&f, 0);

                        read_response_from_file(url, dmr, r, mime_headers, get_dap4_data, get_dmr);

                    }

                    if (verbose)

                        cerr << "DAP version: " << url->get_protocol().c_str() << " Server version: "

    						<< url->get_version().c_str() << endl;

                    // Always write the DMR

                    XMLWriter xml;

                    dmr.print_dap4(xml);

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

                    if (get_dap4_data)

                    	print_data(dmr, print_rows);

                }

                catch (Error & e) {

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

                    delete url; url = 0;

                    if (report_errors)

                        return EXIT_FAILURE;

                }

            }

            else if (get_dmr) {

                for (int j = 0; j < times; ++j) {

                    D4BaseTypeFactory factory;

                    DMR dmr(&factory);

                    try {

                        url->request_dmr(dmr, expr);

                        if (verbose) {

                            cout << "DAP version: " << url->get_protocol() << ", Server version: " << url->get_version() << endl;

                            cout << "DMR:" << endl;

                        }

                        XMLWriter xml;

                        dmr.print_dap4(xml);

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

                    }

                    catch (Error & e) {

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

                        if (report_errors)

                        	return EXIT_FAILURE;

                        continue;       // Goto the next URL or exit the loop.

                    }

                }

            }

            else if (get_dap4_data) {

                 for (int j = 0; j < times; ++j) {

                     D4BaseTypeFactory factory;

                     DMR dmr(&factory);

                     try {

                         url->request_dap4_data(dmr, expr);

                         if (verbose) {

                             cout << "DAP version: " << url->get_protocol() << ", Server version: " << url->get_version() << endl;

                             cout << "DMR:" << endl;

                         }

                         XMLWriter xml;

                         dmr.print_dap4(xml);

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

                         print_data(dmr, print_rows);

                    }

                     catch (Error & e) {

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

                         if (report_errors)

                             return EXIT_FAILURE;

                         continue;       // Goto the next URL or exit the loop.

                     }

                 }

            }

            else {

                HTTPConnect http(RCReader::instance());

                // This overrides the value set in the .dodsrc file.

                if (accept_deflate)

                    http.set_accept_deflate(accept_deflate);

                if (dap_client_major > 2)

                    url->set_xdap_protocol(dap_client_major, dap_client_minor);

                string url_string = argv[i];

                for (int j = 0; j < times; ++j) {

                    try {

                        HTTPResponse *r = http.fetch_url(url_string);

                        if (verbose) {

                        	vector<string> *headers = r->get_headers();

                        	copy(headers->begin(), headers->end(), ostream_iterator<string>(cout, "\n"));

                        }

                        if (!read_data(r->get_stream())) {

                            continue;

                        }

                        delete r;

                        r = 0;

                    }

                    catch (Error & e) {

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

                        if (report_errors)

                            return EXIT_FAILURE;

                        continue;

                    }

                }

            }

#if 0

            else if (get_version) {

                fprintf(stderr, "DAP version: %s, Server version: %s\n",

                        url->request_protocol().c_str(),

                        url->get_version().c_str());

            }

#endif

            delete url;  url = 0;

        }

    }

    catch (Error &e) {

    	if(e.get_error_code() == malformed_expr || e.get_error_code() == malformed_expr){

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

        	usage(argv[0]);

    	}

    	else {

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

    	}

        cerr << "Exiting." << endl;

        return 1;

    }

    catch (exception &e) {

        cerr << "C++ library exception: " << e.what() << endl;

        cerr << "Exiting." << endl;

        return 1;

    }

    return 0;

}