#include <iostream>
#include <vector>
#include <stdexcept>
#include <initializer_list>
using namespace std;

class Vektor
{
public:
    Vektor(size_t size = 1, double init = {})
        : values(size, init) 
    {
        if ( size == 0 )
            throw runtime_error{"Size can't be 0!"};
    }
    Vektor(initializer_list<double> vals)
        : values{vals} {}

    Vektor(Vektor const &) = default;

    double & operator[](size_t index)
    {
        return values.at(index);
    }
    double operator[](size_t index) const
    {
        return values.at(index);
    }

    size_t size() const
    {
        return values.size();
    }

    Vektor operator+(double val) const
    {
        Vektor res{*this};
        for ( auto & value: res.values )
            value += val;
        return res;
    }
    
    Vektor operator+(Vektor const & rhs) const
    {
        if ( size() != rhs.size() )
            throw runtime_error{"Different sizes!"};
        Vektor res {*this};
        for ( size_t idx {}; idx < size(); ++idx )
        {
            res[idx] += rhs[idx];
        }
        return res;
    }

    friend ostream & operator<<(ostream & os, Vektor const & v)
    {
        bool first {true};
        for ( auto val: v.values )
        {
            if (!first)
                os << ", ";
            os << val;
            first = false;
        }
        return os;
    }

private:
    vector<double> values;
};

Vektor operator+(double val, Vektor const & v)
{
    return v+val;
}

#define CATCH_CONFIG_MAIN
#include "catch.hpp"

TEST_CASE("Initiering och storlek")
{
    SECTION("Empty")
    {
        CHECK_THROWS(Vektor(0));
    }
    SECTION("One element")
    {
        Vektor v;
        CHECK(v.size() == 1);
    }
    SECTION("N elements")
    {
        Vektor v(2);
        CHECK(v.size() == 2);
    }
    SECTION("initializer_list")
    {
        Vektor v{2,3,4,5,4.4};
        CHECK(v.size() == 5);
    }
}
TEST_CASE("Indexering")
{
    Vektor v{2,3,4.2};
    REQUIRE(v[0] == Approx(2.0));
    vector<double> vals {2,3,4.2};
    for ( size_t index{}; index < v.size(); ++index )
    {
        CHECK(v[index] == Approx(vals[index]));
    }
}

TEST_CASE("Addition")
{
    Vektor v{2.3, 4, 5.5};
    SECTION( "Vektor + skalär" )
    {
        Vektor v2{ v+2 };
        CHECK(v2[0] == Approx(4.3));
        CHECK(v2[2] == Approx(7.5));
    }
    SECTION( "skalär + Vektor" )
    {
        Vektor v2{ 2+v };
        CHECK(v2[0] == Approx(4.3));
        CHECK(v2[2] == Approx(7.5));
    }
    SECTION( "Vektor + Vektor")
    {
        Vektor v2 {4, 2.3, 6};
        Vektor summa { v + v2 };
        CHECK(summa[0] == Approx(6.3));
        CHECK(summa[1] == Approx(6.3));
        CHECK(summa[2] == Approx(11.5));
    }
    SECTION( "Vektor + Vektor (fel storlek)" )
    {
        Vektor v2 {2,3,5,6,8};
        CHECK_THROWS( v + v2 );
    }
}