/*
    Copyright (C) 2000-2003 Paul Davis

    This program 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.

    This program 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 this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include <iostream>
#include <cmath>
#include <climits>
#include <algorithm>
#include <sstream>


#include <glibmm/thread.h>
#include "pbd/xml++.h"
#include "pbd/stacktrace.h"
#include "pbd/enumwriter.h"

#include "ardour/debug.h"
#include "ardour/region.h"
#include "ardour/playlist.h"
#include "ardour/session.h"
#include "ardour/source.h"
#include "ardour/tempo.h"
#include "ardour/region_factory.h"
#include "ardour/filter.h"
#include "ardour/profile.h"
#include "ardour/utils.h"

#include "i18n.h"

using namespace std;
using namespace ARDOUR;
using namespace PBD;

PropertyChange Region::FadeChanged       = PBD::new_change ();
PropertyChange Region::SyncOffsetChanged = PBD::new_change ();
PropertyChange Region::MuteChanged       = PBD::new_change ();
PropertyChange Region::OpacityChanged    = PBD::new_change ();
PropertyChange Region::LockChanged       = PBD::new_change ();
PropertyChange Region::LayerChanged      = PBD::new_change ();
PropertyChange Region::HiddenChanged     = PBD::new_change ();

namespace ARDOUR { 
	namespace Properties {
		PBD::PropertyDescriptor<bool> muted;
		PBD::PropertyDescriptor<bool> opaque;
		PBD::PropertyDescriptor<bool> locked;
		PBD::PropertyDescriptor<bool> automatic;
		PBD::PropertyDescriptor<bool> whole_file;
		PBD::PropertyDescriptor<bool> import;
		PBD::PropertyDescriptor<bool> external;
		PBD::PropertyDescriptor<bool> sync_marked;
		PBD::PropertyDescriptor<bool> left_of_split;
		PBD::PropertyDescriptor<bool> right_of_split;
		PBD::PropertyDescriptor<bool> hidden;
		PBD::PropertyDescriptor<bool> position_locked;
		PBD::PropertyDescriptor<framepos_t> start;
		PBD::PropertyDescriptor<framecnt_t> length;
		PBD::PropertyDescriptor<framepos_t> position;
		PBD::PropertyDescriptor<framecnt_t> sync_position;
		PBD::PropertyDescriptor<layer_t> layer;
		PBD::PropertyDescriptor<framepos_t> ancestral_start;
		PBD::PropertyDescriptor<framecnt_t> ancestral_length;
		PBD::PropertyDescriptor<float> stretch;
		PBD::PropertyDescriptor<float> shift;
	}
}
	
PBD::Signal1<void,boost::shared_ptr<ARDOUR::Region> > Region::RegionPropertyChanged;

void
Region::make_property_quarks ()
{
	Properties::muted.id = g_quark_from_static_string (X_("muted"));
	Properties::opaque.id = g_quark_from_static_string (X_("opaque"));
	Properties::locked.id = g_quark_from_static_string (X_("locked"));
	Properties::automatic.id = g_quark_from_static_string (X_("automatic"));
	Properties::whole_file.id = g_quark_from_static_string (X_("whole-file"));
	Properties::import.id = g_quark_from_static_string (X_("import"));
	Properties::external.id = g_quark_from_static_string (X_("external"));
	Properties::sync_marked.id = g_quark_from_static_string (X_("sync-marked"));
	Properties::left_of_split.id = g_quark_from_static_string (X_("left-of-split"));
	Properties::right_of_split.id = g_quark_from_static_string (X_("right-of-split"));
	Properties::hidden.id = g_quark_from_static_string (X_("hidden"));
	Properties::position_locked.id = g_quark_from_static_string (X_("position-locked"));
	Properties::start.id = g_quark_from_static_string (X_("start"));
	Properties::length.id = g_quark_from_static_string (X_("length"));
	Properties::position.id = g_quark_from_static_string (X_("position"));
	Properties::sync_position.id = g_quark_from_static_string (X_("sync-position"));
	Properties::layer.id = g_quark_from_static_string (X_("layer"));
	Properties::ancestral_start.id = g_quark_from_static_string (X_("ancestral-start"));
	Properties::ancestral_length.id = g_quark_from_static_string (X_("ancestral-length"));
	Properties::stretch.id = g_quark_from_static_string (X_("stretch"));
	Properties::shift.id = g_quark_from_static_string (X_("shift"));
}

void
Region::register_properties ()
{
	_xml_node_name = X_("Region");

	add_property (_muted);
	add_property (_opaque);
	add_property (_locked);
	add_property (_automatic);
	add_property (_whole_file);
	add_property (_import);
	add_property (_external);
	add_property (_sync_marked);
	add_property (_left_of_split);
	add_property (_right_of_split);
	add_property (_hidden);
	add_property (_position_locked);
	add_property (_start);
	add_property (_length);
	add_property (_position);
	add_property (_sync_position);
	add_property (_layer);
	add_property (_ancestral_start);
	add_property (_ancestral_length);
	add_property (_stretch);
	add_property (_shift);
}

#define REGION_DEFAULT_STATE(s,l) \
	_muted (Properties::muted, MuteChanged, false)	     \
	, _opaque (Properties::opaque, OpacityChanged, true) \
	, _locked (Properties::locked, LockChanged, false) \
	, _automatic (Properties::automatic, PropertyChange (0), false) \
	, _whole_file (Properties::whole_file, PropertyChange (0), false) \
	, _import (Properties::import, PropertyChange (0), false) \
	, _external (Properties::external, PropertyChange (0), false) \
	, _sync_marked (Properties::sync_marked, SyncOffsetChanged, false) \
	, _left_of_split (Properties::left_of_split, PropertyChange (0), false) \
	, _right_of_split (Properties::right_of_split, PropertyChange (0), false) \
	, _hidden (Properties::hidden, HiddenChanged, false) \
	, _position_locked (Properties::position_locked, PropertyChange (0), false) \
	, _start (Properties::start, StartChanged, (s))	\
	, _length (Properties::length, LengthChanged, (l))	\
	, _position (Properties::position, PositionChanged, 0) \
	, _sync_position (Properties::sync_position, SyncOffsetChanged, (s)) \
	, _layer (Properties::layer, LayerChanged, 0)	\
	, _ancestral_start (Properties::ancestral_start, PropertyChange (0), (s)) \
	, _ancestral_length (Properties::ancestral_length, PropertyChange (0), (l)) \
	, _stretch (Properties::stretch, PropertyChange (0), 1.0) \
	, _shift (Properties::shift, PropertyChange (0), 1.0)

#define REGION_COPY_STATE(other) \
	  _muted (other->_muted) \
	, _opaque (other->_opaque) \
	, _locked (other->_locked) \
	, _automatic (other->_automatic) \
	, _whole_file (other->_whole_file) \
	, _import (other->_import) \
	, _external (other->_external) \
	, _sync_marked (other->_sync_marked) \
	, _left_of_split (other->_left_of_split) \
	, _right_of_split (other->_right_of_split) \
	, _hidden (other->_hidden) \
	, _position_locked (other->_position_locked) \
	, _start(other->_start) \
	, _length(other->_length) \
	, _position(other->_position) \
	, _sync_position(other->_sync_position) \
        , _layer (other->_layer) \
	, _ancestral_start (other->_ancestral_start) \
	, _ancestral_length (other->_ancestral_length) \
	, _stretch (other->_stretch) \
	, _shift (other->_shift)

/* derived-from-derived constructor (no sources in constructor) */
Region::Region (Session& s, framepos_t start, framecnt_t length, const string& name, DataType type)
	: SessionObject(s, name)
	, _type(type)
	, _no_property_changes (true)
	, REGION_DEFAULT_STATE(start,length)
	, _last_length (length)
	, _last_position (0)
	, _positional_lock_style(AudioTime)
	, _first_edit (EditChangesNothing)
	, _frozen(0)
	, _read_data_count(0)
	, _pending_changed(PropertyChange (0))
	, _last_layer_op(0)
	, _pending_explicit_relayer (false)
{
	register_properties ();

	/* no sources at this point */
}

