#include "tstroke.h"
#include "tvectorrenderdata.h"
#include "tgl.h"
#include "tstrokeoutline.h"
#include "tsimplecolorstyles.h"
#include "tpalette.h"
#include "tregion.h"
#include "tregionoutline.h"
#include "tmathutil.h"
#include "tlevel_io.h"
#include "tenv.h"
 
#include "tvectorbrushstyle.h"
 
//**********************************************************************
//    Vector Brush Style  static members
//**********************************************************************
 
TFilePath TVectorBrushStyle::m_rootDir = TFilePath();
 
//**********************************************************************
//    Vector Brush Prop  declaration
//**********************************************************************
 
class VectorBrushProp : public TStrokeProp
{
	TVectorBrushStyle *m_style;
	TVectorImageP m_brush;
	TRectD m_brushBox;
 
	std::vector<TStrokeOutline> m_strokeOutlines;
	std::vector<TRegionOutline> m_regionOutlines;
	double m_pixelSize;
 
public:
	VectorBrushProp(const TStroke *stroke, TVectorBrushStyle *style);
 
	TStrokeProp *clone(const TStroke *stroke) const;
 
	void draw(const TVectorRenderData &rd);
	void draw(TFlash &flash) {}
 
	const TColorStyle *getColorStyle() const;
 
private:
	// not implemented
	VectorBrushProp(const VectorBrushProp &);
	VectorBrushProp &operator=(const VectorBrushProp &);
};
 
//**********************************************************************
//    Vector Brush Prop  implementation
//**********************************************************************
 
VectorBrushProp::VectorBrushProp(const TStroke *stroke, TVectorBrushStyle *style)
	: TStrokeProp(stroke), m_style(style), m_brush(style->getImage()), m_brushBox(m_brush->getBBox()), m_pixelSize(.0)
{
}
 
//-----------------------------------------------------------------
 
TStrokeProp *VectorBrushProp::clone(const TStroke *stroke) const
{
	return new VectorBrushProp(stroke, m_style);
}
 
//-----------------------------------------------------------------
 
void VectorBrushProp::draw(const TVectorRenderData &rd)
{
	//Ensure that the stroke overlaps our clipping rect
	if (rd.m_clippingRect != TRect() && !rd.m_is3dView &&
		!convert(rd.m_aff * m_stroke->getBBox()).overlaps(rd.m_clippingRect))
		return;
 
	TPaletteP palette(m_brush->getPalette());
	if (!palette)
		return;
 
	static TOutlineUtil::OutlineParameter param; //unused, but requested
 
	//Build a solid color style to draw each m_vi's stroke with.
	TSolidColorStyle colorStyle;
 
	//Push the specified rd affine before drawing
	glPushMatrix();
	tglMultMatrix(rd.m_aff);
 
	//1. If necessary, build the outlines
	double currentPixelSize = sqrt(tglGetPixelSize2());
	bool differentPixelSize = !isAlmostZero(currentPixelSize - m_pixelSize, 1e-5);
	m_pixelSize = currentPixelSize;
 
	int i, viRegionsCount = m_brush->getRegionCount(), viStrokesCount = m_brush->getStrokeCount();
	if (differentPixelSize || m_strokeChanged) {
		m_strokeChanged = false;
 
		//1a. First, the regions
		m_regionOutlines.resize(viRegionsCount);
 
		for (i = 0; i < viRegionsCount; ++i) {
			TRegionOutline &outline = m_regionOutlines[i];
			const TRegion *brushRegion = m_brush->getRegion(i);
 
			//Build the outline
			outline.clear();
			TOutlineUtil::makeOutline(*getStroke(), *brushRegion, m_brushBox,
									  outline);
		}
 
		//1b. Then, the strokes
		m_strokeOutlines.resize(viStrokesCount);
 
		for (i = 0; i < viStrokesCount; ++i) {
			TStrokeOutline &outline = m_strokeOutlines[i];
			const TStroke *brushStroke = m_brush->getStroke(i);
 
			outline.getArray().clear();
			TOutlineUtil::makeOutline(*getStroke(), *brushStroke, m_brushBox,
									  outline, param);
		}
	}
 
	//2. Draw the outlines
 
	UINT s, t, r,
		strokesCount = m_brush->getStrokeCount(),
		regionCount = m_brush->getRegionCount();
 
	for (s = 0; s < strokesCount; s = t) //Each cycle draws a group
	{
		//A vector image stores group strokes with consecutive indices.
 
		//2a. First, draw regions in the strokeIdx-th stroke's group
		for (r = 0; r < regionCount; ++r) {
			if (m_brush->sameGroupStrokeAndRegion(s, r)) {
				const TRegion *brushRegion = m_brush->getRegion(r);
				const TColorStyle *brushStyle =
					palette->getStyle(brushRegion->getStyle());
				assert(brushStyle);
 
				//Draw the outline
				colorStyle.setMainColor(brushStyle->getMainColor());
				colorStyle.drawRegion(0, false, m_regionOutlines[r]);
			}
		}
 
		//2b. Then, draw all strokes in strokeIdx-th stroke's group
		for (t = s; t < strokesCount && m_brush->sameGroup(s, t); ++t) {
			const TStroke *brushStroke = m_brush->getStroke(t);
			const TColorStyle *brushStyle =
				palette->getStyle(brushStroke->getStyle());
			if (!brushStyle)
				continue;
 
			colorStyle.setMainColor(brushStyle->getMainColor());
			colorStyle.drawStroke(0, &m_strokeOutlines[t], brushStroke); //brushStroke unused but requested
		}
	}
 
	glPopMatrix();
}
 
