// ***************************************************************** -*- 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:      iptc.cpp

  Author(s): Brad Schick (brad) <brad@robotbattle.com>

  History:   31-July-04, brad: created

 */

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

// included header files

#include "iptc.hpp"

#include "types.hpp"

#include "error.hpp"

#include "value.hpp"

#include "datasets.hpp"

#include "jpgimage.hpp"

#include "image_int.hpp"

// + standard includes

#include <iostream>

#include <algorithm>

#include <iterator>

#include <fstream>      // write the temporary file

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

namespace {

    /*!

      @brief Read a single dataset payload and create a new metadata entry.

      @param iptcData IPTC metadata container to add the dataset to

      @param dataSet  DataSet number

      @param record   Record Id

      @param data     Pointer to the first byte of dataset payload

      @param sizeData Length in bytes of dataset payload

      @return 0 if successful.

     */

    int readData(

              Exiv2::IptcData& iptcData,

              uint16_t         dataSet,

              uint16_t         record,

        const Exiv2::byte*     data,

              uint32_t         sizeData

    );

    //! Unary predicate that matches an Iptcdatum with given record and dataset

    class FindIptcdatum {

    public:

        //! Constructor, initializes the object with the record and dataset id

        FindIptcdatum(uint16_t dataset, uint16_t record)

            : dataset_(dataset), record_(record) {}

        /*!

          @brief Returns true if the record and dataset id of the argument

                Iptcdatum is equal to that of the object.

        */

        bool operator()(const Exiv2::Iptcdatum& iptcdatum) const

        {

            return dataset_ == iptcdatum.tag() && record_ == iptcdatum.record();

        }

    private:

        // DATA

        uint16_t dataset_;

        uint16_t record_;

    }; // class FindIptcdatum

}

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

// class member definitions

namespace Exiv2 {

    Iptcdatum::Iptcdatum(const IptcKey& key,

                         const Value* pValue)

        : key_(key.clone())

    {

        if (pValue) value_ = pValue->clone();

    }

    Iptcdatum::Iptcdatum(const Iptcdatum& rhs)

        : Metadatum(rhs)

    {

        if (rhs.key_.get() != 0) key_ = rhs.key_->clone(); // deep copy

        if (rhs.value_.get() != 0) value_ = rhs.value_->clone(); // deep copy

    }

    Iptcdatum::~Iptcdatum()

    {

    }

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

    {

        return value_.get() == 0 ? 0 : value_->copy(buf, byteOrder);

    }

    std::ostream& Iptcdatum::write(std::ostream& os, const ExifData*) const

    {

        return os << value();

    }

    std::string Iptcdatum::key() const

    {

        return key_.get() == 0 ? "" : key_->key();

    }

    std::string Iptcdatum::recordName() const

    {

        return key_.get() == 0 ? "" : key_->recordName();

    }

    uint16_t Iptcdatum::record() const

    {

        return key_.get() == 0 ? 0 : key_->record();

    }

    const char* Iptcdatum::familyName() const

    {

        return key_.get() == 0 ? "" : key_->familyName();

    }

    std::string Iptcdatum::groupName() const

    {

        return key_.get() == 0 ? "" : key_->groupName();

    }

    std::string Iptcdatum::tagName() const

    {

        return key_.get() == 0 ? "" : key_->tagName();

    }

    std::string Iptcdatum::tagLabel() const

    {

        return key_.get() == 0 ? "" : key_->tagLabel();

    }

    uint16_t Iptcdatum::tag() const

    {

        return key_.get() == 0 ? 0 : key_->tag();

    }

    TypeId Iptcdatum::typeId() const

    {

        return value_.get() == 0 ? invalidTypeId : value_->typeId();

    }

    const char* Iptcdatum::typeName() const

    {

        return TypeInfo::typeName(typeId());

    }

    long Iptcdatum::typeSize() const

    {

        return TypeInfo::typeSize(typeId());

    }

    long Iptcdatum::count() const

    {

        return value_.get() == 0 ? 0 : value_->count();

    }

    long Iptcdatum::size() const

    {

        return value_.get() == 0 ? 0 : value_->size();

    }

    std::string Iptcdatum::toString() const

