/* This file is part of Machina.
 * Copyright 2007-2011 David Robillard <http://drobilla.net>
 *
 * Machina is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Machina is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Machina.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "ganv/Canvas.hpp"

#include "machina/Controller.hpp"
#include "machina/types.hpp"

#include "EdgeView.hpp"
#include "MachinaCanvas.hpp"
#include "MachinaGUI.hpp"
#include "NodeView.hpp"

using Machina::URIs;

/* probability colour stuff */

#define RGB_TO_UINT(r, g, b) ((((guint)(r)) << 16) | (((guint)(g)) << 8) | ((guint)(b)))
#define RGB_TO_RGBA(x, a) (((x) << 8) | ((((guint)a) & 0xff)))
#define RGBA_TO_UINT(r, g, b, a) RGB_TO_RGBA(RGB_TO_UINT(r, g, b), a)

#define UINT_RGBA_R(x) (((uint32_t)(x)) >> 24)
#define UINT_RGBA_G(x) ((((uint32_t)(x)) >> 16) & 0xff)
#define UINT_RGBA_B(x) ((((uint32_t)(x)) >> 8) & 0xff)
#define UINT_RGBA_A(x) (((uint32_t)(x)) & 0xff)

#define MONO_INTERPOLATE(v1, v2, t) ((int)rint((v2) * (t) + (v1) * (1 - (t))))

#define UINT_INTERPOLATE(c1, c2, t) \
	RGBA_TO_UINT(MONO_INTERPOLATE(UINT_RGBA_R(c1), UINT_RGBA_R(c2), t), \
	             MONO_INTERPOLATE(UINT_RGBA_G(c1), UINT_RGBA_G(c2), t), \
	             MONO_INTERPOLATE(UINT_RGBA_B(c1), UINT_RGBA_B(c2), t), \
	             MONO_INTERPOLATE(UINT_RGBA_A(c1), UINT_RGBA_A(c2), t) )

inline static uint32_t edge_color(float prob)
{
	static const uint32_t min = 0xFF4444C0;
	static const uint32_t mid = 0xFFFF44C0;
	static const uint32_t max = 0x44FF44C0;

	if (prob <= 0.5) {
		return UINT_INTERPOLATE(min, mid, prob * 2.0);
	} else {
		return UINT_INTERPOLATE(mid, max, (prob - 0.5) * 2.0);
	}
}

/* end probability colour stuff */

using namespace Ganv;

EdgeView::EdgeView(Canvas&                                  canvas,
                   SharedPtr<NodeView>                      src,
                   SharedPtr<NodeView>                      dst,
                   SharedPtr<Machina::Client::ClientObject> edge)
	: Ganv::Edge(canvas, src.get(), dst.get(), 0x9FA0A0F4, true, false)
	, _edge(edge)
{
	set_color(edge_color(probability()));

	edge->signal_property.connect(
		sigc::mem_fun(this, &EdgeView::on_property));

	signal_event().connect(
		sigc::mem_fun(this, &EdgeView::on_event));
}

float
EdgeView::probability() const
{
	return _edge->get(URIs::instance().machina_probability).get_float();
}

double
EdgeView::length_hint() const
{
	NodeView* tail = dynamic_cast<NodeView*>(get_tail());
	return tail->node()->get(URIs::instance().machina_duration).get_float()
		* 10.0;
}

void
EdgeView::show_label(bool show)
{
	set_color(edge_color(probability()));
}

bool
EdgeView::on_event(GdkEvent* ev)
{
	MachinaCanvas* canvas = dynamic_cast<MachinaCanvas*>(this->canvas());
	Raul::Forge&   forge  = canvas->app()->forge();

	if (ev->type == GDK_BUTTON_PRESS) {
		if (ev->button.state & GDK_CONTROL_MASK) {
			if (ev->button.button == 1) {
				canvas->app()->controller()->set_property(
					_edge->id(),
					URIs::instance().machina_probability,
					forge.make(float(probability() - 0.1f)));
				return true;
			} else if (ev->button.button == 3) {
				canvas->app()->controller()->set_property(
					_edge->id(),
					URIs::instance().machina_probability,
					forge.make(float(probability() + 0.1f)));
				return true;
			}
		}
	}
	return false;
}

void
EdgeView::on_property(Machina::URIInt key, const Raul::Atom& value)
{
	if (key == URIs::instance().machina_probability) {
		set_color(edge_color(value.get_float()));
	}
}