#include <iostream>
#include <array>
#include <vector>
#include <memory>
#include <list>
#include <math.h>
class OneVertexException:public std::exception{
public:
    const char * what(){
        return "Edge must have minimum 2 vertices!";
    }
};

template<typename T, std::size_t N>
class Point {
public:
    template<typename ... Ts>
    explicit Point(Ts... ts)
            : data_{ts...}
    {
    }

    T operator[](std::size_t index) const
    {
        return data_[index];
    }

private:
    std::array<T, N> data_;
};

template<typename T, std::size_t N>
class LamanLine {
    std::vector<Point<T, N>> vectorOfPoints_;
    std::list<std::pair<Point<T, N>, Point<T, N>>> edges_;

public:
    void addPoint(Point<T, N> & newPoint) {

        if(vectorOfPoints_.size()>=1) {
            std::pair<Point<T, N>, Point<T, N>> buf;
            buf.first = vectorOfPoints_.back();
            vectorOfPoints_.push_back(newPoint);
            buf.second = vectorOfPoints_.back();
            edges_.push_back(buf);
        } else {
            vectorOfPoints_.push_back(newPoint);
        }

    }
    double calculateLenght(){
        double result=0;
        if(vectorOfPoints_.size()<2) throw OneVertexException();
        for(auto &element: edges_) result += (double)distance(element.first, element.second);
        return result;
    }
};



template<typename T, std::size_t N>
std::ostream& operator<<(std::ostream& os, const Point<T,N>& point)
{
    os << "<";
    for(std::size_t i = 0; i < N-1; ++i)
    {
        os << point[i] << ", ";
    }
    os << point[N-1] << ">";

    return os;
}

// uzupelnic metode !!.
template<typename T, std::size_t N>
T distance(const Point<T,N>& lhs, const Point<T,N>& rhs)
{
    T sum =0;
    for(size_t i=0; i<N; i++){
        sum += (T)pow(lhs[i]-rhs[i], 2);
    }
    auto result = (T)sqrt(sum);
    return result;
}

// Zadanie
// Nalezy stworzyc szablon klasy reprezentujacy linie lamana w N wymiarowej przestrzeni.
// Nalezy zaimplementowac metode dodajaca kolejne punkty do lamanej.
// Nalezy zaimplementowac metode obliczajaca dlugosc lamanej i pokazac jej dzialanie.
// Nalezy obsluzyc jeden (dowolnego rodzaju) wyjatek i pokazac w programie dzialanie mechamizmu.
//
// kompilacja i uruchomienie
// clear; g++ -std=c++17 nDpoints.cc; ./a.out;

int main()
{
    std::cout << "PROE2020L gr 101 - sprawdzian \"szablony i wyjatki\"" << std::endl;
    auto p1 = Point<int, 2>(3,5);
    auto p2 = Point<int, 2>(6,3);
    auto p3 = Point<int, 2>(6,8);
    auto l2 = LamanLine<int, 2>();
    l2.addPoint(p1);
    //l2.addPoint(p2);
    //l2.addPoint(p3);
    std::cout << p1 << p2 << std::endl;
    try {
        std::cout<< l2.calculateLenght()<<std::endl;
    }
    catch (OneVertexException & exp) {
        std::cout<<exp.what()<<std::endl;
    }
    return 0;
}