/*
 * Copyright (C) 2023 Holger Dehnhardt <holger@dehnhardt.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.
 */

#include "ardour/meter.h"
#include "ardour/monitor_control.h"
#include "ardour/phase_control.h"
#include "ardour/presentation_info.h"
#include "ardour/session.h"

#include "c1_control.h"
#include "console1.h"

using namespace ARDOUR;
using namespace ArdourSurface;
using namespace PBD;
using namespace Glib;
using namespace std;

/* Operations */

void
Console1::bank (bool up)
{
	DEBUG_TRACE (DEBUG::Console1, "Console1::page\n");
	bool changed = false;
	uint32_t list_size = strip_inventory.size ();

	if (up) {
		if ((current_bank + 1) * bank_size < list_size) {
			changed = true;
			++current_bank;
			current_strippable_index = 0;
		}
	} else {
		if (current_bank > 0) {
			changed = true;
			--current_bank;
			current_strippable_index = bank_size - 1;
		}
	}
	if (changed) {
		uint32_t new_index = current_bank * bank_size + current_strippable_index;
		if (new_index > (list_size - 1))
			new_index = list_size - 1;
		select_rid_by_index (new_index);
		BankChange ();
	}
}

void
Console1::gain (const uint32_t value)
{
	if (!_current_stripable) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->gain_control ();
	double gain = midi_to_control (control, value);
	session->set_control (control, gain, PBD::Controllable::UseGroup);
}

void
Console1::mute (const uint32_t)
{
	DEBUG_TRACE (DEBUG::Console1, "Console1::mute ...\n");
	if (!_current_stripable) {
		return;
	}

	if (_current_stripable == session->monitor_out ()) {
		std::shared_ptr<MonitorProcessor> mp = _current_stripable->monitor_control ();
		mp->set_cut_all (!mp->cut_all ());
		return;
	}

	_current_stripable->mute_control ()->set_value (!_current_stripable->mute_control ()->muted (),
	                                                PBD::Controllable::UseGroup);
}

void
Console1::pan (const uint32_t value)
{
	if (!_current_stripable) {
		return;
	}
	if (current_pan_control) {
		std::shared_ptr<AutomationControl> control = current_pan_control;
		double pan = midi_to_control (control, value);
		session->set_control (control, pan, PBD::Controllable::UseGroup);
	}
}

void
Console1::phase (const uint32_t value)
{
	DEBUG_TRACE (DEBUG::Console1, "phase() \n");
	if (!_current_stripable || !_current_stripable->phase_control ()) {
		return;
	}
	bool inverted = _current_stripable->phase_control ()->inverted (0);
	for (uint64_t i = 0; i < _current_stripable->phase_control ()->size (); i++) {
		_current_stripable->phase_control ()->set_phase_invert (i, !inverted);
	}
}

void
Console1::rude_solo (const uint32_t value)
{

	DEBUG_TRACE (DEBUG::Console1, "rude_solo() \n");
	if (!value) {
		session->cancel_all_solo ();
	} else {
		try {
			get_button (ControllerID::DISPLAY_ON)->set_led_state (false);
		} catch (ControlNotFoundException const&) {
			DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
		}
	}
}

void
Console1::select (const uint32_t i)
{
	uint32_t strip_index = current_bank * bank_size + i;
	DEBUG_TRACE (DEBUG::Console1, string_compose ("select( %1 / %2 ) : idx %3\n", current_bank, i, strip_index));
	select_rid_by_index (strip_index);
}

void
Console1::shift (const uint32_t val)
{
	DEBUG_TRACE (DEBUG::Console1, "shift()\n");
	shift_state = !shift_state;
	ShiftChange (val);
}

void
Console1::plugin_state (const uint32_t)
{
	DEBUG_TRACE (DEBUG::Console1, "plugin_state()\n");
	in_plugin_state = !in_plugin_state;
	PluginStateChange (in_plugin_state);
}

void
Console1::solo (const uint32_t)
{
	DEBUG_TRACE (DEBUG::Console1, "Console1::solo())\n");
	if (!_current_stripable) {
		return;
	}

	session->set_control (_current_stripable->solo_control (),
	                      !_current_stripable->solo_control ()->self_soloed (),
	                      PBD::Controllable::UseGroup);
}

