// TnzBase includes

#include "tfx.h"

// TnzLib includes

#include "toonz/txshcolumn.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshsoundcolumn.h"

#include "toonz/txshpalettecolumn.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/txshsoundtextcolumn.h"

#include "toonz/txshmeshcolumn.h"

#include "toonz/txshcell.h"

#include "toonz/txsheet.h"

#include "toonz/fxdag.h"

#include "toonz/tcolumnfxset.h"

#include "toonz/preferences.h"

#include "toonz/txshleveltypes.h"

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

//TXshCellColumn

TXshCellColumn::TXshCellColumn()

	: m_first(0)

{

}

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

TXshCellColumn::~TXshCellColumn()

{

	m_cells.clear();

}

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

int TXshCellColumn::getRange(int &r0, int &r1) const

{

	int cellCount = m_cells.size();

	r0 = m_first;

	r1 = r0 + cellCount - 1;

	int i;

	for (i = 0; i < cellCount && m_cells[i].isEmpty(); i++) {

	}

	if (i >= cellCount) {

		r0 = 0;

		r1 = -1;

		return 0;

	}

	r0 = m_first + i;

	for (i = cellCount - 1; i >= 0 && m_cells[i].isEmpty(); i--) {

	}

	r1 = m_first + i;

	return r1 - r0 + 1;

}

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

int TXshCellColumn::getRowCount() const

{

	int i = m_cells.size();

	for (; i > 0 && m_cells[i - 1].isEmpty(); i--) {

	}

	if (i == 0)

		return 0;

	else

		return m_first + i;

}

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

int TXshCellColumn::getMaxFrame() const

{

	int r0, r1;

	getRange(r0, r1);

	return r1;

}

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

int TXshCellColumn::getFirstRow() const

{

	return m_first;

}

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

const TXshCell &TXshCellColumn::getCell(int row) const

{

	static TXshCell emptyCell;

	if (row < 0 || row < m_first ||

		row >= m_first + (int)m_cells.size())

		return emptyCell;

	return m_cells[row - m_first];

}

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

bool TXshCellColumn::isCellEmpty(int row) const

{

	return getCell(row).isEmpty();

}

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

//--- debug only

void TXshCellColumn::checkColumn() const

{

	assert(m_first >= 0);

	int r0, r1;

	int range = getRange(r0, r1);

	assert(range >= 0);

	assert(range == (int)m_cells.size());

	assert(getRowCount() >= 0);

	TXshCell firstCell = getCell(m_first);

	TXshCell lastCell = getCell(r1);

	if (range == 0)

		assert(firstCell.isEmpty() && lastCell.isEmpty());

	else {

		assert(firstCell.isEmpty() == 0);

		assert(lastCell.isEmpty() == 0);

		int maxFrame = getMaxFrame();

		assert(maxFrame == r1);

		assert(getCell(maxFrame).isEmpty() == 0);

	}

}

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

void TXshCellColumn::getCells(int row, int rowCount, TXshCell cells[])

{

	const TXshCell emptyCell;

	int first = m_first;

	int i;

	int cellCount = m_cells.size();

	if (row < 0 || row + rowCount - 1 < first ||

		row >= first + cellCount) {

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

			cells[i] = emptyCell;

		return;

	}

	int dst, src, n, delta;

	n = rowCount;

	delta = m_first - row;

	if (delta < 0) { // le celle cominciano PRIMA della zona da leggere

		dst = 0;

		src = -delta;

	} else { //le celle cominciano DOPO della zona da leggere

		dst = delta;

		src = 0;

		n -= delta;

	}

	if (n + src > cellCount)

		n = cellCount - src;

	TXshCell *dstCell = cells;

	TXshCell *endDstCell = dstCell + dst;

	while (dstCell < endDstCell)

		*dstCell++ = emptyCell;

	endDstCell += n;

	while (dstCell < endDstCell)

		*dstCell++ = m_cells[src++];

	endDstCell = cells + rowCount;

	while (dstCell < endDstCell)

		*dstCell++ = emptyCell;

}

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

bool TXshCellColumn::setCell(int row, const TXshCell &cell)

