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

/*
  Random number ops.
*/

#include "sharpy/Random.hpp"
#include "sharpy/Factory.hpp"
#include "sharpy/NDArray.hpp"
#include <bitsery/traits/vector.h>

namespace SHARPY {

using ptr_type = array_i::ptr_type;

#if 0
namespace x {

    template<typename T>
    struct Rand
    {
        //template<typename L, typename U>
        static ptr_type op(const shape_type & shp, T lower, T upper)
        {
            PVSlice pvslice(shp);
            shape_type shape(std::move(pvslice.tile_shape()));
            auto r = operatorx<T>::mk_tx(std::move(pvslice), std::move(xt::random::rand(std::move(shape), lower, upper)));
            return r;
        }
    };
}
#endif // if 0

struct DeferredRandomOp : public Deferred {
  shape_type _shape;
  double _lower, _upper;
  DTypeId _dtype;

  DeferredRandomOp() = default;
  DeferredRandomOp(const shape_type &shape, double lower, double upper,
                   DTypeId dtype)
      : _shape(shape), _lower(lower), _upper(upper), _dtype(dtype) {}

  void run() override {
#if 0
        switch(_dtype) {
        case FLOAT64:
            set_value(std::move(x::Rand<double>::op(_shape, _lower, _upper)));
            return;
        case FLOAT32:
            set_value(std::move(x::Rand<float>::op(_shape, static_cast<float>(_lower), static_cast<float>(_upper))));
            return;
        }
        throw std::runtime_error("rand: dtype must be a floating point type");
#endif // if 0
  }

  FactoryId factory() const override { return F_RANDOM; }

  template <typename S> void serialize(S &ser) {
    ser.template container<sizeof(shape_type::value_type)>(_shape, 8);
    ser.template value<sizeof(_lower)>(_lower);
    ser.template value<sizeof(_upper)>(_upper);
    ser.template value<sizeof(_dtype)>(_dtype);
  }
};

FutureArray *Random::rand(DTypeId dtype, const shape_type &shape,
                          const py::object &lower, const py::object &upper) {
  return new FutureArray(defer<DeferredRandomOp>(
      shape, to_native<double>(lower), to_native<double>(upper), dtype));
}

void Random::seed(uint64_t s) {
  // FIXME defer_lambda([s](){xt::random::seed(s); return
  // array_i::ptr_type();});
}

FACTORY_INIT(DeferredRandomOp, F_RANDOM);
} // namespace SHARPY