/* This file is part of Machina.
 * Copyright (C) 2007-2009 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 <cassert>
#include <iostream>
#include "raul/Atom.hpp"
#include "raul/AtomRDF.hpp"
#include "redlandmm/World.hpp"
#include "redlandmm/Model.hpp"

#include "machina/URIs.hpp"

#include "ActionFactory.hpp"
#include "Edge.hpp"
#include "Node.hpp"

using namespace Raul;
using namespace std;

namespace Machina {


Node::Node(TimeDuration duration, bool initial)
	: _enter_time(duration.unit())
	, _duration(duration)
	, _is_initial(initial)
	, _is_selector(false)
	, _is_active(false)
{
}


Node::Node(const Node& copy)
	: Stateful() // don't copy RDF ID
	, _enter_time(copy._enter_time)
	, _duration(copy._duration)
	, _enter_action(ActionFactory::copy(copy._enter_action))
	, _exit_action(ActionFactory::copy(copy._exit_action))
	, _is_initial(copy._is_initial)
	, _is_selector(copy._is_selector)
	, _is_active(false)
{
	for (Edges::const_iterator i = copy._edges.begin(); i != copy._edges.end(); ++i) {
		SharedPtr<Edge> edge(new Edge(*i->get()));
		_edges.push_back(edge);
	}
}


/** Always returns an edge, unless there are none */
SharedPtr<Edge>
Node::random_edge()
{
	SharedPtr<Edge> ret;
	if (_edges.empty())
		return ret;

	size_t i = rand() % _edges.size();

	// FIXME: O(n) worst case :(
	for (Edges::const_iterator e = _edges.begin(); e != _edges.end(); ++e, --i) {
		if (i == 0) {
			ret = *e;
			break;
		}
	}

	return ret;
}


void
Node::edges_changed()
{
	if ( ! _is_selector)
		return;

	// Normalize edge probabilities if we're a selector
	double prob_sum = 0;

	for (Edges::iterator i = _edges.begin(); i != _edges.end(); ++i)
		prob_sum += (*i)->probability();

	for (Edges::iterator i = _edges.begin(); i != _edges.end(); ++i)
		(*i)->set_probability((*i)->probability() / prob_sum);

	_changed = true;
}


void
Node::set_selector(bool yn)
{
	_is_selector = yn;

	if (yn)
		edges_changed();

	_changed = true;
}


void
Node::set_enter_action(SharedPtr<Action> action)
{
	_enter_action = action;
	_changed = true;
}


void
Node::set_exit_action(SharedPtr<Action> action)
{
	_exit_action = action;
	_changed = true;
}


void
Node::enter(SharedPtr<MIDISink> sink, TimeStamp time)
{
	assert(!_is_active);

	_changed = true;
	_is_active = true;
	_enter_time = time;

	if (sink && _enter_action)
		_enter_action->execute(sink, time);
}


void
Node::exit(SharedPtr<MIDISink> sink, TimeStamp time)
{
	assert(_is_active);

	if (sink && _exit_action)
		_exit_action->execute(sink, time);

	_changed = true;
	_is_active = false;
	_enter_time = 0;
}


void
Node::add_edge(SharedPtr<Edge> edge)
{
	assert(edge->tail().lock().get() == this);
	for (Edges::const_iterator i = _edges.begin(); i != _edges.end(); ++i)
		if ((*i)->head() == edge->head())
			return;

	_edges.push_back(edge);
	edges_changed();
}


void
Node::remove_edge(SharedPtr<Edge> edge)
{
	_edges.erase(_edges.find(edge));
	edges_changed();
}


bool
Node::connected_to(SharedPtr<Node> node)
{
	for (Edges::const_iterator i = _edges.begin(); i != _edges.end(); ++i)
		if ((*i)->head() == node)
			return true;

	return false;
}


SharedPtr<Edge>
Node::remove_edge_to(SharedPtr<Node> node)
{
	for (Edges::iterator i = _edges.begin(); i != _edges.end(); ++i) {
		if ((*i)->head() == node) {
			SharedPtr<Edge> edge(*i);
			_edges.erase(i);
			edges_changed();
			return edge;
		}
	}

	return SharedPtr<Edge>();
}


void
Node::set(URIInt key, const Raul::Atom& value)
{
	if (key == URIs::instance().machina_initial) {
		set_initial(value.get_bool());
	} else if (key == URIs::instance().machina_selector) {
		set_selector(value.get_bool());
	}
}


void
Node::write_state(Redland::Model& model)
{
	using namespace Raul;

	const Redland::Node& rdf_id = this->rdf_id(model.world());

	if (_is_selector)
		model.add_statement(
			rdf_id,
			"rdf:type",
			Redland::Node(model.world(), Redland::Node::RESOURCE, "machina:SelectorNode"));
	else
		model.add_statement(
			rdf_id,
			"rdf:type",
			Redland::Node(model.world(), Redland::Node::RESOURCE, "machina:Node"));

	model.add_statement(
		rdf_id,
		"machina:duration",
		AtomRDF::atom_to_node(model, Atom((float)_duration.to_double())));

	if (_enter_action) {
		_enter_action->write_state(model);

		model.add_statement(rdf_id,
		                    "machina:enterAction",
		                    _enter_action->rdf_id(model.world()));
	}

	if (_exit_action) {
		_exit_action->write_state(model);

		model.add_statement(rdf_id,
		                    "machina:exitAction",
		                    _exit_action->rdf_id(model.world()));
	}
}


} // namespace Machina