{

	if (!canSetCell(cell))

		return false;

	assert(row >= 0);

#ifndef NDEBUG

	checkColumn();

#endif

	if (m_cells.empty()) //se la colonna e' vuota

	{

		if (!cell.isEmpty()) {

			m_cells.push_back(cell);

			m_first = row;

			//updateIcon();

		}

		return true;

	}

	int oldCellCount = m_cells.size();

	assert(oldCellCount > 0);

	int lastRow = m_first + oldCellCount - 1;

	if (row < m_first) //prima

	{

		if (cell.isEmpty())

			return false; //non faccio nulla

		int delta = m_first - row;

		assert(delta > 0);

		m_cells.insert(m_cells.begin(), delta - 1, TXshCell()); //celle vuote

		m_cells.insert(m_cells.begin(), cell);					//devo settare la prima comp. del vettore

		m_first = row;											//row 'e la nuova firstrow

//updateIcon();

#ifndef NDEBUG

		checkColumn();

#endif

		return true;

	} else if (row > lastRow) //dopo

	{

		if (cell.isEmpty())

			return false; //non faccio nulla

		int count = row - lastRow - 1;

		//se necessario, inserisco celle vuote

		for (int i = 0; i < count; ++i)

			m_cells.push_back(TXshCell());

		m_cells.push_back(cell);

#ifndef NDEBUG

		checkColumn();

#endif

		return true;

	}

	//"[r0,r1]"

	int index = row - m_first;

	assert(0 <= index && index < (int)m_cells.size());

	m_cells[index] = cell;

	//if(index == 0) updateIcon();

	if (cell.isEmpty()) {

		if (row == lastRow) {

			// verifico la presenza di celle bianche alla fine

			while (!m_cells.empty() && m_cells.back().isEmpty())

				m_cells.pop_back();

		} else if (row == m_first) {

			// verifico la presenza di celle bianche all'inizio

			while (!m_cells.empty() && m_cells.front().isEmpty()) {

				m_cells.erase(m_cells.begin());

				m_first++;

			}

		}

		if (m_cells.empty())

			m_first = 0;

	}

	checkColumn();

	return true;

}

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

bool TXshCellColumn::setCells(int row, int rowCount, const TXshCell cells[])

{

	assert(row >= 0);

	int i;

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

		if (!canSetCell(cells[i]))

			return false;

	int oldCellCount = m_cells.size();

	// le celle da settare sono [ra, rb]

	int ra = row;

	int rb = row + rowCount - 1;

	assert(ra <= rb);

	// le celle non vuote sono [c_ra, c_rb]

	int c_rb = m_first + oldCellCount - 1;

	if (row > c_rb) //sono oltre l'ultima riga

	{

		if (oldCellCount == 0)

			m_first = row; //row 'e la nuova firstrow

		int newCellCount = row - m_first + rowCount;

		m_cells.resize(newCellCount);

	} else if (row < m_first) {

		int delta = m_first - row;

		m_cells.insert(m_cells.begin(), delta, TXshCell());

		m_first = row; //row e' la nuova firstrow

	}

	if (rb > c_rb) {

		for (int i = 0; i < rb - c_rb; ++i)

			m_cells.push_back(TXshCell());

	}

	int index = row - m_first;

	assert(0 <= index && index < (int)m_cells.size());

	for (int i = 0; i < rowCount; i++)

		m_cells[index + i] = cells[i];

	// verifico la presenza di celle bianche alla fine

	while (!m_cells.empty() && m_cells.back().isEmpty()) {

		m_cells.pop_back();

	}

	// verifico la presenza di celle bianche all'inizio

	while (!m_cells.empty() && m_cells.front().isEmpty()) {

		m_cells.erase(m_cells.begin());

		m_first++;

	}

	if (m_cells.empty()) {

		m_first = 0;

	}

	//updateIcon();

	return true;

}

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

void TXshCellColumn::insertEmptyCells(int row, int rowCount)

{

	if (m_cells.empty())

		return; //se la colonna e' vuota non devo inserire celle

	if (row >= m_first + (int)m_cells.size())

		return;			//dopo:non inserisco nulla

	if (row <= m_first) //prima

	{

		m_first += rowCount;

	} else //in mezzo

	{

		int delta = row - m_first;

		std::vector<txshcell>::iterator it = m_cells.begin();</txshcell>

		std::advance(it, delta);

		m_cells.insert(it, rowCount, TXshCell());

	}

}

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

// sbianca le celle [row, row+rowCount-1] (senza shiftare)

void TXshCellColumn::clearCells(int row, int rowCount)

