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

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

// Access Protocol.

// Copyright (c) 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.

#include "config.h"

//#define DODS_DEBUG

#include "D4Attributes.h"

#include "D4AttributeType.h"

#include "InternalErr.h"

#include "AttrTable.h"

#include "util.h"

#include "debug.h"

namespace libdap {

/** Convert an AttrType to it's string representation.

 @param at The Attribute Type.

 @return The type's string representation */

string D4AttributeTypeToString(D4AttributeType at)

{

    switch(at) {

    case attr_null_c:

        return "null";

    case attr_byte_c:

        return "Byte";

    case attr_int16_c:

        return "Int16";

    case attr_uint16_c:

        return "UInt16";

    case attr_int32_c:

        return "Int32";

    case attr_uint32_c:

        return "UInt32";

    case attr_float32_c:

        return "Float32";

    case attr_float64_c:

        return "Float64";

    case attr_str_c:

        return "String";

    case attr_url_c:

        return "Url";

        // Added for DAP4

    case attr_int8_c:

        return "Int8";

    case attr_uint8_c:

        return "UInt8";

    case attr_int64_c:

        return "Int64";

    case attr_uint64_c:

        return "UInt64";

    case attr_enum_c:

        return "Enum";

    case attr_opaque_c:

        return "Opaque";

        // These are specific to attributes while the other types are

        // also supported by the variables. jhrg 4/17/13

    case attr_container_c:

        return "Container";

    case attr_otherxml_c:

        return "OtherXML";

    default:

        throw InternalErr(__FILE__, __LINE__, "Unsupported attribute type");

    }

}

D4AttributeType StringToD4AttributeType(string s)

{

    downcase(s);

    if (s == "container")

        return attr_container_c;

    else if (s == "byte")

        return attr_byte_c;

    else if (s == "int8")

        return attr_int8_c;

    else if (s == "uint8")

        return attr_uint8_c;

    else if (s == "int16")

        return attr_int16_c;

    else if (s == "uint16")

        return attr_uint16_c;

    else if (s == "int32")

        return attr_int32_c;

    else if (s == "uint32")

        return attr_uint32_c;

    else if (s == "int64")

        return attr_int64_c;

    else if (s == "uint64")

        return attr_uint64_c;

    else if (s == "float32")

        return attr_float32_c;

    else if (s == "float64")

        return attr_float64_c;

    else if (s == "string")

        return attr_str_c;

    else if (s == "url")

        return attr_url_c;

    else if (s == "otherxml")

        return attr_otherxml_c;

    else

        return attr_null_c;

}

void

D4Attribute::m_duplicate(const D4Attribute &src)

{

    d_name = src.d_name;

    d_type = src.d_type;

    d_values = src.d_values;

    if (src.d_attributes)

        d_attributes = new D4Attributes(*src.d_attributes);

    else

        d_attributes = 0;

}

D4Attribute::D4Attribute(const D4Attribute &src)

{

    m_duplicate(src);

}

D4Attribute::~D4Attribute()

{

    delete d_attributes;

}

D4Attribute &

D4Attribute::operator=(const D4Attribute &rhs)

{

    if (this == &rhs) return *this;

    m_duplicate(rhs);

    return *this;

}

D4Attributes *

D4Attribute::attributes()

{

    if (!d_attributes) d_attributes = new D4Attributes();

    return d_attributes;

}

/** @brief copy attributes from DAP2 to DAP4

 *

 * Given a DAP2 AttrTable, copy all of its attributes into

 * this DAP4 D4Attributes object as D4Attribute object instances.

 *

 *

 * @param at Read the DAP2 attributes from here.

 */

void

D4Attributes::transform_to_dap4(AttrTable &at)

{

    // for every attribute in at, copy it to this.

    for (AttrTable::Attr_iter i = at.attr_begin(), e = at.attr_end(); i != e; ++i) {

        string name = at.get_name(i);

        AttrType type = at.get_attr_type(i);

        switch (type) {

        case Attr_container: {

            D4Attribute *a = new D4Attribute(name, attr_container_c);

            D4Attributes *attributes = a->attributes(); // allocates a new object

            attributes->transform_to_dap4(*at.get_attr_table(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_byte: {

            D4Attribute *a = new D4Attribute(name, attr_byte_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_int16: {

            D4Attribute *a = new D4Attribute(name, attr_int16_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_uint16: {

            D4Attribute *a = new D4Attribute(name, attr_uint16_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_int32: {

            D4Attribute *a = new D4Attribute(name, attr_int32_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_uint32: {

            D4Attribute *a = new D4Attribute(name, attr_uint32_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_float32: {

            D4Attribute *a = new D4Attribute(name, attr_float32_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_float64: {

            D4Attribute *a = new D4Attribute(name, attr_float64_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_string: {

            D4Attribute *a = new D4Attribute(name, attr_str_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_url: {

            D4Attribute *a = new D4Attribute(name, attr_url_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        case Attr_other_xml: {

            D4Attribute *a = new D4Attribute(name, attr_otherxml_c);

            a->add_value_vector(*at.get_attr_vector(i));

            add_attribute_nocopy(a);

            break;

        }

        default:

            throw InternalErr(__FILE__, __LINE__, "Unknown DAP2 attribute type in D4Attributes::copy_from_dap2()");

        }

    }

}

AttrType get_dap2_AttrType(D4AttributeType d4_type){

    switch (d4_type) {

    case attr_container_c: { return Attr_container; }

    case attr_byte_c:      { return Attr_byte; }

    case attr_int16_c:     { return Attr_int16; }

    case attr_uint16_c:    { return Attr_uint16; }

    case attr_int32_c:     { return Attr_int32; }

    case attr_uint32_c:    { return Attr_uint32; }

    case attr_float32_c:   { return Attr_float32; }

    case attr_float64_c:   { return Attr_float64; }

    case attr_str_c:       { return Attr_string; }

    case attr_url_c:       { return Attr_url; }

    case attr_otherxml_c:  { return Attr_other_xml; }

    default:

        throw InternalErr(__FILE__, __LINE__, "Unknown DAP4 attribute");

    }

}

void

D4Attributes::load_AttrTable(AttrTable *d2_attr_table, D4Attributes *d4_attrs)

{

   //  cerr << __func__ << "() - Loading attribute table: '" << d2_attr_table->get_name() << "'  addr: " << (void *)d2_attr_table << endl;

    // for every attribute in at, copy it to this.

    for ( D4Attributes::D4AttributesIter i = d4_attrs->attribute_begin(), e = d4_attrs->attribute_end(); i != e; ++i) {

        string name = (*i)->name();

        D4AttributeType d4_attr_type = (*i)->type();

        AttrType d2_attr_type = get_dap2_AttrType(d4_attr_type);

        string d2_attr_type_name = AttrType_to_String(d2_attr_type);

        D4Attribute::D4AttributeIter vitr =(*i)->value_begin();

        D4Attribute::D4AttributeIter end =(*i)->value_end();

        vector<string> values;

        for(;vitr!=end; vitr++){

            values.push_back((*vitr));

        }

        switch (d4_attr_type) {

        case attr_container_c: {

            // Attr_container

            AttrTable *child_attr_table = new AttrTable();

            child_attr_table->set_name(name);

            // cerr << __func__ << "() - Created child attribute table: " << name << " addr: " << (void *)child_attr_table << endl;

            load_AttrTable(child_attr_table,(*i)->attributes());

            d2_attr_table->append_container(child_attr_table,name);

            break;

        }

        default:{

            // cerr << __func__ << "() - "<< name << " has " << values.size() << " value(s). d2_attr_type_name: " << d2_attr_type_name << endl;

            d2_attr_table->append_attr(name,d2_attr_type_name, &values);

            break;

        }

        }

    }

}

/** @brief copy attributes from DAP4 to DAP2

 *

 * Given a DAP4 AttrTable, copy all of its attributes into a DAP4 D4Attributes

 * object.

 *

 * @param at Read the DAP2 attributes from here.

 */

AttrTable *D4Attributes::get_AttrTable(const string name)

{

    AttrTable *my_pretty_pony = new AttrTable();

    load_AttrTable(my_pretty_pony, this);

    my_pretty_pony->set_name(name);

    return my_pretty_pony;

}

D4Attribute *

D4Attributes::find_depth_first(const string &name, D4AttributesIter i)

{

    if (i == attribute_end())

        return 0;

    else if ((*i)->name() == name)

        return *i;

    else if ((*i)->type() == attr_container_c)

        return find_depth_first(name, (*i)->attributes()->attribute_begin());

    else

        return find_depth_first(name, ++i);

}

D4Attribute *

D4Attributes::find(const string &name)

{

    return find_depth_first(name, attribute_begin());

}

/** Return a pointer to the D4Attribute object that has the given FQN.

 * @note A FQN for an attribute is a series of names separated by dots.

 */

D4Attribute *

D4Attributes::get(const string &fqn)

{

    // name1.name2.name3

    // name1

    // name1.name2

    size_t pos = fqn.find('.');

    string part = fqn.substr(0, pos);

    string rest= "";

    if (pos != string::npos)

        rest = fqn.substr(pos + 1);

    DBG(cerr << "part: '" << part << "'; rest: '" << rest << "'" << endl);

    if (!part.empty()) {

        if (!rest.empty()) {

            D4AttributesIter i = attribute_begin();

            while (i != attribute_end()) {

                if ((*i)->name() == part && (*i)->type() == attr_container_c)

                    return (*i)->attributes()->get(rest);

                ++i;

            }

        }

        else {

            D4AttributesIter i = attribute_begin();

            while (i != attribute_end()) {

                if ((*i)->name() == part)

                    return (*i);

                ++i;

            }

        }

    }

    return 0;

}

void

D4Attribute::print_dap4(XMLWriter &xml) const

{

    if (xmlTextWriterStartElement(xml.get_writer(), (const xmlChar*) "Attribute") < 0)

        throw InternalErr(__FILE__, __LINE__, "Could not write Attribute element");

    if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "name", (const xmlChar*)name().c_str()) < 0)

        throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");

    if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "type", (const xmlChar*) D4AttributeTypeToString(type()).c_str()) < 0)

        throw InternalErr(__FILE__, __LINE__, "Could not write attribute for type");

    switch (type()) {

    case attr_container_c:

        if (!d_attributes)

            throw InternalErr(__FILE__, __LINE__, "Null Attribute container");

        d_attributes->print_dap4(xml);

        break;

    case attr_otherxml_c:

        if (num_values() != 1)

            throw Error("OtherXML attributes cannot be vector-valued.");

        if (xmlTextWriterWriteRaw(xml.get_writer(), (const xmlChar*) value(0).c_str()) < 0)

            throw InternalErr(__FILE__, __LINE__, "Could not write OtherXML value");

        break;

    default: {

        // Assume only valid types make it into instances

        D4AttributeCIter i = d_values.begin();//value_begin();

        while (i != d_values.end()) {

            if (xmlTextWriterStartElement(xml.get_writer(), (const xmlChar*) "Value") < 0)

                throw InternalErr(__FILE__, __LINE__, "Could not write value element");

            if (xmlTextWriterWriteString(xml.get_writer(), (const xmlChar*) (*i++).c_str()) < 0)

                throw InternalErr(__FILE__, __LINE__, "Could not write attribute value");

            if (xmlTextWriterEndElement(xml.get_writer()) < 0)

                throw InternalErr(__FILE__, __LINE__, "Could not end value element");

        }

        break;

    }

    }

    if (xmlTextWriterEndElement(xml.get_writer()) < 0)

        throw InternalErr(__FILE__, __LINE__, "Could not end Attribute element");

}

/** @brief dumps information about this object

 *

 * Displays the pointer value of this instance and then displays information

 * about this base type.

 *

 * @param strm C++ i/o stream to dump the information to

 * @return void

 */

void

D4Attribute::dump(ostream &strm) const

{

    strm << DapIndent::LMarg << "D4Attribute::dump - (" << (void *)this << ")" << endl;

    DapIndent::Indent() ;

    XMLWriter xml;

    print_dap4(xml);

    strm << DapIndent::LMarg << xml.get_doc() << flush;

    DapIndent::UnIndent() ;

}

void

D4Attributes::print_dap4(XMLWriter &xml) const

{

    if (empty())

        return;

    D4AttributesCIter i = d_attrs.begin();

    while (i != d_attrs.end()) {

        (*i++)->print_dap4(xml);

    }

}

/** @brief dumps information about this object

 *

 * Displays the pointer value of this instance and then displays information

 * about this base type.

 *

 * @param strm C++ i/o stream to dump the information to

 * @return void

 */

void

D4Attributes::dump(ostream &strm) const

{

    strm << DapIndent::LMarg << "D4Attributes::dump - (" << (void *)this << ")" << endl;

    DapIndent::Indent() ;

    XMLWriter xml;

    print_dap4(xml);

    strm << DapIndent::LMarg << xml.get_doc() << flush;

    DapIndent::UnIndent() ;

}

} // namespace libdap