// default constructor with owner
GAnimTRSNode2D::GAnimTRSNode2D(const GElement* Owner) : GAnimElement(Owner) {

	// gPivotPosition is automatically set to (0, 0)
	gPivotRotation = 0;
	gPivotScale.Set(1, 1);
	gFather = NULL;
	gCustomData = NULL;

	// add TRS properties
	GBool alreadyExists;
	GUInt32 index;

	GProperty *tmpProp = AddProperty("transform", G_PROPERTY_CLASSID, GKeyValue(), alreadyExists, index);
	if (tmpProp) {
		G_ASSERT(alreadyExists == G_FALSE);
		// default value for "x" and "y" sub-properties will be set automatically to 0
		tmpProp->AddProperty("position", G_TWOHERMITEPROPERTY1D_CLASSID, GKeyValue(), alreadyExists, index);
		G_ASSERT(alreadyExists == G_FALSE);
		tmpProp->AddProperty("rotation", G_HERMITEPROPERTY1D_CLASSID, GKeyValue((GReal)0), alreadyExists, index);
		G_ASSERT(alreadyExists == G_FALSE);
		// we must impose a default value of 1 to "x" and "y" sub-properties
		GProperty *p = tmpProp->AddProperty("scale", G_TWOHERMITEPROPERTY1D_CLASSID, GKeyValue(), alreadyExists, index);
		G_ASSERT(alreadyExists == G_FALSE);
		p->Property("x")->SetDefaultValue(GKeyValue((GReal)1));
		p->Property("y")->SetDefaultValue(GKeyValue((GReal)1));
	}
}

GError GAnimTRSNode2D::SetScale(const GTimeValue TimePos, const GVectBase<GReal, 2>& RelScale) {

	GError err;
	GProperty *tmpProp = Property("transform");

	// this can be the case of a curve not created through a kernel
	if (!tmpProp) {
		err = G_MISSING_KERNEL;
	}
	else {
		// extract position track
		GProperty *scaleProp = tmpProp->Property("scale");
		G_ASSERT(scaleProp);

		GKeyValue tmpValue;
		tmpValue.SetTimePosition(TimePos);

		// set "x" property
		tmpProp = scaleProp->Property("x");
		G_ASSERT(tmpProp != NULL);
		tmpValue.SetValue(RelScale[G_X]);
		err = tmpProp->SetValue(tmpValue, TimePos, G_ABSOLUTE_VALUE);
		if (err != G_NO_ERROR)
			return err;
		// set "y" property
		tmpProp = scaleProp->Property("y");
		G_ASSERT(tmpProp != NULL);
		tmpValue.SetValue(RelScale[G_Y]);
		err = tmpProp->SetValue(tmpValue, TimePos, G_ABSOLUTE_VALUE);
	}
	return err;
}

// clone properties
GError GAnimElement::CloneProperties(const GAnimElement& Source) {

	const GProperty *srcProp;
	GProperty *tmpProp;
	GBool alreadyExists;
	GUInt32 i;
	GError err;

	G_ASSERT(this != &Source);

	GDynArray<GProperty *>::const_iterator it = Source.gProperties.begin();
	
	// clone every property
	for (; it != Source.gProperties.end(); ++it) {
		srcProp = *it;
		G_ASSERT(srcProp != NULL);

		tmpProp = AddProperty(srcProp->Name(), srcProp->ClassID(), GKeyValue(), alreadyExists, i);
		if (tmpProp) {
			// lets do copy
			err = tmpProp->CopyFrom(*srcProp);
			if (err != G_NO_ERROR)
				RemoveProperty(i);
		}
		else
			G_ASSERT(tmpProp != NULL);
	}
	return G_NO_ERROR;
}

void Label::setAttachPoint(int p_attachPoint)
{
	G_ASSERT(!((p_attachPoint & AP_LEFT) && (p_attachPoint & AP_RIGHT)) && "bad value");
	G_ASSERT(!((p_attachPoint & AP_TOP) && (p_attachPoint & AP_BOTTOM)) && "bad value");

	m_attachPoint = p_attachPoint;
}