//-----------------------------------------------------------------
 
const TColorStyle *VectorBrushProp::getColorStyle() const
{
	return m_style;
}
 
//**********************************************************************
//    Vector Brush Style  implementation
//**********************************************************************
 
TVectorBrushStyle::TVectorBrushStyle()
	: m_colorCount(0)
{
}
 
//-----------------------------------------------------------------
 
TVectorBrushStyle::TVectorBrushStyle(const std::string &brushName, TVectorImageP vi)
	: m_brush(vi)
{
	loadBrush(brushName);
}
 
//-----------------------------------------------------------------
 
TVectorBrushStyle::~TVectorBrushStyle()
{
}
 
//-----------------------------------------------------------------
 
void TVectorBrushStyle::loadBrush(const std::string &brushName)
{
	m_brushName = brushName;
	m_colorCount = 0;
 
	if (brushName.empty())
		return;
 
	if (!m_brush) {
		//Load the image associated with fp
		TFilePath fp(m_rootDir + TFilePath(brushName + ".pli"));
 
		TLevelReaderP lr(fp);
		TLevelP level = lr->loadInfo();
 
		m_brush = lr->getFrameReader(level->begin()->first)->load();
		assert(m_brush);
 
		TPalette *palette = level->getPalette();
		m_brush->setPalette(palette);
	}
 
	assert(m_brush);
	m_colorCount = m_brush->getPalette()->getStyleInPagesCount() - 1; //No transparent
}
 
//-----------------------------------------------------------------
 
TColorStyle *TVectorBrushStyle::clone() const
{
	TVectorImageP brush;
	if (m_brush) {
		//Clone m_brush and its palette
		brush = m_brush->clone(); //NOTE: This does NOT clone the palette, too.
		brush->setPalette(m_brush->getPalette()->clone());
	}
 
	TVectorBrushStyle *theClone = new TVectorBrushStyle(m_brushName, brush);
	theClone->assignNames(this);
	theClone->setFlags(getFlags());
 
	return theClone;
}
 
//-----------------------------------------------------------------
 
QString TVectorBrushStyle::getDescription() const
{
	return "VectorBrushStyle";
}
 
//-----------------------------------------------------------------
 
