#pragma once

#ifndef TCOLUMNSET_INCLUDED

#define TCOLUMNSET_INCLUDED

#include "tsmartpointer.h"

#undef DVAPI

#undef DVVAR

#ifdef TXSHEET_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//=============================================================================

class DVAPI TColumnHeader : public TSmartObject

{

	DECLARE_CLASS_CODE

	int m_index; //!< The header's index in a columns set

	int m_pos;   //!< The header's screen X pos in a columns viewer

	int m_width; //!< The header's width in a columns viewer

	bool m_inColumnsSet; //!< (TO BE REMOVED ASAP) Whether the header

						 //!< belongs to a columns set. Should be

						 //!< redirected to a negative m_index.

public:

	TColumnHeader();

	virtual ~TColumnHeader() {}

	int getIndex() const { return m_index; }

	int getPos() const { return m_pos; }

	int getX0() const { return m_pos; }

	int getX1() const { return m_pos + m_width - 1; }

	void getCoords(int &x0, int &x1) const

	{

		x0 = m_pos;

		x1 = m_pos + m_width - 1;

	}

	int getWidth() const { return m_width; }

	bool inColumnsSet() const { return m_inColumnsSet; }

private:

	template <class t=""></class>

	friend class TColumnSetT;

};

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

#ifdef _WIN32

template class DVAPI TSmartPointerT<tcolumnheader>;</tcolumnheader>

#endif

typedef TSmartPointerT<tcolumnheader> TColumnHeaderP;</tcolumnheader>

//=============================================================================

template <class t=""></class>

class TColumnSetT

{

	typedef TSmartPointerT<t> ColumnP;</t>

	std::vector<columnp> m_columns;</columnp>

	int m_defaultWidth;

	static bool compareColumnPos(const int pos, const ColumnP &ch2)

	{

		return pos <= ch2->getX1();

	}

public:

	TColumnSetT(int defaultWidth = 100) : m_defaultWidth(defaultWidth) {}

	~TColumnSetT() {}

	int getColumnCount() const { return m_columns.size(); }

	void clear() { m_columns.clear(); }

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

	void col2pos(int index, int &x0, int &x1) const

	{

		assert(index >= 0);

		int columnCount = (int)m_columns.size();

		if (index < columnCount)

			m_columns[index]->getCoords(x0, x1);

		else {

			x0 = (columnCount > 0 ? m_columns.back()->getX1() + 1 : 0) + (index - columnCount) * m_defaultWidth;

			x1 = x0 + m_defaultWidth - 1;

		}

	}

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

	//versione con upper_bound

	int pos2col(int pos) const

	{

		// n.b. endPos e' la coordinata del primo pixel non occupato da colonne

		int endPos = m_columns.empty() ? 0 : m_columns.back()->getX1() + 1;

		if (pos >= endPos)

			return m_columns.size() + (pos - endPos) / m_defaultWidth;

		typename std::vector<columnp>::const_iterator loc;</columnp>

		loc = std::upper_bound(m_columns.begin(), m_columns.end(), pos, compareColumnPos);

		return std::distance(m_columns.begin(), loc);

	}

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

	const ColumnP &getColumn(int index) const

	{

		static const ColumnP empty;

		if (index >= 0 && index < (int)m_columns.size())

			return m_columns[index];

		return empty;

	}

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

	const ColumnP &touchColumn(int index, int type = 0)

	{

		assert(index >= 0);

		const int count = m_columns.size();

		if (index < count)

			return m_columns[index];

		for (int i = count; i <= index; ++i) {

			int cType = (i != index) ? 0 : type;

			ColumnP col = T::createEmpty(cType);

			m_columns.push_back(col);

		}

		update(count);

		assert(index == (int)m_columns.size() - 1);

		return m_columns[index];

	}

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

	const ColumnP &insertColumn(int index, const ColumnP &column)

	{

		//assert(column && column->m_index < 0);

		assert(column && !column->m_inColumnsSet);

		if (index > 0)

			touchColumn(index - 1);

		m_columns.insert(m_columns.begin() + index, column);

		update(index);

		return column;

	}

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

	const ColumnP removeColumn(int index)

	{

		assert(index >= 0);

		int columnCount = m_columns.size();

		if (index >= columnCount) // Shouldn't be asserted instead ?

			return ColumnP();

		ColumnP column = m_columns[index];

		//column->m_index = -1;                           // We should enforce this. Unfortunately, must be tested extensively.

		column->m_inColumnsSet = false;

		m_columns.erase(m_columns.begin() + index);

		update(index);

		return column;

	}

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

	void rollLeft(int index, int count)

	{

		assert(index >= 0);

		assert(count > 1);

		int columnCount = m_columns.size();

		if (index + count > columnCount)

			count = columnCount - index;

		if (count < 2)

			return;

		assert(0 <= index && index + count - 1 < columnCount);

		assert(count > 0);

		int i = index, j = index + count - 1;

		ColumnP tmp = m_columns[i];

		for (int k = i; k < j; ++k)

			m_columns[k] = m_columns[k + 1];

		m_columns[j] = tmp;

		update(0);

	}

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

	void rollRight(int index, int count)

	{

		assert(index >= 0);

		assert(count > 1);

		int columnCount = m_columns.size();

		if (index + count > columnCount)

			count = columnCount - index;

		if (count < 2)

			return;

		assert(0 <= index && index + count - 1 < columnCount);

		assert(count > 0);

		int i = index, j = index + count - 1;

		ColumnP tmp = m_columns[j];

		for (int k = j; k > i; --k)

			m_columns[k] = m_columns[k - 1];

		m_columns[i] = tmp;

		update(0);

	}

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

	void update(int fromIdx)

	{

		int pos = 0, index = 0;

		if (fromIdx > 0) {

			assert(fromIdx <= (int)m_columns.size());

			const ColumnP &left = m_columns[fromIdx - 1];

			pos = left->getX1() + 1;

			index = left->m_index + 1;

		}

		int c, cCount = m_columns.size();

		for (c = fromIdx; c != cCount; ++c) {

			const ColumnP &col = m_columns[c];

			col->m_pos = pos;

			col->m_index = index++;

			pos += col->m_width;

			col->m_inColumnsSet = true;

		}

	}

private:

	// Not copyable

	TColumnSetT(const TColumnSetT &);

	TColumnSetT &operator=(const TColumnSetT &);

};

#endif // TCOLUMNSET_INCLUDED