    {

        return value_.get() == 0 ? "" : value_->toString();

    }

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

    {

        return value_.get() == 0 ? "" : value_->toString(n);

    }

    long Iptcdatum::toLong(long n) const

    {

        return value_.get() == 0 ? -1 : value_->toLong(n);

    }

    float Iptcdatum::toFloat(long n) const

    {

        return value_.get() == 0 ? -1 : value_->toFloat(n);

    }

    Rational Iptcdatum::toRational(long n) const

    {

        return value_.get() == 0 ? Rational(-1, 1) : value_->toRational(n);

    }

    Value::AutoPtr Iptcdatum::getValue() const

    {

        return value_.get() == 0 ? Value::AutoPtr(0) : value_->clone();

    }

    const Value& Iptcdatum::value() const

    {

        if (value_.get() == 0) throw Error(kerValueNotSet);

        return *value_;

    }

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

    {

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

        Metadatum::operator=(rhs);

        key_.reset();

        if (rhs.key_.get() != 0) key_ = rhs.key_->clone(); // deep copy

        value_.reset();

        if (rhs.value_.get() != 0) value_ = rhs.value_->clone(); // deep copy

        return *this;

    } // Iptcdatum::operator=

    Iptcdatum& Iptcdatum::operator=(const uint16_t& value)

    {

        UShortValue::AutoPtr v(new UShortValue);

        v->value_.push_back(value);

        value_ = v;

        return *this;

    }

    Iptcdatum& Iptcdatum::operator=(const std::string& value)

    {

        setValue(value);

        return *this;

    }

    Iptcdatum& Iptcdatum::operator=(const Value& value)

    {

        setValue(&value);

        return *this;

    }

    void Iptcdatum::setValue(const Value* pValue)

    {

        value_.reset();

        if (pValue) value_ = pValue->clone();

    }

    int Iptcdatum::setValue(const std::string& value)

    {

        if (value_.get() == 0) {

            TypeId type = IptcDataSets::dataSetType(tag(), record());

            value_ = Value::create(type);

        }

        return value_->read(value);

    }

    Iptcdatum& IptcData::operator[](const std::string& key)

    {

        IptcKey iptcKey(key);

        iterator pos = findKey(iptcKey);

        if (pos == end()) {

            add(Iptcdatum(iptcKey));

            pos = findKey(iptcKey);

        }

        return *pos;

    }

    long IptcData::size() const

    {

        long newSize = 0;

        const_iterator iter = iptcMetadata_.begin();

        const_iterator end = iptcMetadata_.end();

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

            // marker, record Id, dataset num, first 2 bytes of size

            newSize += 5;

            long dataSize = iter->size();

            newSize += dataSize;

            if (dataSize > 32767) {

                // extended dataset (we always use 4 bytes)

                newSize += 4;

            }

        }

