// ***************************************************************** -*- C++ -*-

/*

 * Copyright (C) 2004-2018 Exiv2 authors

 * This program is part of the Exiv2 distribution.

 *

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

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

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

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.

 */

/*

  File:      value.cpp

  Author(s): Andreas Huggel (ahu) <ahuggel@gmx.net>

  History:   26-Jan-04, ahu: created

             11-Feb-04, ahu: isolated as a component

             31-Jul-04, brad: added Time, Date and String values

 */

// *****************************************************************************

// included header files

#include "value.hpp"

#include "types.hpp"

#include "enforce.hpp"

#include "error.hpp"

#include "convert.hpp"

#include "unused.h"

// + standard includes

#include <iostream>

#include <iomanip>

#include <sstream>

#include <cassert>

#include <cstring>

#include <ctime>

#include <cstdarg>

#include <cstdio>

#include <cstdlib>

#include <ctype.h>

#if defined(_MSC_VER) && _MSC_VER < 1900

#define snprintf c99_snprintf

#define vsnprintf c99_vsnprintf

__inline int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap)

{

    int count = -1;

    if (size != 0)

        count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);

    if (count == -1)

        count = _vscprintf(format, ap);

    return count;

}

__inline int c99_snprintf(char *outBuf, size_t size, const char *format, ...)

{

    int count;

    va_list ap;

    va_start(ap, format);

    count = c99_vsnprintf(outBuf, size, format, ap);

    va_end(ap);

    return count;

}

#endif

// *****************************************************************************

// class member definitions

namespace Exiv2 {

    Value::Value(TypeId typeId)

        : ok_(true), type_(typeId)

    {

    }

    Value::~Value()

    {

    }

    Value& Value::operator=(const Value& rhs)

    {

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

        type_ = rhs.type_;

        ok_ = rhs.ok_;

        return *this;

    }

    Value::AutoPtr Value::create(TypeId typeId)

    {

        AutoPtr value;

        switch (typeId) {

        case invalidTypeId:

        case signedByte:

        case unsignedByte:

            value = AutoPtr(new DataValue(typeId));

            break;

        case asciiString:

            value = AutoPtr(new AsciiValue);

            break;

        case unsignedShort:

            value = AutoPtr(new ValueType<uint16_t>);

            break;

        case unsignedLong:

        case tiffIfd:

            value = AutoPtr(new ValueType<uint32_t>(typeId));

            break;

        case unsignedRational:

            value = AutoPtr(new ValueType<URational>);

            break;

        case undefined:

            value = AutoPtr(new DataValue);

            break;

        case signedShort:

            value = AutoPtr(new ValueType<int16_t>);

            break;

        case signedLong:

            value = AutoPtr(new ValueType<int32_t>);

            break;

        case signedRational:

            value = AutoPtr(new ValueType<Rational>);

            break;

        case tiffFloat:

            value = AutoPtr(new ValueType<float>);

            break;

        case tiffDouble:

            value = AutoPtr(new ValueType<double>);

            break;

        case string:

            value = AutoPtr(new StringValue);

            break;

        case date:

            value = AutoPtr(new DateValue);

            break;

        case time:

            value = AutoPtr(new TimeValue);

            break;

        case comment:

            value = AutoPtr(new CommentValue);

            break;

        case xmpText:

            value = AutoPtr(new XmpTextValue);

            break;

        case xmpBag:

        case xmpSeq:

        case xmpAlt:

            value = AutoPtr(new XmpArrayValue(typeId));

            break;

        case langAlt:

            value = AutoPtr(new LangAltValue);

            break;

        default:

            value = AutoPtr(new DataValue(typeId));

            break;

        }

        return value;

    } // Value::create

    int Value::setDataArea(const byte* /*buf*/, long /*len*/)

    {

        return -1;

    }

    std::string Value::toString() const

    {

        std::ostringstream os;

        write(os);

        ok_ = !os.fail();

        return os.str();

    }

    std::string Value::toString(long /*n*/) const

    {

        return toString();

    }

    long Value::sizeDataArea() const

    {

        return 0;

    }

    DataBuf Value::dataArea() const

    {

        return DataBuf(0, 0);

    }

    DataValue::DataValue(TypeId typeId) : Value(typeId)

    {

    }

    DataValue::DataValue(const byte* buf,

              long len, ByteOrder byteOrder,TypeId typeId)

        : Value(typeId)

    {

        read(buf, len, byteOrder);

    }

    DataValue::~DataValue()

    {

    }

    long DataValue::count() const

    {

        return size();

    }

    int DataValue::read(const byte* buf, long len, ByteOrder /*byteOrder*/)