/** Basic Region constructor (single source) */
Region::Region (boost::shared_ptr<Source> src)
	: SessionObject(src->session(), "toBeRenamed")
	, _type (src->type())
	, _no_property_changes (true)
	, REGION_DEFAULT_STATE(0,0)
	, _last_length (0)
	, _last_position (0)
        , _positional_lock_style (_type == DataType::AUDIO ? AudioTime : MusicTime)
	, _first_edit (EditChangesNothing)
	, _frozen(0)
	, _valid_transients(false)
	, _read_data_count(0)
	, _pending_changed(PropertyChange (0))
	, _last_layer_op(0)
	, _pending_explicit_relayer (false)
{
	register_properties ();

	_sources.push_back (src);
	_master_sources.push_back (src);

	src->DropReferences.connect_same_thread (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(src)));
	
	assert (_sources.size() > 0);
	assert (_type == src->type());
}

/** Basic Region constructor (many sources) */
Region::Region (const SourceList& srcs)
	: SessionObject(srcs.front()->session(), "toBeRenamed")
	, _type (srcs.front()->type())
	, _no_property_changes (true)
	, REGION_DEFAULT_STATE(0,0)
	, _last_length (0)
	, _last_position (0)
        , _positional_lock_style (_type == DataType::AUDIO ? AudioTime : MusicTime)
	, _first_edit (EditChangesNothing)
	, _frozen (0)
	, _valid_transients(false)
	, _read_data_count(0)
	, _pending_changed(PropertyChange (0))
	, _last_layer_op (0)
	, _pending_explicit_relayer (false)
{
	register_properties ();

	_type = srcs.front()->type();

	use_sources (srcs);

	assert(_sources.size() > 0);
	assert (_type == srcs.front()->type());
}

/** Create a new Region from part of an existing one, starting at one of two places:

    if @param offset_relative is true, then the start within @param other is given by @param offset
    (i.e. relative to the start of @param other's sources, the start is @param offset + @param other.start()

    if @param offset_relative is false, then the start within the source is given @param offset.
*/
Region::Region (boost::shared_ptr<const Region> other, frameoffset_t offset, bool offset_relative)
	: SessionObject(other->session(), "toBeRenamed")
	, _type (other->data_type())
	, _no_property_changes (true)
	, REGION_COPY_STATE (other)
	, _last_length (other->_last_length)
	, _last_position(other->_last_position) \
	, _positional_lock_style(other->_positional_lock_style) \
	, _first_edit (EditChangesNothing)
	, _frozen (0)
	, _valid_transients(false)
	, _read_data_count(0)
	, _pending_changed(PropertyChange (0))
	, _last_layer_op (0)
	, _pending_explicit_relayer (false)

