#ifndef TAG_PARSER_MP4TAGATOM_H
#define TAG_PARSER_MP4TAGATOM_H

#include "../generictagfield.h"

#include <c++utilities/conversion/stringconversion.h>
#include <c++utilities/io/binarywriter.h>

#include <cstdint>
#include <sstream>
#include <vector>

namespace TagParser {

/*!
 * \brief Encapsulates the most common data type IDs of MP4 tag fields.
 */
namespace RawDataType {
enum KnownValue : std::uint32_t {
    Reserved = 0, /**< reserved for use where no type needs to be indicated */
    Utf8 = 1, /**< without any count or NULL terminator */
    Utf16 = 2, /**< also known as UTF-16BE */
    Sjis = 3, /**< S/JIS: deprecated unless it is needed for special Japanese characters */
    Utf8Sort = 4, /**< variant storage of a string for sorting only */
    Utf16Sort = 5, /**< variant storage of a string for sorting only */
    Html = 6, /**< the HTML file header specifies which HTML version */
    Xml = 7, /**< the XML header must identify the DTD or schemas */
    Uuid = 8, /**< also known as GUID; stored as 16 bytes in binary (valid as an ID) */
    Isrc = 9, /**< stored as UTF-8 text (valid as an ID) */
    Mi3p = 10, /**< stored as UTF-8 text (valid as an ID) */
    Gif = 12, /**< (deprecated) a GIF image */
    Jpeg = 13, /**< in a JFIF wrapper */
    Png = 14, /**< in a PNG wrapper */
    Url = 15, /**< absolute, in UTF-8 characters */
    Duration = 16, /**< in milliseconds, 32-bit integer */
    DateTime = 17, /**< in UTC, counting seconds since midnight, January 1, 1904; 32 or 64-bits */
    Genred = 18, /**< a list of enumerated values */
    BeSignedInt = 21, /**< the size of the integer is derived from the container size (max 4 byte assumed) */
    BeUnsignedInt = 22, /**< the size of the integer is derived from the container size (max 4 byte assumed) */
    BeFloat32 = 23, /**< IEEE754 */
    BeFloat64 = 24, /**< IEEE754 */
    Upc = 25, /**< Universal Product Code, in text UTF-8 format (valid as an ID) */
    Bmp = 27, /**< windows bitmap format graphics */
    QuickTimeMetadataAtom = 28, /**< a block of data having the structure of the Metadata atom defined in this specification */
    Undefined = 255 /**< a undefined */
};
}

class Mp4TagField;
class Diagnostics;

/*!
 * \brief Defines traits for the TagField implementation of the Mp4TagField class.
 */
template <> class TAG_PARSER_EXPORT TagFieldTraits<Mp4TagField> {
public:
    using IdentifierType = std::uint32_t;
    using TypeInfoType = std::uint32_t;
};

class Mp4Atom;

class TAG_PARSER_EXPORT Mp4TagFieldMaker {
    friend class Mp4TagField;

public:
    Mp4TagFieldMaker(Mp4TagFieldMaker &&) = default;
    void make(std::ostream &stream);
    const Mp4TagField &field() const;
    std::uint64_t requiredSize() const;

private:
    /// \cond
    struct Data {
        Data();
        Data(Data &&) = default;
        std::string_view rawData;
        std::stringstream convertedData;
        std::uint64_t size = 0;
        std::uint32_t rawType = 0;
        std::uint16_t countryIndicator = 0;
        std::uint16_t languageIndicator = 0;
    };
    /// \endcond

    Mp4TagFieldMaker(Mp4TagField &field, Diagnostics &diag);
    std::uint64_t prepareDataAtom(
        const TagValue &value, std::uint16_t countryIndicator, std::uint16_t languageIndicator, const std::string &context, Diagnostics &diag);

    Mp4TagField &m_field;
    CppUtilities::BinaryWriter m_writer;
    std::vector<Data> m_data;
    std::uint64_t m_totalSize;
};

/*!
 * \brief Returns the associated field.
 */
inline const Mp4TagField &Mp4TagFieldMaker::field() const
{
    return m_field;
}

/*!
 * \brief Returns number of bytes which will be written when making the field.
 */
inline std::uint64_t Mp4TagFieldMaker::requiredSize() const
{
    return m_totalSize;
}

class TAG_PARSER_EXPORT Mp4TagField : public TagField<Mp4TagField> {
    friend class TagField<Mp4TagField>;

public:
    struct AdditionalData {
        TagValue value;
        std::uint32_t rawDataType = 0;
        std::uint16_t countryIndicator = 0;
        std::uint16_t languageIndicator = 0;
    };

    Mp4TagField();
    Mp4TagField(IdentifierType id, const TagValue &value);
    Mp4TagField(const std::string &mean, const std::string &name, const TagValue &value);

