IH5.h

#pragma once

#include <H5Cpp.h>
#include <complex>
#include <iostream>
#include <isce3/core/Constants.h>
#include <isce3/except/Error.h>
#include <regex>
#include <string>
#include <type_traits>
#include <typeindex>
#include <valarray>
#include <array>
#include <vector>

namespace isce3 {
namespace io {

// Dataset chunking size
const hsize_t chunkSizeX = 128;
const hsize_t chunkSizeY = 128;

// String length (fixed-length string by default in file)
const int STRLENGTH = 50;

// Specific isce data type for HDF5
// May be stored elsewhere eventually
typedef struct float16 {
} float16;
typedef struct n1bit {
} n1bit;
typedef struct n2bit {
} n2bit;

// Parameters containers for HDF5 searching capability
struct findMeta {
    std::vector<std::string> outList;
    std::string searchStr;
    std::string searchType;
    std::string basePath;
};

class IDataSet : public H5::DataSet {

public:
    IDataSet() : H5::DataSet() {};
    IDataSet(const H5::DataSet& dset) : H5::DataSet(dset) {};
    IDataSet(const hid_t id) : H5::DataSet(id) {};

    // Metadata query

    std::vector<std::string> getAttrs();

    H5::DataSpace getDataSpace(const std::string& v = "");

    int getRank(const std::string& v = "");

    int getNumElements(const std::string& v = "");

    std::vector<int> getDimensions(const std::string& v = "");

    std::string getTypeClassStr(const std::string& v = "");

    std::vector<int> getChunkSize();

    int getNumBits(const std::string& v = "");

    std::string toGDAL() const;

    // Dataset reading queries

    template<typename T> inline void read(T& v, const std::string& att = "");

    void read(std::string& v, const std::string& att = "");

    template<typename T> inline void read(T* buf, const std::string& att);

    template<typename T>
    inline void read(std::vector<T>& buf, const std::string& att);

    template<typename T>
    inline void read(std::valarray<T>& buf, const std::string& att);

    // Function to read a dataset from file to memory variable. The input
    // parameter is a raw point/vector/valarray that will store the (partial)
    // multi-dimensional dataset. Input vector/valarray is initialized by
    // caller, but resized (if needed) by the function. Raw pointer have to be
    // allocated by caller. Partial extraction of data is possible using
    // startIn, countIn, and strideIn. startIn: Array containing the position of
    // the first element to read in all
    //          dimension. SizeIn size must be equal to the number of dimension
    //          of the dataset. If nullptr, startIn values are 0.
    // countIn: Array containing the number of elements to read in all
    // dimension.
    //          countIn size must be equal to the number of dimension of the
    //          dataset.
    // strideIn:Array containing the stride between elements to read in all
    // dimension.
    //          strideIn size must be equal to the number of dimension of the
    //          dataset. If nullptr, stridIn values are 1.
    //
    // Examples:
    // - Dataset contains a 3-bands raster. Dimensions are (100,100,3).
    // To retrieve the full second band:
    // startIn=[0,0,1], countIn=[100,100,1], strideIn=nullptr or [1,1,1]
    // To retrieve the first band, but only every other elements in X direction:
    // startIn=[0,0,0], countIn=[50,100,1], strideIn=[2,1,1]

    template<typename T>
    inline void read(T* buf, const int* startIn = nullptr,
                     const int* countIn = nullptr,
                     const int* strideIn = nullptr);

    template<typename T>
    inline void read(T* buf, const std::vector<std::slice>* slicesIn);

    template<typename T> inline void read(T* buf, const std::gslice* gsliceIn);

    template<typename T> inline void read(std::vector<T>& buf);

    template<typename T>
    inline void read(std::vector<T>& buf, const std::vector<int>* startIn,
                     const std::vector<int>* countIn,
                     const std::vector<int>* strideIn);

    template<typename T>
    inline void read(std::vector<T>& buf,
                     const std::vector<std::slice>* slicesIn);

    template<typename T>
    inline void read(std::vector<T>& buf, const std::gslice* gsliceIn);