    {

        // byteOrder not needed

        value_.assign(buf, buf + len);

        return 0;

    }

    int DataValue::read(const std::string& buf)

    {

        std::istringstream is(buf);

        int tmp;

        ValueType val;

        while (!(is.eof())) {

            is >> tmp;

            if (is.fail()) return 1;

            val.push_back(static_cast<byte>(tmp));

        }

        value_.swap(val);

        return 0;

    }

    long DataValue::copy(byte* buf, ByteOrder /*byteOrder*/) const

    {

        // byteOrder not needed

        return static_cast<long>(

            std::copy(value_.begin(), value_.end(), buf) - buf

            );

    }

    long DataValue::size() const

    {

        return static_cast<long>(value_.size());

    }

    DataValue* DataValue::clone_() const

    {

        return new DataValue(*this);

    }

    std::ostream& DataValue::write(std::ostream& os) const

    {

        std::vector<byte>::size_type end = value_.size();

        for (std::vector<byte>::size_type i = 0; i != end; ++i) {

            os << static_cast<int>(value_[i]);

            if (i < end - 1) os << " ";

        }

        return os;

    }

    std::string DataValue::toString(long n) const

    {

        std::ostringstream os;

        os << static_cast<int>(value_[n]);

        ok_ = !os.fail();

        return os.str();

    }

    long DataValue::toLong(long n) const

    {

        ok_ = true;

        return value_[n];

    }

    float DataValue::toFloat(long n) const

    {

        ok_ = true;

        return value_[n];

    }

    Rational DataValue::toRational(long n) const

    {

        ok_ = true;

        return Rational(value_[n], 1);

    }

    StringValueBase::StringValueBase(TypeId typeId)

        : Value(typeId)

    {

    }

    StringValueBase::StringValueBase(TypeId typeId, const std::string& buf)

        : Value(typeId)

    {

        read(buf);

    }

    StringValueBase::StringValueBase(const StringValueBase& rhs)

        : Value(rhs), value_(rhs.value_)

    {

    }

    StringValueBase::~StringValueBase()

    {

    }

    StringValueBase& StringValueBase::operator=(const StringValueBase& rhs)

    {

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

        Value::operator=(rhs);

        value_ = rhs.value_;

        return *this;

    }

    int StringValueBase::read(const std::string& buf)

    {

        value_ = buf;

        return 0;

    }

    int StringValueBase::read(const byte* buf, long len, ByteOrder /*byteOrder*/)

    {

        // byteOrder not needed

        if (buf) value_ = std::string(reinterpret_cast<const char*>(buf), len);

        return 0;

    }

    long StringValueBase::copy(byte* buf, ByteOrder /*byteOrder*/) const

    {

        if (value_.size() == 0) return 0;

        // byteOrder not needed

        assert(buf != 0);

        return static_cast<long>(

            value_.copy(reinterpret_cast<char*>(buf), value_.size())

            );

    }

    long StringValueBase::count() const

    {

        return size();

    }

    long StringValueBase::size() const

    {

        return static_cast<long>(value_.size());

    }

    std::ostream& StringValueBase::write(std::ostream& os) const

    {

        return os << value_;

    }

    long StringValueBase::toLong(long n) const

    {

        ok_ = true;

        return value_[n];

    }

    float StringValueBase::toFloat(long n) const

    {

        ok_ = true;

        return value_[n];

    }

    Rational StringValueBase::toRational(long n) const

    {

        ok_ = true;

        return Rational(value_[n], 1);

    }

    StringValue::StringValue()

        : StringValueBase(string)

    {

    }

    StringValue::StringValue(const std::string& buf)

        : StringValueBase(string, buf)

    {

    }

    StringValue::~StringValue()

    {

    }

    StringValue* StringValue::clone_() const

    {

        return new StringValue(*this);

    }

    AsciiValue::AsciiValue()

        : StringValueBase(asciiString)

    {

    }

    AsciiValue::AsciiValue(const std::string& buf)

        : StringValueBase(asciiString, buf)

    {

    }

    AsciiValue::~AsciiValue()

    {

    }

    int AsciiValue::read(const std::string& buf)

    {

        value_ = buf;

        if (value_.size() > 0 && value_[value_.size()-1] != '\0') value_ += '\0';

        return 0;

    }

    AsciiValue* AsciiValue::clone_() const

    {

        return new AsciiValue(*this);

    }

    std::ostream& AsciiValue::write(std::ostream& os) const

    {

        // Write only up to the first '\0' (if any)

        std::string::size_type pos = value_.find_first_of('\0');

        if (pos == std::string::npos) pos = value_.size();

        return os << value_.substr(0, pos);

    }