{
	register_properties ();

	/* override state that may have been incorrectly inherited from the other region
	 */

	_position = 0;
	_locked = false;
	_whole_file = false;
	_hidden = false;

	use_sources (other->_sources);

	if (!offset_relative) {

		/* not sure why we do this, but its a hangover from ardour before
		   property lists. this would be nice to remove.
		*/

		_positional_lock_style = other->_positional_lock_style;
		_first_edit = other->_first_edit;

		if (offset == 0) {

			_start = 0;

			/* sync pos is relative to start of file. our start-in-file is now zero,
			   so set our sync position to whatever the the difference between
			   _start and _sync_pos was in the other region.
			   
			   result is that our new sync pos points to the same point in our source(s)
			   as the sync in the other region did in its source(s).
			   
			   since we start at zero in our source(s), it is not possible to use a sync point that
			   is before the start. reset it to _start if that was true in the other region.
			*/
			
			if (other->sync_marked()) {
				if (other->_start < other->_sync_position) {
					/* sync pos was after the start point of the other region */
					_sync_position = other->_sync_position - other->_start;
				} else {
					/* sync pos was before the start point of the other region. not possible here. */
					_sync_marked = false;
					_sync_position = _start;
				}
			} else {
				_sync_marked = false;
				_sync_position = _start;
			}
		} else {
			/* XXX do something else ! */
			fatal << string_compose (_("programming error: %1"), X_("Region+offset constructor used with illegal combination of offset+relative"))
			      << endmsg;
			/*NOTREACHED*/
		}

	} else {

		_start = other->_start + offset;
		
		/* if the other region had a distinct sync point
		   set, then continue to use it as best we can.
		   otherwise, reset sync point back to start.
		*/
		
		if (other->sync_marked()) {
			if (other->_sync_position < _start) {
				_sync_marked = false;
				_sync_position = _start;
		} else {
				_sync_position = other->_sync_position;
			}
		} else {
			_sync_marked = false;
			_sync_position = _start;
		}
	}

	if (Profile->get_sae()) {
		/* reset sync point to start if its ended up
		   outside region bounds.
		*/

		if (_sync_position < _start || _sync_position >= _start + _length) {
			_sync_marked = false;
			_sync_position = _start;
		}
	}

	assert (_type == other->data_type());
}

/** Create a copy of @param other but with different sources. Used by filters */
Region::Region (boost::shared_ptr<const Region> other, const SourceList& srcs)
	: SessionObject (other->session(), other->name())
	, _type (srcs.front()->type())
	, _no_property_changes (true)
	, REGION_COPY_STATE (other)
	, _last_length (other->_last_length)
	, _last_position (other->_last_position)
        , _positional_lock_style (other->_positional_lock_style)
	, _first_edit (EditChangesID)
	, _frozen (0)
	, _valid_transients (false)
	, _read_data_count (0)
	, _pending_changed (PropertyChange(0))
	, _last_layer_op (other->_last_layer_op)
	, _pending_explicit_relayer (false)
{
	register_properties ();

	_locked = false;
	_position_locked = false;

	other->_first_edit = EditChangesName;

	if (other->_extra_xml) {
		_extra_xml = new XMLNode (*other->_extra_xml);
	} else {
		_extra_xml = 0;
	}

	use_sources (srcs);
	assert(_sources.size() > 0);
}

/** Simple "copy" constructor */
Region::Region (boost::shared_ptr<const Region> other)
	: SessionObject(other->session(), other->name())
	, _type(other->data_type())
	, _no_property_changes (true)
	, REGION_COPY_STATE (other)
	, _last_length (other->_last_length)
	, _last_position (other->_last_position)
        , _positional_lock_style (other->_positional_lock_style)
	, _first_edit (EditChangesID)
	, _frozen(0)
	, _valid_transients(false)
	, _read_data_count(0)
	, _pending_changed(PropertyChange(0))
	, _last_layer_op(other->_last_layer_op)
	, _pending_explicit_relayer (false)
{
	register_properties ();

	_locked = false;
	_position_locked = false;

	other->_first_edit = EditChangesName;

	if (other->_extra_xml) {
		_extra_xml = new XMLNode (*other->_extra_xml);
	} else {
		_extra_xml = 0;
	}

	use_sources (other->_sources);
	assert(_sources.size() > 0);
}

Region::Region (const SourceList& srcs, const XMLNode& node)
	: SessionObject(srcs.front()->session(), X_("error: XML did not reset this"))
	, _type (srcs.front()->type())
	, REGION_DEFAULT_STATE(0,0)
	, _last_length (0)
	, _last_position (0)
        , _positional_lock_style (_type == DataType::AUDIO ? AudioTime : MusicTime)
	, _first_edit (EditChangesNothing)
	, _frozen(0)
	, _valid_transients(false)
	, _read_data_count(0)
	, _pending_changed(PropertyChange(0))
	, _last_layer_op(0)
	, _pending_explicit_relayer (false)
{
	const XMLProperty* prop;

	register_properties ();

	if ((prop = node.property (X_("id")))) {
		_id = prop->value();
	}

	use_sources (srcs);

	if (set_state (node, Stateful::loading_state_version)) {
		throw failed_constructor();
	}

	assert(_type != DataType::NIL);
	assert(_sources.size() > 0);
	assert (_type == srcs.front()->type());

}

