#ifndef RTTL_VEC_H
#define RTTL_VEC_H

#include "RTInclude.hxx"

#include <fstream>
using namespace std;

/// Explicit conversions from int/floats ...
template<typename DataType> _INLINE DataType convert(int n)   { return DataType(n); }
template<typename DataType> _INLINE DataType convert(float n) { return DataType(n); }
/// ...and their specializations for SSE values.
template<> _INLINE sse_f convert<sse_f> (int n)   { return _mm_set_ps1((float)n); }
template<> _INLINE sse_f convert<sse_f> (float n) { return _mm_set_ps1(n); }
template<> _INLINE sse_i convert<sse_i>(int n)    { return _mm_set1_epi32(n); }
template<> _INLINE sse_i convert<sse_i>(float n)  { return _mm_set1_epi32((int)n); }

// Don't need templates for these conversions (overloaded function is deduced from arguments).
_INLINE sse_f convert(float n) { return _mm_set_ps1(n); }
_INLINE sse_i convert(int n)   { return _mm_set1_epi32(n); }
_INLINE sse_f convert(float n0, float n1, float n2, float n3) { return _mm_set_ps(n0,n1,n2,n3); }
_INLINE sse_i convert(int n0,   int n1,   int n2,   int n3)   { return _mm_set_epi32(n0,n1,n2,n3); }

/// SSE ops (outside rttl).
#include "RTSSE.hxx"

/// Define ops for arrays of basic data types.
#include "RTData.hxx"

namespace RTTL {
    /// Template arguments:
    /// N         - vector size
    /// DataType  - basic data type
    /// align     - alignment (0 for none, 16 for SSE, other values could also be defined).

    /// Generic vector for sizes 1, 5, 6, etc.
    template<int N, typename DataType, int align = 0> class RTVec_t
    #include "RTVecBody.h"

    /// Specialized vectors of size 2.
    #define N 2
    template<typename DataType, int align> class RTVec_t<N, DataType, align>
    #include "RTVecBody.h"

    /// Specialized vectors of size 3. Among other things,
    /// have support for cross product.
    #define N 3
    template<typename DataType, int align> class RTVec_t<N, DataType, align>
    #include "RTVecBody.h"

    /// Specialized vectors of size 4.
    #define N 4
    template<typename DataType, int align> class RTVec_t<N, DataType, align>
    #include "RTVecBody.h"

    /// Generic numerics and their SSE specializations.
    template<typename DataType>
    _INLINE DataType nan()  { return numeric_limits<DataType>::quiet_NaN(); }
    template<typename DataType>
    _INLINE DataType epsilon()  { return numeric_limits<DataType>::epsilon(); }
    template<typename DataType>
    _INLINE DataType minValue() { return numeric_limits<DataType>::min(); }
    template<typename DataType>
    _INLINE DataType maxValue() { return numeric_limits<DataType>::max(); }
    template<typename DataType>
    _INLINE DataType infinity() { return numeric_limits<DataType>::infinity(); }
    template<>
    _INLINE sse_f  nan<sse_f>()       { return _mm_set_ps1(numeric_limits<float>::quiet_NaN()); }
    template<>
    _INLINE sse_f  epsilon<sse_f>()   { return _mm_set_ps1(FLT_EPSILON); }
    template<>
    _INLINE sse_f  minValue<sse_f>()  { return _mm_set_ps1(FLT_MIN); }
    template<>
    _INLINE sse_f  maxValue<sse_f>()  { return _mm_set_ps1(FLT_MAX); }
    template<>
    _INLINE sse_f  infinity<sse_f>()  { return _mm_set_ps1(numeric_limits<float>::infinity()); }
    template<>
    _INLINE sse_i epsilon<sse_i>()    { return _mm_set1_epi32(0); }
    template<>                        
    _INLINE sse_i minValue<sse_i>()   { return _mm_set1_epi32(INT_MIN); }
    template<>                        
    _INLINE sse_i maxValue<sse_i>()   { return _mm_set1_epi32(INT_MAX); }
    template<>                        
    _INLINE sse_i infinity<sse_i>()   { return _mm_set1_epi32(numeric_limits<int>::infinity()); }

