/** Utilities
 */

#ifndef WIRECELLAUX_UTIL
#define WIRECELLAUX_UTIL

#include "WireCellIface/ITensorSet.h"
#include "WireCellIface/ITensor.h"
#include "WireCellAux/SimpleTensor.h"
#include "WireCellUtil/Exceptions.h"

#include <Eigen/Core>

#include <iostream>

namespace {
}
namespace WireCell {
    namespace Aux {

        // TODO this function seems too complicated...
        template <typename ElementType>
        inline std::string dump(const WireCell::ITensor::pointer iten, std::vector<size_t> loc, const size_t limit = 10)
        {
            std::stringstream ss;
            auto shape = iten->shape();
            if (shape.size() > loc.size()) {
                loc.push_back(0);
                ss << "[";
                bool skip = false;
                if (shape[loc.size() - 1] > limit) {
                    skip = true;
                }
                for (size_t i = 0; i < shape[loc.size() - 1]; ++i) {
                    if (i >= limit / 2 && skip == true) {
                        ss << " ... ";
                        if (loc.size() != shape.size()) {
                            ss << "\n";
                        }
                        i = shape[loc.size() - 1] - limit / 2;
                        skip = false;
                    }
                    loc.back() = i;
                    ss << dump<ElementType>(iten, loc, limit);
                }
                ss << "]";
                if (loc.size() == 1 && loc[0] == shape[0] - 1) {
                    return ss.str();
                }
                if (loc[loc.size() - 2] != shape[loc.size() - 2] - 1) {
                    for (int i = 0; i < (int) shape.size() - (int) loc.size() + 1; ++i) {
                        ss << "\n";
                    }
                }
            }
            else if (shape.size() == loc.size()) {
                auto data = (ElementType *) iten->data();
                auto ind = loc.back();
                for (size_t d = 0; d < loc.size() - 1; ++d) {
                    size_t plus = loc[d];
                    for (size_t i = d + 1; i < shape.size(); ++i) {
                        plus *= shape[i];
                    }
                    ind += plus;
                }
                ss << data[ind] << " ";
            }
            else {
                THROW(WireCell::ValueError() << WireCell::errmsg{"shape.size() < loc.size()"});
            }
            return ss.str();
        }

        template <typename ElementType>
        inline std::string dump(const ITensor::pointer iten, const size_t limit = 10)
        {
            std::stringstream ss;
            ss << "ITensor: ";
            Json::FastWriter jwriter;
            ss << "shape: [";
            for (auto l : iten->shape()) {
                ss << l << " ";
            }
            ss << "]\n";
            ss << dump<ElementType>(iten, {}, limit);
            ss << "\n";

            return ss.str();
        }

        inline std::string dump(const ITensorSet::pointer itens)
        {
            std::stringstream ss;
            ss << "ITensorSet: ";
            Json::FastWriter jwriter;
            ss << itens->ident() << ", " << jwriter.write(itens->metadata());
            for (auto iten : *itens->tensors()) {
                const auto &md = iten->metadata();
                ss << "tag: " << md["tag"];
                ss << ", type: " << md["type"];
                ss << ", shape: [";
                for (auto l : iten->shape()) {
                    ss << l << " ";
                }
                ss << "]\n";
            }
            return ss.str();
        }

        template <typename ElementType>
        inline Eigen::Array<ElementType, Eigen::Dynamic, Eigen::Dynamic> itensor_to_eigen_array(
            const ITensor::pointer iten)
        {
            if (!iten) {
                THROW(ValueError() << errmsg{"(iten == null"});
            }

            if (iten->shape().size() != 2) {
                THROW(ValueError() << errmsg{"iten->shape().size()!=2"});
            }

            // Eigen storage is col major by default
            auto nrows = iten->shape()[0];
            auto ncols = iten->shape()[1];
            Eigen::Map<const Eigen::Array<ElementType, Eigen::Dynamic, Eigen::Dynamic> > arr(
                (const ElementType *) iten->data(), nrows, ncols);

            return arr;
        }

        template <typename ElementType>
        inline SimpleTensor<ElementType> *eigen_array_to_simple_tensor(
            const Eigen::Array<ElementType, Eigen::Dynamic, Eigen::Dynamic> &arr)
        {
            std::vector<size_t> shape = {(size_t) arr.rows(), (size_t) arr.cols()};
            SimpleTensor<ElementType> *st = new SimpleTensor<ElementType>(shape);
            auto dst = (ElementType *) st->data();
            auto src = (ElementType *) arr.data();
            size_t size = sizeof(ElementType) * arr.rows() * arr.cols();
            memcpy(dst, src, size);

            return st;
        }

        template <typename ElementType>
        inline ITensor::pointer eigen_array_to_itensor(
            const Eigen::Array<ElementType, Eigen::Dynamic, Eigen::Dynamic> &arr)
        {
            auto st = eigen_array_to_simple_tensor<ElementType>(arr);
            return ITensor::pointer(st);
        }

    };  // namespace Aux
}  // namespace WireCell

#endif  // WIRECELLSIG_UTIL