Region::Region (boost::shared_ptr<Source> src, const XMLNode& node)
	: SessionObject(src->session(), X_("error: XML did not reset this"))
	, _type (src->type())
	, REGION_DEFAULT_STATE(0,0)
	, _last_length (0)
	, _last_position (0)
        , _positional_lock_style (_type == DataType::AUDIO ? AudioTime : MusicTime)
	, _first_edit (EditChangesNothing)
	, _frozen (0)
	, _read_data_count (0)
	, _pending_changed (PropertyChange(0))
	, _last_layer_op (0)
	, _pending_explicit_relayer (false)
{
	const XMLProperty *prop;

	register_properties ();

	_sources.push_back (src);

	if ((prop = node.property (X_("id")))) {
		_id = prop->value();
	}

	if (set_state (node, Stateful::loading_state_version)) {
		throw failed_constructor();
	}

	assert (_type != DataType::NIL);
	assert (_sources.size() > 0);
	assert (_type == src->type());
}

Region::~Region ()
{
	DEBUG_TRACE (DEBUG::Destruction, string_compose ("Region %1 destructor @ %2\n", _name, this));
}

void
Region::set_playlist (boost::weak_ptr<Playlist> wpl)
{
	_playlist = wpl.lock();
}

bool
Region::set_name (const std::string& str)
{
	if (_name != str) {
		SessionObject::set_name(str); // EMIT SIGNAL NameChanged()
		assert(_name == str);
		send_change (ARDOUR::NameChanged);
	}

	return true;
}

void
Region::set_length (framecnt_t len, void */*src*/)
{
	//cerr << "Region::set_length() len = " << len << endl;
	if (locked()) {
		return;
	}

	if (_length != len && len != 0) {

		/* check that the current _position wouldn't make the new
		   length impossible.
		*/

		if (max_frames - len < _position) {
			return;
		}

		if (!verify_length (len)) {
			return;
		}


		_last_length = _length;
		_length = len;
		_whole_file = false;
		first_edit ();
		maybe_uncopy ();
		invalidate_transients ();

		if (!_frozen) {
			recompute_at_end ();
		}

		send_change (LengthChanged);
	}
}

void
Region::maybe_uncopy ()
{
	/* this does nothing but marked a semantic moment once upon a time */
}

void
Region::first_edit ()
{
	boost::shared_ptr<Playlist> pl (playlist());

	if (_first_edit != EditChangesNothing && pl) {

		_name = _session.new_region_name (_name);
		_first_edit = EditChangesNothing;

		send_change (ARDOUR::NameChanged);
		RegionFactory::CheckNewRegion (shared_from_this());
	}
}

bool
Region::at_natural_position () const
{
	boost::shared_ptr<Playlist> pl (playlist());

	if (!pl) {
		return false;
	}

	boost::shared_ptr<Region> whole_file_region = get_parent();

	if (whole_file_region) {
		if (_position == whole_file_region->position() + _start) {
			return true;
		}
	}

	return false;
}

void
Region::move_to_natural_position (void *src)
{
	boost::shared_ptr<Playlist> pl (playlist());

	if (!pl) {
		return;
	}

	boost::shared_ptr<Region> whole_file_region = get_parent();

	if (whole_file_region) {
		set_position (whole_file_region->position() + _start, src);
	}
}

void
Region::special_set_position (framepos_t pos)
{
	/* this is used when creating a whole file region as
	   a way to store its "natural" or "captured" position.
	*/

	_position = _position;
	_position = pos;
}

void
Region::set_position_lock_style (PositionLockStyle ps)
{
	boost::shared_ptr<Playlist> pl (playlist());

	if (!pl) {
		return;
	}

	_positional_lock_style = ps;

	if (_positional_lock_style == MusicTime) {
		_session.tempo_map().bbt_time (_position, _bbt_time);
	}

}

void
Region::update_position_after_tempo_map_change ()
{
	boost::shared_ptr<Playlist> pl (playlist());

	if (!pl || _positional_lock_style != MusicTime) {
		return;
	}

	TempoMap& map (_session.tempo_map());
	framepos_t pos = map.frame_time (_bbt_time);
	set_position_internal (pos, false);
}

void
Region::set_position (framepos_t pos, void* /*src*/)
{
	if (!can_move()) {
		return;
	}

	set_position_internal (pos, true);
}

void
Region::set_position_internal (framepos_t pos, bool allow_bbt_recompute)
{
	if (_position != pos) {
		_last_position = _position;
		_position = pos;

		/* check that the new _position wouldn't make the current
		   length impossible - if so, change the length.

		   XXX is this the right thing to do?
		*/

		if (max_frames - _length < _position) {
			_last_length = _length;
			_length = max_frames - _position;
		}

		if (allow_bbt_recompute) {
			recompute_position_from_lock_style ();
		}

		invalidate_transients ();
	}

	/* do this even if the position is the same. this helps out
	   a GUI that has moved its representation already.
	*/

	send_change (PositionChanged);
}

void
Region::set_position_on_top (framepos_t pos, void* /*src*/)
{
	if (locked()) {
		return;
	}

	if (_position != pos) {
		_last_position = _position;
		_position = pos;
	}

	boost::shared_ptr<Playlist> pl (playlist());

	if (pl) {
		pl->raise_region_to_top (shared_from_this ());
	}

	/* do this even if the position is the same. this helps out
	   a GUI that has moved its representation already.
	*/

	send_change (PositionChanged);
}

void
Region::recompute_position_from_lock_style ()
{
	if (_positional_lock_style == MusicTime) {
		_session.tempo_map().bbt_time (_position, _bbt_time);
	}
}

void
Region::nudge_position (frameoffset_t n, void* /*src*/)
{
	if (locked()) {
		return;
	}

	if (n == 0) {
		return;
	}

	_last_position = _position;

	if (n > 0) {
		if (_position > max_frames - n) {
			_position = max_frames;
		} else {
			_position += n;
		}
	} else {
		if (_position < -n) {
			_position = 0;
		} else {
			_position += n;
		}
	}

	send_change (PositionChanged);
}