void ShaderImpl::begin(CL_GraphicContext &p_gc)
{
	G_ASSERT(m_initialized);
	G_ASSERT(!m_began);

	// new texture
	m_drawRect = m_parent->getDrawRect(m_boundRect);
	m_texture = CL_Texture(p_gc, m_drawRect.get_width(), m_drawRect.get_height());

	// attach frame buffer
	m_frameBuffer.attach_color_buffer(0, m_texture);
	p_gc.set_frame_buffer(m_frameBuffer);

	// clear to transparent
	p_gc.clear(CL_Colorf::transparent);

	// set proper matrix
	p_gc.push_modelview();

	// get scaling in count
	const CL_Mat4f &matrix = p_gc.get_modelview();
	const float scaleX = matrix[0];
	const float scaleY = matrix[5];

	p_gc.mult_translate(-m_drawRect.left / scaleX, -m_drawRect.top / scaleY);

	m_began = true;
}

void GOpenGLBoard::GrabFrameBuffer(const GAABox2& LogicBox, GLGrabbedRect& Shot) {

	GLDisableShaders();

	GReal left, right, bottom, top;
	Projection(left, right, bottom, top);

	if (LogicBox.Min()[G_X] > left)
		left = LogicBox.Min()[G_X];
	if (LogicBox.Max()[G_X] < right)
		right = LogicBox.Max()[G_X];
	if (LogicBox.Min()[G_Y] > bottom)
		bottom = LogicBox.Min()[G_Y];
	if (LogicBox.Max()[G_Y] < top)
		top = LogicBox.Max()[G_Y];

	GAABox2 tmpBox(GPoint2(left, bottom), GPoint2(right, top));

	GPoint<GInt32, 2> p0 = LogicalToPhysicalInt(tmpBox.Min());
	GPoint<GInt32, 2> p1 = LogicalToPhysicalInt(tmpBox.Max());
	p0[G_X] -= 1;
	p0[G_Y] -= 1;
	p1[G_X] += 1;
	p1[G_Y] += 1;
	GGenericAABox<GInt32, 2> intBox(p0, p1);

	GUInt32 width = (GUInt32)GMath::Abs(p1[G_X] - p0[G_X]);
	GUInt32 height = (GUInt32)GMath::Abs(p1[G_Y] - p0[G_Y]);

	glPixelStorei(GL_PACK_ALIGNMENT, 1);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	UpdateGrabBuffer(width, height, Shot);

	G_ASSERT(Shot.TexName > 0);
	G_ASSERT(Shot.TexWidth > 0 && Shot.TexHeight > 0);
	G_ASSERT(Shot.TexWidth >= width && Shot.TexHeight >= height);

	SELECT_AND_DISABLE_TUNIT(1)
	SELECT_AND_DISABLE_TUNIT(0)
	glEnable(Shot.Target);
	glBindTexture(Shot.Target, Shot.TexName);
	glCopyTexSubImage2D(Shot.Target, 0, 0, 0, (GLint)intBox.Min()[G_X], (GLint)intBox.Min()[G_Y], (GLsizei)width, (GLsizei)height);

	Shot.Width = width;
	Shot.Height = height;
	Shot.IsEmpty = G_FALSE;

	Shot.gNotExpandedLogicBox = tmpBox;

	GPoint2 q0 = PhysicalToLogical(p0);
	GPoint2 q1 = PhysicalToLogical(p1);
	Shot.gExpandedLogicBox.SetMinMax(q0, q1);

	SELECT_AND_DISABLE_TUNIT(0)
	glPixelStorei(GL_PACK_ALIGNMENT, 4);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
}

 /**
  * @brief Realization::clear
  */
 void Realization::clear()
 {
     Entity::SharedClass head = std::dynamic_pointer_cast<Entity::Class>(G_ASSERT(headClass()));
     Q_ASSERT_X(head, "Realization::clear", "head class not found or not Class");
     for (auto method : m_Methods) {
         head->removeMethods(method->name());
         G_ASSERT(tailClass())->removeMethods(method->name());
     }
 }

void RaceScene::initializeOnline(const CL_String &p_hostname, int p_port)
{
	G_ASSERT(p_hostname.length() > 0);
	G_ASSERT(p_port > 0 && p_port <= 0xFFFF);

	if (!m_initialized) {
		m_logic = new Race::OnlineRaceLogic(p_hostname, p_port);
		initCommon();
	}

}

