#pragma once

#include "data.hpp"
#include "schema_math.hpp"
#include "iterator.hpp"

#include <cmath>

namespace saw {
/*
template<typename T>
class data<schema::Quaternion<T>,encode::Native> {
public:
	using Schema = schema::Quaternion<T>;
private:
	data<schema::FixedArray<T,4u>,encode::Native> vals_;

	using NativeType = typename native_data_type<T>::type;
public:
	data() = default;

	data(data<T,encode::Native> i__, data<T,encode::Native> j__, data<T,encode::Native> k__, data<T,encode::Native> w__):
		vals_{i__,j__,k__,w__}
	{}

	constexpr void normalize() {
		data<T,encode::Native> norm{};

		for(data<schema::UInt64,encode::Native> i = 0u; i < vals_.size(); ++i){
			norm += vals_.at(i) * vals_.at(i);
		}

		norm.set(std::sqrt(norm.get()));

		for(data<schema::UInt64,encode::Native> i = 0u; i < vals_.size(); ++i){
			vals_.at(i) = vals_.at(i) / norm;
		}
	}

	constexpr data<T,encode::Native>& at(data<schema::UInt64,encode::Native> i){
		return vals_.at(i);
	}

	constexpr const data<T,encode::Native>& at(data<schema::UInt64,encode::Native> i) const {
		return vals_.at(i);
	}

	constexpr data<Schema, encode::Native> operator*(const data<schema::Quaternion,encode::Native>& rhs) const {
		data<Schema,encode::Native> mult;

		data<schema::UInt64,encode::Native> i_i{0u};
		data<schema::UInt64,encode::Native> j_i{1u};
		data<schema::UInt64,encode::Native> k_i{2u};
		data<schema::UInt64,encode::Native> w_i{3u};

		mult.at(i_i) = at(w_i) * rhs.at(i_i) + at(i_i) * rhs.at(w_i) + at(j_i) * rhs.at(k_i) - at(k_i) * rhs.at(j_i);
		
		mult.at(j_i) = at(w_i) * rhs.at(j_i) + at(j_i) * rhs.at(w_i) - at(i_i) * rhs.at(k_i) + at(k_i) * rhs.at(i_i);
		
		mult.at(k_i) = at(w_i) * rhs.at(k_i) + at(k_i) * rhs.at(w_i) + at(i_i) * rhs.at(j_i) - at(j_i) * rhs.at(i_i);

		mult.at(w_i) = at(w_i) * rhs.at(w_i) - at(i_i) * rhs.at(i_i) - at(j_i) * rhs.at(j_i) - at(k_i) * rhs.at(k_i);

		return mult;
	}
};
*/

template<typename Inner, uint64_t... Dims>
class data<schema::Tensor<Inner, Dims...>, encode::Native> {
public:
	using Schema = schema::Tensor<Inner, Dims...>;
private:
	data<schema::Array<Inner,Schema::Rank>, encode::Native> values_;

public:
	data():
		values_{data<schema::FixedArray<schema::UInt64,sizeof...(Dims)>>{{data<schema::UInt64, encode::Native>{Dims}...}}}
	{}

	data<Inner, encode::Native>& at(const data<schema::FixedArray<schema::UInt64, sizeof...(Dims)>, encode::Native>& index){
		return values_.at(index);
	}

	const data<Inner, encode::Native>& at(const data<schema::FixedArray<schema::UInt64, sizeof...(Dims)>, encode::Native>& index) const {
		return values_.at(index);
	}

	data<Inner, encode::Native>& operator()(const data<schema::FixedArray<schema::UInt64, sizeof...(Dims)>, encode::Native>& index){
		return values_.at(index);
	}

	const data<Inner, encode::Native>& operator()(const data<schema::FixedArray<schema::UInt64, sizeof...(Dims)>, encode::Native>& index) const {
		return values_.at(index);
	}

	data<schema::Tensor<Inner, Dims...>, encode::Native> operator+(const data<schema::Tensor<Inner, Dims...>, encode::Native>& rhs) {
		data<schema::Tensor<Inner, Dims...>, encode::Native> c;

		rank_iterator<Dims...>::in_fixed_bounds([&](const data<schema::FixedArray<schema::UInt64, sizeof...(Dims)>, encode::Native>& index) -> error_or<void>{
			c.at(index) = at(index) + rhs.at(index);
			return make_void();
		});

		return c;
	}
};

}