    CommentValue::CharsetTable::CharsetTable(CharsetId charsetId,

                                             const char* name,

                                             const char* code)

        : charsetId_(charsetId), name_(name), code_(code)

    {

    }

    //! Lookup list of supported IFD type information

    const CommentValue::CharsetTable CommentValue::CharsetInfo::charsetTable_[] = {

        CharsetTable(ascii,            "Ascii",            "ASCII\0\0\0"),

        CharsetTable(jis,              "Jis",              "JIS\0\0\0\0\0"),

        CharsetTable(unicode,          "Unicode",          "UNICODE\0"),

        CharsetTable(undefined,        "Undefined",        "\0\0\0\0\0\0\0\0"),

        CharsetTable(invalidCharsetId, "InvalidCharsetId", "\0\0\0\0\0\0\0\0"),

        CharsetTable(lastCharsetId,    "InvalidCharsetId", "\0\0\0\0\0\0\0\0")

    };

    const char* CommentValue::CharsetInfo::name(CharsetId charsetId)

    {

        return charsetTable_[ charsetId < lastCharsetId ? charsetId : undefined ].name_;

    }

    const char* CommentValue::CharsetInfo::code(CharsetId charsetId)

    {

        return charsetTable_[ charsetId < lastCharsetId ? charsetId : undefined ].code_;

    }

    CommentValue::CharsetId CommentValue::CharsetInfo::charsetIdByName(

        const std::string& name)

    {

        int i = 0;

        for (;    charsetTable_[i].charsetId_ != lastCharsetId

               && charsetTable_[i].name_ != name; ++i) {}

        return charsetTable_[i].charsetId_ == lastCharsetId ?

               invalidCharsetId : charsetTable_[i].charsetId_;

    }

    CommentValue::CharsetId CommentValue::CharsetInfo::charsetIdByCode(

        const std::string& code)

    {

        int i = 0;

        for (;    charsetTable_[i].charsetId_ != lastCharsetId

               && std::string(charsetTable_[i].code_, 8) != code; ++i) {}

        return charsetTable_[i].charsetId_ == lastCharsetId ?

               invalidCharsetId : charsetTable_[i].charsetId_;

    }

    CommentValue::CommentValue()

        : StringValueBase(Exiv2::undefined), byteOrder_(littleEndian)

    {

    }

    CommentValue::CommentValue(const std::string& comment)

        : StringValueBase(Exiv2::undefined), byteOrder_(littleEndian)

    {

        read(comment);

    }

    CommentValue::~CommentValue()

    {

    }

    int CommentValue::read(const std::string& comment)

    {

        std::string c = comment;

        CharsetId charsetId = undefined;

        if (comment.length() > 8 && comment.substr(0, 8) == "charset=") {

            std::string::size_type pos = comment.find_first_of(' ');

            std::string name = comment.substr(8, pos-8);

            // Strip quotes (so you can also specify the charset without quotes)

            if (name[0] == '"') name = name.substr(1);

            if (name[name.length()-1] == '"') name = name.substr(0, name.length()-1);

            charsetId = CharsetInfo::charsetIdByName(name);

            if (charsetId == invalidCharsetId) {

#ifndef SUPPRESS_WARNINGS

                EXV_WARNING << Error(kerInvalidCharset, name) << "\n";

#endif

                return 1;

            }

            c.clear();

            if (pos != std::string::npos) c = comment.substr(pos+1);

        }

        if (charsetId == unicode) {

            const char* to = byteOrder_ == littleEndian ? "UCS-2LE" : "UCS-2BE";

            convertStringCharset(c, "UTF-8", to);

        }

        const std::string code(CharsetInfo::code(charsetId), 8);

        return StringValueBase::read(code + c);

    }

    int CommentValue::read(const byte* buf, long len, ByteOrder byteOrder)

    {

        byteOrder_ = byteOrder;

        return StringValueBase::read(buf, len, byteOrder);

    }

    long CommentValue::copy(byte* buf, ByteOrder byteOrder) const

    {

        std::string c = value_;

        if (charsetId() == unicode) {

            c = value_.substr(8);

            const size_t sz = c.size();

            UNUSED(sz);

            if (byteOrder_ == littleEndian && byteOrder == bigEndian) {

                convertStringCharset(c, "UCS-2LE", "UCS-2BE");

                assert(c.size() == sz);

            }

            else if (byteOrder_ == bigEndian && byteOrder == littleEndian) {

                convertStringCharset(c, "UCS-2BE", "UCS-2LE");

                assert(c.size() == sz);

            }

            c = value_.substr(0, 8) + c;

        }

        if (c.size() == 0)

            return 0;

        assert(buf != 0);

        return static_cast<long>(c.copy(reinterpret_cast<char*>(buf), c.size()));

    }

