/*
 * Copyright (C) 2017 Robin Gareus <robin@gareus.org>
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef _ardour_surfaces_fp8button_h_
#define _ardour_surfaces_fp8button_h_

#include <stdint.h>

#include "pbd/base_ui.h"
#include "pbd/signals.h"

#include "fp8_base.h"

namespace ArdourSurface { namespace FP_NAMESPACE {

/* virtual base-class and interface */
class FP8ButtonInterface
{
public:
	FP8ButtonInterface () {}
	virtual ~FP8ButtonInterface () {}

	/* user API */
	PBD::Signal<void()> pressed;
	PBD::Signal<void()> released;

	virtual bool is_pressed () const { return false; }
	virtual bool is_active () const { return false; }

	virtual void ignore_release () {}

	/* internal API - called from midi thread,
	 * user pressed/released button the device
	 */
	virtual bool midi_event (bool) = 0;

	/* internal API - called from surface thread
	 * set Light on the button
	 */
	virtual void set_active (bool a) = 0;
	virtual void set_color (uint32_t rgba) {}
	virtual void set_blinking (bool) {}

	static bool force_change; // used during init
};

/* ****************************************************************************
 * Implementations
 */

class FP8DummyButton : public FP8ButtonInterface
{
public:
	virtual void set_active (bool a) {}
	virtual bool midi_event (bool) { return false; }
};


/* common implementation */
class FP8ButtonBase : public FP8ButtonInterface
{
public:
	FP8ButtonBase (FP8Base& b)
		: _base (b)
		, _pressed (false)
		, _active (false)
		, _ignore_release (false)
		, _rgba (0)
		, _blinking (false)
	{ }

	bool is_pressed () const { return _pressed; }
	bool is_active () const { return _active; }

	virtual bool midi_event (bool a)
	{
		if (a == _pressed) {
			return false;
		}
		_pressed = a;
		if (a) {
			pressed (); /* EMIT SIGNAL */
		} else {
			if (_ignore_release) {
				_ignore_release = false;
			} else {
				released (); /* EMIT SIGNAL */
			}
		}
		return true;
	}

	virtual void ignore_release () {
		if (_pressed) {
			_ignore_release = true;
		}
	}

	bool blinking () const { return _blinking; }

	void set_blinking (bool yes) {
		if (yes && !_blinking) {
			_blinking = true;
			_base.BlinkIt.connect_same_thread (_blink_connection, std::bind (&FP8ButtonBase::blink, this, _1));
		} else if (!yes && _blinking) {
			_blink_connection.disconnect ();
			_blinking = false;
			blink (true);
		}
	}

protected:
	FP8Base&              _base;
	bool                  _pressed;
	bool                  _active;
	bool                  _ignore_release;
	uint32_t              _rgba;
	virtual void blink (bool onoff) = 0;

private:
	PBD::ScopedConnection _blink_connection;
	bool _blinking;
};

/* A basic LED or RGB button, not shift sensitive */
class FP8Button : public FP8ButtonBase
{
public:
	FP8Button (FP8Base& b, uint8_t id, bool color = false)
		: FP8ButtonBase (b)
		, _midi_id (id)
		, _has_color (color)
	{ }

	virtual void set_active (bool a)
	{
		if (_active == a && !force_change) {
			return;
		}
		_active = a;
		_base.tx_midi3 (0x90, _midi_id, a ? 0x7f : 0x00);
	}

	void set_color (uint32_t rgba)
	{
		if (!_has_color || _rgba == rgba) {
			return;
		}
		_rgba = rgba;
		_base.tx_midi3 (0x91, _midi_id, (_rgba >> 25) & 0x7f);
		_base.tx_midi3 (0x92, _midi_id, (_rgba >> 17) & 0x7f);
		_base.tx_midi3 (0x93, _midi_id, (_rgba >>  9) & 0x7f);
	}

protected:
	void blink (bool onoff)
	{
		if (!_active) { return; }
		_base.tx_midi3 (0x90, _midi_id, onoff ? 0x7f : 0x00);
	}

	uint8_t  _midi_id; // MIDI-note
	bool     _has_color;
};

/* footswitch and encoder-press buttons */
class FP8ReadOnlyButton : public FP8Button
{
public:
	FP8ReadOnlyButton (FP8Base& b, uint8_t id, bool color = false)
		: FP8Button (b, id, color)
	{}