    template<typename T> inline void read(std::valarray<T>& buf);

    template<typename T>
    inline void read(std::valarray<T>& buf, const std::valarray<int>* startIn,
                     const std::valarray<int>* countIn,
                     const std::valarray<int>* strideIn);

    template<typename T>
    inline void read(std::valarray<T>& buf,
                     const std::vector<std::slice>* slicesIn);

    template<typename T>
    inline void read(std::valarray<T>& buf, const std::gslice* gsliceIn);

    // Dataset writing queries

    template<typename T> inline void write(const std::vector<T>& buf);

    template<typename T, size_t S>
    inline void write(const std::vector<T>& buf,
                      const std::array<int, S>& startIn,
                      const std::array<int, S>& countIn,
                      const std::array<int, S>& strideIn);

    template<typename T>
    inline void write(const std::vector<T>& buf,
                      const std::vector<std::slice>* slicesIn);

    template<typename T>
    inline void write(const std::vector<T>& buf, const std::gslice* gsliceIn);

    template<typename T> inline void write(const std::valarray<T>& buf);

    template<typename T, size_t S>
    inline void write(const std::valarray<T>& buf,
                      const std::array<int, S>& startIn,
                      const std::array<int, S>& countIn,
                      const std::array<int, S>& strideIn);

    template<typename T>
    inline void write(const std::valarray<T>& buf,
                      const std::vector<std::slice>* slicesIn);

    template<typename T>
    inline void write(const std::valarray<T>& buf, const std::gslice* gsliceIn);

    template<typename T> inline void write(const T* buf, const size_t sz);

    template<typename T, size_t S>
    inline void write(const T* buf, const std::array<int, S>& startIn,
                      const std::array<int, S>& countIn,
                      const std::array<int, S>& strideIn);

    template<typename T>
    inline void write(const T* buf, const std::vector<std::slice>* slicesIn);

    template<typename T>
    inline void write(const T* buf, const std::gslice* gsliceIn);

    template<typename T>
    inline void createAttribute(const std::string& name, const T& data);

    template<typename T>
    inline void createAttribute(const std::string& name,
                                const std::vector<T>& values);

    template<typename T>
    inline void createAttribute(const std::string& name,
                                const std::valarray<T>& values);

    template<typename T, typename T2, size_t S>
    inline void createAttribute(const std::string& name,
                                const std::array<T2, S>& dims,
                                const std::vector<T>& values);

    template<typename T, typename T2, size_t S>
    inline void createAttribute(const std::string& name,
                                const std::array<T2, S>& dims,
                                const std::valarray<T>& values);

    template<typename T, typename T2, size_t S>
    inline void createAttribute(const std::string& name,
                                const std::array<T2, S>& dims, const T* buffer);

    H5::DataSpace getDataSpace(const int* startIn, const int* countIn,
                               const int* strideIn);

    H5::DataSpace getDataSpace(const std::vector<std::slice>* sliceIn);

    H5::DataSpace getDataSpace(const std::gslice* gsliceIn);

    H5::DataSpace getDataSpace(const size_t xidx, const size_t yidx,
                               const size_t iowidth, const size_t iolength,
                               const size_t band);

private:
    template<typename T> void read(T* buffer, const H5::DataSpace& dspace);

    void read(std::string* buffer, const H5::DataSpace& dspace);
    void read(std::string* buf, const std::string& att);

    template<typename T>
    void createAttribute(const std::string& name, const H5::DataType& datatype,
                         const H5::DataSpace& dataspace, const T* buffer);

    template<typename T>
    void write(const T* buf, const H5::DataSpace& filespace);
};

// Specialized instantiations
template<>
void IDataSet::write(const std::string* buf, const H5::DataSpace& dspace);
template<>
void IDataSet::createAttribute(const std::string& name,
                               const H5::DataType& datatype,
                               const H5::DataSpace& dataspace,
                               const std::string* buffer);

class IGroup : public H5::Group {

public:
    IGroup() : H5::Group() {};
    IGroup(const H5::Group& group) : H5::Group(group) {};
    IGroup(hid_t group) : H5::Group(group) {};

