#ifndef MIGRAPHX_GUARD_OPERATORS_BROADCAST_HPP
#define MIGRAPHX_GUARD_OPERATORS_BROADCAST_HPP

#include <array>
#include <migraphx/check_shapes.hpp>
#include <migraphx/argument.hpp>
#include <migraphx/functional.hpp>
#include <migraphx/config.hpp>
#include <cmath>
#include <utility>

namespace migraphx {
inline namespace MIGRAPHX_INLINE_NS {
namespace op {

/// The broadcast operator performs the numpy-style broadcasting of an axis of a given tensor. This
/// is achieved primarily by setting the stride of the broadcasted axis to zero. Linear indicies are
/// computed from multi-indicies by computing the inner product on the multi-index with the strides.
/// For example, if we have a tensor A(2,3) it has lengths of (2,3) and strides of (3,1). If we want
/// to compute the linear offset that corresponds to the element on the 2nd row (i = 1) and 3rd
/// column (j = 2), we compute the following inner product (1,2) dot (3, 1) = 1*3 + 2*1 = 5. It is
/// obvious from there that we can negate the effects of a given axis by setting the stride of that
/// axis to zero.
struct broadcast
{
    uint64_t axis = 0;
    std::vector<std::size_t> broadcast_lens;

    template <class Self, class F>
    static auto reflect(Self& self, F f)
    {
        return pack(f(self.axis, "axis"), f(self.broadcast_lens, "dims"));
    }

    std::string name() const { return "broadcast"; }
    shape compute_shape(std::vector<shape> inputs) const
    {
        auto input = inputs.at(0);
        auto t     = input.type();

        std::vector<size_t> bcast_strides(broadcast_lens.size(), 0);
        // the broacast op is deprecated now, so not handling the negative
        // value of axis anymore
        if(axis >= broadcast_lens.size())
        {
            MIGRAPHX_THROW("BROADCAST : axis is out of range");
        }

        if(std::all_of(
               broadcast_lens.cbegin(), broadcast_lens.cend(), [&](auto x) { return x == 1; }))
        {
            if(axis != 0)
                MIGRAPHX_THROW("BROADCAST: when broadcasting tensor of size 1, axis should be 0");
            return {t, broadcast_lens, std::move(bcast_strides)};
        }
        else
        {
            if(broadcast_lens.size() - axis < input.lens().size())
            {
                MIGRAPHX_THROW("BROADCAST: when broadcasting success sizes must match");
            }

            if(!std::equal(input.lens().begin(), input.lens().end(), broadcast_lens.begin() + axis))
            {
                MIGRAPHX_THROW("BROADCAST: when broadcasting success sizes must match");
            }
            std::copy(input.strides().begin(), input.strides().end(), bcast_strides.begin() + axis);
            return {t, broadcast_lens, std::move(bcast_strides)};
        }
    }
    argument compute(shape output_shape, std::vector<argument> args) const
    {
        return {std::move(output_shape), std::move(args.at(0).data)};
    }
    std::ptrdiff_t output_alias(const std::vector<shape>&) const { return 0; }
};

} // namespace op
} // namespace MIGRAPHX_INLINE_NS
} // namespace migraphx

#endif
