#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