    std::ostream& CommentValue::write(std::ostream& os) const

    {

        CharsetId csId = charsetId();

        if (csId != undefined) {

            os << "charset=\"" << CharsetInfo::name(csId) << "\" ";

        }

        return os << comment();

    }

    std::string CommentValue::comment(const char* encoding) const

    {

        std::string c;

        if (value_.length() < 8) {

            return c;

        }

        c = value_.substr(8);

        if (charsetId() == unicode) {

            const char* from = encoding == 0 || *encoding == '\0' ? detectCharset(c) : encoding;

            convertStringCharset(c, from, "UTF-8");

        }

        return c;

    }

    CommentValue::CharsetId CommentValue::charsetId() const

    {

        CharsetId charsetId = undefined;

        if (value_.length() >= 8) {

            const std::string code = value_.substr(0, 8);

            charsetId = CharsetInfo::charsetIdByCode(code);

        }

        return charsetId;

    }

    const char* CommentValue::detectCharset(std::string& c) const

    {

        // Interpret a BOM if there is one

        if (0 == strncmp(c.data(), "\xef\xbb\xbf", 3)) {

            c = c.substr(3);

            return "UTF-8";

        }

        if (0 == strncmp(c.data(), "\xff\xfe", 2)) {

            c = c.substr(2);

            return "UCS-2LE";

        }

        if (0 == strncmp(c.data(), "\xfe\xff", 2)) {

            c = c.substr(2);

            return "UCS-2BE";

        }

        // Todo: Add logic to guess if the comment is encoded in UTF-8

        return byteOrder_ == littleEndian ? "UCS-2LE" : "UCS-2BE";

    }

    CommentValue* CommentValue::clone_() const

    {

        return new CommentValue(*this);

    }

    XmpValue::XmpValue(TypeId typeId)

        : Value(typeId),

          xmpArrayType_(xaNone),

          xmpStruct_(xsNone)

    {

    }

    XmpValue& XmpValue::operator=(const XmpValue& rhs)

    {

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

        xmpArrayType_ = rhs.xmpArrayType_;

        xmpStruct_ = rhs.xmpStruct_;

        return *this;

    }

    void XmpValue::setXmpArrayType(XmpArrayType xmpArrayType)

    {

        xmpArrayType_ = xmpArrayType;

    }

    void XmpValue::setXmpStruct(XmpStruct xmpStruct)

    {

        xmpStruct_ = xmpStruct;

    }

    XmpValue::XmpArrayType XmpValue::xmpArrayType() const

    {

        return xmpArrayType_;

    }

    XmpValue::XmpArrayType XmpValue::xmpArrayType(TypeId typeId)

    {

        XmpArrayType xa = xaNone;

        switch (typeId) {

        case xmpAlt: xa = xaAlt; break;

        case xmpBag: xa = xaBag; break;

        case xmpSeq: xa = xaSeq; break;

        default: break;

        }

        return xa;

    }

    XmpValue::XmpStruct XmpValue::xmpStruct() const

    {

        return xmpStruct_;

    }

    long XmpValue::copy(byte* buf,

                        ByteOrder /*byteOrder*/) const

    {

        std::ostringstream os;

        write(os);

        std::string s = os.str();

        if (s.size() > 0) std::memcpy(buf, &s[0], s.size());

        return static_cast<long>(s.size());

    }

    int XmpValue::read(const byte* buf,

                       long len,

                       ByteOrder /*byteOrder*/)

    {

        std::string s(reinterpret_cast<const char*>(buf), len);

        return read(s);

    }

    long XmpValue::size() const

    {

        std::ostringstream os;

        write(os);

        return static_cast<long>(os.str().size());

    }

    XmpTextValue::XmpTextValue()

        : XmpValue(xmpText)

    {

    }

    XmpTextValue::XmpTextValue(const std::string& buf)

        : XmpValue(xmpText)

    {

        read(buf);

    }

    int XmpTextValue::read(const std::string& buf)