void
Region::set_ancestral_data (framepos_t s, framecnt_t l, float st, float sh)
{
	_ancestral_length = l;
	_ancestral_start = s;
	_stretch = st;
	_shift = sh;
}

void
Region::set_start (framepos_t pos, void* /*src*/)
{
	if (locked() || position_locked()) {
		return;
	}
	/* This just sets the start, nothing else. It effectively shifts
	   the contents of the Region within the overall extent of the Source,
	   without changing the Region's position or length
	*/

	if (_start != pos) {

		if (!verify_start (pos)) {
			return;
		}

		_start = pos;
		_whole_file = false;
		first_edit ();
		invalidate_transients ();

		send_change (StartChanged);
	}
}

void
Region::trim_start (framepos_t new_position, void */*src*/)
{
	if (locked() || position_locked()) {
		return;
	}
	framepos_t new_start;
	frameoffset_t start_shift;

	if (new_position > _position) {
		start_shift = new_position - _position;
	} else {
		start_shift = -(_position - new_position);
	}

	if (start_shift > 0) {

		if (_start > max_frames - start_shift) {
			new_start = max_frames;
		} else {
			new_start = _start + start_shift;
		}

		if (!verify_start (new_start)) {
			return;
		}

	} else if (start_shift < 0) {

		if (_start < -start_shift) {
			new_start = 0;
		} else {
			new_start = _start + start_shift;
		}
	} else {
		return;
	}

	if (new_start == _start) {
		return;
	}

	_start = new_start;
	_whole_file = false;
	first_edit ();

	send_change (StartChanged);
}

void
Region::trim_front (framepos_t new_position, void *src)
{
	if (locked()) {
		return;
	}

	framepos_t end = last_frame();
	framepos_t source_zero;

	if (_position > _start) {
		source_zero = _position - _start;
	} else {
		source_zero = 0; // its actually negative, but this will work for us
	}

	if (new_position < end) { /* can't trim it zero or negative length */

		framecnt_t newlen;

		/* can't trim it back passed where source position zero is located */

		new_position = max (new_position, source_zero);


		if (new_position > _position) {
			newlen = _length - (new_position - _position);
		} else {
			newlen = _length + (_position - new_position);
		}

		trim_to_internal (new_position, newlen, src);
		if (!_frozen) {
			recompute_at_start ();
		}
	}
}

/** @param new_endpoint New region end point, such that, for example,
 *  a region at 0 of length 10 has an endpoint of 9.
 */

void
Region::trim_end (framepos_t new_endpoint, void */*src*/)
{
	if (locked()) {
		return;
	}

	if (new_endpoint > _position) {
		trim_to_internal (_position, new_endpoint - _position + 1, this);
		if (!_frozen) {
			recompute_at_end ();
		}
	}
}

void
Region::trim_to (framepos_t position, framecnt_t length, void *src)
{
	if (locked()) {
		return;
	}

	trim_to_internal (position, length, src);

	if (!_frozen) {
		recompute_at_start ();
		recompute_at_end ();
	}
}

void
Region::trim_to_internal (framepos_t position, framecnt_t length, void */*src*/)
{
	frameoffset_t start_shift;
	framepos_t new_start;

	if (locked()) {
		return;
	}

	if (position > _position) {
		start_shift = position - _position;
	} else {
		start_shift = -(_position - position);
	}

	if (start_shift > 0) {

		if (_start > max_frames - start_shift) {
			new_start = max_frames;
		} else {
			new_start = _start + start_shift;
		}


	} else if (start_shift < 0) {

		if (_start < -start_shift) {
			new_start = 0;
		} else {
			new_start = _start + start_shift;
		}
	} else {
		new_start = _start;
	}

	if (!verify_start_and_length (new_start, length)) {
		return;
	}

	PropertyChange what_changed = PropertyChange (0);

	if (_start != new_start) {
		_start = new_start;
		what_changed = PropertyChange (what_changed|StartChanged);
	}
	if (_length != length) {
		if (!_frozen) {
			_last_length = _length;
		}
		_length = length;
		what_changed = PropertyChange (what_changed|LengthChanged);
	}
	if (_position != position) {
		if (!_frozen) {
			_last_position = _position;
		}
		_position = position;
		what_changed = PropertyChange (what_changed|PositionChanged);
	}

	_whole_file = false;

	if (what_changed & (StartChanged|LengthChanged)) {
		first_edit ();
	}

	if (what_changed) {
		send_change (what_changed);
	}
}

void
Region::set_hidden (bool yn)
{
	if (hidden() != yn) {
		_hidden = yn;
		send_change (HiddenChanged);
	}
}

void
Region::set_whole_file (bool yn)
{
	_whole_file = yn;
	/* no change signal */
}

void
Region::set_automatic (bool yn)
{
	_automatic = yn;
	/* no change signal */
}

void
Region::set_muted (bool yn)
{
	if (muted() != yn) {
		_muted = yn;
		send_change (MuteChanged);
	}
}

void
Region::set_opaque (bool yn)
{
	if (opaque() != yn) {
		_opaque = yn;
		send_change (OpacityChanged);
	}
}

void
Region::set_locked (bool yn)
{
	if (locked() != yn) {
		_locked = yn;
		send_change (LockChanged);
	}
}

void
Region::set_position_locked (bool yn)
{
	if (position_locked() != yn) {
		_position_locked = yn;
		send_change (LockChanged);
	}
}

