#pragma once

#include <stddef.h>
#include <sstream>
#include <iostream>
#include <iterator>

template <size_t S, typename T = float>
struct Vector {
public:
    Vector(): elements{} {};

    template<typename ...Args>
    Vector<S, T>(Args... args) : elements{ args... } {};

    Vector<S, T>(T values[S]) {
        std::copy(values, values + S, elements);
    };

    T& operator[](size_t index) {
        return elements[index];
    }

    Vector<S, T> operator*(T scalar) const {
        Vector<S, T> result;
        for (size_t index; index < S; index++) {
            result = this[index] * scalar;
        }
        return result;
    }

    T operator*(Vector<S, T> other) const {
        T result = 0;
        for (size_t index = 0; index < S; index++) {
            result += this->elements[index] * other[index];
        }
        return result;
    }

    T x() {
        static_assert(S > 0);
        return elements[0];
    }

    T y() {
        static_assert(S > 1);
        return elements[1];
    }

    T z() {
        static_assert(S > 2);
        return elements[2];
    }

    T w() {
        static_assert(S > 3);
        return elements[3];
    }

    std::string string() {
        std::stringstream str{};

        str << "[ ";
        for (int i = 0; i < S; i++) {
            str << elements[i] << " ";
        }
        str << "]";

        return str.str();
    }

    T elements[S];
};