#include "toonz/skeleton.h"

#include "toonz/tstageobject.h"

#include "toonz/tpinnedrangeset.h"

#include "toonz/tstageobjectkeyframe.h"

#include "toonz/txsheet.h"

#include "toonz/stage.h"

namespace

{

TStageObjectId getAncestor(TXsheet *xsh, TStageObjectId id)

{

	assert(id.isColumn());

	TStageObjectId parentId;

	while (parentId = xsh->getStageObjectParent(id), parentId.isColumn())

		id = parentId;

	return id;

}

} // namespace

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

int Skeleton::Bone::getColumnIndex() const

{

	return m_stageObject->getId().getIndex();

}

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

void Skeleton::Bone::setParent(Bone *parent)

{

	if (m_parent != parent) {

		m_parent = parent;

		parent->m_children.push_back(this);

	}

}

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

Skeleton::Skeleton()

	: m_rootBone(0)

{

}

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

Skeleton::~Skeleton()

{

	clearPointerContainer(m_bones);

}

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

void Skeleton::clear()

{

	clearPointerContainer(m_bones);

	m_rootBone = 0;

}

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

void Skeleton::build(TXsheet *xsh, int row, int col, const std::set<int> &tempPinnedColumns)</int>

{

	// clear

	m_rootBone = 0;

	clearPointerContainer(m_bones);

	// antenato (colonna) della colonna corrente

	TStageObjectId ancestorId = getAncestor(xsh, TStageObjectId::ColumnId(col));

	// costruisco le "ossa"

	std::map<tstageobjectid, *="" bone=""> boneTable;</tstageobjectid,>

	int columnCount = xsh->getColumnCount();

	int pinnedCount = 0;

	for (int i = 0; i < columnCount; i++) {

		TStageObjectId columnId(TStageObjectId::ColumnId(i));

		if (getAncestor(xsh, columnId) != ancestorId)

			continue;

		TAffine aff = xsh->getPlacement(columnId, row);

		TPointD center = Stage::inch * xsh->getCenter(columnId, row);

		TPointD p = aff * center;

		TStageObject *obj = xsh->getStageObject(columnId);

		Bone *bone = new Bone(obj, p);

		boneTable[columnId] = bone;

		m_bones.push_back(bone);

		if (columnId == ancestorId)

			m_rootBone = bone;

		if (obj->getPinnedRangeSet()->isPinned(row)) {

			pinnedCount++;

			bone->setPinnedStatus(Bone::PINNED);

		} else if (tempPinnedColumns.count(i) > 0)

			bone->setPinnedStatus(Bone::TEMP_PINNED);

	}

	// if no bone is pinned then the root is considered pinned

	if (pinnedCount == 0 && m_rootBone)

		m_rootBone->setPinnedStatus(Bone::PINNED);

	// The skeleton could possibly be empty

	if (boneTable.empty()) {

		assert(!m_rootBone);

		return;

	}

	// assign parents

	std::map<tstageobjectid, *="" bone="">::iterator it, sit;</tstageobjectid,>

	for (it = boneTable.begin(); it != boneTable.end(); ++it) {

		sit = boneTable.find(xsh->getStageObjectParent(it->first));

		if (sit != boneTable.end())

			it->second->setParent(sit->second);

	}

	// select the "active chain", i.e. the starting bone (columnIndex=col) and the ancestors

	it = boneTable.find(TStageObjectId::ColumnId(col));

	if (it != boneTable.end()) {

		Bone *bone = it->second;

		while (bone) {

			bone->select();

			bone = bone->getParent();

		}

	}

}

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

Skeleton::Bone *Skeleton::getBone(int index) const

{

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

	return m_bones[index];

}

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

Skeleton::Bone *Skeleton::getBoneByColumnIndex(int columnIndex) const

{

	for (int i = 0; i < (int)m_bones.size(); i++)

		if (m_bones[i]->getColumnIndex() == columnIndex)

			return m_bones[i];

	return 0;

}

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

bool Skeleton::isIKEnabled() const

{

	return m_rootBone && m_rootBone->getStageObject()->getStatus() == TStageObject::IK;

}

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

bool Skeleton::hasPinnedRanges() const

{

	for (int i = 0; i < getBoneCount(); i++) {

		TStageObject *obj = getBone(i)->getStageObject();

		if (obj->getPinnedRangeSet()->getRangeCount() > 0)

			return true;

	}

	return false;

}

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

void Skeleton::clearAllPinnedRanges()

{

	for (int i = 0; i < getBoneCount(); i++) {

		TStageObject *obj = getBone(i)->getStageObject();

		obj->getPinnedRangeSet()->removeAllRanges();

		obj->invalidate();

	}

}