void
Region::set_sync_position (framepos_t absolute_pos)
{
	framepos_t const file_pos = _start + (absolute_pos - _position);

	if (file_pos != _sync_position) {
		_sync_marked = true;
		_sync_position = file_pos;
		if (!_frozen) {
			maybe_uncopy ();
		}
		send_change (SyncOffsetChanged);
	}
}

void
Region::clear_sync_position ()
{
	if (sync_marked()) {
		_sync_marked = false;
		if (!_frozen) {
			maybe_uncopy ();
		}
		send_change (SyncOffsetChanged);
	}
}

framepos_t
Region::sync_offset (int& dir) const
{
	/* returns the sync point relative the first frame of the region */

	if (sync_marked()) {
		if (_sync_position > _start) {
			dir = 1;
			return _sync_position - _start;
		} else {
			dir = -1;
			return _start - _sync_position;
		}
	} else {
		dir = 0;
		return 0;
	}
}

framepos_t
Region::adjust_to_sync (framepos_t pos) const
{
	int sync_dir;
	frameoffset_t offset = sync_offset (sync_dir);

	// cerr << "adjusting pos = " << pos << " to sync at " << _sync_position << " offset = " << offset << " with dir = " << sync_dir << endl;

	if (sync_dir > 0) {
		if (pos > offset) {
			pos -= offset;
		} else {
			pos = 0;
		}
	} else {
		if (max_frames - pos > offset) {
			pos += offset;
		}
	}

	return pos;
}

framepos_t
Region::sync_position() const
{
	if (sync_marked()) {
		return _sync_position;
	} else {
		return _start;
	}
}

void
Region::raise ()
{
	boost::shared_ptr<Playlist> pl (playlist());
	if (pl) {
		pl->raise_region (shared_from_this ());
	}
}

void
Region::lower ()
{
	boost::shared_ptr<Playlist> pl (playlist());
	if (pl) {
		pl->lower_region (shared_from_this ());
	}
}


void
Region::raise_to_top ()
{
	boost::shared_ptr<Playlist> pl (playlist());
	if (pl) {
		pl->raise_region_to_top (shared_from_this());
	}
}

void
Region::lower_to_bottom ()
{
	boost::shared_ptr<Playlist> pl (playlist());
	if (pl) {
		pl->lower_region_to_bottom (shared_from_this());
	}
}

void
Region::set_layer (layer_t l)
{
	if (_layer != l) {
		_layer = l;

		send_change (LayerChanged);
	}
}

XMLNode&
Region::state (bool /*full_state*/)
{
	XMLNode *node = new XMLNode ("Region");
	char buf[64];
	const char* fe = NULL;

	add_properties (*node);

	_id.print (buf, sizeof (buf));
	node->add_property ("id", buf);
	node->add_property ("type", _type.to_string());

	switch (_first_edit) {
	case EditChangesNothing:
		fe = X_("nothing");
		break;
	case EditChangesName:
		fe = X_("name");
		break;
	case EditChangesID:
		fe = X_("id");
		break;
	default: /* should be unreachable but makes g++ happy */
		fe = X_("nothing");
		break;
	}

	node->add_property ("first-edit", fe);

	/* note: flags are stored by derived classes */

	if (_positional_lock_style != AudioTime) {
		node->add_property ("positional-lock-style", enum_2_string (_positional_lock_style));
		stringstream str;
		str << _bbt_time;
		node->add_property ("bbt-position", str.str());
	}

	return *node;
}

XMLNode&
Region::get_state ()
{
	return state (true);
}

int
Region::set_state (const XMLNode& node, int version)
{
	PropertyChange what_changed = PropertyChange (0);
	return _set_state (node, version, what_changed, true);
}

int
Region::_set_state (const XMLNode& node, int version, PropertyChange& what_changed, bool send)
{
	const XMLProperty* prop;

	what_changed = set_properties (node);

	if ((prop = node.property (X_("id")))) {
		_id = prop->value();
	}

	if ((prop = node.property ("positional-lock-style")) != 0) {
		_positional_lock_style = PositionLockStyle (string_2_enum (prop->value(), _positional_lock_style));

		if (_positional_lock_style == MusicTime) {
			if ((prop = node.property ("bbt-position")) == 0) {
				/* missing BBT info, revert to audio time locking */
				_positional_lock_style = AudioTime;
			} else {
				if (sscanf (prop->value().c_str(), "%d|%d|%d",
					    &_bbt_time.bars,
					    &_bbt_time.beats,
					    &_bbt_time.ticks) != 3) {
					_positional_lock_style = AudioTime;
				}
			}
		}

	}

	/* fix problems with old sessions corrupted by impossible
	   values for _stretch or _shift
	*/
	if (_stretch == 0.0f) {
		_stretch = 1.0f;
	}
	
	if (_shift == 0.0f) {
		_shift = 1.0f;
	}

	const XMLNodeList& nlist = node.children();

	for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {

		XMLNode *child;

		child = (*niter);

		if (child->name () == "Extra") {
			delete _extra_xml;
			_extra_xml = new XMLNode (*child);
			break;
		}
	}

	if (send) {
		cerr << _name << ": final change to be sent: " << hex << what_changed << dec << endl;
		send_change (what_changed);
	}

	return 0;
}

void
Region::freeze ()
{
	_frozen++;
	_last_length = _length;
	_last_position = _position;
}

