#include "tools/stylepicker.h"

#include "tcolorstyles.h"

#include "tstroke.h"

#include "tofflinegl.h"

#include "tvectorrenderdata.h"

#include "tvectorimage.h"

#include "ttoonzimage.h"

#include "trasterimage.h"

#include "toonz/dpiscale.h"

#include "tpixelutils.h"

#include "tregion.h"

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

StylePicker::StylePicker(const TImageP &image)

	: m_image(image), m_palette(image->getPalette())

{

}

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

StylePicker::StylePicker(const TImageP &image, const TPaletteP &palette)

	: m_image(image), m_palette(palette)

{

}

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

TPoint StylePicker::getRasterPoint(const TPointD &p) const

{

	if (TToonzImageP ti = m_image) {

		//DpiScale dpiScale(ti);

		TDimension size = ti->getSize();

		return TPoint(

			tround(0.5 * size.lx + p.x),  ///dpiScale.getSx()),

			tround(0.5 * size.ly + p.y)); ///dpiScale.getSy()));

	} else if (TRasterImageP ri = m_image) {

		//DpiScale dpiScale(ri);

		TDimension size = ri->getRaster()->getSize();

		return TPoint(

			tround(0.5 * size.lx + p.x),  // /dpiScale.getSx()),

			tround(0.5 * size.ly + p.y)); // /dpiScale.getSy()));

	} else

		return TPoint(tround(p.x), tround(p.y));

}

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

/*-- (StylePickerTool内で)LineとAreaを切り替えてPickできる。mode: 0=Area, 1=Line, 2=Line&Areas(default)  --*/

int StylePicker::pickStyleId(const TPointD &pos, double radius2, int mode) const

{

	int styleId = 0;

	if (TToonzImageP ti = m_image) {

		TRasterCM32P ras = ti->getRaster();

		TPoint point = getRasterPoint(pos);

		if (!ras->getBounds().contains(point))

			return -1;

		TPixelCM32 col = ras->pixels(point.y)[point.x];

		switch (mode) {

		case 0: //AREAS

			styleId = col.getPaint();

			break;

		case 1: //LINES

			styleId = col.getInk();

			break;

		case 2: //ALL (Line & Area)

		default:

			styleId = col.isPurePaint() ? col.getPaint() : col.getInk();

			break;

		}

	} else if (TRasterImageP ri = m_image) {

		const TPalette *palette = m_palette.getPointer();

		if (!palette)

			return -1;

		TRaster32P ras = ri->getRaster();

		if (!ras)

			return -1;

		TPoint point = getRasterPoint(pos);

		if (!ras->getBounds().contains(point))

			return -1;

		TPixel32 col = ras->pixels(point.y)[point.x];

		styleId = palette->getClosestStyle(col);

	} else if (TVectorImageP vi = m_image) {

		// prima cerca lo stile della regione piu' vicina

		TRegion *r = vi->getRegion(pos);

		if (r)

			styleId = r->getStyle();

		// poi cerca quello della stroke, ma se prima aveva trovato una regione, richiede che

		// il click sia proprio sopra la stroke, altrimenti cerca la stroke piu' vicina (max circa 10 pixel)

		const double maxDist2 = (styleId == 0) ? 100.0 * radius2 : 0;

		bool strokeFound;

		double dist2, w, thick;

		UINT index;

		//!funzionerebbe ancora meglio con un getNearestStroke che considera

		//la thickness, cioe' la min distance dalla outline e non dalla centerLine

		strokeFound = vi->getNearestStroke(pos, w, index, dist2);

		if (strokeFound) {

			TStroke *stroke = vi->getStroke(index);

			thick = stroke->getThickPoint(w).thick;

			if (dist2 - thick * thick < maxDist2) {

				assert(stroke);

				styleId = stroke->getStyle();

			}

		}

	}

	return styleId;

}

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

/*--- Toonz Raster LevelのToneを拾う。 ---*/

int StylePicker::pickTone(const TPointD &pos)

{

	if (TToonzImageP ti = m_image) {

		TRasterCM32P ras = ti->getRaster();

		if (!ras)

			return -1;

		TPoint point = getRasterPoint(pos);

		if (!ras->getBounds().contains(point))

			return -1;

		TPixelCM32 col = ras->pixels(point.y)[point.x];

		return col.getTone();

	} else

		return -1;

}

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

TPixel32 StylePicker::pickColor(const TPointD &pos, double radius2) const

