#ifndef MY_VECTOR_H
#define MY_VECTOR_H
#pragma once

#include <boost/geometry/geometry.hpp>
#include <boost/geometry/arithmetic/cross_product.hpp>
#include <boost/geometry/strategies/distance.hpp>

#include <boost/units/quantity.hpp>

#include <cstddef>

template<class Unit>
class Vector {

public:
  typedef ::boost::units::quantity<Unit> value_type;

  typedef ::boost::geometry::point<
      value_type, 3, ::boost::geometry::cs::cartesian> Point;

private:
  Point _impl;

public:
  Vector() : _impl(value_type()) { }

  Vector(value_type dx, value_type dy)
    : _impl(dx, dy) { }

  Vector(value_type dx, value_type dy, value_type dz)
    : _impl(dx, dy, dz) { }

  Vector(const Point& from_, const Point& to_)
    : _impl(to_)
    { ::boost::geometry::subtract_point(_impl, from_); }

  template<int N>
  value_type get() const { return _impl.get<N>(); }

  value_type x() const { return get<0>(); }
  value_type y() const { return get<1>(); }
  value_type z() const { return get<2>(); }

  Vector& operator+=(const Vector& rhs) {
    ::boost::geometry::add_point(_impl, rhs._impl);
    return *this;
  }

  Vector& operator-=(const Vector& rhs) {
    ::boost::geometry::subtract_point(_impl, rhs._impl);
    return *this;
  }

  Vector& operator*=(value_type x) {
    ::boost::geometry::multiply_value(_impl, x);
    return *this;
  }

  Vector& operator/=(value_type x) {
    ::boost::geometry::divide_value(_impl, x);
    return *this;
  }

  friend Vector operator+(Vector lhs, const Vector& rhs)
    { return lhs += rhs; }

  friend Vector operator-(Vector lhs, const Vector& rhs)
    { return lhs -= rhs; }

  friend value_type operator*(const Vector& lhs, const Vector& rhs)
    { return ::boost::geometry::dot_product(lhs._impl, rhs._impl); }

  friend Vector operator*(Vector lhs, value_type rhs)
    { return lhs *= rhs; }

  friend Vector operator/(Vector lhs, value_type rhs)
    { return lhs /= rhs; }

  friend Vector cross_product(const Vector& lhs, const Vector& rhs)
    { return Vector(::boost::geometry::cross_product(lhs._impl, rhs._impl)); }

  friend Point operator+(Point lhs, const Vector& rhs) {
    ::boost::geometry::add_point(lhs, rhs._impl);
    return lhs;
  }

  friend Point operator+(const Vector& lhs, Point rhs)
    { return rhs + lhs; }

  friend Vector operator-(const Point& lhs, const Point& rhs)
    { return Vector(rhs, lhs); }

  friend bool operator==(const Vector& lhs, const Vector& rhs)
    { return ::boost::geometry::equals(lhs._impl, rhs._impl); }

  friend bool operator!=(const Vector& lhs, const Vector& rhs)
    { return !(lhs == rhs); }

  friend
  ::boost::geometry::cartesian_distance<value_type>
  abs(const Vector& v) {
    return ::boost::geometry::distance(v._impl, Point(value_type()));
  }

}; // Vector

#endif