void
Console1::trim (const uint32_t value)
{
	if (!_current_stripable) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->trim_control ();
	double trim = midi_to_control (control, value);
	session->set_control (control, trim, PBD::Controllable::UseGroup);
}

void
Console1::window (const uint32_t value)
{
	DEBUG_TRACE (DEBUG::Console1, "window()\n");
	switch (value) {
		case 0:
			access_action ("Common/show-editor");
			break;
		case 63:
			access_action ("Common/show-mixer");
			break;
		case 127:
			access_action ("Common/show-trigger");
			break;
		default:
			break;
	}
}

void
Console1::zoom (const uint32_t value)
{
	DEBUG_TRACE (DEBUG::Console1, "zoom()\n");
	access_action ("Editor/zoom-to-selection");
}

// Filter Section
void
Console1::filter (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->filter_enable_controllable (true))
		return;
	session->set_control (
	  _current_stripable->filter_enable_controllable (true), value > 0, PBD::Controllable::UseGroup);
}

void
Console1::low_cut (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->filter_freq_controllable (true)) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->filter_freq_controllable (true);
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

void
Console1::high_cut (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->filter_freq_controllable (false)) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->filter_freq_controllable (false);
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

// Gate Section
void
Console1::gate (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_enable_controllable ())
		return;
	session->set_control (_current_stripable->gate_enable_controllable (), value > 0, PBD::Controllable::UseGroup);
}

void
Console1::gate_scf (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_key_filter_enable_controllable ())
		return;
	session->set_control (
	  _current_stripable->gate_key_filter_enable_controllable (), value > 0, PBD::Controllable::UseGroup);
}

void
Console1::gate_listen (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_key_listen_controllable ())
		return;
	session->set_control (_current_stripable->gate_key_listen_controllable (), value > 0, PBD::Controllable::UseGroup);
}