{

	TToonzImageP ti = m_image;

	TRasterImageP ri = m_image;

	if (!!ri) // !!ti || !!ri)

	{

		TRasterP raster;

		//if(ti)

		//  raster = ti->getRGBM(true);

		//else

		raster = ri->getRaster();

		TPoint point = getRasterPoint(pos);

		if (!raster->getBounds().contains(point))

			return TPixel32::Transparent;

		TRaster32P raster32 = raster;

		if (raster32)

			return raster32->pixels(point.y)[point.x];

		TRasterGR8P rasterGR8 = raster;

		if (rasterGR8)

			return toPixel32(rasterGR8->pixels(point.y)[point.x]);

	} else if (TVectorImageP vi = m_image) {

		const TPalette *palette = m_palette.getPointer();

		if (!palette)

			return TPixel32::Transparent;

		int styleId = pickStyleId(pos, radius2);

		if (0 <= styleId && styleId < palette->getStyleCount())

			return palette->getStyle(styleId)->getAverageColor();

	}

	return TPixel32::Transparent;

}

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

namespace

{

TPixel32 getAverageColor(const TRect &rect)

{

	GLenum fmt =

#ifdef TNZ_MACHINE_CHANNEL_ORDER_BGRM

		GL_RGBA;

#elif TNZ_MACHINE_CHANNEL_ORDER_MBGR

		GL_ABGR_EXT;

#elif TNZ_MACHINE_CHANNEL_ORDER_RGBM

		GL_RGBA;

#elif TNZ_MACHINE_CHANNEL_ORDER_MRGB

		GL_BGRA;

#else

//   Error  PLATFORM NOT SUPPORTED

#error	"unknown channel order!"

#endif

	UINT r = 0, g = 0, b = 0, m = 0;

	std::vector<tpixel32> buffer(rect.getLx() * rect.getLy());</tpixel32>

	glReadPixels(rect.x0, rect.y0, rect.getLx(), rect.getLy(), fmt, GL_UNSIGNED_BYTE, &buffer[0]);

	int size = rect.getLx() * rect.getLy();

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

		r += buffer[i].r;

		g += buffer[i].g;

		b += buffer[i].b;

	}

	return TPixel32(b / size, g / size, r / size, 255);

}

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

TPixel32 getAverageColor(TStroke *stroke)

{

	GLenum fmt =

#ifdef TNZ_MACHINE_CHANNEL_ORDER_BGRM

		GL_RGBA;

#elif TNZ_MACHINE_CHANNEL_ORDER_MBGR

		GL_ABGR_EXT;

#elif TNZ_MACHINE_CHANNEL_ORDER_RGBM

		GL_RGBA;

#elif TNZ_MACHINE_CHANNEL_ORDER_MRGB

		GL_BGRA;

#else

//   Error  PLATFORM NOT SUPPORTED

#error	"unknown channel order"

#endif

	//leggo il buffer e mi prendo i pixels

	UINT r = 0, g = 0, b = 0, m = 0;

	TRect rect = convert(stroke->getBBox());

	std::vector<tpixel32> buffer(rect.getLx() * rect.getLy());</tpixel32>

	glReadPixels(rect.x0, rect.y0, rect.getLx(), rect.getLy(), fmt, GL_UNSIGNED_BYTE, &buffer[0]);

	//calcolo le regioni dello stroke

	TVectorImage aux;

	aux.addStroke(stroke);

	aux.transform(TTranslation(convert(-rect.getP00())));

	aux.findRegions();

	int regionCount = aux.getRegionCount();

	int size = 0, lx = rect.getLx();

	for (int j = 0; j < regionCount; j++) {

		TRegion *reg = aux.getRegion(j);

		TRect regRect = convert(reg->getBBox());

		for (int y = regRect.y0; y < regRect.y1; y++) {

			std::vector<double> intersections;</double>

			reg->computeScanlineIntersections(y, intersections);

			assert(!(intersections.size() & 0x1));

			for (UINT i = 0; i < intersections.size(); i += 2) {

				if (intersections[i] == intersections[i + 1])

					continue;

				int firstInters = (int)intersections[i];

				int secondInters = (int)intersections[i + 1];

				for (int x = firstInters + 1; x < secondInters - 1; x++) {

					r += buffer[y * lx + x].r;

					g += buffer[y * lx + x].g;

					b += buffer[y * lx + x].b;

					size++;

				}

			}

		}

	}

	if (size != 0)

		return TPixel32(b / size, g / size, r / size, 255);

	else

		return TPixel32(buffer[0].b, buffer[0].g, buffer[0].r, 255);

}

} //namspace

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

TPixel32 StylePicker::pickColor(const TRectD &area) const

{

	//TRectD rect=area.enlarge(-1,-1);

	return getAverageColor(convert(area));

}

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

TPixel32 StylePicker::pickColor(TStroke *stroke) const

{

	return getAverageColor(stroke);

}

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