{

	if (rowCount <= 0)

		return;

	if (m_cells.empty())

		return; //se la colonna e' vuota

	// le celle da cancellare sono [ra, rb]

	int ra = row;

	int rb = row + rowCount - 1;

	assert(ra <= rb);

	int cellCount = m_cells.size();

	// le celle non vuote sono [c_ra, c_rb]

	int c_ra = m_first;

	int c_rb = m_first + cellCount - 1;

	assert(c_ra <= c_rb);

	// se e' sotto o sopra le celle occupate non devo far nulla

	if (rb < c_ra || ra > c_rb)

		return;

	// restringo l'area da cancellare in modo che comprenda solo celle non vuote

	if (ra < c_ra)

		ra = c_ra;

	if (rb > c_rb)

		rb = c_rb;

	// devo "sbiancare" n celle

	int n = rb - ra + 1;

	assert(n >= 0);

	if (n == cellCount) // ho cancellato tutto

	{

		m_cells.clear();

		m_first = 0;

	} else {

		assert(ra - c_ra < (int)m_cells.size());

		assert(ra - c_ra + n <= (int)m_cells.size());

		//std::fill_n(&m_cells[ra-c_ra],n, TXshCell());

		int i;

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

			m_cells[ra - c_ra + i] = TXshCell();

		// verifico la presenza di celle bianche alla fine

		while (!m_cells.empty() && m_cells.back().isEmpty()) {

			m_cells.pop_back();

		}

		if (m_cells.empty()) {

			m_first = 0;

		} else {

			// verifico la presenza di celle bianche all'inizio

			while (!m_cells.empty() && m_cells.front().isEmpty()) {

				m_cells.erase(m_cells.begin());

				m_first++;

			}

		}

	}

	//updateIcon();

}

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

// rimuove le celle [row, row+rowCount-1] (shiftando)

void TXshCellColumn::removeCells(int row, int rowCount)

{

	if (rowCount <= 0)

		return;

	if (m_cells.empty())

		return; //se la colonna e' vuota

	int cellCount = m_cells.size();

	if (row >= m_first + cellCount)

		return; //sono "sotto" l'ultima cella

	if (row < m_first) {

		if (row + rowCount <= m_first) //"sono sopra la prima cella"

		{							   // aggiorno solo m_first

			m_first -= rowCount;

			return;

		}

		rowCount += row - m_first;

		m_first = row;

	}

	assert(row >= m_first);

	// le celle sotto m_first+cellCount sono gia' vuote

	if (rowCount > m_first + cellCount - row)

		rowCount = m_first + cellCount - row;

	if (rowCount <= 0)

		return;

	if (row == m_first) {

		//cancello all'inizio

		assert(rowCount <= cellCount);

		std::vector<txshcell>::iterator it = m_cells.begin();</txshcell>

		std::vector<txshcell>::iterator it2 = m_cells.begin();</txshcell>

		std::advance(it2, rowCount);

		m_cells.erase(it, it2);

		// verifico la presenza di celle bianche all'inizio

		while (!m_cells.empty() && m_cells.front().isEmpty()) {

			m_cells.erase(m_cells.begin());

			m_first++;

		}

	} else {

		// cancello dopo l'inizio

		int d = row - m_first;

		std::vector<txshcell>::iterator it = m_cells.begin();</txshcell>

		std::vector<txshcell>::iterator it2 = m_cells.begin();</txshcell>

		std::advance(it, d);

		std::advance(it2, d + rowCount);

		m_cells.erase(it, it2);

		if (row + rowCount == m_first + cellCount) {

			// verifico la presenza di celle bianche alla fine

			while (!m_cells.empty() && m_cells.back().isEmpty()) {

				m_cells.pop_back();

			}

		}

	}

	if (m_cells.empty()) {

		m_first = 0;

	}

	//updateIcon();

}

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

bool TXshCellColumn::getLevelRange(int row, int &r0, int &r1) const

{

	r0 = r1 = row;

	TXshCell cell = getCell(row);

	if (cell.isEmpty())

		return false;

	while (r0 > 0 && getCell(r0 - 1).m_level.getPointer() == cell.m_level.getPointer())

		r0--;

	while (getCell(r1 + 1).m_level.getPointer() == cell.m_level.getPointer())

		r1++;

	return true;

}

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

//TXshColumn

void TXshColumn::setStatusWord(int status)

{

	m_status = status;

}

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

TXshColumn *TXshColumn::createEmpty(int type)