/*
 * Event source function - destructor of the source, called 
 *  before the source object destroyed. we decrease the reference
 *  count of ioc channel since the source object owes the count
 *  of it.
*/
static void
hm_watch_finalize(GSource *source)
{
    HmWatch *watch;
    G_ASSERT(source != NULL);

    g_atomic_int_add(&total_watch_count, -1);

    watch = (HmWatch*)source;

    hm_debug(
        "Net IO '%p' finalized. total %d left.",
        NET_IO(watch), g_atomic_int_get(&total_watch_count)
    );

    if (watch->funcs && watch->funcs->finalize)
    {
        (*watch->funcs->finalize)(watch);
    }

    hm_watch_destroy_private(watch->priv_data);
    watch->priv_data = NULL;

    if (watch->conn)    /* we need to flush the rest of data!!! */
    {
        hm_connection_close(watch->conn);
    }

    if (watch->buffer)
    {
        hm_net_buf_free(watch->buffer);
    }

    g_mutex_free(watch->lock);
}

OnlineRaceLogic::OnlineRaceLogic(const CL_String &p_host, int p_port) :
	m_initialized(false),
	m_host(p_host),
	m_port(p_port),
	m_client(&Game::getInstance().getNetworkConnection()),
	m_localPlayer(Game::getInstance().getPlayer()),
	m_voteRunning(false)
{
	G_ASSERT(p_port > 0 && p_port <= 0xFFFF);

	m_client->setServerAddr(m_host);
	m_client->setServerPort(m_port);

	// connect signal and slots from player's car
	Car &car = m_localPlayer.getCar();

	m_slots.connect(car.sig_inputChanged(), this, &OnlineRaceLogic::onInputChange);

	// connect signals and slots from client
	m_slots.connect(m_client->sig_connected(),         this, &OnlineRaceLogic::onConnected);
	m_slots.connect(m_client->sig_disconnected(),      this, &OnlineRaceLogic::onDisconnected);
	m_slots.connect(m_client->sig_goodbyeReceived(),   this, &OnlineRaceLogic::onGoodbye);
	m_slots.connect(m_client->sig_playerJoined(),      this, &OnlineRaceLogic::onPlayerJoined);
	m_slots.connect(m_client->sig_playerLeaved(),      this, &OnlineRaceLogic::onPlayerLeaved);
	m_slots.connect(m_client->sig_gameStateReceived(), this, &OnlineRaceLogic::onGameState);
	m_slots.connect(m_client->sig_carStateReceived(),  this, &OnlineRaceLogic::onCarState);
	m_slots.connect(m_client->sig_raceStartReceived(), this, &OnlineRaceLogic::onRaceStart);
	m_slots.connect(m_client->sig_voteStarted(),       this, &OnlineRaceLogic::onVoteStarted);
	m_slots.connect(m_client->sig_voteEnded(),         this, &OnlineRaceLogic::onVoteEnded);
	m_slots.connect(m_client->sig_voteTickReceived(),  this, &OnlineRaceLogic::onVoteTick);
}

void OnlineRaceLogic::onPlayerLeaved(const CL_String &p_name)
{
	// get the player
	Player &player = getPlayer(p_name);

	// remove from level
	getLevel().removeCar(&player.getCar());

	// remove from game
	removePlayer(player);

	TPlayerList::iterator itor;
	bool found = false;

	for (itor = m_remotePlayers.begin(); itor != m_remotePlayers.end(); ++itor) {

		if (reinterpret_cast<unsigned> (itor->get()) == reinterpret_cast<unsigned> (&player)) {
			m_remotePlayers.erase(itor);
			found = true;
			break;
		}
	}

	G_ASSERT(found);
	display(cl_format("Player %1 leaved", p_name));
}

__export NmpIO *
nmp_io_new(NmpConnection *conn, NmpPacketProto *proto, 
	NmpIOFuncs *funcs, gsize size)
{
	NmpIO *io;
	G_ASSERT(conn != NULL && proto != NULL && funcs != NULL);

	if (nmp_connection_is_blocked(conn))
	{
		nmp_warning(
			"Net create io on blocked connection '%p'.",
			conn
		);
		return NULL;		
	}

	io = (NmpIO*)nmp_watch_create(
		conn, &nmp_io_watch_funcs, size);
	if (!io)
	{
		nmp_warning(
			"Net create watch failed."
		);
		return NULL;
	}

	nmp_io_initialize(io, 0);

	io->proto = proto;
	io->funcs = funcs;

	return io;
}

__export void
hm_watch_unref(HmWatch *watch)
{
    G_ASSERT(watch != NULL);

    g_source_unref((GSource*)watch);
}

static void
nmp_sysmsg_default_priv_des(gpointer priv, gsize size)
{
    G_ASSERT(priv != NULL);

    nmp_mem_kfree(priv, size);
}

