#include "toonz/tpinnedrangeset.h"

#include "tstream.h"

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

TPinnedRangeSet::TPinnedRangeSet()

	: m_stageObject()

{

}

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

int TPinnedRangeSet::getRangeIndex(int frame) const

{

	if (m_ranges.empty())

		return -1;

	if (frame < m_ranges.front().first || m_ranges.back().second < frame)

		return -1;

	int start = 0, end = (int)m_ranges.size() - 1;

	while (start < end) {

		if (start + 1 == end) {

			if (m_ranges[end].first <= frame)

				start = end;

			else

				end = start;

			break;

		}

		int m = (start + end) / 2;

		assert(start < m && m < end);

		if (m_ranges[m].first <= frame)

			start = m;

		else

			end = m;

	}

	int index = start;

	if (m_ranges[index].first <= frame && frame <= m_ranges[index].second)

		return index;

	else

		return -1;

}

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

void TPinnedRangeSet::setRange(int first, int second)

{

	std::vector<range>::iterator it;</range>

	// finds the range which could possibly be merged before : range.second+1 >= first

	for (it = m_ranges.begin(); it != m_ranges.end(); ++it)

		if (it->second + 1 >= first)

			break;

	if (it == m_ranges.end()) {

		// not found => for every range : range.second+1 < first. Just add the new one

		m_ranges.push_back(Range(first, second));

	} else if (it->first > second + 1) {

		// it comes after and can not be merged. Just insert the new one

		m_ranges.insert(it, Range(first, second));

	} else {

		// merge

		if (first < it->first)

			it->first = first;

		// update it->second, and find all the ranges which should be deleted

		std::vector<range>::iterator it2 = it;</range>

		for (++it2; it2 != m_ranges.end(); ++it2)

			if (it2->first > second + 1)

				break;

			else

				it->second = it2->second;

		if (second > it->second)

			it->second = second;

		++it;

		if (it != it2)

			m_ranges.erase(it, it2);

	}

}

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

void TPinnedRangeSet::removeRange(int first, int second)

{

	std::vector<range>::iterator it;</range>

	// finds the first range which could possibly overlap [first,second] : range.second>=first

	for (it = m_ranges.begin(); it != m_ranges.end(); ++it)

		if (it->second >= first)

			break;

	if (it == m_ranges.end() || it->first > second) {

		// nothing to do: for each range range.second < first or range.first > second

	} else if (it->first < first && it->second > second) {

		// [first,second] is a "hole"

		Range range(it->first, first - 1);

		it->first = second + 1;

		m_ranges.insert(it, range);

	} else {

		std::vector<range>::iterator it2;</range>

		if (it->first < first) {

			it->second = first - 1;

			++it;

		}

		it2 = it;

		while (it != m_ranges.end() && it->second <= second)

			++it;

		if (it != m_ranges.end() && it->first <= second)

			it->first = second + 1;

		if (it2 != it)

			m_ranges.erase(it2, it);

	}

}

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

void TPinnedRangeSet::removeAllRanges()

{

	m_ranges.clear();

}

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

void TPinnedRangeSet::setPlacement(const TAffine &placement)

{

	m_placement = placement;

}

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

TPinnedRangeSet *TPinnedRangeSet::clone()

{

	TPinnedRangeSet *clonedPinnedRangeSet = new TPinnedRangeSet();

	clonedPinnedRangeSet->m_stageObject = m_stageObject;

	clonedPinnedRangeSet->m_placement = m_placement;

	clonedPinnedRangeSet->m_ranges = m_ranges;

	return clonedPinnedRangeSet;

}

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

void TPinnedRangeSet::loadData(TIStream &is)

{

	m_ranges.clear();

	int prevFrame = 0;

	int i = 0;

	std::string tagName;

	int count = 0;

	while (is.matchTag(tagName) && count < 3) {

		if (tagName == "permanent") {

			while (!is.matchEndTag()) {

				i++;

				int frame = 0;

				is >> frame;

				if (i % 2 == 0)

					m_ranges.push_back(Range(prevFrame, frame));

				prevFrame = frame;

			}

			count++;

		} else if (tagName == "temp") {

			assert(0);

			// OBSOLETO

			while (!is.matchEndTag()) {

				int frame = 0;

				is >> frame;

				//m_tempPinned.push_back(frame);

			}

			count++;

		} else if (tagName == "lockedAngle") {

			assert(0);

			// OBSOLETO

			while (!is.matchEndTag()) {

				int rangeIndex = -1;

				is >> rangeIndex;

			}

			count++;

		} else if (tagName == "placement") {

			is >> m_placement.a11 >> m_placement.a12 >> m_placement.a13;

			is >> m_placement.a21 >> m_placement.a22 >> m_placement.a23;

			is.matchEndTag();

		}

	}

}

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

void TPinnedRangeSet::saveData(TOStream &os)

{

	if ((int)m_ranges.size() == 0)

		return;

	os.openChild("pinnedStatus");

	if (m_ranges.size() > 0) {

		os.openChild("permanent");

		for (int p = 0; p < (int)m_ranges.size(); p++) {

			os << m_ranges[p].first << m_ranges[p].second;

		}

		os.closeChild();

	}

	if (m_placement != TAffine()) {

		os.openChild("placement");

		os << m_placement.a11 << m_placement.a12 << m_placement.a13;

		os << m_placement.a21 << m_placement.a22 << m_placement.a23;

		os.closeChild();

	}

	os.closeChild();

}