void
Console1::gate_thresh (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_threshold_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->gate_threshold_controllable ();
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

void
Console1::gate_depth (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_depth_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->gate_depth_controllable ();
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

void
Console1::gate_release (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_release_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->gate_release_controllable ();
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

void
Console1::gate_attack (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_attack_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->gate_attack_controllable ();
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

void
Console1::gate_hyst (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_hysteresis_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->gate_hysteresis_controllable ();
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

void
Console1::gate_hold (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_hold_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->gate_hold_controllable ();
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

void
Console1::gate_filter_freq (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->gate_key_filter_freq_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->gate_key_filter_freq_controllable ();
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

// EQ-Section

void
Console1::eq (const uint32_t value)
{
	DEBUG_TRACE (DEBUG::Console1, "EQ ...\n");
	if (!_current_stripable) {
		return;
	}
	if (_current_stripable->eq_enable_controllable ())
		session->set_control (_current_stripable->eq_enable_controllable (), value > 0, PBD::Controllable::UseGroup);
	else
		map_eq ();
}

void
Console1::eq_low_shape (const uint32_t value)
{
	DEBUG_TRACE (DEBUG::Console1, string_compose ("EQ eq_low_shape( %1 )\n", value));
	if (!_current_stripable) {
		return;
	}
	if (_current_stripable->eq_shape_controllable (0))
		session->set_control (_current_stripable->eq_shape_controllable (0), value > 0, PBD::Controllable::UseGroup);
	else
		map_eq_low_shape ();
}

void
Console1::eq_high_shape (const uint32_t value)
{
	DEBUG_TRACE (DEBUG::Console1, "EQ eq_high_shape...\n");
	if (!_current_stripable) {
		return;
	}
	if (_current_stripable->eq_shape_controllable (3))
		session->set_control (_current_stripable->eq_shape_controllable (3), value > 0, PBD::Controllable::UseGroup);
	else
		map_eq_high_shape ();
}

void
Console1::eq_freq (const uint32_t band, uint32_t value)
{
	if (!_current_stripable || !_current_stripable->eq_freq_controllable (band)) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->eq_freq_controllable (band);
	double freq = midi_to_control (control, value);
	session->set_control (control, freq, PBD::Controllable::UseGroup);
}

void
Console1::eq_gain (const uint32_t band, uint32_t value)
{
	if (!_current_stripable || !_current_stripable->eq_gain_controllable (band)) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->eq_gain_controllable (band);
	double gain = midi_to_control (control, value);
	session->set_control (control, gain, PBD::Controllable::UseGroup);
}

// The Mixbus-Sends are in the EQ section
// Without Shift:
// LowMid Shape is Send 11
// HighMid Shape is Send 12
//
// With Shift
// LowMid Shape is Send 9
// HighMid Shape is Send 10
// And the rest is
// Send 01  02  03  04
// Send 05  06  07  08

void
Console1::mb_send_level (const uint32_t n, const uint32_t value)
{
	uint32_t n_offset = n;
#ifdef MIXBUS
	if (_current_stripable->presentation_info ().flags () & PresentationInfo::Flag::Mixbus) {
		n_offset = n - 8;
	}
#endif
	if (!_current_stripable || !_current_stripable->send_level_controllable (n_offset)) {
		return;
	}

	std::shared_ptr<AutomationControl> control = _current_stripable->send_level_controllable (n_offset);
	double gain = midi_to_control (control, value);
	session->set_control (control, gain, PBD::Controllable::UseGroup);
	if (value == 0) {
		std::shared_ptr<AutomationControl> enable_control = _current_stripable->send_enable_controllable (n_offset);
		if (enable_control) {
			session->set_control (enable_control, 0, PBD::Controllable::UseGroup);
		}
	}
}

// Drive Button
void
Console1::drive (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->tape_drive_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->tape_drive_controllable ();
	if (_current_stripable->presentation_info ().flags () & PresentationInfo::AudioTrack) {
		DEBUG_TRACE (DEBUG::Console1, string_compose ("drive audio track %1\n", value));
		session->set_control (control, value > 62 ? 1 : 0, PBD::Controllable::UseGroup);
	} else {
		double gain = midi_to_control (control, value);
		session->set_control (control, gain, PBD::Controllable::UseGroup);
	}
}

// Comp Section
void
Console1::comp (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->comp_enable_controllable ())
		return;
	session->set_control (_current_stripable->comp_enable_controllable (), value > 0, PBD::Controllable::UseGroup);
}

void
Console1::comp_mode (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->comp_mode_controllable ())
		return;
	int new_val = value == 63 ? 1 : value == 127 ? 2 : 0;
	session->set_control (_current_stripable->comp_mode_controllable (), new_val, PBD::Controllable::UseGroup);
}

void
Console1::comp_thresh (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->comp_threshold_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->comp_threshold_controllable ();
	double gain = midi_to_control (control, value);
	session->set_control (control, gain, PBD::Controllable::UseGroup);
}

void
Console1::comp_attack (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->comp_attack_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->comp_attack_controllable ();
	double gain = midi_to_control (control, value);
	session->set_control (control, gain, PBD::Controllable::UseGroup);
}

void
Console1::comp_release (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->comp_release_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->comp_release_controllable ();
	double gain = midi_to_control (control, value);
	session->set_control (control, gain, PBD::Controllable::UseGroup);
}

void
Console1::comp_ratio (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->comp_ratio_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->comp_ratio_controllable ();
	double gain = midi_to_control (control, value);
	session->set_control (control, gain, PBD::Controllable::UseGroup);
}

void
Console1::comp_makeup (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->comp_makeup_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->comp_makeup_controllable ();
	double gain = midi_to_control (control, value);
	session->set_control (control, gain, PBD::Controllable::UseGroup);
}

void
Console1::comp_emph (const uint32_t value)
{
	if (!_current_stripable || !_current_stripable->comp_key_filter_freq_controllable ()) {
		return;
	}
	std::shared_ptr<AutomationControl> control = _current_stripable->comp_key_filter_freq_controllable ();
	double gain = midi_to_control (control, value);
	session->set_control (control, gain, PBD::Controllable::UseGroup);
}

/* **********************************************************
************************** Mappings *************************
*************************************************************/
void
Console1::map_bank ()
{
	uint32_t list_size = strip_inventory.size ();
	try {
		get_button (PAGE_UP)->set_led_state (list_size > (current_bank + 1) * bank_size);
		get_button (PAGE_DOWN)->set_led_state (current_bank > 0);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_gain ()
{
	ControllerID controllerID = ControllerID::VOLUME;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->gain_control ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_monitoring ()
{
	if (_current_stripable && _current_stripable->monitoring_control ()) {
		std::shared_ptr<MonitorControl> control = _current_stripable->monitoring_control ();
		monitor_state = control->monitoring_state ();
	} else {
		monitor_state = ARDOUR::MonitorState::MonitoringSilence;
	}
}

void
Console1::map_mute ()
{
	DEBUG_TRACE (DEBUG::Console1, "Console1::map_mute ...\n");
	if (_current_stripable) {
		if (_current_stripable->mute_control ()->muted ()) {
			try {
				get_button (swap_solo_mute ? SOLO : MUTE)->set_led_state (true);
			} catch (ControlNotFoundException const&) {
				DEBUG_TRACE (DEBUG::Console1, "solo/mute button not found\n");
			}
		} else if (_current_stripable->mute_control ()->muted_by_others_soloing () ||
				_current_stripable->mute_control ()->muted_by_masters ()) {

			DEBUG_TRACE (DEBUG::Console1, "Console1::map_mute start blinking\n");
			start_blinking (swap_solo_mute ? SOLO : MUTE);
		} else {
			DEBUG_TRACE (DEBUG::Console1, "Console1::map_mute stop blinking\n");
			stop_blinking (swap_solo_mute ? SOLO : MUTE);
		}
	} else {
		DEBUG_TRACE (DEBUG::Console1, "Console1::map_mute stop blinking 2\n");
		stop_blinking (swap_solo_mute ? SOLO : MUTE);
	}
}

void
Console1::map_pan ()
{
	ControllerID controllerID = ControllerID::PAN;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = current_pan_control;
		map_encoder (controllerID, control);
	}
}

void
Console1::map_phase ()
{
	DEBUG_TRACE (DEBUG::Console1, "map_phase \n");
	ControllerButton* controllerButton = get_button (PHASE_INV);
	if (_current_stripable && _current_stripable->phase_control ()) {
		uint32_t channels = _current_stripable->phase_control ()->size ();
		uint32_t inverted = 0;
		for (uint32_t i = 0; i < channels; ++i) {
			if (_current_stripable->phase_control ()->inverted (i))
				++inverted;
		}
		if (inverted == 0) {
			stop_blinking (PHASE_INV);
			controllerButton->set_led_state (false);
		} else if (inverted == channels) {
			stop_blinking (PHASE_INV);
			controllerButton->set_led_state (true);
		} else
			start_blinking (PHASE_INV);
	} else {
		controllerButton->set_led_state (false);
	}
}

void
Console1::map_recenable ()
{
	DEBUG_TRACE (DEBUG::Console1, "map_recenable()\n");
	if (!_current_stripable)
		strip_recenabled = false;
	else if (_current_stripable->rec_enable_control ()) {
		strip_recenabled = _current_stripable->rec_enable_control ()->get_value ();
	}
}

void
Console1::map_select ()
{
	DEBUG_TRACE (DEBUG::Console1, "map_select())\n");
	for (uint32_t i = 0; i < bank_size; ++i) {
		get_button (ControllerID (FOCUS1 + i))->set_led_state (i == current_strippable_index);
	}
}

void
Console1::map_shift (bool shift)
{
	DEBUG_TRACE (DEBUG::Console1, "map_shift()\n");
	try {
		ControllerButton* controllerButton = get_button (PRESET);
		controllerButton->set_led_state (shift);
		map_stripable_state ();
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_plugin_state (bool plugin_state)
{
	DEBUG_TRACE (DEBUG::Console1, "map_plugin_state()\n");
	try {
		ControllerButton* controllerButton = get_button (TRACK_GROUP);
		controllerButton->set_led_state (in_plugin_state);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
	if (!plugin_state) {
		for (uint32_t i = 0; i < bank_size; ++i) {
			stop_blinking (ControllerID (FOCUS1 + i));
		}
		map_stripable_state ();
	} else {
		// I don't plan shift functionality with plugins...
		shift (0);
		// map all plugin related operations
	}
}

void
Console1::map_solo ()
{
	DEBUG_TRACE (DEBUG::Console1, "map_solo()\n");
	try {
		ControllerButton* controllerButton = get_button (swap_solo_mute ? MUTE : SOLO);
		if (_current_stripable) {
			controllerButton->set_led_state (_current_stripable->solo_control ()->soloed ());
		} else {
			controllerButton->set_led_state (false);
		}
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_trim ()
{
	ControllerID controllerID = ControllerID::GAIN;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->trim_control ();
		map_encoder (controllerID, control);
	}
}

// Filter Section
void
Console1::map_filter ()
{
	if (!_current_stripable) {
		return;
	}
	try {
		get_button (ControllerID::FILTER_TO_COMPRESSORS)
		  ->set_led_state (_current_stripable->filter_enable_controllable (true)
		                     ? _current_stripable->filter_enable_controllable (true)->get_value ()
		                     : false);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_low_cut ()
{
	ControllerID controllerID = ControllerID::LOW_CUT;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->filter_freq_controllable (true);
		map_encoder (controllerID, control);
	}
}

void
Console1::map_high_cut ()
{
	ControllerID controllerID = ControllerID::HIGH_CUT;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->filter_freq_controllable (false);
		map_encoder (controllerID, control);
	}
}

// Gate Section
void
Console1::map_gate ()
{
	if (!_current_stripable)
		return;
	try {
		get_button (ControllerID::SHAPE)
		  ->set_led_state (_current_stripable->gate_enable_controllable ()
		                     ? _current_stripable->gate_enable_controllable ()->get_value ()
		                     : false);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_gate_scf ()
{
	if (!_current_stripable || shift_state)
		return;
	try {
		DEBUG_TRACE (DEBUG::Console1, string_compose ("map_gate_scf() - shift: %1\n", shift_state));
		get_button (ControllerID::HARD_GATE)
		  ->set_led_state (_current_stripable->gate_key_filter_enable_controllable ()
		                     ? _current_stripable->gate_key_filter_enable_controllable ()->get_value ()
		                     : false);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_gate_listen ()
{
	if (!_current_stripable || !shift_state)
		return;
	try {
		DEBUG_TRACE (DEBUG::Console1, string_compose ("map_gate_listen() - shift: %1\n", shift_state));
		get_button (ControllerID::HARD_GATE)
		  ->set_led_state (_current_stripable->gate_key_listen_controllable ()
		                     ? _current_stripable->gate_key_listen_controllable ()->get_value ()
		                     : false);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_gate_thresh ()
{
	ControllerID controllerID = ControllerID::SHAPE_GATE;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->gate_threshold_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_gate_release ()
{
	if (shift_state) {
		return;
	}
	ControllerID controllerID = ControllerID::SHAPE_RELEASE;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->gate_release_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_gate_attack ()
{
	if (shift_state) {
		return;
	}
	ControllerID controllerID = ControllerID::SHAPE_SUSTAIN;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->gate_attack_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_gate_depth ()
{
	if (shift_state) {
		return;
	}
	ControllerID controllerID = ControllerID::SHAPE_PUNCH;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->gate_depth_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_gate_hyst ()
{
	if (!shift_state) {
		return;
	}
	ControllerID controllerID = ControllerID::SHAPE_RELEASE;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->gate_hysteresis_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_gate_hold ()
{
	if (!shift_state) {
		return;
	}
	ControllerID controllerID = ControllerID::SHAPE_SUSTAIN;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->gate_hold_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_gate_filter_freq ()
{
	if (!shift_state) {
		return;
	}
	ControllerID controllerID = ControllerID::SHAPE_PUNCH;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->gate_key_filter_freq_controllable ();
		map_encoder (controllerID, control);
	}
}

// EQ Section
void
Console1::map_eq ()
{
	if (!_current_stripable)
		return;
	try {
		get_button (EQ)->set_led_state (_current_stripable->eq_enable_controllable ()
		                                  ? _current_stripable->eq_enable_controllable ()->get_value ()
		                                  : false);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_eq_freq (const uint32_t band)
{
	if (shift_state) {
		return;
	}
	ControllerID controllerID = eq_freq_controller_for_band (band);
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->eq_freq_controllable (band);
		map_encoder (controllerID, control);
	}
}

void
Console1::map_eq_gain (const uint32_t band)
{
	if (shift_state) {
		return;
	}
	ControllerID controllerID = eq_gain_controller_for_band (band);
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->eq_gain_controllable (band);
		map_encoder (controllerID, control);
	}
}

void
Console1::map_eq_low_shape ()
{
	if (!_current_stripable)
		return;
	try {
		uint32_t led_value = _current_stripable->eq_shape_controllable (0)
		                       ? _current_stripable->eq_shape_controllable (0)->get_value () == 0 ? 0 : 63
		                       : 0;
		get_button (ControllerID::LOW_SHAPE)->set_led_state (led_value);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_eq_high_shape ()
{
	if (!_current_stripable)
		return;
	try {
		uint32_t led_value = _current_stripable->eq_shape_controllable (3)
		                       ? _current_stripable->eq_shape_controllable (3)->get_value () == 0 ? 0 : 63
		                       : 0;
		get_button (ControllerID::HIGH_SHAPE)->set_led_state (led_value);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

// Drive
void
Console1::map_drive ()
{
	ControllerID controllerID = ControllerID::CHARACTER;

	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->tape_drive_controllable ();
		if (control && _current_stripable->presentation_info ().flags () & PresentationInfo::AudioTrack) {
			double val = control->get_value ();
			DEBUG_TRACE (DEBUG::Console1, string_compose ("map_drive audio track %1\n", val));
			try {
				get_encoder (controllerID)->set_value (val == 1 ? 127 : 0);
			} catch (ControlNotFoundException const&) {
				DEBUG_TRACE (DEBUG::Console1, "Encoder not found\n");
			}
		} else {
			map_encoder (controllerID, control);
		}
	}
}

// Sends
void
Console1::map_mb_send_level (const uint32_t n)
{
	uint32_t n_offset = n;
#ifdef MIXBUS
	if (_current_stripable->presentation_info ().flags () & PresentationInfo::Flag::Mixbus) {
		n_offset = n + 8;
	}
#endif
	// Theese two sends are available in non-shift state
	if (n_offset > 9 && shift_state) {
		return;
	} else if (n_offset < 10 && !shift_state) // while the rest needs the shift state
	{
		return;
	}
	ControllerID controllerID = get_send_controllerid (n_offset);
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->send_level_controllable (n);
		map_encoder (controllerID, control);
	}
}

// Comp Section
void
Console1::map_comp ()
{
	if (!_current_stripable)
		return;
	try {
		get_button (ControllerID::COMP)
		  ->set_led_state (_current_stripable->comp_enable_controllable ()
		                     ? _current_stripable->comp_enable_controllable ()->get_value ()
		                     : false);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_comp_mode ()
{
	if (!_current_stripable)
		return;
	try {
		double value = _current_stripable->comp_mode_controllable ()
		                 ? _current_stripable->comp_mode_controllable ()->get_value ()
		                 : false;
		DEBUG_TRACE (DEBUG::Console1, string_compose ("****value from comp-type %1\n", value));
		get_mbutton (ControllerID::ORDER)->set_led_state (value);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Button not found\n");
	}
}

void
Console1::map_comp_thresh ()
{
	ControllerID controllerID = ControllerID::COMP_THRESH;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->comp_threshold_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_comp_attack ()
{
	ControllerID controllerID = ControllerID::COMP_ATTACK;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->comp_attack_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_comp_release ()
{
	ControllerID controllerID = ControllerID::COMP_RELEASE;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->comp_release_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_comp_ratio ()
{
	ControllerID controllerID = ControllerID::COMP_RATIO;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->comp_ratio_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_comp_makeup ()
{
	ControllerID controllerID = ControllerID::COMP_PAR;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->comp_makeup_controllable ();
		map_encoder (controllerID, control);
	}
}

void
Console1::map_comp_emph ()
{
	ControllerID controllerID = ControllerID::DRIVE;
	if (map_encoder (controllerID)) {
		std::shared_ptr<AutomationControl> control = _current_stripable->comp_key_filter_freq_controllable ();
		map_encoder (controllerID, control);
	}
}

bool
Console1::map_encoder (ControllerID controllerID)
{
	if (!_current_stripable) {
		try {
			get_encoder (controllerID)->set_value (0);
		} catch (ControlNotFoundException const&) {
			DEBUG_TRACE (DEBUG::Console1, "Encoder not found\n");
			return false;
		}
		return false;
	}
	return true;
}

void
Console1::map_encoder (ControllerID controllerID, std::shared_ptr<ARDOUR::AutomationControl> control)
{

	if (!_current_stripable) {
		try {
			get_encoder (controllerID)->set_value (0);
		} catch (ControlNotFoundException const&) {
			DEBUG_TRACE (DEBUG::Console1, "Encoder not found\n");
		}
		return;
	}

	double val;
	double gain;

	if (!control) {
		val = 0.0;
	} else {
		val = control->get_value ();
		gain = control_to_midi (control, val);
	}
	try {
		get_encoder (controllerID)->set_value (gain);
	} catch (ControlNotFoundException const&) {
		DEBUG_TRACE (DEBUG::Console1, "Encoder not found\n");
	}
}