#include "Dimension.h"

#include "IR.h"
#include "IROperator.h"
#include <utility>

namespace Halide {
namespace Internal {

Dimension::Dimension(const Internal::Parameter &p, int d, Func f)
 : param(p), d(d), f(std::move(f)) {
 user_assert(param.defined())
 << "Can't access the dimensions of an undefined Parameter\n";
 user_assert(param.is_buffer())
 << "Can't access the dimensions of a scalar Parameter\n";
 user_assert(d >= 0 && d < param.dimensions())
 << "Can't access dimension " << d
 << " of a " << param.dimensions() << "-dimensional Parameter\n";
}

Expr Dimension::min() const {
 std::ostringstream s;
 s << param.name() << ".min." << d;
 return Variable::make(Int(32), s.str(), param);
}

Expr Dimension::extent() const {
 std::ostringstream s;
 s << param.name() << ".extent." << d;
 return Variable::make(Int(32), s.str(), param);
}

Expr Dimension::max() const {
 return min() + extent() - 1;
}

// DEPRECATED
Expr Dimension::min_estimate() const {
 return param.min_constraint_estimate(d);
}

// DEPRECATED
Expr Dimension::extent_estimate() const {
 return param.extent_constraint_estimate(d);
}

Expr Dimension::stride() const {
 std::ostringstream s;
 s << param.name() << ".stride." << d;
 return Variable::make(Int(32), s.str(), param);
}

Dimension Dimension::set_extent(Expr extent) {
 // Propagate constant bounds into estimates as well.
 if (is_const(extent)) {
 param.set_extent_constraint_estimate(d, extent);
 }
 param.set_extent_constraint(d, std::move(extent));
 return *this;
}

Dimension Dimension::set_min(Expr min) {
 // Propagate constant bounds into estimates as well.
 if (is_const(min)) {
 param.set_min_constraint_estimate(d, min);
 }
 param.set_min_constraint(d, std::move(min));
 return *this;
}

Dimension Dimension::set_stride(Expr stride) {
 param.set_stride_constraint(d, std::move(stride));
 return *this;
}

Dimension Dimension::set_bounds(Expr min, Expr extent) {
 return set_min(std::move(min)).set_extent(std::move(extent));
}

Dimension Dimension::set_estimate(Expr min, Expr extent) {
 // Update the estimates on the linked Func as well.
 // (This matters mainly for OutputImageParams.)
 // Note that while it's possible/legal for a Dimension to have an undefined
 // Func, you shouldn't ever call set_estimate on such an instance.
 internal_assert(f.defined());
 f.set_estimate(f.args()[d], min, extent);
 param.set_min_constraint_estimate(d, std::move(min));
 param.set_extent_constraint_estimate(d, std::move(extent));
 return *this;
}

Dimension Dimension::dim(int i) const {
 return Dimension(param, i, f);
}

} // namespace Internal
} // namespace Halide