	void set_active (bool) { }
};

/* virtual button. used for shift toggle. */
class ShadowButton : public FP8ButtonBase
{
public:
	ShadowButton (FP8Base& b)
		: FP8ButtonBase (b)
	{}

	PBD::Signal<void(bool)> ActiveChanged;
	PBD::Signal<void()> ColourChanged;

	uint32_t color () const { return _rgba; }

	bool midi_event (bool a)
	{
		assert (0);
		return false;
	}

	bool set_pressed (bool a)
	{
		return FP8ButtonBase::midi_event (a);
	}

	void set_active (bool a)
	{
		if (_active == a && !force_change) {
			return;
		}
		_active = a;
		ActiveChanged (a); /* EMIT SIGNAL */
	}

	void set_color (uint32_t rgba)
	{
		if (_rgba == rgba) {
			return;
		}
		_rgba = rgba;
		ColourChanged ();
	}

protected:
	void blink (bool onoff) {
		if (!_active) { return; }
		ActiveChanged (onoff);
	}
};

/* Wraps 2 buttons with the same physical MIDI ID */
class FP8DualButton : public FP8ButtonInterface
{
public:
	FP8DualButton (FP8Base& b, uint8_t id, bool color = false)
		: _base (b)
		, _b0 (b)
		, _b1 (b)
		, _midi_id (id)
		, _has_color (color)
		, _rgba (0)
		, _shift (false)
	{
		_b0.ActiveChanged.connect_same_thread (_button_connections, std::bind (&FP8DualButton::active_changed, this, false, _1));
		_b1.ActiveChanged.connect_same_thread (_button_connections, std::bind (&FP8DualButton::active_changed, this, true, _1));
		if (_has_color) {
			_b0.ColourChanged.connect_same_thread (_button_connections, std::bind (&FP8DualButton::colour_changed, this, false));
			_b1.ColourChanged.connect_same_thread (_button_connections, std::bind (&FP8DualButton::colour_changed, this, true));
		}
	}

	bool midi_event (bool a) {
		return (_shift ? _b1 : _b0).set_pressed (a);
	}

	void set_active (bool a) {
		/* This button is never directly used
		 * by the libardour side API.
		 */
		assert (0);
	}

	void active_changed (bool s, bool a) {
		if (s != _shift) {
			return;
		}
		_base.tx_midi3 (0x90, _midi_id, a ? 0x7f : 0x00);
	}

	void colour_changed (bool s) {
		if (s != _shift || !_has_color) {
			return;
		}
		uint32_t rgba = (_shift ? _b1 : _b0).color ();
		if (rgba == _rgba) {
			return;
		}
		_rgba = rgba;
		_base.tx_midi3 (0x91, _midi_id, (rgba >> 25) & 0x7f);
		_base.tx_midi3 (0x92, _midi_id, (rgba >> 17) & 0x7f);
		_base.tx_midi3 (0x93, _midi_id, (rgba >>  9) & 0x7f);
	}

	FP8ButtonInterface* button () { return &_b0; }
	FP8ButtonInterface* button_shift () { return &_b1; }

protected:
	FP8Base&     _base;

	virtual void connect_toggle () = 0;

	void shift_changed (bool shift) {
		if (_shift == shift) {
			return;
		}
		(_shift ? _b1 : _b0).set_pressed (false);
		_shift = shift;
		active_changed (_shift, (_shift ? _b1 : _b0).is_active());
		colour_changed (_shift);
	}

private:
	ShadowButton _b0;
	ShadowButton _b1;
	uint8_t      _midi_id; // MIDI-note
	bool         _has_color;
	uint32_t     _rgba;
	bool         _shift;
	PBD::ScopedConnectionList _button_connections;
};

class FP8ShiftSensitiveButton : public FP8DualButton
{
public:
	FP8ShiftSensitiveButton (FP8Base& b, uint8_t id, bool color = false)
		:FP8DualButton (b, id, color)
	{
		connect_toggle ();
	}

protected:
	void connect_toggle ()
	{
		_base.ShiftButtonChange.connect_same_thread (_shift_connection, std::bind (&FP8ShiftSensitiveButton::shift_changed, this, _1));
	}

private:
	PBD::ScopedConnection _shift_connection;
};