        return newSize;

    } // IptcData::size

    int IptcData::add(const IptcKey& key, Value* value)

    {

        return add(Iptcdatum(key, value));

    }

    int IptcData::add(const Iptcdatum& iptcDatum)

    {

        if (!IptcDataSets::dataSetRepeatable(

               iptcDatum.tag(), iptcDatum.record()) &&

               findId(iptcDatum.tag(), iptcDatum.record()) != end()) {

             return 6;

        }

        // allow duplicates

        iptcMetadata_.push_back(iptcDatum);

        return 0;

    }

    IptcData::const_iterator IptcData::findKey(const IptcKey& key) const

    {

        return std::find_if(iptcMetadata_.begin(), iptcMetadata_.end(),

                            FindIptcdatum(key.tag(), key.record()));

    }

    IptcData::iterator IptcData::findKey(const IptcKey& key)

    {

        return std::find_if(iptcMetadata_.begin(), iptcMetadata_.end(),

                            FindIptcdatum(key.tag(), key.record()));

    }

    IptcData::const_iterator IptcData::findId(uint16_t dataset, uint16_t record) const

    {

        return std::find_if(iptcMetadata_.begin(), iptcMetadata_.end(),

                            FindIptcdatum(dataset, record));

    }

    IptcData::iterator IptcData::findId(uint16_t dataset, uint16_t record)

    {

        return std::find_if(iptcMetadata_.begin(), iptcMetadata_.end(),

                            FindIptcdatum(dataset, record));

    }

    void IptcData::sortByKey()

    {

        std::sort(iptcMetadata_.begin(), iptcMetadata_.end(), cmpMetadataByKey);

    }

    void IptcData::sortByTag()

    {

        std::sort(iptcMetadata_.begin(), iptcMetadata_.end(), cmpMetadataByTag);

    }

    IptcData::iterator IptcData::erase(IptcData::iterator pos)

    {

        return iptcMetadata_.erase(pos);

    }

    void IptcData::printStructure(std::ostream& out, const Slice<byte*>& bytes, uint32_t depth)

    {

        uint32_t i = 0;

        while (i < bytes.size() - 3 && bytes.at(i) != 0x1c)

            i++;

        depth++;

        out << Internal::indent(depth) << "Record | DataSet | Name                     | Length | Data" << std::endl;

        while (i < bytes.size() - 3) {

            if (bytes.at(i) != 0x1c) {

                break;

            }

            char buff[100];

            uint16_t record = bytes.at(i + 1);

            uint16_t dataset = bytes.at(i + 2);

            uint16_t len = getUShort(bytes.subSlice(i + 3, bytes.size()), bigEndian);

            sprintf(buff, "  %6d | %7d | %-24s | %6d | ", record, dataset,

                    Exiv2::IptcDataSets::dataSetName(dataset, record).c_str(), len);

            out << buff << Internal::binaryToString(makeSlice(bytes, i + 5, i + 5 + (len > 40 ? 40 : len)))

                << (len > 40 ? "..." : "")

                << std::endl;

            i += 5 + len;

        }

        depth--;

    }

    const char *IptcData::detectCharset() const

    {

        const_iterator pos = findKey(IptcKey("Iptc.Envelope.CharacterSet"));

        if (pos != end()) {

            const std::string value = pos->toString();

            if (pos->value().ok()) {

                if (value == "\033%G") return "UTF-8";

                // other values are probably not practically relevant

            }

        }

        bool ascii = true;

        bool utf8 = true;

        for (pos = begin(); pos != end(); ++pos) {

            std::string value = pos->toString();

            if (pos->value().ok()) {

                int seqCount = 0;

                std::string::iterator i;

                for (i = value.begin(); i != value.end(); ++i) {

                    char c = *i;

                    if (seqCount) {

                        if ((c & 0xc0) != 0x80) {

                            utf8 = false;

                            break;

                        }

                        --seqCount;

                    }

                    else {

                        if (c & 0x80) ascii = false;

                        else continue; // ascii character

                        if      ((c & 0xe0) == 0xc0) seqCount = 1;

                        else if ((c & 0xf0) == 0xe0) seqCount = 2;

                        else if ((c & 0xf8) == 0xf0) seqCount = 3;

                        else if ((c & 0xfc) == 0xf8) seqCount = 4;

                        else if ((c & 0xfe) == 0xfc) seqCount = 5;

                        else {

                            utf8 = false;

                            break;

                        }

                    }

                }

                if (seqCount) utf8 = false; // unterminated seq

                if (!utf8) break;

            }

        }

        if (ascii) return "ASCII";

        if (utf8) return "UTF-8";

        return NULL;

    }

    const byte IptcParser::marker_ = 0x1C;          // Dataset marker

    int IptcParser::decode(

              IptcData& iptcData,

        const byte*     pData,

              uint32_t  size

    )

    {

#ifdef EXIV2_DEBUG_MESSAGES

        std::cerr << "IptcParser::decode, size = " << size << "\n";

#endif

        const byte* pRead = pData;

        const byte* const pEnd = pData + size;

        iptcData.clear();

        uint16_t record = 0;

        uint16_t dataSet = 0;

        uint32_t sizeData = 0;

        byte extTest = 0;

        while (6 <= static_cast<size_t>(pEnd - pRead)) {

            // First byte should be a marker. If it isn't, scan forward and skip

            // the chunk bytes present in some images. This deviates from the

            // standard, which advises to treat such cases as errors.

            if (*pRead++ != marker_) continue;

            record = *pRead++;

            dataSet = *pRead++;

            extTest = *pRead;

            if (extTest & 0x80) {

                // extended dataset

                uint16_t sizeOfSize = (getUShort(pRead, bigEndian) & 0x7FFF);

                if (sizeOfSize > 4) return 5;

                pRead += 2;

                if (sizeOfSize > static_cast<size_t>(pEnd - pRead)) return 6;

                sizeData = 0;

                for (; sizeOfSize > 0; --sizeOfSize) {

                    sizeData |= *pRead++ << (8 *(sizeOfSize-1));

                }

            }

            else {

                // standard dataset

                sizeData = getUShort(pRead, bigEndian);

                pRead += 2;

            }

            if (sizeData <= static_cast<size_t>(pEnd - pRead)) {

                int rc = 0;

                if ((rc = readData(iptcData, dataSet, record, pRead, sizeData)) != 0) {

#ifndef SUPPRESS_WARNINGS

                    EXV_WARNING << "Failed to read IPTC dataset "

                                << IptcKey(dataSet, record)

                                << " (rc = " << rc << "); skipped.\n";

#endif

                }

            }

#ifndef SUPPRESS_WARNINGS

            else {

                EXV_WARNING << "IPTC dataset " << IptcKey(dataSet, record)

                            << " has invalid size " << sizeData << "; skipped.\n";

                return 7;

            }

#endif

            pRead += sizeData;

        }

        return 0;

    } // IptcParser::decode

    /*!

      @brief Compare two iptc items by record. Return true if the record of

             lhs is less than that of rhs.

      This is a helper function for IptcParser::encode().

     */

    bool cmpIptcdataByRecord(const Iptcdatum& lhs, const Iptcdatum& rhs)

    {

        return lhs.record() < rhs.record();

    }

    DataBuf IptcParser::encode(const IptcData& iptcData)

    {

        DataBuf buf(iptcData.size());

        byte *pWrite = buf.pData_;

        // Copy the iptc data sets and sort them by record but preserve the order of datasets

        IptcMetadata sortedIptcData;

        std::copy(iptcData.begin(), iptcData.end(), std::back_inserter(sortedIptcData));

        std::stable_sort(sortedIptcData.begin(), sortedIptcData.end(), cmpIptcdataByRecord);

        IptcData::const_iterator iter = sortedIptcData.begin();

        IptcData::const_iterator end = sortedIptcData.end();

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

            // marker, record Id, dataset num

            *pWrite++ = marker_;

            *pWrite++ = static_cast<byte>(iter->record());

            *pWrite++ = static_cast<byte>(iter->tag());

            // extended or standard dataset?

            long dataSize = iter->size();

            if (dataSize > 32767) {

                // always use 4 bytes for extended length

                uint16_t sizeOfSize = 4 | 0x8000;

                us2Data(pWrite, sizeOfSize, bigEndian);

                pWrite += 2;

                ul2Data(pWrite, dataSize, bigEndian);

                pWrite += 4;

            }

            else {

                us2Data(pWrite, static_cast<uint16_t>(dataSize), bigEndian);

                pWrite += 2;

            }

            pWrite += iter->value().copy(pWrite, bigEndian);

        }

        return buf;

    } // IptcParser::encode

}                                       // namespace Exiv2

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

// local definitions

namespace {

    int readData(

              Exiv2::IptcData& iptcData,

              uint16_t         dataSet,

              uint16_t         record,

        const Exiv2::byte*     data,

              uint32_t         sizeData

    )

    {

        Exiv2::Value::AutoPtr value;

        Exiv2::TypeId type = Exiv2::IptcDataSets::dataSetType(dataSet, record);

        value = Exiv2::Value::create(type);

        int rc = value->read(data, sizeData, Exiv2::bigEndian);

        if (0 == rc) {

            Exiv2::IptcKey key(dataSet, record);

            iptcData.add(key, value.get());

        }

        else if (1 == rc) {

            // If the first attempt failed, try with a string value

            value = Exiv2::Value::create(Exiv2::string);

            rc = value->read(data, sizeData, Exiv2::bigEndian);

            if (0 == rc) {

                Exiv2::IptcKey key(dataSet, record);

                iptcData.add(key, value.get());

            }

        }

        return rc;

    }

}