/* This file is part of Machina.
 * Copyright (C) 2007 Dave 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 2 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 details.
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <algorithm>
#include <raul/midi_events.h>
#include <raul/Quantizer.h>
#include "machina/MachineBuilder.hpp"
#include "machina/Machine.hpp"
#include "machina/Node.hpp"
#include "machina/Edge.hpp"

using namespace std;
using namespace Raul;

namespace Machina {


MachineBuilder::MachineBuilder(SharedPtr<Machine> machine, Raul::BeatTime q)
	: _quantization(q)
	, _time(0)
	, _machine(machine)
	, _initial_node(new Node())
	, _connect_node(_initial_node)
	, _connect_node_end_time(0)
{
	_initial_node->set_initial(true);
}


void
MachineBuilder::reset()
{
	_initial_node = SharedPtr<Node>(new Node());
	_initial_node->set_initial(true);
	_connect_node = _initial_node;
	_connect_node_end_time = 0;
	_time = 0;
}


bool
MachineBuilder::is_delay_node(SharedPtr<Node> node) const
{
	if (node->enter_action() || node->exit_action())
		return false;
	else
		return true;
}


/** Set the duration of a node, with quantization.
 */
void
MachineBuilder::set_node_duration(SharedPtr<Node> node, Raul::BeatTime d) const
{
	Raul::BeatTime q_dur = Quantizer::quantize(_quantization, d);

	// Never quantize a note to duration 0
	if (q_dur == 0 && ( node->enter_action() || node->exit_action() ))
		q_dur = _quantization; // Round up

	node->set_duration(q_dur);
}


/** Connect two nodes, inserting a delay node between them if necessary.
 *
 * If a delay node is added to the machine, it is returned.
 */
SharedPtr<Node>
MachineBuilder::connect_nodes(SharedPtr<Machine> m,
                              SharedPtr<Node>    tail, Raul::BeatTime tail_end_time,
                              SharedPtr<Node>    head, Raul::BeatTime head_start_time)
{
	assert(tail != head);
	assert(head_start_time >= tail_end_time);

	SharedPtr<Node> delay_node;

	if (is_delay_node(tail) && tail->outgoing_edges().size() == 0) {
		// Tail is a delay node, just accumulate the time difference into it
		set_node_duration(tail, tail->duration() + head_start_time - tail_end_time);
		tail->add_outgoing_edge(SharedPtr<Edge>(new Edge(tail, head)));
	} else if (head_start_time == tail_end_time) {
		// Connect directly
		tail->add_outgoing_edge(SharedPtr<Edge>(new Edge(tail, head)));
	} else {
		// Need to actually create a delay node
		delay_node = SharedPtr<Node>(new Node());
		set_node_duration(delay_node, head_start_time - tail_end_time);
		tail->add_outgoing_edge(SharedPtr<Edge>(new Edge(tail, delay_node)));
		delay_node->add_outgoing_edge(SharedPtr<Edge>(new Edge(delay_node, head)));
		m->add_node(delay_node);
	}
	
	return delay_node;
}


