#include "toonz/columnfan.h"

// TnzCore includes

#include "tstream.h"

// STD includss

#include <assert.h></assert.h>

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

const int colWidth = 74;

const int colSkip = 9;

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

// ColumnFan

ColumnFan::ColumnFan()

	: m_firstFreePos(0)

{

}

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

void ColumnFan::update()

{

	int lastPos = -colWidth;

	bool lastActive = true;

	int m = m_columns.size();

	int i;

	for (i = 0; i < m; i++) {

		bool active = m_columns[i].m_active;

		if (lastActive)

			lastPos += colWidth;

		else if (active)

			lastPos += colSkip;

		m_columns[i].m_pos = lastPos;

		lastActive = active;

	}

	m_firstFreePos = lastPos + (lastActive ? colWidth : colSkip);

	m_table.clear();

	for (i = 0; i < m; i++)

		if (m_columns[i].m_active)

			m_table[m_columns[i].m_pos + colWidth - 1] = i;

		else if (i + 1 < m && m_columns[i + 1].m_active)

			m_table[m_columns[i + 1].m_pos - 1] = i;

		else if (i + 1 == m)

			m_table[m_firstFreePos - 1] = i;

}

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

int ColumnFan::xToCol(int x) const

{

	if (x < m_firstFreePos) {

		std::map<int, int="">::const_iterator it = m_table.lower_bound(x);</int,>

		if (it == m_table.end())

			return -3;

		assert(it != m_table.end());

		return it->second;

	} else

		return m_columns.size() + (x - m_firstFreePos) / colWidth;

}

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

int ColumnFan::colToX(int col) const

{

	int m = m_columns.size();

	if (col >= 0 && col < m)

		return m_columns[col].m_pos;

	else

		return m_firstFreePos + (col - m) * colWidth;

}

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

void ColumnFan::activate(int col)

{

	int m = m_columns.size();

	if (col < m) {

		m_columns[col].m_active = true;

		int i;

		for (i = m - 1; i >= 0 && m_columns[i].m_active; i--) {

		}

		i++;

		if (i < m) {

			m = i;

			m_columns.erase(

				m_columns.begin() + i,

				m_columns.end());

		}

	}

	update();

}

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

void ColumnFan::deactivate(int col)

{

	while ((int)m_columns.size() <= col)

		m_columns.push_back(Column());

	m_columns[col].m_active = false;

	update();

}

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

bool ColumnFan::isActive(int col) const

{

	return 0 <= col && col < (int)m_columns.size() ? m_columns[col].m_active : true;

}

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

bool ColumnFan::isEmpty() const

{

	return m_columns.empty();

}

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

void ColumnFan::saveData(TOStream &os)

{

	int index, n = (int)m_columns.size();

	for (index = 0; index < n;) {

		while (index < n && m_columns[index].m_active)

			index++;

		if (index < n) {

			int firstIndex = index;

			os << index;

			index++;

			while (index < n && !m_columns[index].m_active)

				index++;

			os << index - firstIndex;

		}

	}

}

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

void ColumnFan::loadData(TIStream &is)

{

	m_columns.clear();

	m_table.clear();

	m_firstFreePos = 0;

	while (!is.eos()) {

		int index = 0, count = 0;

		is >> index >> count;

		int j;

		for (j = 0; j < count; j++)

			deactivate(index + j);

	}

}