#include <algorithm></algorithm>

#include <iostream></iostream>

#include <glib.h></glib.h>

#include <glibmm.h></glibmm.h>

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

#include FT_BITMAP_H

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

#include <pango pango-renderer.h=""></pango>

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

#include "surface.h"

#include "log.h"

#include "freetypeview.h"

static void put_bitmap(Surface &surface, FT_Bitmap &bitmap, int x, int y, const Color &color);

// my pango renderer

#define MY_TYPE_PANGO_RENDERER (my_pango_renderer_get_type ())

struct _MyPangoRenderer {

	PangoRenderer parent_instance;

	Surface *surface;

	ColorReal color[4];

};

struct _MyPangoRendererClass {

  PangoRendererClass parent_class;

};

typedef _MyPangoRenderer MyPangoRenderer;

typedef _PangoRendererClass MyPangoRendererClass;

#define PANGO_FT2_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FT2_RENDERER, PangoFT2RendererClass))

#define PANGO_IS_FT2_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FT2_RENDERER))

#define PANGO_FT2_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FT2_RENDERER, PangoFT2RendererClass))

G_DEFINE_TYPE(MyPangoRenderer, my_pango_renderer, PANGO_TYPE_RENDERER)

static void

my_pango_renderer_draw_glyph(

	PangoRenderer *renderer,

	PangoFont     *font,

	PangoGlyph     glyph,

	double         x,

	double         y )

{

	MyPangoRenderer *my_renderer = (MyPangoRenderer*)renderer;

	if (!my_renderer->surface)

		return;

	const Color &color = *(const Color*)my_renderer->color;

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

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

	const int ix = fx / 64;

	const int iy = fy / 64;

	FT_Vector vec = {};

	vec.x = fx % 64;

	vec.y = fy % 64;

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

	FT_Set_Transform(face, nullptr, &vec);

	if (!FT_Load_Glyph(face, glyph, FT_LOAD_NO_HINTING)) {

		if (!FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL)) {

			put_bitmap(

				*my_renderer->surface,

				face->glyph->bitmap,

				face->glyph->bitmap_left + ix,

				iy - face->glyph->bitmap_top,

				color );

		}

	}

	pango_fc_font_unlock_face((PangoFcFont*)font);

}

static void

my_pango_renderer_draw_trapezoid(

	PangoRenderer  *renderer,

	PangoRenderPart part,

	double          y1,

	double          x11,

	double          x21,

	double          y2,

	double          x12,

	double          x22 )

{

	std::cout << "my_pango_renderer_draw_trapezoid" << std::endl;

}

static void

my_pango_renderer_init(MyPangoRenderer *renderer) {

	renderer->surface = nullptr;

	*(Color*)renderer->color = Color();

}

static void

my_pango_renderer_class_init(MyPangoRendererClass *klass)

{

  PangoRendererClass *renderer_class = PANGO_RENDERER_CLASS(klass);

  renderer_class->draw_glyph = my_pango_renderer_draw_glyph;

  renderer_class->draw_trapezoid = my_pango_renderer_draw_trapezoid;

}

PangoRenderer*

my_pango_renderer_new(Surface &surface, const Color &color) {

  MyPangoRenderer *renderer = (MyPangoRenderer*)g_object_new(MY_TYPE_PANGO_RENDERER, nullptr);

  renderer->surface = &surface;

  *(Color*)renderer->color = color;

  return (PangoRenderer*)renderer;

}

static void set_substitute(FcPattern *pattern, gpointer) {

	FcPatternDel(pattern, FC_HINTING);

	FcPatternAddBool(pattern, FC_HINTING, FcFalse);

}

static void put_bitmap(Surface &surface, FT_Bitmap &bitmap, int x, int y, const Color &color) {

	if (x >= surface.width() || y >= surface.height())

		return;

	if (x + (int)bitmap.width <= 0 || y + (int)bitmap.rows <= 0)

		return;

	const int bx = std::max(0, -x);

	const int by = std::max(0, -y);

	x = std::max(0, x);

	y = std::max(0, y);

	const int w = std::min(surface.width() - x, (int)bitmap.width - bx);

	const int h = std::min(surface.height() - y, (int)bitmap.rows - by);

	const int pitch = surface.pitch();

	Color *dst_pixel = &surface[y][x];

	const int dst_row_step = pitch - w;

	const unsigned char *src_pixel = bitmap.buffer + by*bitmap.pitch + bx;

	const int src_row_step = bitmap.pitch - w;

	for(const Color *end = dst_pixel + pitch*h; dst_pixel != end; dst_pixel += dst_row_step, src_pixel += src_row_step) {

		for(const Color *row_end = dst_pixel + w; dst_pixel != row_end; ++dst_pixel, ++src_pixel) {

			Real a = *src_pixel * (1/255.0);

			*dst_pixel = *dst_pixel*(1-a) + color*a;

		}

	}

}

FreeTypeView::FreeTypeView() {

	params.family = "Ani";

	params.bold = false;

	params.italic = false;

	params.size = 12;

	params.position = Vector2(15.5, 18.4);

	params.color = Color(1, 1, 0, 1);

	params.text = "Hello World! 123456";

	Glib::signal_timeout().connect(

		sigc::mem_fun(*this, &FreeTypeView::on_timeout),

		20,

		Glib::PRIORITY_DEFAULT_IDLE );

}

FreeTypeView::~FreeTypeView()

	{ }

bool

FreeTypeView::on_timeout() {

	if (!is_visible()) return false;

	params.position.x += 0.01;

	update_surface();

	return true;

}

void

FreeTypeView::update_surface() {

	this->surface.clear();

	const int width = get_allocated_width();

	const int height = get_allocated_height();

	if (width <= 0 || height <= 0)

		return;

	// init

	PangoFontMap *font_map = pango_ft2_font_map_new();

	pango_ft2_font_map_set_default_substitute(

		(PangoFT2FontMap*)font_map,

		&set_substitute,

		nullptr,

		nullptr );

	PangoContext *context = pango_font_map_create_context(font_map);

	// load font

	PangoFontDescription *font_desc = pango_font_description_new();

	pango_font_description_set_family(font_desc, params.family.c_str());

	pango_font_description_set_weight(font_desc, params.bold ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);

	pango_font_description_set_style(font_desc, params.italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);

	pango_font_description_set_absolute_size(font_desc, params.size * PANGO_SCALE);

	PangoFont *font = pango_font_map_load_font(font_map, context, font_desc);	

	// create layout

	PangoLayout *layout = pango_layout_new(context);

	pango_layout_set_font_description(layout, font_desc);

	pango_layout_set_text(layout, params.text.c_str(), (int)params.text.size());

	// reneder

	DataSurface surface(width, height);

	PangoRenderer *renderer = my_pango_renderer_new(surface, params.color);

	pango_renderer_draw_layout(

		renderer,

		layout,

		(int)round(params.position.x*PANGO_SCALE),

		(int)round(params.position.y*PANGO_SCALE) );

	// free pango

	g_object_unref(renderer);

	pango_font_description_free(font_desc);

	g_object_unref(layout);

	g_object_unref(font);

	g_object_unref(context);

	g_object_unref(font_map);

	this->surface = surface.to_cairo_surface(true);

	queue_draw();

}

void

FreeTypeView::on_draw_view(const Cairo::RefPtr<cairo::context> &context) {</cairo::context>

	if (surface) {

		context->save();

		context->transform(transform_from_pixels().to_cairo());

		context->set_source(surface, 0, 0);

		context->paint();

		context->restore();

	}

}