{

	switch (type) {

	case eSoundType:

		return new TXshSoundColumn;

		CASE eZeraryFxType : return new TXshZeraryFxColumn(0);

		CASE ePaletteType : return new TXshPaletteColumn;

		CASE eSoundTextType : return new TXshSoundTextColumn;

		CASE eMeshType : return new TXshMeshColumn;

	}

	assert(type == eLevelType);

	return new TXshLevelColumn;

}

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

TXshColumn::ColumnType TXshColumn::toColumnType(int levelType)

{

	ColumnType colType = TXshColumn::eLevelType;

	if (levelType & LEVELCOLUMN_XSHLEVEL)

		colType = TXshColumn::eLevelType;

	else if (levelType == ZERARYFX_XSHLEVEL)

		colType = TXshColumn::eZeraryFxType;

	else if (levelType == PLT_XSHLEVEL)

		colType = TXshColumn::ePaletteType;

	else if (levelType == SND_XSHLEVEL)

		colType = TXshColumn::eSoundType;

	else if (levelType == SND_TXT_XSHLEVEL)

		colType = TXshColumn::eSoundTextType;

	else if (levelType == MESH_XSHLEVEL)

		colType = TXshColumn::eMeshType;

	else

		assert(!"Unkown level type!");

	return colType;

}

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

bool TXshColumn::isRendered() const

{

	if (!getXsheet() || !getFx())

		return false;

	if (!isPreviewVisible())

		return false;

	return getXsheet()->getFxDag()->isRendered(getFx());

}

/*

bool TXshColumn::isReference() const

{

  if(!getXsheet() || !getFx()) return true;

  if(getXsheet()->getFxDag()->getTerminalFxs()->containsFx(getFx())) return false;

  return getFx()->getOutputConnectionCount()==0;

}

*/

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

bool TXshColumn::isControl() const

{

	if (!getXsheet() || !getFx())

		return false;

	return getXsheet()->getFxDag()->isControl(getFx());

	/*

  TFx *fx = getFx();

  if(!fx) return false;

  if(!getXsheet()) return false;

  if(getXsheet()->getFxDag()->getTerminalFxs()->containsFx(getFx())) return false;

  for(int i=0;i<fx->getOutputConnectionCount();i++)</fx->

  {

    TFxPort *port = fx->getOutputConnection(i);

    if(port->getOwnerFx()->getInputPort(0) != port)

      return true;

  }

  return false;

  */

}

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

#ifdef LEVO

void TXshColumn::setCamstandNextState()

{

	setCamstandVisible(!isCamstandVisible());

	if (Preferences::instance()->isCamStandOpacityEnabled()) {

		// camera stand, 3-state-toggle: notvisible -> visible+nottransparent -> visible+transparent

		if (isCamstandVisible()) {

			if (isCamstandTransparent())

				setCamstandVisible(false);

			else

				setCamstandTransparent(true);

		} else {

			setCamstandVisible(true);

			setCamstandTransparent(false);

		}

	} else {

		setCamstandTransparent(false);

		setCamstandVisible(!isCamstandVisible());

	}

}

#endif

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

bool TXshColumn::isCamstandVisible() const

{

	return (m_status & eCamstandVisible) == 0;

}

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

/*

bool TXshColumn::isCamstandTransparent() const

{

  return (m_status&eCamstandTransparent)!=0;

}

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

void TXshColumn::setCamstandTransparent(bool on)

{

  const int mask = eCamstandTransparent;

  if(!on) m_status&=~mask; else m_status|=mask; 

}

*/

void TXshColumn::setCamstandVisible(bool on)

{

	const int mask = eCamstandVisible;

	if (on)

		m_status &= ~mask;

	else

		m_status |= mask;

}

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

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

bool TXshColumn::isPreviewVisible() const

{

	return (m_status & ePreviewVisible) == 0;

}

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

void TXshColumn::setPreviewVisible(bool on)

{

	const int mask = ePreviewVisible;

	if (on)

		m_status &= ~mask;

	else

		m_status |= mask;

}

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

bool TXshColumn::isLocked() const

{

	return (m_status & eLocked) != 0;

}

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

void TXshColumn::lock(bool on)

{

	const int mask = eLocked;

	if (on)

		m_status |= mask;

	else

		m_status &= ~mask;

}

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

bool TXshColumn::isMask() const

{

	return (m_status & eMasked) != 0;

}

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

void TXshColumn::setIsMask(bool on)

{

	const int mask = eMasked;

	if (on)

		m_status |= mask;

	else

		m_status &= ~mask;

}