    {

        // support a type=Alt,Bag,Seq,Struct indicator

        std::string b = buf;

        std::string type;

        if (buf.length() > 5 && buf.substr(0, 5) == "type=") {

            std::string::size_type pos = buf.find_first_of(' ');

            type = buf.substr(5, pos-5);

            // Strip quotes (so you can also specify the type without quotes)

            if (type[0] == '"') type = type.substr(1);

            if (type[type.length()-1] == '"') type = type.substr(0, type.length()-1);

            b.clear();

            if (pos != std::string::npos) b = buf.substr(pos+1);

        }

        if (!type.empty()) {

            if (type == "Alt") {

                setXmpArrayType(XmpValue::xaAlt);

            }

            else if (type == "Bag") {

                setXmpArrayType(XmpValue::xaBag);

            }

            else if (type == "Seq") {

                setXmpArrayType(XmpValue::xaSeq);

            }

            else if (type == "Struct") {

                setXmpStruct();

            }

            else {

                throw Error(kerInvalidXmpText, type);

            }

        }

        value_ = b;

        return 0;

    }

    XmpTextValue::AutoPtr XmpTextValue::clone() const

    {

        return AutoPtr(clone_());

    }

    long XmpTextValue::size() const

    {

        return static_cast<long>(value_.size());

    }

    long XmpTextValue::count() const

    {

        return size();

    }

    std::ostream& XmpTextValue::write(std::ostream& os) const

    {

        bool del = false;

        if (xmpArrayType() != XmpValue::xaNone) {

            switch (xmpArrayType()) {

            case XmpValue::xaAlt: os << "type=\"Alt\""; break;

            case XmpValue::xaBag: os << "type=\"Bag\""; break;

            case XmpValue::xaSeq: os << "type=\"Seq\""; break;

            case XmpValue::xaNone: break; // just to suppress the warning

            }

            del = true;

        }

        else if (xmpStruct() != XmpValue::xsNone) {

            switch (xmpStruct()) {

            case XmpValue::xsStruct: os << "type=\"Struct\""; break;

            case XmpValue::xsNone: break; // just to suppress the warning

            }

            del = true;

        }

        if (del && !value_.empty()) os << " ";

        return os << value_;

    }

    long XmpTextValue::toLong(long /*n*/) const

    {

        return parseLong(value_, ok_);

    }

    float XmpTextValue::toFloat(long /*n*/) const

    {

        return parseFloat(value_, ok_);

    }

    Rational XmpTextValue::toRational(long /*n*/) const

    {

        return parseRational(value_, ok_);

    }

    XmpTextValue* XmpTextValue::clone_() const

    {

        return new XmpTextValue(*this);

    }

    XmpArrayValue::XmpArrayValue(TypeId typeId)

        : XmpValue(typeId)

    {

        setXmpArrayType(xmpArrayType(typeId));

    }

    int XmpArrayValue::read(const std::string& buf)

    {

        if (!buf.empty()) value_.push_back(buf);

        return 0;

    }

    XmpArrayValue::AutoPtr XmpArrayValue::clone() const

    {

        return AutoPtr(clone_());

    }

    long XmpArrayValue::count() const

    {

        return static_cast<long>(value_.size());

    }

    std::ostream& XmpArrayValue::write(std::ostream& os) const

    {

        for (std::vector<std::string>::const_iterator i = value_.begin();

             i != value_.end(); ++i) {

            if (i != value_.begin()) os << ", ";

            os << *i;

        }

        return os;

    }

    std::string XmpArrayValue::toString(long n) const

    {

        ok_ = true;

        return value_[n];

    }

    long XmpArrayValue::toLong(long n) const

    {

        return parseLong(value_[n], ok_);

    }

    float XmpArrayValue::toFloat(long n) const

    {

        return parseFloat(value_[n], ok_);

    }

    Rational XmpArrayValue::toRational(long n) const

    {

        return parseRational(value_[n], ok_);

    }

    XmpArrayValue* XmpArrayValue::clone_() const

    {

        return new XmpArrayValue(*this);

    }

    LangAltValue::LangAltValue()

        : XmpValue(langAlt)

    {

    }

    LangAltValue::LangAltValue(const std::string& buf)

        : XmpValue(langAlt)

    {

        read(buf);

    }

    int LangAltValue::read(const std::string& buf)

    {

        std::string b = buf;

        std::string lang = "x-default";

        if (buf.length() > 5 && buf.substr(0, 5) == "lang=") {

            std::string::size_type pos = buf.find_first_of(' ');

            lang = buf.substr(5, pos-5);

            // Strip quotes (so you can also specify the language without quotes)

            if (lang[0] == '"') lang = lang.substr(1);

            if (lang[lang.length()-1] == '"') lang = lang.substr(0, lang.length()-1);

            b.clear();

            if (pos != std::string::npos) b = buf.substr(pos+1);

        }

        value_[lang] = b;

        return 0;

    }

    LangAltValue::AutoPtr LangAltValue::clone() const

    {

        return AutoPtr(clone_());

    }

    long LangAltValue::count() const

    {

        return static_cast<long>(value_.size());

    }

    static const std::string x_default = "x-default";