    /// Two-operand operators. All operations are performed through DataArray class.
    /// Comparison ops are overloaded wrt constantness (with the same semantic).
    template<int N, typename DataType, int align>
    _INLINE bool operator==(const RTVec_t<N, DataType, align>& v1, const RTVec_t<N, DataType, align>& v2) {
        return v1.array() == v2.array();
    }
    template<int N, typename DataType, int align>
    _INLINE bool operator==(const RTVec_t<N, DataType, align>& v1, const DataType v2[]) {
        return v1.array() == v2;
    }
    template<int N, typename DataType, int align>
    _INLINE bool operator==(const DataType v1[], const RTVec_t<N, DataType, align>& v2) {
        return v1 == v2.array();
    }
    template<int N, typename DataType, int align>
    _INLINE bool operator==(const RTVec_t<N, DataType, align>& v1, DataType v2[]) {
        return v1.array() == v2;
    }
    template<int N, typename DataType, int align>
    _INLINE bool operator==(DataType v1[], const RTVec_t<N, DataType, align>& v2) {
        return v1 == v2.array();
    }

    template<int N, typename DataType, int align>
    _INLINE bool operator!=(const RTVec_t<N, DataType, align>& v1, const RTVec_t<N, DataType, align>& v2) {
        return !(v1 == v2);
    }
    template<int N, typename DataType, int align>
    _INLINE bool operator!=(const RTVec_t<N, DataType, align>& v1, const DataType v2[]) {
        return !(v1 == v2);
    }
    template<int N, typename DataType, int align>
    _INLINE bool operator!=(const DataType v1[], const RTVec_t<N, DataType, align>& v2) {
        return !(v1 == v2);
    }
    template<int N, typename DataType, int align>
    _INLINE bool operator!=(const RTVec_t<N, DataType, align>& v1, DataType v2[]) {
        return !(v1 == v2);
    }
    template<int N, typename DataType, int align>
    _INLINE bool operator!=(DataType v1[], const RTVec_t<N, DataType, align>& v2) {
        return !(v1 == v2);
    }

    /// Arithmetic +.
    template<int N, typename DataType, int align>
    _INLINE RTVec_t<N, DataType, align> operator+(const RTVec_t<N, DataType, align>& a, const RTVec_t<N, DataType, align>& b) {
        RTVec_t<N, DataType, align> result;
        (result.array()).add(a.array(), b.array());
        return result;
    }

    template<int N, typename DataType, int align>
    _INLINE RTVec_t<N, DataType, align> operator-(const RTVec_t<N, DataType, align>& a, const RTVec_t<N, DataType, align>& b) {
        RTVec_t<N, DataType, align> result;
        (result.array()).subtract(a.array(), b.array());
        return result;
    }

    template<int N, typename DataType, int align>
    _INLINE RTVec_t<N, DataType, align> operator*(const RTVec_t<N, DataType, align>& a, const RTVec_t<N, DataType, align>& b) {
        RTVec_t<N, DataType, align> result;
        (result.array()).multiply(a.array(), b.array());
        return result;
    }

    template<int N, typename DataType, int align>
    _INLINE RTVec_t<N, DataType, align> operator/(const RTVec_t<N, DataType, align>& a, const RTVec_t<N, DataType, align>& b) {
        RTVec_t<N, DataType, align> result;
        (result.array()).divide(a.array(), b.array());
        return result;
    }

    template<int N, typename DataType, int align>
    _INLINE DataType dot(const RTVec_t<N, DataType, align>& x, const RTVec_t<N, DataType, align>& y) {
        DataType v;
        for (int i = 0; i < N; i++)
            v += x[i] * y[i];
        return v;
    }

    /// Unary operator.
    template<int N, typename DataType, int align>
    _INLINE RTVec_t<N, DataType, align> operator-(const RTVec_t<N, DataType, align>& a) {
        RTVec_t<N, DataType, align> result;
        for (int i = 0; i < N; i++)
            result[i] = -a[i];
        return result;
    }

    /// Mixed operands.
    template<int N, typename DataType, int align>
    _INLINE bool operator==(const RTVec_t<N, DataType, align>& v1, const DataType& v2) {
        return v1.array() == v2;
    }