void
MachineBuilder::event(Raul::BeatTime time_offset,
                      size_t         ev_size,
                      unsigned char* buf)
{
	Raul::BeatTime t = _time + time_offset;

	if (ev_size == 0)
		return;

	if ((buf[0] & 0xF0) == MIDI_CMD_NOTE_ON) {
		
		SharedPtr<Node> node(new Node());
		node->set_enter_action(SharedPtr<Action>(new MidiAction(ev_size, buf)));

		SharedPtr<Node> this_connect_node;
		Raul::BeatTime  this_connect_node_end_time;

		// If currently polyphonic, use a poly node with no successors as connect node
		// Results in patterns closes to what a human would choose
		if ( ! _poly_nodes.empty()) {
			for (PolyList::iterator j = _poly_nodes.begin(); j != _poly_nodes.end(); ++j) {
				if (j->second->outgoing_edges().empty()) {
					this_connect_node = j->second;
					this_connect_node_end_time = j->first + j->second->duration();
					break;
				}
			}
		}

		// Currently monophonic, or didn't find a poly node, so use _connect_node
		// which is maintained below on note off events.
		if ( ! this_connect_node) {
			this_connect_node          = _connect_node;
			this_connect_node_end_time = _connect_node_end_time;
		}


		SharedPtr<Node> delay_node = connect_nodes(_machine,
				this_connect_node, this_connect_node_end_time, node, t);

		if (delay_node) {
		  _connect_node = delay_node;
		  _connect_node_end_time = t;
		}

		node->enter(SharedPtr<Raul::MIDISink>(), t);
		_active_nodes.push_back(node);

	} else if ((buf[0] & 0xF0) == MIDI_CMD_NOTE_OFF) {
		
		for (ActiveList::iterator i = _active_nodes.begin(); i != _active_nodes.end(); ++i) {
			SharedPtr<MidiAction> action = PtrCast<MidiAction>((*i)->enter_action());
			if (!action)
				continue;

			const size_t         ev_size = action->event_size();
			const unsigned char* ev      = action->event();

			if (ev_size == 3 && (ev[0] & 0xF0) == MIDI_CMD_NOTE_ON
					&& (ev[0] & 0x0F) == (buf[0] & 0x0F) // same channel
					&& ev[1] == buf[1]) // same note
			{
				SharedPtr<Node> resolved = *i;

				resolved->set_exit_action(SharedPtr<Action>(new MidiAction(ev_size, buf)));
				set_node_duration(resolved, t - resolved->enter_time());

				// Last active note
				if (_active_nodes.size() == 1) {

					_connect_node_end_time = t;

					// Finish a polyphonic section
					if (_poly_nodes.size() > 0) {

						_connect_node = SharedPtr<Node>(new Node());
						_machine->add_node(_connect_node);

						connect_nodes(_machine, resolved, t, _connect_node, t);

						for (PolyList::iterator j = _poly_nodes.begin(); j != _poly_nodes.end(); ++j) {
							_machine->add_node(j->second);
							if (j->second->outgoing_edges().size() == 0)
								connect_nodes(_machine, j->second, j->first + j->second->duration(),
										_connect_node, t);
						}
						_poly_nodes.clear();

						_machine->add_node(resolved);

					// Just monophonic
					} else {
						
						// Trim useless delay node if possible (these appear after poly sections)
						if (is_delay_node(_connect_node) && _connect_node->duration() == 0
								&& _connect_node->outgoing_edges().size() == 1
								&& (*_connect_node->outgoing_edges().begin())->head() == resolved) {

							_connect_node->outgoing_edges().clear();
							assert(_connect_node->outgoing_edges().empty());
							_connect_node->set_enter_action(resolved->enter_action());
							_connect_node->set_exit_action(resolved->exit_action());
							resolved->remove_enter_action();
							resolved->remove_exit_action();
							set_node_duration(_connect_node, resolved->duration());
							resolved = _connect_node;
							if (_machine->nodes().find(_connect_node) == _machine->nodes().end())
								_machine->add_node(_connect_node);

						} else {
							_connect_node = resolved;
							_machine->add_node(resolved);
						}
					} 

				// Polyphonic, add this state to poly list
				} else {
					_poly_nodes.push_back(make_pair(resolved->enter_time(), resolved));
					_connect_node = resolved;
					_connect_node_end_time = t;
				}
					
				if (resolved->is_active())
					resolved->exit(SharedPtr<Raul::MIDISink>(), t);

				_active_nodes.erase(i);

				break;
			}
		}
		
	}
}


/** Finish the constructed machine and prepare it for use.
 * Resolve any stuck notes, quantize, etc.
 */
void
MachineBuilder::resolve()
{
	// Resolve stuck notes
	if ( ! _active_nodes.empty()) {
		for (list<SharedPtr<Node> >::iterator i = _active_nodes.begin(); i != _active_nodes.end(); ++i) {
			cerr << "WARNING:  Resolving stuck note." << endl;
			SharedPtr<MidiAction> action = PtrCast<MidiAction>((*i)->enter_action());
			if (!action)
				continue;

			const size_t         ev_size = action->event_size();
			const unsigned char* ev      = action->event();
			if (ev_size == 3 && (ev[0] & 0xF0) == MIDI_CMD_NOTE_ON) {
				unsigned char note_off[3] = { ((MIDI_CMD_NOTE_OFF & 0xF0) | (ev[0] & 0x0F)), ev[1], 0x40 };
				(*i)->set_exit_action(SharedPtr<Action>(new MidiAction(3, note_off)));
				set_node_duration((*i), _time - (*i)->enter_time());
				(*i)->exit(SharedPtr<Raul::MIDISink>(), _time);
				_machine->add_node((*i));
			}
		}
		_active_nodes.clear();
	}

	// Add initial note if necessary
	if (_machine->nodes().size() > 0 
			&& _machine->nodes().find(_initial_node) == _machine->nodes().end())
		_machine->add_node(_initial_node);

}


SharedPtr<Machine>
MachineBuilder::finish()
{
	resolve();

	return _machine;
}


} // namespace Machina