    std::vector<std::string> getAttrs();

    std::vector<std::string> find(const std::string name,
                                  const std::string start = ".",
                                  const std::string type = "BOTH",
                                  const std::string path = "FULL");

    std::string getPathname();

    H5::DataSpace getDataSpace(const std::string& name);

    int getNumElements(const std::string& name);

    template<typename T> inline void read(T& v, const std::string& att);

    void read(std::string& v, const std::string& att);

    template<typename T> inline void read(T* buf, const std::string& att);

    void read(std::string* buf, const std::string& att);

    template<typename T>
    inline void read(std::vector<T>& buf, const std::string& att);

    template<typename T>
    inline void read(std::valarray<T>& buf, const std::string& att);

    IDataSet openDataSet(const H5std_string& name);

    IGroup openGroup(const H5std_string& name);

    IGroup createGroup(const H5std_string& name);

    IDataSet createDataSet(const std::string& name, const std::string& data);

    template<typename T>
    inline IDataSet createDataSet(const std::string& name, const T& data);

    template<typename T>
    inline IDataSet createDataSet(const std::string& name,
                                  const std::vector<T>& data);

    template<typename T>
    inline IDataSet createDataSet(const std::string& name,
                                  const std::valarray<T>& data);

    template<typename T>
    inline IDataSet createDataSet(const std::string& name, const T* buffer,
                                  const size_t size);

    template<typename T, typename T2, size_t S>
    inline IDataSet createDataSet(const std::string& name,
                                  const std::vector<T>& data,
                                  const std::array<T2, S>& dims);

    template<typename T, typename T2, size_t S>
    inline IDataSet createDataSet(const std::string& name,
                                  const std::valarray<T>& data,
                                  const std::array<T2, S>& dims);

    template<typename T, typename T2, size_t S>
    inline IDataSet createDataSet(const std::string& name, const T* data,
                                  const std::array<T2, S>& dims);

    template<typename T, typename T2, size_t S>
    IDataSet createDataSet(const std::string& name,
                           const std::array<T2, S>& dims, const int chunk = 0,
                           const int shuffle = 0, const int deflate = 0);

    template<typename T>
    inline void createAttribute(const std::string& name, const T& data);

    template<typename T>
    inline void createAttribute(const std::string& name,
                                const std::vector<T>& values);

    template<typename T>
    inline void createAttribute(const std::string& name,
                                const std::valarray<T>& values);

    template<typename T, typename T2, size_t S>
    inline void createAttribute(const std::string& name,
                                const std::array<T2, S>& dims,
                                const std::vector<T>& values);

    template<typename T, typename T2, size_t S>
    inline void createAttribute(const std::string& name,
                                const std::array<T2, S>& dims,
                                const std::valarray<T>& values);

    template<typename T, typename T2, size_t S>
    inline void createAttribute(const std::string& name,
                                const std::array<T2, S>& dims, const T* buffer);

private:
    template<typename T>
    void createAttribute(const std::string& name, const H5::DataType& datatype,
                         const H5::DataSpace& dataspace, const T* buffer);
};

template<>
void IGroup::createAttribute(const std::string& name,
                             const H5::DataType& datatype,
                             const H5::DataSpace& dataspace,
                             const std::string* buffer);

class IH5File : public H5::H5File {
public:
    IH5File() : H5::H5File() {};

    IH5File(const H5std_string& name, const char mode = 'r');

    void openFile(const H5std_string& name);

    IDataSet openDataSet(const H5std_string& name);

    IGroup openGroup(const H5std_string& name);

    std::vector<std::string> find(const std::string name,
                                  const std::string start = "/",
                                  const std::string type = "BOTH",
                                  const std::string path = "FULL");

    inline std::string filename() const { return getFileName(); }

    IGroup createGroup(const H5std_string& name);
};
} // namespace io
} // namespace isce3

// Get inline implementations for IH5
#define ISCE_IO_IH5_ICC
#include "IH5.icc"
#undef ISCE_IO_IH5_ICC