    template<int N, typename DataType, int align>
    _INLINE bool operator==(const DataType& v1, const RTVec_t<N, DataType, align>& v2) {
        return v1 == v2.array();
    }

    template<int N, typename DataType, int align>
    _INLINE bool operator!=(const RTVec_t<N, DataType, align>& v1, const DataType& v2) {
        return !(v1 == v2);
    }

    template<int N, typename DataType, int align>
    _INLINE bool operator!=(const DataType& v1, const RTVec_t<N, DataType, align>& v2) {
        return !(v1 == v2);
    }

    /// Ops with scalar operands.
    template<int N, typename DataType, int align, typename ScalarType>
    _INLINE RTVec_t<N, DataType, align> operator+(const RTVec_t<N, DataType, align>& a, const ScalarType& b) {
        RTVec_t<N, DataType, align> result;
        (result.array()).addScalar(a.array(), b);
        return result;
    }

    template<int N, typename DataType, int align, typename ScalarType>
    _INLINE RTVec_t<N, DataType, align> operator+(const ScalarType& b, const RTVec_t<N, DataType, align>& a) {
        RTVec_t<N, DataType, align> result;
        (result.array()).addScalar(b.array(), a);
        return result;
    }

    template<int N, typename DataType, int align, typename ScalarType>
    _INLINE RTVec_t<N, DataType, align> operator-(const RTVec_t<N, DataType, align>& a, const ScalarType& b) {
        RTVec_t<N, DataType, align> result;
        (result.array()).subtractScalar(a.array(), b);
        return result;
    }

    template<int N, typename DataType, int align, typename ScalarType>
    _INLINE RTVec_t<N, DataType, align> operator-(const ScalarType& b, const RTVec_t<N, DataType, align>& a) {
        RTVec_t<N, DataType, align> result;
        (result.array()).subtractScalar(b, a.array());
        return result;
    }

    template<int N, typename DataType, int align, typename ScalarType>
    _INLINE RTVec_t<N, DataType, align> operator*(const RTVec_t<N, DataType, align>& a, const ScalarType& b) {
        RTVec_t<N, DataType, align> result;
        (result.array()).multiplyScalar(a.array(), b);
        return result;
    }

    template<int N, typename DataType, int align, typename ScalarType>
    _INLINE RTVec_t<N, DataType, align> operator*(const ScalarType& b, const RTVec_t<N, DataType, align>& a) {
        RTVec_t<N, DataType, align> result;
        (result.array()).multiplyScalar(a.array(), b);
        return result;
    }

    template<int N, typename DataType, int align, typename ScalarType>
    _INLINE RTVec_t<N, DataType, align> operator/(const RTVec_t<N, DataType, align>& a, const ScalarType& b) {
        RTVec_t<N, DataType, align> result;
        (result.array()).divideScalar(a.array(), b);
        return result;
    }

    template<int N, typename DataType, int align, typename ScalarType>
    _INLINE RTVec_t<N, DataType, align> operator/(const ScalarType& b, const RTVec_t<N, DataType, align>& a) {
        RTVec_t<N, DataType, align> result;
        (result.array()).divideScalar(b, a.array());
        return result;
    }

    /// Streaming.
    template<int N, typename DataType, int align>
    _INLINE ostream& operator<<(ostream& out, const RTVec_t<N, DataType, align>& t) {
        out << "[" << t[0];
        for (int i = 1; i < N; i++)
            out << "," << t[i];
        out << "]";

        return out;
    }
};

namespace RTTL {

    typedef RTTL::RTVec_t<2, float> RTVec2f;
    typedef RTTL::RTVec_t<3, float> RTVec3f;
    typedef RTTL::RTVec_t<4, float> RTVec4f;
    typedef RTTL::RTVec_t<2, int  > RTVec2i;
    typedef RTTL::RTVec_t<3, int  > RTVec3i;
    typedef RTTL::RTVec_t<4, int  > RTVec4i;
    
    _INLINE int maxDim3(const sse_f t) {
        return ((RTVec3f*)&t)->maxIndex();
    }

    _INLINE sse_f vec3fToSSE(const RTVec3f &v, const float w = 0.0f) {
        return _mm_setr_ps(v.x,v.y,v.z,w);
    }

};

#endif