// SPDX-License-Identifier: BSD-3-Clause

// Copyright (c) Contributors to the OpenEXR Project.

#ifndef INCLUDED_IMF_ID_MANIFEST_H

#define INCLUDED_IMF_ID_MANIFEST_H

//-----------------------------------------------------------------------------

//

//        class IDManifest, to store a table mapping ID numbers to text

//

//-----------------------------------------------------------------------------

#include "ImfForward.h"

#include <cstdint>

#include <deque>

#include <map>

#include <set>

#include <string>

#include <vector>

OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER

class IMF_EXPORT_TYPE IDManifest

{

public:

    // indication of how long a mapping between an ID number and the text holds for

    enum IMF_EXPORT_ENUM IdLifetime

    {

        LIFETIME_FRAME, // The mapping may change every frame:

        LIFETIME_SHOT,  // The mapping is consistent for every frame of a shot

        LIFETIME_STABLE // The mapping is consistent for all time.

    };

    //

    // hashing scheme is stored as a string rather than an enum, to allow

    // proprietary schemes to be encoded with less danger of collision

    // proprietary schemes should be encoded in a reverse-URL syntax

    //

    IMF_EXPORT

    static const std::string

        UNKNOWN; // = "unknown" : default value for encoding scheme and hash scheme - should be changed

    IMF_EXPORT

    static const std::string

        NOTHASHED; // = "none" : no relationship between text and ID

    IMF_EXPORT

    static const std::string

        CUSTOMHASH; // = "custom" : text is hashed using defined scheme

    IMF_EXPORT

    static const std::string

        MURMURHASH3_32; // = "MurmurHash3_32" : MurmurHash3 32 bit is used

    IMF_EXPORT

    static const std::string

        MURMURHASH3_64; // = "MurmurHash3_64" : bottom 8 bytes of MurmarHash3_128 (64 bit architecture version) is used

    IMF_EXPORT

    static const std::string

        ID_SCHEME; // ="id" : 32 bit ID stored directly in a UINT channel

    IMF_EXPORT

    static const std::string

        ID2_SCHEME; // ="id2" : 64 bit ID stored in two channels, specified by the ChannelGroup

    IMF_EXPORT

    IDManifest ();

    friend class CompressedIDManifest;

    //

    // decompress a compressed IDManifest into IDManifest for reading

    //

    IMF_EXPORT

    IDManifest (const CompressedIDManifest&);

    //

    // construct manifest from serialized representation stored at 'data'

    //

    IMF_EXPORT

    IDManifest (const char* data, const char* end);

private:

    // internal helper function called by constructors

    IMF_HIDDEN void init (const char* data, const char* end);

public:

    //

    // Description of the information represented by a single group of channels

    //

    class IMF_EXPORT_TYPE ChannelGroupManifest

    {

    private:

        std::set<std::string>

            _channels; // group of channels this manifest represents

        std::vector<std::string>

            _components; // ordered list of components represented by this channel group

        IdLifetime _lifeTime;

        std::string

            _hashScheme; //one of above strings or custom value e.g "nz.co.wetafx.cleverhash2"

        std::string

            _encodingScheme; //string identifying scheme to encode ID numbers within the image

        typedef std::map<uint64_t, std::vector<std::string>> IDTable;

        IDTable                                              _table;

        // used for << operator to work: tracks the last item inserted into the Manifest

        IDTable::iterator _insertionIterator;

        bool

            _insertingEntry; // true if << has been called but not enough strings yet set

    public:

        IMF_EXPORT

        ChannelGroupManifest ();

        IMF_EXPORT

        const std::set<std::string>& getChannels () const;

        IMF_EXPORT

        std::set<std::string>& getChannels ();

        IMF_EXPORT

        void setChannels (const std::set<std::string>& channels);

        IMF_EXPORT

        void setChannel (const std::string& channel);

        // get list of components for this channel group

        IMF_EXPORT

        const std::vector<std::string>& getComponents () const;

        // set components: throws an exception if there are already entries in the table

        // and the component length changes

        IMF_EXPORT

        void setComponents (const std::vector<std::string>& components);

        // set name of single component: throws an exception if there are already entries in the table

        // unless there was previously one component

        IMF_EXPORT

        void setComponent (const std::string& component);

        IdLifetime getLifetime () const { return _lifeTime; }

        void setLifetime (const IdLifetime& lifeTime) { _lifeTime = lifeTime; }

        const std::string& getHashScheme () const { return _hashScheme; }

        void               setHashScheme (const std::string& hashScheme)

        {

            _hashScheme = hashScheme;

        }

        const std::string& getEncodingScheme () const

        {

            return _encodingScheme;

        }

