/*******************************************************
 * Copyright (c) 2014, ArrayFire
 * All rights reserved.
 *
 * This file is distributed under 3-clause BSD license.
 * The complete license agreement can be obtained at:
 * http://arrayfire.com/licenses/BSD-3-Clause
 ********************************************************/

#include <af/array.h>
#include <af/data.h>
#include <af/seq.h>

#include "error.hpp"

#include <cmath>

namespace af {
int end = -1;
seq span(af_span);

void seq::init(double begin, double end, double step) {
    this->s.begin = begin;
    this->s.end   = end;
    this->s.step  = step;
    if (step != 0) {  // Not Span
        size = std::fabs((end - begin) / step) + 1;
    } else {
        size = 0;
    }
}

#ifndef signbit
// wtf windows?!
inline int signbit(double x) {
    if (x < 0) { return -1; }
    return 0;
}
#endif

seq::~seq() = default;

seq::seq(double length) : s{}, size{}, m_gfor(false) {
    if (length < 0) {
        init(0, length, 1);
    } else {
        init(0, length - 1, 1);
    }
}

seq::seq(const af_seq& s_) : s{}, size{}, m_gfor(false) {
    init(s_.begin, s_.end, s_.step);
}

seq& seq::operator=(const af_seq& s_) {
    init(s_.begin, s_.end, s_.step);
    return *this;
}

seq::seq(double begin, double end, double step) : s{}, size{}, m_gfor(false) {
    if (step == 0) {
        if (begin != end) {  // Span
            AF_THROW_ERR("Invalid step size", AF_ERR_ARG);
        }
    }
    if ((signbit(end) == signbit(begin)) &&
        (signbit(end - begin) != signbit(step))) {
        AF_THROW_ERR("Sequence is invalid", AF_ERR_ARG);
    }
    init(begin, end, step);
}

seq::seq(seq other,  // NOLINT(performance-unnecessary-value-param)
         bool is_gfor)
    : s(other.s), size(other.size), m_gfor(is_gfor) {}

seq::operator array() const {
    double diff = s.end - s.begin;
    dim_t len   = static_cast<int>(
        (diff + std::fabs(s.step) * (signbit(diff) == 0 ? 1 : -1)) / s.step);

    array tmp = (m_gfor) ? range(1, 1, 1, len, 3) : range(len);

    array res = s.begin + s.step * tmp;
    return res;
}
}  // namespace af