#pragma once

#ifndef TCG_FACE_H

#define TCG_FACE_H

// STD includes

#include "assert.h"

namespace tcg

{

template <typename f=""></typename>

struct face_traits {

	typedef typename F::edges_const_iterator edges_const_iterator;

	typedef typename F::edges_iterator edges_iterator;

};

//-------------------------------------------------------------------------------

class Face

{

protected:

	int m_index;

	tcg::list<int> m_edges;</int>

public:

	typedef tcg::list<int>::const_iterator edges_const_iterator;</int>

	typedef tcg::list<int>::iterator edges_iterator;</int>

public:

	Face() : m_index(-1) {}

	~Face() {}

	void setIndex(int idx) { m_index = idx; }

	int getIndex() const { return m_index; }

	int edge(int e) const { return m_edges[e]; }

	int &edge(int e) { return m_edges[e]; }

	int edgesCount() const { return (int)m_edges.size(); }

	void addEdge(int idx) { m_edges.push_back(idx); }

	edges_iterator eraseEdge(const edges_iterator &it) { return m_edges.erase(it); }

	edges_const_iterator edgesBegin() const { return m_edges.begin(); }

	edges_const_iterator edgesEnd() const { return m_edges.end(); }

	edges_iterator edgesBegin() { return m_edges.begin(); }

	edges_iterator edgesEnd() { return m_edges.end(); }

};

//-------------------------------------------------------------------------------

template <int n=""></int>

class FaceN

{

public:

	typedef const int *edges_const_iterator;

	typedef int *edges_iterator;

protected:

	int m_e[N], m_count;

	int m_index;

public:

	FaceN() : m_index(-1), m_count(0)

	{

		std::fill(m_e, m_e + N, -1);

	}

	FaceN(int(&edges)[N]) : m_index(-1), m_count(0)

	{

		std::copy(edges, edges + N, m_e), m_count = N;

	}

	~FaceN() {}

	void setIndex(int idx) { m_index = idx; }

	int getIndex() const { return m_index; }

	int edge(int e) const

	{

		assert(e < m_count);

		return m_e[e];

	}

	int &edge(int e)

	{

		assert(e < m_count);

		return m_e[e];

	}

	int edgesCount() const { return m_count; }

	void addEdge(int idx)

	{

		assert(m_count < N);

		m_e[m_count++] = idx;

	}

	void setEdge(int e, int idx)

	{

		assert(e < m_count);

		m_e[e] = idx;

	}

	edges_iterator eraseEdge(const edges_iterator &it)

	{

		std::copy(it + 1, edgesEnd(), it);

		m_e[--m_count] = -1;

		return it;

	}

	edges_const_iterator edgesBegin() const { return m_e; }

	edges_const_iterator edgesEnd() const { return m_e + m_count; }

	edges_iterator edgesBegin() { return m_e; }

	edges_iterator edgesEnd() { return m_e + m_count; }

};

} // namespace tcg

#endif // TCG_FACE_H