        void setEncodingScheme (const std::string& encodingScheme)

        {

            _encodingScheme = encodingScheme;

        }

        class Iterator;      // iterator which allows modification of the text

        class ConstIterator; // iterator which does not allow modification

        IMF_EXPORT

        Iterator begin ();

        IMF_EXPORT

        ConstIterator begin () const;

        IMF_EXPORT

        Iterator end ();

        IMF_EXPORT

        ConstIterator end () const;

        // return number of entries in manifest - could be 0

        IMF_EXPORT

        size_t size () const;

        // insert a new entry - text must contain same number of items as getComponents

        IMF_EXPORT

        Iterator

        insert (uint64_t idValue, const std::vector<std::string>& text);

        // insert a new entry - getComponents must be a single entry

        IMF_EXPORT

        Iterator insert (uint64_t idValue, const std::string& text);

        // compute hash of given entry, insert into manifest, and return

        // the computed hash. Exception will be thrown if hash scheme isn't recognised

        IMF_EXPORT

        uint64_t insert (const std::vector<std::string>& text);

        IMF_EXPORT

        uint64_t insert (const std::string& text);

        IMF_EXPORT

        Iterator find (uint64_t idValue);

        IMF_EXPORT

        ConstIterator find (uint64_t idValue) const;

        IMF_EXPORT

        void erase (uint64_t idValue);

        // return reference to idName for given idValue. Adds the mapping to the vector if it doesn't exist

        IMF_EXPORT

        std::vector<std::string>& operator[] (uint64_t idValue);

        // add a new entry to the manifest as an insertion operator: <<

        // the component strings must also be inserted using <<

        // throws an exception if the previous insert operation didn't insert the correct number of string components

        IMF_EXPORT

        ChannelGroupManifest& operator<< (uint64_t idValue);

        // insert a string as the next component of a previously inserted attribute

        IMF_EXPORT

        ChannelGroupManifest& operator<< (const std::string& text);

        IMF_EXPORT

        bool operator== (const ChannelGroupManifest& other) const;

        bool operator!= (const ChannelGroupManifest& other) const

        {

            return !(*this == other);

        }

        friend class IDManifest;

    };

private:

    // deque vs vector: add() returns references to groups; vector may reallocate

    // and invalidate them when another group is added 

    std::deque<ChannelGroupManifest> _manifest;

public:

    // add a new channel group definition to the table, presumably populated with mappings

    // 'table' will be copied to the internal manifest; to further modify use the return value

    IMF_EXPORT

    ChannelGroupManifest& add (const ChannelGroupManifest& table);

    //insert an empty table definition for the given channel / group of channels

    IMF_EXPORT

    ChannelGroupManifest& add (const std::set<std::string>& group);

    IMF_EXPORT

    ChannelGroupManifest& add (const std::string& channel);

    // return number of items in manifest

    IMF_EXPORT

    size_t size () const;

    // find the first manifest ChannelGroupManifest that defines the given channel

    // if channel not find, returns a value equal to size()

    IMF_EXPORT

    size_t find (const std::string& channel) const;

    IMF_EXPORT

    const ChannelGroupManifest& operator[] (size_t index) const;

    IMF_EXPORT

    ChannelGroupManifest& operator[] (size_t index);

    //

    // serialize manifest into data array. Array will be resized to the required size

    //

    IMF_EXPORT

    void serialize (std::vector<char>& data) const;

    IMF_EXPORT

    bool operator== (const IDManifest& other) const;

    IMF_EXPORT

    bool operator!= (const IDManifest& other) const;

    //

    // add entries from 'other' into this manifest if possible

    // * all ChannelGroupsManifests for different ChannelGroups

    //   will be appended.

    // * Where 'other' contains a manifest for the same

    //   ChannelGroup:

    //     * If _components differs, the entire ChannelGroupManifest is skipped

    //     * Otherwise, entries not present in 'this' will be inserted

    //     * _hashScheme, _lifeTime and _encodingScheme will be unchanged

    //

    // returns 'false' if the same ChannelGroupManifest appears in both 'other' and 'this',

    // but with different _components, _hashScheme, _lifeTime or _encodingScheme

    // or if any idValue maps to different strings in 'other' and 'this'

    //

    IMF_EXPORT

    bool merge (const IDManifest& other);

    //

    // static has generation functions

    //

    IMF_EXPORT

    static unsigned int MurmurHash32 (const std::string& idString);

    IMF_EXPORT

    static unsigned int MurmurHash32 (const std::vector<std::string>& idString);

    IMF_EXPORT

    static uint64_t MurmurHash64 (const std::string& idString);

    IMF_EXPORT