void
Region::thaw ()
{
	PropertyChange what_changed = PropertyChange (0);

	{
		Glib::Mutex::Lock lm (_lock);

		if (_frozen && --_frozen > 0) {
			return;
		}

		if (_pending_changed) {
			what_changed = _pending_changed;
			_pending_changed = PropertyChange (0);
		}
	}

	if (what_changed == PropertyChange (0)) {
		return;
	}

	if (what_changed & LengthChanged) {
		if (what_changed & PositionChanged) {
			recompute_at_start ();
		}
		recompute_at_end ();
	}

	send_change (what_changed);
}

void
Region::send_change (PropertyChange what_changed)
{

	{
		Glib::Mutex::Lock lm (_lock);
		if (_frozen) {
			_pending_changed = PropertyChange (_pending_changed|what_changed);
			return;
		}
	}

	cerr << _name << " actually sends " << hex << what_changed << dec << " @" << get_microseconds() << endl;
	StateChanged (what_changed);
	cerr << _name << " done with " << hex << what_changed << dec << " @" << get_microseconds() << endl;

	if (!_no_property_changes) {
		
		/* Try and send a shared_pointer unless this is part of the constructor.
		   If so, do nothing.
		*/

		try {
			boost::shared_ptr<Region> rptr = shared_from_this();
			cerr << _name << " actually sends prop change " << hex << what_changed << dec <<  " @ " << get_microseconds() << endl;
			RegionPropertyChanged (rptr);
			cerr << _name << " done with prop change  @ " << get_microseconds() << endl;

		} catch (...) {
			/* no shared_ptr available, relax; */
		}
	}

}

void
Region::set_last_layer_op (uint64_t when)
{
	_last_layer_op = when;
}

bool
Region::overlap_equivalent (boost::shared_ptr<const Region> other) const
{
	return coverage (other->first_frame(), other->last_frame()) != OverlapNone;
}

bool
Region::equivalent (boost::shared_ptr<const Region> other) const
{
	return _start == other->_start &&
		_position == other->_position &&
		_length == other->_length;
}

bool
Region::size_equivalent (boost::shared_ptr<const Region> other) const
{
	return _start == other->_start &&
		_length == other->_length;
}

bool
Region::region_list_equivalent (boost::shared_ptr<const Region> other) const
{
	return size_equivalent (other) && source_equivalent (other) && _name == other->_name;
}

void
Region::source_deleted (boost::weak_ptr<Source>)
{
	_sources.clear ();

	if (!_session.deletion_in_progress()) {
		/* this is a very special case: at least one of the region's
		   sources has bee deleted, so invalidate all references to
		   ourselves. Do NOT do this during session deletion, because
		   then we run the risk that this will actually result
		   in this object being deleted (as refcnt goes to zero)
		   while emitting DropReferences.
		*/

		drop_references ();
	}
}

vector<string>
Region::master_source_names ()
{
	SourceList::iterator i;

	vector<string> names;
	for (i = _master_sources.begin(); i != _master_sources.end(); ++i) {
		names.push_back((*i)->name());
	}

	return names;
}

void
Region::set_master_sources (const SourceList& srcs)
{
	_master_sources = srcs;
	assert (_sources.size() == _master_sources.size());
}

bool
Region::source_equivalent (boost::shared_ptr<const Region> other) const
{
	if (!other)
		return false;

	SourceList::const_iterator i;
	SourceList::const_iterator io;

	for (i = _sources.begin(), io = other->_sources.begin(); i != _sources.end() && io != other->_sources.end(); ++i, ++io) {
		if ((*i)->id() != (*io)->id()) {
			return false;
		}
	}

	for (i = _master_sources.begin(), io = other->_master_sources.begin(); i != _master_sources.end() && io != other->_master_sources.end(); ++i, ++io) {
		if ((*i)->id() != (*io)->id()) {
			return false;
		}
	}

	return true;
}

bool
Region::uses_source (boost::shared_ptr<const Source> source) const
{
	for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
		if (*i == source) {
			return true;
		}
	}
	return false;
}

sframes_t
Region::source_length(uint32_t n) const
{
	return _sources[n]->length(_position - _start);
}

bool
Region::verify_length (framecnt_t len)
{
	if (source() && (source()->destructive() || source()->length_mutable())) {
		return true;
	}

	framecnt_t maxlen = 0;

	for (uint32_t n=0; n < _sources.size(); ++n) {
		maxlen = max (maxlen, source_length(n) - _start);
	}

	len = min (len, maxlen);

	return true;
}

bool
Region::verify_start_and_length (framepos_t new_start, framecnt_t& new_length)
{
	if (source() && (source()->destructive() || source()->length_mutable())) {
		return true;
	}

	framecnt_t maxlen = 0;

	for (uint32_t n=0; n < _sources.size(); ++n) {
		maxlen = max (maxlen, source_length(n) - new_start);
	}

	new_length = min (new_length, maxlen);

	return true;
}

bool
Region::verify_start (framepos_t pos)
{
	if (source() && (source()->destructive() || source()->length_mutable())) {
		return true;
	}

	for (uint32_t n=0; n < _sources.size(); ++n) {
		if (pos > source_length(n) - _length) {
			return false;
		}
	}
	return true;
}

bool
Region::verify_start_mutable (framepos_t& new_start)
{
	if (source() && (source()->destructive() || source()->length_mutable())) {
		return true;
	}

	for (uint32_t n=0; n < _sources.size(); ++n) {
		if (new_start > source_length(n) - _length) {
			new_start = source_length(n) - _length;
		}
	}
	return true;
}

