#include "tools/levelselection.h"

// TnzTools includes

#include "tools/tool.h"

#include "tools/toolhandle.h"

// TnzCore includes

#include "tfilepath.h"

#include "tvectorimage.h"

#include "tstroke.h"

#include "tregion.h"

// Boost includes

#include <boost algorithm="" copy_if.hpp="" cxx11=""></boost>

#include <boost counting_iterator.hpp="" iterator=""></boost>

#include <boost bind.hpp=""></boost>

namespace boost_a = boost::algorithm;

//*******************************************************************************

//    Local namespace  stuff

//*******************************************************************************

namespace

{

TTool *tool()

{

	return TTool::getApplication()->getCurrentTool()->getTool();

}

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

struct StrokeData {

	UCHAR m_hasColor,

		m_hasRegion;

};

void getBoundaries(TVectorImage &vi, std::vector<int> &strokes)</int>

{

	enum { FORWARD = 0x1,

		   BACKWARD = 0x2,

		   INTERNAL = FORWARD | BACKWARD };

	struct locals {

		static inline bool isBoundary(const std::vector<strokedata> &sData, UINT s)</strokedata>

		{

			return (sData[s].m_hasColor != INTERNAL);

		}

		static void markEdges(const TRegion ®ion, std::vector<strokedata> &sData,</strokedata>

							  bool parentRegionHasColor)

		{

			bool regionHasColor = (region.getStyle() != 0);

			// Traverse region edges, marking associated strokes accordingly

			UINT e, eCount = region.getEdgeCount();

			for (e = 0; e != eCount; ++e) {

				const TEdge &ed = *region.getEdge(e);

				assert(ed.m_s);

				int strokeIdx = ed.m_index;

				if (strokeIdx >= 0) // Could be <0 in case the corresponding

				{					// stroke is a region 'closure' (autoclose)

					assert(0 <= strokeIdx && strokeIdx < sData.size());

					StrokeData &sd = sData[strokeIdx];

					UCHAR side = (ed.m_w1 > ed.m_w0) ? FORWARD : BACKWARD;

					sd.m_hasRegion |= side;

					if (regionHasColor)

						sd.m_hasColor |= side;

				}

			}

			if (parentRegionHasColor) {

				// Mark non-region edge sides with color

				for (e = 0; e != eCount; ++e) {

					const TEdge &ed = *region.getEdge(e);

					assert(ed.m_s);

					int strokeIdx = ed.m_index;

					if (strokeIdx >= 0) {

						StrokeData &sd = sData[strokeIdx];

						sd.m_hasColor |= (INTERNAL & ~sd.m_hasRegion);

					}

				}

			}

			// Mark recursively on sub-regions

			UINT sr, srCount = region.getSubregionCount();

			for (sr = 0; sr != srCount; ++sr)

				markEdges(*region.getSubregion(sr), sData, regionHasColor);

		}

	}; // locals

	std::vector<strokedata> sData(vi.getStrokeCount());</strokedata>

	// Traverse regions, mark each stroke edge with the side a COLORED region is on

	UINT r, rCount = vi.getRegionCount();

	for (r = 0; r != rCount; ++r)

		locals::markEdges(*vi.getRegion(r), sData, false);

	// Strokes not appearing as region edges must be checked for region inclusion separately

	UINT s, sCount = vi.getStrokeCount();

	for (s = 0; s != sCount; ++s) {

		if (!sData[s].m_hasRegion) {

			TRegion *parentRegion = vi.getRegion(vi.getStroke(s)->getPoint(0.5));

			if (parentRegion && parentRegion->getStyle())

				sData[s].m_hasColor = INTERNAL;

		}

	}

	// Output all not internal regions

	boost_a::copy_if(boost::make_counting_iterator(0u), boost::make_counting_iterator(vi.getStrokeCount()),

					 std::back_inserter(strokes), boost::bind(locals::isBoundary, sData, _1));

}

} // namespace

//*******************************************************************************

//    VectorLevelSelection  implementation

//*******************************************************************************

LevelSelection::LevelSelection()

	: m_framesMode(FRAMES_NONE), m_filter(EMPTY)

{

}

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

bool LevelSelection::isEmpty() const

{

	return (m_framesMode == FRAMES_NONE || m_filter == EMPTY);

}

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

void LevelSelection::selectNone()

{

	m_framesMode = FRAMES_NONE;

	m_filter = EMPTY;

	m_styles.clear();

}

//*******************************************************************************

//    Related standalone functions

//*******************************************************************************

std::vector<int> getBoundaryStrokes(TVectorImage &vi)</int>

{

	std::vector<int> result;</int>

	getBoundaries(vi, result);

	return result;

}

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

std::vector<int> getSelectedStrokes(TVectorImage &vi, const LevelSelection &levelSelection)</int>

{

	struct locals {

		static void selectStyles(const TVectorImage &vi, const std::set<int> &styles,</int>

								 std::vector<int> &strokes)</int>

		{

			UINT s, sCount = vi.getStrokeCount();

			for (s = 0; s != sCount; ++s) {

				if (styles.count(vi.getStroke(s)->getStyle()))

					strokes.push_back(s);

			}

		}

	}; // locals

	std::vector<int> strokes;</int>

	switch (levelSelection.filter()) {

	case LevelSelection::EMPTY:

		break;

	case LevelSelection::WHOLE:

		strokes.assign(boost::make_counting_iterator(0u),

		               boost::make_counting_iterator(vi.getStrokeCount()));

		break;

	case LevelSelection::SELECTED_STYLES:

		locals::selectStyles(vi, levelSelection.styles(), strokes);

		break;

	case LevelSelection::BOUNDARY_STROKES:

		getBoundaries(vi, strokes);

		break;

	}

	return strokes;

}