#pragma once
 
#ifndef TCG_VERTEX_H
#define TCG_VERTEX_H
 
// tcg includes
#include "list.h"
#include "point.h"
 
namespace tcg {
 
template <typename V>
struct vertex_traits {
  typedef typename V::point_type point_type;
 
  typedef typename V::edges_const_iterator edges_const_iterator;
  typedef typename V::edges_iterator edges_iterator;
};
 
//----------------------------------------------------------------------
 
template <typename Point>
class Vertex {
protected:
  Point m_p;
  int m_index;
  tcg::list<int> m_edgeList;
 
public:
  typedef Point point_type;
 
  typedef tcg::list<int>::const_iterator edges_const_iterator;
  typedef tcg::list<int>::iterator edges_iterator;
 
public:
  Vertex() : m_index(-1) {}
  Vertex(const point_type &p) : m_p(p), m_index(-1) {}
  ~Vertex() {}
 
  void setIndex(int idx) { m_index = idx; }
  int getIndex() const { return m_index; }
 
  const tcg::list<int> &edges() const { return m_edgeList; }
  tcg::list<int> &edges() { return m_edgeList; }
 
  int edgesCount() const { return int(m_edgeList.size()); }
  int edge(int e) const { return int(m_edgeList[e]); }
 
  void addEdge(int e) { m_edgeList.push_back(e); }
  edges_iterator eraseEdge(edges_iterator it) { return m_edgeList.erase(it); }
 
  edges_const_iterator edgesBegin() const { return m_edgeList.begin(); }
  edges_const_iterator edgesEnd() const { return m_edgeList.end(); }
  edges_iterator edgesBegin() { return m_edgeList.begin(); }
  edges_iterator edgesEnd() { return m_edgeList.end(); }
 
  void setP(const point_type &p) { m_p = p; }
  const point_type &P() const { return m_p; }
  point_type &P() { return m_p; }
 
  bool operator==(const Vertex &v) const { return (m_p == v.m_p); }
  bool operator!=(const Vertex &v) const { return (m_p != v.m_p); }
};
 
//----------------------------------------------------------------------
 
template <typename P>
struct point_traits<Vertex<P>> {
  typedef Vertex<P> point_type;
  typedef typename point_traits<P>::value_type value_type;
  typedef typename point_traits<P>::float_type float_type;
 
  static inline value_type x(const point_type &p) { return p.P().x; }
  static inline value_type y(const point_type &p) { return p.P().y; }
};
 
}  // namespace tcg
 
#endif  // TCG_VERTEX_H