class FP8ARMSensitiveButton : public FP8DualButton
{
public:
	FP8ARMSensitiveButton (FP8Base& b, uint8_t id, bool color = false)
		:FP8DualButton (b, id, color)
	{
		connect_toggle ();
	}

protected:
	void connect_toggle ()
	{
		_base.ARMButtonChange.connect_same_thread (_arm_connection, std::bind (&FP8ARMSensitiveButton::shift_changed, this, _1));
	}

private:
	PBD::ScopedConnection _arm_connection;
};


// short press: activate in press, deactivate on release,
// long press + hold, activate on press, de-activate directly on release
// e.g. mute/solo  press + hold => changed()
class FP8MomentaryButton : public FP8ButtonBase
{
public:
	FP8MomentaryButton (FP8Base& b, uint8_t id)
		: FP8ButtonBase (b)
		, _midi_id (id)
	{}

	~FP8MomentaryButton () {
		_hold_connection.disconnect ();
	}

	PBD::Signal<void(bool)> StateChange;

	void set_active (bool a)
	{
		if (_active == a && !force_change) {
			return;
		}
		_active = a;
		_base.tx_midi3 (0x90, _midi_id, a ? 0x7f : 0x00);
	}

	void reset ()
	{
		_was_active_on_press = false;
		_hold_connection.disconnect ();
	}

	void ignore_release () { }

	bool midi_event (bool a)
	{
		if (a == _pressed) {
			return false;
		}

		_pressed = a;

		if (a) {
			_was_active_on_press = _active;
		}

		if (a && !_active) {
			_momentaty = false;
			StateChange (true); /* EMIT SIGNAL */
			Glib::RefPtr<Glib::TimeoutSource> hold_timer =
				Glib::TimeoutSource::create (500);
			hold_timer->attach (fp8_loop()->get_context());
			_hold_connection = hold_timer->connect (sigc::mem_fun (*this, &FP8MomentaryButton::hold_timeout));
		} else if (!a && _was_active_on_press) {
			_hold_connection.disconnect ();
			_momentaty = false;
			StateChange (false); /* EMIT SIGNAL */
		} else if (!a && _momentaty) {
			_hold_connection.disconnect ();
			_momentaty = false;
			StateChange (false); /* EMIT SIGNAL */
		}
		return true;
	}

protected:
	void blink (bool onoff)
	{
		if (!blinking ()) {
			_base.tx_midi3 (0x90, _midi_id, _active ? 0x7f : 0x00);
			return;
		}
		_base.tx_midi3 (0x90, _midi_id, onoff ? 0x7f : 0x00);
	}

	uint8_t  _midi_id; // MIDI-note
	bool     _momentaty;
	bool     _was_active_on_press;

private:
	bool hold_timeout ()
	{
		_momentaty = true;
		return false;
	}
	sigc::connection _hold_connection;
};

/* an auto-repeat button.
 * press + hold emits continuous "press" events.
 */
class FP8RepeatButton : public FP8Button
{
public:
	FP8RepeatButton (FP8Base& b, uint8_t id, bool color = false)
		: FP8Button (b, id, color)
		, _skip (0)
	{}

	~FP8RepeatButton ()
	{
		stop_repeat ();
	}

	bool midi_event (bool a)
	{
		bool rv = FP8Button::midi_event (a);
		if (rv && a) {
			start_repeat ();
		}
		return rv;
	}

	void stop_repeat ()
	{
		_press_timeout_connection.disconnect ();
	}

private:
	void start_repeat ()
	{
		stop_repeat ();
		_skip = 5;
		Glib::RefPtr<Glib::TimeoutSource> press_timer =
			Glib::TimeoutSource::create (100);
		press_timer->attach (fp8_loop()->get_context());
		_press_timeout_connection = press_timer->connect (sigc::mem_fun (*this, &FP8RepeatButton::repeat_press));
	}

	bool repeat_press ()
	{
		if (!_pressed) {
			return false;
		}
		if (_skip > 0) {
			--_skip;
			return true;
		}
		pressed ();
		return true;
	}

	int _skip;
	sigc::connection _press_timeout_connection;
};

} } /* namespace */
#endif /* _ardour_surfaces_fp8button_h_ */