    void reparse(Mp4Atom &ilstChild, Diagnostics &diag);
    Mp4TagFieldMaker prepareMaking(Diagnostics &diag);
    void make(std::ostream &stream, Diagnostics &diag);

    const std::vector<AdditionalData> &additionalData() const;
    std::vector<AdditionalData> &additionalData();
    bool isAdditionalTypeInfoUsed() const;
    const std::string &name() const;
    void setName(const std::string &name);
    const std::string &mean() const;
    void setMean(const std::string &mean);
    std::uint32_t parsedRawDataType() const;
    std::uint16_t countryIndicator() const;
    std::uint16_t languageIndicator() const;
    bool supportsNestedFields() const;
    std::vector<std::uint32_t> expectedRawDataTypes() const;
    std::uint32_t appropriateRawDataType() const;
    std::uint32_t appropriateRawDataTypeForValue(const TagValue &value) const;

    static IdentifierType fieldIdFromString(const char *idString, std::size_t idStringSize = std::string::npos);
    static std::string fieldIdToString(IdentifierType id);

private:
    void internallyClearValue();
    void internallyClearFurtherData();
    std::string m_name;
    std::string m_mean;
    std::vector<AdditionalData> m_additionalData;
    std::uint32_t m_parsedRawDataType;
    std::uint16_t m_countryIndicator;
    std::uint16_t m_langIndicator;
};

/*!
 * \brief Returns additional data (and the corresponding raw data type, country and language).
 * \remarks Some files seen in the wild have multiple data atoms. This function allows to access the data from additional atoms.
 */
inline const std::vector<Mp4TagField::AdditionalData> &Mp4TagField::additionalData() const
{
    return m_additionalData;
}

/*!
 * \brief Returns additional data (and the corresponding raw data type, country and language).
 * \remarks Some files seen in the wild have multiple data atoms. This function allows to access the data from additional atoms.
 */
inline std::vector<Mp4TagField::AdditionalData> &Mp4TagField::additionalData()
{
    return m_additionalData;
}

/*!
 * \brief Returns whether the additional type info is used.
 */
inline bool Mp4TagField::isAdditionalTypeInfoUsed() const
{
    return false;
}

/*!
 * \brief Returns the "name" for "extended" fields.
 */
inline const std::string &Mp4TagField::name() const
{
    return m_name;
}

/*!
 * \brief Sets the "name" for the "extended" field.
 */
inline void Mp4TagField::setName(const std::string &name)
{
    m_name = name;
}

/*!
 * \brief Returns the "mean" for "extended" fields.
 */
inline const std::string &Mp4TagField::mean() const
{
    return m_mean;
}

/*!
 * \brief Sets the "mean" for the "extended" field.
 */
inline void Mp4TagField::setMean(const std::string &mean)
{
    m_mean = mean;
}

/*!
 * \brief Returns the raw data type which has been determined when parsing.
 */
inline std::uint32_t Mp4TagField::parsedRawDataType() const
{
    return m_parsedRawDataType;
}

/*!
 * \brief Returns the country indicator.
 */
inline std::uint16_t Mp4TagField::countryIndicator() const
{
    return m_countryIndicator;
}

/*!
 * \brief Returns the language indicator.
 */
inline std::uint16_t Mp4TagField::languageIndicator() const
{
    return m_langIndicator;
}

/*!
 * \brief Returns whether nested fields are supported.
 */
inline bool Mp4TagField::supportsNestedFields() const
{
    return false;
}

/*!
 * \brief Converts the specified ID string representation to an actual ID.
 * \remarks The specified \a idString is assumed to be UTF-8 encoded. In order to get the ©-sign
 *          correctly, it is converted to Latin-1.
 */
inline Mp4TagField::IdentifierType Mp4TagField::fieldIdFromString(const char *idString, std::size_t idStringSize)
{
    const auto latin1 = CppUtilities::convertUtf8ToLatin1(idString, idStringSize != std::string::npos ? idStringSize : std::strlen(idString));
    switch (latin1.second) {
    case 4:
        return CppUtilities::BE::toUInt32(latin1.first.get());
    default:
        throw CppUtilities::ConversionException("MP4 ID must be exactly 4 chars");
    }
}

/*!
 * \brief Returns the string representation for the specified \a id.
 * \remarks The specified \a id is considered Latin-1 encoded. In order to get the ©-sign
 *          correctly, it is converted to UTF-8.
 */
inline std::string Mp4TagField::fieldIdToString(Mp4TagField::IdentifierType id)
{
    const auto utf8 = CppUtilities::convertLatin1ToUtf8(CppUtilities::interpretIntegerAsString<std::uint32_t>(id).data(), 4);
    return std::string(utf8.first.get(), utf8.second);
}

} // namespace TagParser

#endif // TAG_PARSER_MP4TAGATOM_H