#include "bag_dataset.h"

#include "bag_georefmetadatalayerdescriptor.h"

#include "bag_metadataprofiles.h"

#include "bag_hdfhelper.h"

#include "bag_private.h"

#include "bag_valuetable.h"

#include <iostream>

#include <array>

#include <H5Cpp.h>

namespace BAG {

//! Constructor.

/*!

\param dataset

    The BAG Dataset this layer belongs to.

\param name

    The name of the simple layer this layer has metadata for.

\param keyType

    The type of the key.

    Must be DT_UINT8, DT_UINT16, DT_UINT32, or DT_UINT64.

\param definition

    The list of fields describing a record/value.

\param chunkSize

    The chunk size the HDF5 DataSet will use.

\param compressionLevel

    The compression level the HDF5 DataSet will use.

*/

GeorefMetadataLayerDescriptor::GeorefMetadataLayerDescriptor(

        Dataset& dataset,

        const std::string& name,

        GeorefMetadataProfile profile,

        DataType keyType,

        RecordDefinition definition,

        uint32_t rows, uint32_t cols,

        uint64_t chunkSize,

        int compressionLevel)

    : LayerDescriptor(dataset.getNextId(), GEOREF_METADATA_PATH + name, name,

                      Georef_Metadata, rows, cols, chunkSize, compressionLevel)

    , m_pBagDataset(dataset.shared_from_this())

    , m_profile(profile)

    , m_keyType(keyType)

    , m_elementSize(Layer::getElementSize(keyType))

    , m_definition(std::move(definition))

{

}

//! Create a georeferenced metadata layer descriptor.

/*!

\param dataset

    The BAG Dataset this layer belongs to.

\param name

    The name of the simple layer this layer has metadata for.

\param keyType

    The type of the key.

    Must be DT_UINT8, DT_UINT16, DT_UINT32, or DT_UINT64.

\param definition

    The list of fields describing a record/value this layer contains for each node.

\param chunkSize

    The chunk size the HDF5 DataSet will use.

\param compressionLevel

    The compression level the HDF5 DataSet will use.

\return

    The new georeferenced metadata layer descriptor.

*/

std::shared_ptr<GeorefMetadataLayerDescriptor> GeorefMetadataLayerDescriptor::create(

            Dataset& dataset,

            const std::string& name,

            GeorefMetadataProfile profile,

            DataType keyType,

            RecordDefinition definition,

            uint32_t rows, uint32_t cols,

            uint64_t chunkSize,

            int compressionLevel)

{

    return std::shared_ptr<GeorefMetadataLayerDescriptor>(

        new GeorefMetadataLayerDescriptor{dataset, name, profile, keyType,

                                          std::move(definition), rows, cols,

                                          chunkSize, compressionLevel});

}

//! Open an existing georeferenced metadata layer descriptor.

/*!

\param dataset

    The BAG Dataset this layer belongs to.

\param name

    The name of the simple layer this layer has metadata for.

\return

    The existing georeferenced metadata layer descriptor.

*/

std::shared_ptr<GeorefMetadataLayerDescriptor> GeorefMetadataLayerDescriptor::open(

    Dataset& dataset,

    const std::string& name)

{

    const auto& h5file = dataset.getH5file();

    const std::string internalPath{GEOREF_METADATA_PATH + name + COMPOUND_KEYS};

    const auto h5dataSet = ::H5::DataSet{h5file.openDataSet(internalPath)};

    // Determine keyType.

    const auto fileDataType = h5dataSet.getDataType();

    DataType keyType = DT_UNKNOWN_DATA_TYPE;

    switch(fileDataType.getSize())

    {

    case 1:

        keyType = DT_UINT8;

        break;

    case 2:

        keyType = DT_UINT16;

        break;

    case 4:

        keyType = DT_UINT32;

        break;

    case 8:

        keyType = DT_UINT64;

        break;

    default:

        throw InvalidKeyType{};

    }

    // Determine Record Definition.

    const auto attribute = h5dataSet.openAttribute(COMPOUND_RECORD_DEFINITION);

    const auto fileDataSpace = attribute.getSpace();

    const auto numDims = fileDataSpace.getSimpleExtentNdims();

    if (numDims != 1)

        throw InvalidValueSize{};

    hsize_t numFields = 0;

    fileDataSpace.getSimpleExtentDims(&numFields, nullptr);

    RecordDefinition definition(numFields);

    attribute.read(attribute.getDataType(), definition.data());

    // Determine chunk size and compression level.

    const auto chunkSize = BAG::getChunkSize(h5file, internalPath);

    const auto compressionLevel = BAG::getCompressionLevel(h5file, internalPath);

    // Read metadata profile as string from HDF5 file attribute and convert to GeorefMetadataProfile enum value.

    std::string profileString;

    if (h5dataSet.attrExists(METADATA_PROFILE_TYPE)) {

        const auto metadataProfileAtt = h5dataSet.openAttribute(METADATA_PROFILE_TYPE);

        metadataProfileAtt.read(metadataProfileAtt.getDataType(), profileString);

    } else {

        std::cerr << "Unable to find georeferenced metadata layer attribute '" << METADATA_PROFILE_TYPE <<

                  "' for simple layer '" << name << "', setting profile to '" << UNKOWN_METADATA_PROFILE_NAME <<

                  "'." << std::endl;

        profileString = UNKOWN_METADATA_PROFILE_NAME;

    }

    GeorefMetadataProfile profile;

    auto search = BAG::kStringMapGeorefMetadataProfile.find(profileString);

    if (search != BAG::kStringMapGeorefMetadataProfile.end()) {

        // This is a recognized metadata profile (either a specific known profile or the unknown profile)

        profile = search->second;

    } else {

        std::cerr << "WARNING: Unrecognized georeferenced metadata layer metadata profile '" << profileString <<

                  "' for simple layer '" << name << "', assuming value was '" << UNKOWN_METADATA_PROFILE_NAME <<

                  "'." << std::endl;

        profile = UNKNOWN_METADATA_PROFILE;

    }

    std::array<hsize_t, 2> dims;

    h5dataSet.getSpace().getSimpleExtentDims(dims.data(), nullptr);

    return std::shared_ptr<GeorefMetadataLayerDescriptor>(

        new GeorefMetadataLayerDescriptor{dataset, name, profile, keyType, definition,

                                          static_cast<const uint32_t>(dims[0]),

                                          static_cast<const uint32_t>(dims[1]),

                                          chunkSize, compressionLevel});

}

//! \copydoc LayerDescriptor::getDataType

DataType GeorefMetadataLayerDescriptor::getDataTypeProxy() const noexcept

{

    return m_keyType;

}

//! Retrieve the BAG Dataset this layer belongs to.

/*!

\return

    The BAG Dataset.

*/

std::weak_ptr<Dataset> GeorefMetadataLayerDescriptor::getDataset() const &

{

    return m_pBagDataset;

}

//! \copydoc LayerDescriptor::getElementSize

uint8_t GeorefMetadataLayerDescriptor::getElementSizeProxy() const noexcept

{

    return m_elementSize;

}

//! Retrieve the definition of a record/value.

/*!

\return

    The definition of a record/value.

*/

const RecordDefinition&

GeorefMetadataLayerDescriptor::getDefinition() const & noexcept

{

    return m_definition;

}

//! Retrieve the metadata profile type.

/*!

\return

    The metadata profile type.

 */

GeorefMetadataProfile GeorefMetadataLayerDescriptor::getProfile() {

    return m_profile;

}

}  // namespace BAG