// -*- 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

//

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

#include "config.h"

#include "D4Group.h"

#include "D4EnumDefs.h"

#include <sstream>

#include "dods-limits.h"

#include "util.h"

namespace libdap {

/** Test if a particular value is legal for a given type. In a D4EnumDef,

 * all values are actually stored in a long long, but the different

 * enumerations can specify different types like Byte, Int32, ..., and this

 * method is used to test that the values match those types.

 */

bool

D4EnumDef::is_valid_enum_value(long long value)

{

    switch (type()) {

        case dods_int8_c:

            return (value >= DODS_SCHAR_MIN && value <= DODS_SCHAR_MAX);

        case dods_byte_c:

        case dods_uint8_c:

            return (value >= 0 && static_cast<unsigned long long>(value) <= DODS_UCHAR_MAX);

        case dods_int16_c:

            return (value >= DODS_SHRT_MIN && value <= DODS_SHRT_MAX);

        case dods_uint16_c:

            return (value >= 0 && static_cast<unsigned long long>(value) <= DODS_USHRT_MAX);

        case dods_int32_c:

            return (value >= DODS_INT_MIN && value <= DODS_INT_MAX);

        case dods_uint32_c:

            return (value >= 0 && static_cast<unsigned long long>(value) <= DODS_UINT_MAX);

        case dods_int64_c:

            return true; // This is always true: (value >= DODS_LLONG_MIN && value <= DODS_LLONG_MAX);

        case dods_uint64_c:

            return (value >= 0 /*Always true: && static_cast<unsigned long long>(value) <= DODS_ULLONG_MAX*/);

        default:

            return false;

    }

}

// Note that in order for this to work the second argument must not be a reference.

// jhrg 8/20/13

static bool

enum_def_name_eq(D4EnumDef *d, const string name)

{

    return d->name() == name;

}

D4EnumDef *

D4EnumDefs::find_enum_def(const string &name)

{

    D4EnumDefIter d = find_if(d_enums.begin(), d_enums.end(), bind2nd(ptr_fun(enum_def_name_eq), name));

    return (d != d_enums.end()) ? *d: 0;

}

void D4EnumDef::print_value(XMLWriter &xml, const D4EnumDef::tuple &tuple) const

{

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

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

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

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

    ostringstream oss;

    oss << tuple.value;

    if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "value", (const xmlChar*)oss.str().c_str()) < 0)

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

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

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

}

void D4EnumDef::print_dap4(XMLWriter &xml) const

{

    vector<D4EnumDef::tuple>::const_iterator i = d_tuples.begin();

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

        print_value(xml, *i++);

    }

}

void D4EnumDefs::m_print_enum(XMLWriter &xml, D4EnumDef *e) const

{

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

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

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

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

    if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "basetype", (const xmlChar*)D4type_name(e->type()).c_str()) < 0)

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

    // print each of e.values

    e->print_dap4(xml);

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

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

}

void D4EnumDefs::print_dap4(XMLWriter &xml, bool constrained) const

{

    D4EnumDefCIter i = d_enums.begin();

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

        if (!constrained || parent()->find_first_var_that_uses_enumeration(*i))

            m_print_enum(xml, *i);

        ++i;

    }

}

} /* namespace libdap */