boost::shared_ptr<Region>
Region::get_parent() const
{
	boost::shared_ptr<Playlist> pl (playlist());

	if (pl) {
		boost::shared_ptr<Region> r;
		boost::shared_ptr<Region const> grrr2 = boost::dynamic_pointer_cast<Region const> (shared_from_this());

		if (grrr2 && (r = _session.find_whole_file_parent (grrr2))) {
			return boost::static_pointer_cast<Region> (r);
		}
	}

	return boost::shared_ptr<Region>();
}

int
Region::apply (Filter& filter)
{
	return filter.run (shared_from_this());
}


void
Region::invalidate_transients ()
{
	_valid_transients = false;
	_transients.clear ();
}


void
Region::use_sources (SourceList const & s)
{
	set<boost::shared_ptr<Source> > unique_srcs;

	for (SourceList::const_iterator i = s.begin (); i != s.end(); ++i) {
		_sources.push_back (*i);
		(*i)->DropReferences.connect_same_thread (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(*i)));
		unique_srcs.insert (*i);
	}

	for (SourceList::const_iterator i = s.begin (); i != s.end(); ++i) {
		_master_sources.push_back (*i);
		if (unique_srcs.find (*i) == unique_srcs.end()) {
			(*i)->DropReferences.connect_same_thread (*this, boost::bind (&Region::source_deleted, this, boost::weak_ptr<Source>(*i)));
		}
	}
}


PropertyChange
Region::set_property (const PropertyBase& prop)
{
	PropertyChange c = PropertyChange (0);

	DEBUG_TRACE (DEBUG::Properties,  string_compose ("region %1 set property %2\n", _name.val(), prop.property_name()));

	if (prop == Properties::muted.id) {
		bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
		if (val != _muted) {
			DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 muted changed from %2 to %3",
									_name.val(), _muted.val(), val));
			_muted = val;
			c = MuteChanged;
		}
	} else if (prop == Properties::opaque.id) {
		bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
		if (val != _opaque) {
			DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 opaque changed from %2 to %3",
									_name.val(), _opaque.val(), val));
			_opaque = val;
			c = OpacityChanged;
		}
	} else if (prop == Properties::locked.id) {
		bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
		if (val != _locked) {
			DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 locked changed from %2 to %3",
									_name.val(), _locked.val(), val));
			_locked = val;
			c = LockChanged;
		}
	} else if (prop == Properties::automatic.id) {
		_automatic = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
	} else if (prop == Properties::whole_file.id) {
		_whole_file = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
	} else if (prop == Properties::import.id) {
		_import = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
	} else if (prop == Properties::external.id) {
		_external = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
	} else if (prop == Properties::sync_marked.id) {
		_sync_marked = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
	} else if (prop == Properties::left_of_split.id) {
		_left_of_split = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
	} else if (prop == Properties::right_of_split.id) {
		_right_of_split = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
	} else if (prop == Properties::hidden.id) {
		bool val = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
		if (val != _hidden) {
			_hidden = val;
			c = HiddenChanged;
		}
	} else if (prop == Properties::position_locked.id) {
		_position_locked = dynamic_cast<const PropertyTemplate<bool>*>(&prop)->val();
	} else if (prop == Properties::start.id) {
		_start = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
	} else if (prop == Properties::length.id) {
		const PropertyTemplate<framecnt_t>* pt1 = dynamic_cast<const PropertyTemplate<framecnt_t>* >(&prop);
		const PropertyTemplate<int>* pt2 = dynamic_cast<const PropertyTemplate<int>* >(&prop);
		
		cerr << "Cast to frmecnt = " << pt1 << " to int = " << pt2 << endl;

		framecnt_t val = dynamic_cast<const PropertyTemplate<framecnt_t>* > (&prop)->val();
		if (val != _length) {
			DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 length changed from %2 to %3",
									_name.val(), _length.val(), val));
			_length = val;
			c = LengthChanged;
		} else {
			DEBUG_TRACE (DEBUG::Properties, string_compose ("length %1 matches %2\n", _length.val(), val));
		}

	} else if (prop == Properties::position.id) {
		framepos_t val = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
		if (val != _position) {
			DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 position changed from %2 to %3",
									_name.val(), _position.val(), val));
			_position = val;
			c = PositionChanged;
		}
	} else if (prop == Properties::sync_position.id) {
		framepos_t val = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
		if (val != _sync_position) {
			DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 syncpos changed from %2 to %3",
									_name.val(), _sync_position, val));
			_sync_position = val;
			c = SyncOffsetChanged;
		}
	} else if (prop == Properties::layer.id) {
		layer_t val = dynamic_cast<const PropertyTemplate<layer_t>*>(&prop)->val();
		if (val != _layer) {
			DEBUG_TRACE (DEBUG::Properties, string_compose ("region %1 syncpos changed from %2 to %3",
									_name.val(), _sync_position, val));
			_layer = val;
			c = LayerChanged;
		}
	} else if (prop == Properties::ancestral_start.id) {
		_ancestral_start = dynamic_cast<const PropertyTemplate<framepos_t>*>(&prop)->val();
	} else if (prop == Properties::ancestral_length.id) {
		_ancestral_length = dynamic_cast<const PropertyTemplate<framecnt_t>*>(&prop)->val();
	} else if (prop == Properties::stretch.id) {
		_stretch = dynamic_cast<const PropertyTemplate<float>*>(&prop)->val();
	} else if (prop == Properties::shift.id) {
		_shift = dynamic_cast<const PropertyTemplate<float>*>(&prop)->val();
	} else {
		return SessionObject::set_property (prop);
	}
	
	return c;
}