    static uint64_t MurmurHash64 (const std::vector<std::string>& idString);

};

//

// zlip compressed version of IDManifest - the IDManifestAttribute encodes this format

// This should be transparent to the user, since there is implicit casting between the two types

//

class CompressedIDManifest

{

public:

    IMF_EXPORT

    CompressedIDManifest ();

    IMF_EXPORT

    CompressedIDManifest (const CompressedIDManifest& other);

    IMF_EXPORT

    CompressedIDManifest& operator= (const CompressedIDManifest& other);

    //

    // construct a compressed version of the given manifest - to decompress it cast to an IDManifest

    //

    IMF_EXPORT

    CompressedIDManifest (const IDManifest& manifest);

    IMF_EXPORT

    ~CompressedIDManifest ();

    int            _compressedDataSize;

    size_t         _uncompressedDataSize;

    unsigned char* _data;

};

//

// Read/Write Iterator object to access individual entries within a manifest

//

class IDManifest::ChannelGroupManifest::Iterator

{

public:

    IMF_EXPORT

    Iterator ();

    IMF_EXPORT

    explicit Iterator (

        const IDManifest::ChannelGroupManifest::IDTable::iterator& i);

    friend class IDManifest::ChannelGroupManifest::ConstIterator;

    IMF_EXPORT

    Iterator& operator++ ();

    IMF_EXPORT

    uint64_t id () const;

    IMF_EXPORT

    std::vector<std::string>& text ();

private:

    std::map<uint64_t, std::vector<std::string>>::iterator _i;

};

//

// Read-only Iterator object to access individual entries within a manifest

//

class IDManifest::ChannelGroupManifest::ConstIterator

{

public:

    IMF_EXPORT

    ConstIterator ();

    // explicit cast from internal map operator (for internal use only)

    IMF_EXPORT

    explicit ConstIterator (

        const IDManifest::ChannelGroupManifest::IDTable::const_iterator& i);

    // cast from non-const to const iterator

    IMF_EXPORT

    ConstIterator (const IDManifest::ChannelGroupManifest::Iterator& other);

    IMF_EXPORT

    ConstIterator& operator++ ();

    IMF_EXPORT

    uint64_t id () const;

    IMF_EXPORT

    const std::vector<std::string>& text () const;

private:

    std::map<uint64_t, std::vector<std::string>>::const_iterator _i;

    friend bool operator== (const ConstIterator&, const ConstIterator&);

    friend bool operator!= (const ConstIterator&, const ConstIterator&);

};

//

// ChannelGroupManifest::Iterator implementation: all inline

//

inline IDManifest::ChannelGroupManifest::Iterator::Iterator ()

{}

inline IDManifest::ChannelGroupManifest::Iterator::Iterator (

    const IDManifest::ChannelGroupManifest::IDTable::iterator& i)

    : _i (i)

{}

inline uint64_t

IDManifest::ChannelGroupManifest::Iterator::id () const

{

    return _i->first;

}

inline std::vector<std::string>&

IDManifest::ChannelGroupManifest::Iterator::text ()

{

    return _i->second;

}

inline IDManifest::ChannelGroupManifest::Iterator&

IDManifest::ChannelGroupManifest::Iterator::operator++ ()

{

    ++_i;

    return *this;

}

//

// ChannelGroupManifest::ConstIterator implementation: all inline

//

inline IDManifest::ChannelGroupManifest::ConstIterator::ConstIterator ()

{}

inline IDManifest::ChannelGroupManifest::ConstIterator::ConstIterator (

    const IDManifest::ChannelGroupManifest::Iterator& other)

    : _i (other._i)

{}

inline IDManifest::ChannelGroupManifest::ConstIterator::ConstIterator (

    const IDManifest::ChannelGroupManifest::IDTable::const_iterator& i)

    : _i (i)

{}

inline uint64_t

IDManifest::ChannelGroupManifest::ConstIterator::id () const

{

    return _i->first;

}

inline const std::vector<std::string>&

IDManifest::ChannelGroupManifest::ConstIterator::text () const

{

    return _i->second;

}

inline IDManifest::ChannelGroupManifest::ConstIterator&

IDManifest::ChannelGroupManifest::ConstIterator::operator++ ()

{

    ++_i;

    return *this;

}

inline bool

operator== (

    const IDManifest::ChannelGroupManifest::ConstIterator& a,

    const IDManifest::ChannelGroupManifest::ConstIterator& b)

{

    return a._i == b._i;

}

inline bool

operator!= (

    const IDManifest::ChannelGroupManifest::ConstIterator& a,

    const IDManifest::ChannelGroupManifest::ConstIterator& b)

{

    return a._i != b._i;

}

OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT

#endif