// (c) Copyright 2010 Terry Golubiewski, all rights reserved.

#ifndef CARTESIAN_POINT_H
#define CARTESIAN_POINT_H
#pragma once

#include <cartesian/vector.h>

namespace cartesian {

template<int Dim, class Rep = double, class Ref = void>
class point {
public:
  typedef Ref ref;
  static const int dim = Dim;
  typedef Rep rep;
  typedef vector<Dim, Rep> vector_type;

private:
  vector_type v_;

public:
  point(uninitialized_t) { }

  point() : v_() { }

  point(const point& p) : v_(p.v_) { }
  point& operator=(const point& p) { v_ = p.v_; return *this; }

  explicit point(const vector_type& v) : v_(v) { }

  template<class U>
  explicit point(const vector<Dim, U>& v)
    { v_ = v; }

  const vector_type& from_origin() const { return v_; }

  template<class U>
  point(const point<Dim, U, Ref>& p) : v_(p.from_origin()) { }

  template<class U>
  point& operator=(const point<dim, U, Ref>& p)
    { v_ = p.from_origin(); return *this; }

  template<class InIter>
  point(InIter first_, InIter last_) : v_(first_, last_) { }

  template<int N> const rep& get() const { return v_.get<N>(); }
  template<int N>       rep& get()       { return v_.get<N>(); }

  template<int N> void set(rep v) { v_.set<N>(v); }
  
        rep& operator[](int i)       { return v_[i]; }
  const rep& operator[](int i) const { return v_[i]; }

  template<class U>
  point& operator+=(const vector<Dim, U>& v) { v_ += v; return *this; }

  template<class U>
  point& operator-=(const vector<Dim, U>& v) { v_ -= v; return *this; }

}; // point

template<int Dim, class T1, class T2, class Ref> inline
bool operator==(const point<Dim, T1, Ref>& lhs, const point<Dim, T2, Ref>& rhs)
  { return (lhs.from_origin() == rhs.from_origin()); }

template<int Dim, class T1, class T2, class Ref> inline
bool operator!=(const point<Dim, T1, Ref>& lhs, const point<Dim, T2, Ref>& rhs)
  { return !(lhs == rhs); }

template<int Dim, class T1, class T2, class Ref> inline
vector<Dim, typename std0x::common_type<T1, T2>::type>
operator-(const point<Dim, T1, Ref>& lhs, const point<Dim, T2, Ref>& rhs)
  { return lhs.from_origin() - rhs.from_origin(); }

template<int Dim, class T1, class T2, class Ref> inline
point<Dim, typename std0x::common_type<T1, T2>::type, Ref>
operator+(const point<Dim, T1, Ref>& lhs, const vector<Dim, T2>& rhs) {
 point<Dim, typename std0x::common_type<T1, T2>::type, Ref> rval(lhs);
 return rval += rhs;
}

template<int Dim, class T1, class T2, class Ref> inline
point<Dim, typename std0x::common_type<T1, T2>::type, Ref>
operator+(const vector<Dim, T1>& lhs, const point<Dim, T2, Ref>& rhs)
  { return rhs + lhs; }

class point2d: public point<2, double, void> {
public:
  point2d(double x_, double y_)
    : point<2, double, void>(make_vector(x_, y_)) { }

  template<class U>
  point2d(point<2, U, void> p) : point<2, double, void>(p) { }

  double& x() { return get<0>(); }
  double& y() { return get<1>(); }

  const double& x() const { return get<0>(); }
  const double& y() const { return get<1>(); }
}; // point2d

class point3d: public point<3, double, void> {
public:
  point3d(double x_, double y_, double z_=0)
    : point<3, double, void>(make_vector(x_, y_, z_)) { }

  template<class U>
  point3d(point<3, U, void> p) : point<3, double, void>(p) { }

  double& x() { return get<0>(); }
  double& y() { return get<1>(); }
  double& z() { return get<2>(); }

  const double& x() const { return get<0>(); }
  const double& y() const { return get<1>(); }
  const double& z() const { return get<2>(); }
}; // point3d

} // cartesian

#endif