gint
nmp_sysmsg_set_userdata(NmpSysMsg *msg, gpointer data, gsize size)
{
	gpointer p;
	G_ASSERT(NMP_IS_SYSMSG(msg));

	if (data && size)
	{
		p = nmp_mem_kalloc(size);
		if (!p)
		{
			return -ENOMEM;
		}

		if (msg->user_data)
		{
			nmp_mem_kfree(msg->user_data, msg->user_size);
		}

		msg->user_data = p;
		msg->user_size = size;
		memcpy(msg->user_data, data, size);
		return 0;
	}

	return -EINVAL;
}

__export gint
hm_net_kill_io(HmNet *net, HmNetIO *net_io)
{
    G_ASSERT(net != NULL && net_io != NULL);

    return _hm_net_kill_io(net, net_io, 0, 0);
}

//------------------------------------------------------------
GError QGLWidgetTest::LoadAndTesselateGlyphs(const GString& FileName, const GReal Deviation) {

	if (!FileUtils::FileExists(StrUtils::ToAscii(FileName)))
		return G_FILE_NOT_FOUND;

	// create the font
	GFont2D *font = (GFont2D *)gKernel->CreateNew(G_FONT2D_CLASSID);
	if (!font)
		return G_MEMORY_ERROR;
	// load the font, normalizing points into [0;1]x[0;1] range (scale=0 option)
	GError err = font->Load(StrUtils::ToAscii(FileName), "scale=0");
	if (err != G_NO_ERROR)
		return err;
	// flatten and tessellate every character
	GInt32 i, j = font->CharsCount();
	for (i = 0; i < j; ++i) {
		const GFontChar2D *fontChar = font->CharByIndex(i);
		G_ASSERT(fontChar != NULL);
		if (!fontChar->IsComposite()) {
			GTesselatedGlyph *tessGlyph = new(std::nothrow) GTesselatedGlyph(fontChar, Deviation);
			if (tessGlyph) {
				gTesselatedGlyphs.push_back(tessGlyph);
			}
		}
	}
	// delete font from memory and return
	delete font;
	return G_NO_ERROR;
}

gint
nmp_mod_mds_setup(NmpAppMod *am_self)
{
	gint err;
	NmpModAccess *ma_self;
	NmpModMds *self;
	struct sockaddr_in sin;
	G_ASSERT(am_self != NULL);

	self = (NmpModMds*)am_self;
	ma_self = (NmpModAccess*)am_self;

	bzero(&sin, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(JPFCMS_MDU_PORT);
	sin.sin_addr.s_addr = INADDR_ANY;

	nmp_mod_acc_init_net(ma_self, &nmp_packet_proto, &nmp_xml_proto);

	self->listen_io = nmp_mod_acc_create_listen_io(
		ma_self, (struct sockaddr*)&sin, &err
	);
	if (!self->listen_io)
	{
		nmp_error("<NmpModPu> create listen io failed!");
		return err;
	}

	nmp_net_set_heavy_io_load(self->listen_io);
	nmp_app_mod_set_name(am_self, "MOD-MDU");
	nmp_mod_mds_register_msg_handler(self);

	return 0;
}

/*
 * Create a event source object for connection. The object 
 * will be added to "Event Context" for polling. 
*/ 
__export HmWatch *
hm_listen_watch_create(HmConnection *conn, HmWatchFuncs *funcs, gint size)
{
    GSource *source;
    HmWatch *watch;
    G_ASSERT(conn != NULL && funcs != NULL && size >= sizeof(HmWatch));

    source = g_source_new(&hm_watch_funcs, size);
    watch = (HmWatch*)source;

    watch->buffer = NULL;

    watch->lock = g_mutex_new();
    watch->conn = conn;
    watch->funcs = funcs;

    watch->r_fd.fd = hm_connection_get_fd(conn);
    watch->r_fd.events = READ_COND;
    watch->r_fd.revents = 0;

    hm_watch_init_time(watch);

    watch->w_pending = 0;
    watch->killed = 0;
    watch->heavy_io_load = hm_connection_is_heavy(conn);
    watch->block_size = hm_connection_get_buffer_size(conn);

    hm_watch_set_callback(watch, hm_watch_listen_dispatch, NULL);
    g_source_add_poll(source, &watch->r_fd);
    g_atomic_int_add(&total_watch_count, 1);

    return watch;
}

__export void
hm_watch_attach(HmWatch *watch, GMainContext *context)
{
    G_ASSERT(watch != NULL);

    g_source_attach((GSource*)watch, context);
}