TStrokeProp *TVectorBrushStyle::makeStrokeProp(const TStroke *stroke)
{
	return new VectorBrushProp(stroke, this);
}
 
//-----------------------------------------------------------------
 
void TVectorBrushStyle::saveData(TOutputStreamInterface &osi) const
{
	osi << m_brushName;
 
	//Save palette
	osi << m_colorCount;
 
	TPalette *pal = m_brush->getPalette();
	assert(pal);
 
	int p, pagesCount = pal->getPageCount();
	for (p = 0; p < pagesCount; ++p) {
		TPalette::Page *page = pal->getPage(p);
 
		int s, stylesCount = page->getStyleCount();
		for (s = 0; s < stylesCount; ++s)
			osi << page->getStyle(s)->getMainColor();
	}
}
 
//-----------------------------------------------------------------
 
void TVectorBrushStyle::loadData(TInputStreamInterface &isi)
{
	std::string str;
	isi >> str;
 
	assert(!str.empty());
	loadBrush(str);
 
	int colorCount;
	isi >> colorCount;
 
	if (colorCount != m_colorCount)
		return; //Palette mismatch! Just skip palette loading...
 
	//WARNING: Is it needed to read all colors nonetheless?
 
	//Load palette colors
	TPalette *pal = m_brush->getPalette();
	assert(pal);
 
	TPixel32 color;
 
	int p, pagesCount = pal->getPageCount();
	for (p = 0; p < pagesCount; ++p) {
		TPalette::Page *page = pal->getPage(p);
 
		int s, stylesCount = page->getStyleCount();
		for (s = 0; s < stylesCount; ++s) {
			isi >> color;
			page->getStyle(s)->setMainColor(color);
		}
	}
}
 
//-----------------------------------------------------------------
 
int TVectorBrushStyle::getColorStyleId(int index) const
{
	if (index < 0)
		return 1;
 
	++index; //Skipping transparent
 
	TPalette *pal = m_brush->getPalette();
	assert(pal);
 
	int p, pagesCount = pal->getPageCount();
	for (p = 0; p < pagesCount; ++p) {
		TPalette::Page *page = pal->getPage(p);
 
		int stylesCount = page->getStyleCount();
		if (index - stylesCount < 0)
			break;
 
		index -= stylesCount;
	}
 
	if (p >= pagesCount)
		return -1;
 
	TPalette::Page *page = pal->getPage(p);
	return page->getStyleId(index);
}
 
//-----------------------------------------------------------------
 
TPixel32 TVectorBrushStyle::getMainColor() const
{
	if (!m_brush)
		return TPixel32::Transparent;
 
	TPalette *pal = m_brush->getPalette();
	return pal->getStyle(1)->getMainColor();
}
 
//-----------------------------------------------------------------
 
void TVectorBrushStyle::setMainColor(const TPixel32 &color)
{
	if (!m_brush)
		return;
 
	TPalette *pal = m_brush->getPalette();
	pal->getStyle(1)->setMainColor(color);
}
 
//-----------------------------------------------------------------
 
int TVectorBrushStyle::getColorParamCount() const
{
	return m_colorCount;
}
 
//-----------------------------------------------------------------
 
TPixel32 TVectorBrushStyle::getColorParamValue(int index) const
{
	TPalette *pal = m_brush->getPalette();
	assert(pal);
 
	int styleId = getColorStyleId(index);
	if (styleId < 0)
		styleId = 1;
 
	return pal->getStyle(styleId)->getMainColor();
}
 
//-----------------------------------------------------------------
 
void TVectorBrushStyle::setColorParamValue(int index, const TPixel32 &color)
{
	TPalette *pal = m_brush->getPalette();
	assert(pal);
 
	int styleId = getColorStyleId(index);
	if (styleId < 0)
		styleId = 1;
 
	return pal->getStyle(styleId)->setMainColor(color);
}
 
//**************************************************************
//    Vector Style  global declaration instance
//**************************************************************
 
namespace
{
TColorStyle::Declaration declaration(new TVectorBrushStyle());
}