#include <freetype2 ft2build.h=""></freetype2>

#include FT_BITMAP_H

#include <pango pangoft2.h=""></pango>

#include "layoutdraw.h"

template<bool antialiasing,="" bool="" eraze=""></bool>

static void

put_ft_bitmap(

	Surface &surface,

	const IntPair2 &/*bounds*/,

	const FT_Bitmap &bitmap,

	const IntVector2 &offset,

	const Color &color )

{

	const IntPair2 b = /*bounds

					 & */IntPair2( IntVector2(0, 0), IntVector2(surface.width(), surface.height()) )

					 & IntPair2( offset, IntVector2(offset.x + bitmap.width, offset.y + bitmap.rows) );

	if (b.empty())

		return;

	const IntVector2 size = b.size();

	const IntVector2 sp0 = b.p0 - offset;

	const int pitch = surface.pitch();

	Color *dp = &surface[b.p0.y][b.p0.x];

	const int dstep = pitch - size.x;

	if (antialiasing) {

		const unsigned char *sp = bitmap.buffer + sp0.y*bitmap.pitch + sp0.x;

		const int sstep = bitmap.pitch - size.x;

		for(const Color *end = dp + pitch*size.y; dp != end; dp += dstep, sp += sstep) {

			for(const Color *row_end = dp + size.x; dp < row_end; ++dp, ++sp) {

				const Real a = *sp*(1/255.0);

				if (eraze) *dp *= 1-a;

					  else *dp = *dp*(1-a) + color*a;

			}

		}

	} else {

		const unsigned char *sp = bitmap.buffer + sp0.y*bitmap.pitch;

		const int sstep = bitmap.pitch;

		const int sp1x = sp0.x + size.x;

		for(const Color *end = dp + pitch*size.y; dp != end; dp += dstep, sp += sstep)

			for(int bit = sp0.x; bit < sp1x; ++dp, ++bit)

				if (sp[bit/8] & (128 >> (bit%8)))

					*dp = eraze ? Color() : color;

	}

}

void

LayoutDraw::draw(

	Surface &surface,

	const IntPair2 &bounds,

	const RefPtr<transformedlayout> &layout,</transformedlayout>

	const Matrix &matrix,

	const Color &color,

	bool eraze,

	const Vector2 &position,

	const Real *realign )

{

	if (!layout)

		return;

	IntPair2 b = bounds & IntPair2(IntVector2(), IntVector2(surface.width(), surface.height()));

	if (b.empty())

		return;

	const Matrix2 &spacing_matrix = layout->get_spacing_matrix();

	const Matrix2 &glyph_matrix = layout->get_glyph_matrix();

	const Pair2 fb(Vector2(b.p0.x, b.p0.y), Vector2(b.p1.x, b.p1.y));

	const Pair2 flb = matrix.transform_bounds(layout->get_bounds() + spacing_matrix*position);

	if ((fb & flb).empty())

		return;

	const Matrix3 full_spacing_matrix = matrix * Matrix3(

		Vector3(spacing_matrix.row_x()),

		Vector3(spacing_matrix.row_y()) );

	const Matrix2 full_glyph_matrix = Matrix2(

		matrix.row_x().vec2(),

		matrix.row_y().vec2() )*glyph_matrix;

	FT_Matrix mat = {};

	mat.xx = (int)round( full_glyph_matrix.m00*65536);

	mat.xy = (int)round(-full_glyph_matrix.m10*65536);

	mat.yx = (int)round(-full_glyph_matrix.m01*65536);

	mat.yy = (int)round( full_glyph_matrix.m11*65536);

	FT_Vector vec = {};

	const bool hinting = layout->get_layout()->get_hinting();

	const bool antialiasing = layout->get_layout()->get_antialiasing();

	const FT_Int32 load_flags = hinting ? FT_LOAD_DEFAULT : FT_LOAD_NO_HINTING;

	const FT_Render_Mode render_mode = antialiasing ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO;

	const Pair2 &logical_bounds = layout->get_layout()->get_logical_bounds();

	const Layout::LineList &lines = layout->get_layout()->get_lines();

	const TransformedLayout::LineBoundsList &line_bounds = layout->get_line_bounds();

	PangoFont *font = nullptr;

	assert(lines.size() == line_bounds.size());

	TransformedLayout::LineBoundsList::const_iterator lbi = line_bounds.begin();

	for(Layout::LineList::const_iterator li = lines.begin(); li != lines.end(); ++li, ++lbi) {

		Vector2 linepos = li->position;

		if (realign)

			linepos.x = (logical_bounds.p1.x - li->logical_bounds.p1.x)*clamp(*realign, 0, 1);

		linepos += position;

		const Vector2 lb_offset = spacing_matrix*linepos;

		const Pair2 lb = matrix.transform_bounds(*lbi + lb_offset);

		if ((fb & lb).empty())

			continue;

		for(Layout::RunList::const_iterator ri = li->runs.begin(); ri != li->runs.end(); ++ri) {

			assert(ri->font);

			PangoFont *next_font = ri->font->gobj();

			if (!next_font) continue;

			if (font != next_font) {

				if (font) pango_fc_font_unlock_face((PangoFcFont*)font);

				font = next_font;

			}

			assert(PANGO_IS_FC_FONT(font));

			FT_Face face = pango_fc_font_lock_face((PangoFcFont*)font);

			for(Layout::GlyphList::const_iterator gi = ri->glyphs.begin(); gi != ri->glyphs.end(); ++gi) {

				const Vector2 gb_offset = (full_spacing_matrix*Vector3(linepos + gi->position, 1)).vec2();

				const Pair2 gb = full_glyph_matrix.transform_bounds(gi->bounds) + gb_offset;

				if ((fb & gb).empty())

					continue;

				const Vector2 gp = gb_offset + full_glyph_matrix*gi->origin;

				const int fx = (int)round(gp.x*64);

				const int fy = (int)round(gp.y*64);

				int ix = fx / 64;

				int iy = fy / 64;

				vec.x = fx % 64;

				vec.y = fy % 64;

				if (hinting) {

					if (vec.x >= 32) ++ix;

					if (vec.y >= 32) ++iy;

					vec.x = 0;

					vec.y = 0;

				}

				vec.y = -vec.y;

				FT_Set_Transform(face, &mat, &vec);

				if ( !FT_Load_Glyph(face, gi->glyph_index, load_flags)

				  && !FT_Render_Glyph(face->glyph, render_mode) )

				{

					const FT_Bitmap &bitmap = face->glyph->bitmap;

					const IntVector2 offset( ix + face->glyph->bitmap_left,

											 iy - face->glyph->bitmap_top );

					if (antialiasing) {

						if (eraze) put_ft_bitmap<true ,="" true="">(surface, bounds, bitmap, offset, color);</true>

							  else put_ft_bitmap<true ,="" false="">(surface, bounds, bitmap, offset, color);</true>

					} else {

						if (eraze) put_ft_bitmap<false, true="">(surface, bounds, bitmap, offset, color);</false,>

							  else put_ft_bitmap<false, false="">(surface, bounds, bitmap, offset, color);</false,>

					}

				}

			}

		}

	}

	if (font) pango_fc_font_unlock_face((PangoFcFont*)font);

}