ot-tools-io 0.11.2

/*
SPDX-License-Identifier: GPL-3.0-or-later
Copyright © 2026 Mike Robeson [dijksterhuis]
*/

//! Data structures for the Octatrack Project Settings 'Control Menu'.

use ot_tools_io_derive::{AsMutDerive, AsRefDerive};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

use crate::projects::{
    parse_hashmap_string_value, parse_hashmap_string_value_bool, ProjectParseError,
};
use crate::settings::ProgChMidiChannel;

/// Convenience struct for all data related to the Octatrack Project Settings 'Control' Menu.

// todo: default
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct ControlMenu {
    /// 'Audio' page
    pub audio: AudioControlPage,

    /// 'Input' page
    pub input: InputControlPage,

    /// 'Sequencer' page
    pub sequencer: SequencerControlPage,

    /// 'MIDI Sequencer' page
    pub midi_sequencer: MidiSequencerControlPage,

    /// 'Memory' page
    pub memory: MemoryControlPage,

    /// 'Metronome' page
    pub metronome: MetronomeControlPage,

    /// 'Midi' sub menu
    pub midi: MidiSubMenu,
}

impl TryFrom<&HashMap<String, String>> for ControlMenu {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        let audio = AudioControlPage::try_from(value)?;
        let input = InputControlPage::try_from(value)?;
        let sequencer = SequencerControlPage::try_from(value)?;
        let midi_sequencer = MidiSequencerControlPage {};
        let memory = MemoryControlPage::try_from(value)?;
        let metronome = MetronomeControlPage::try_from(value)?;
        let midi = MidiSubMenu::try_from(value)?;

        Ok(Self {
            audio,
            input,
            sequencer,
            midi_sequencer,
            memory,
            metronome,
            midi,
        })
    }
}

/// Convenience struct for all data related to the 'MIDI' sub-menu
/// within the Octatrack Project Settings 'Control' Menu.

// todo: default
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiSubMenu {
    pub control: MidiControlMidiPage,
    pub sync: MidiSyncMidiPage,
    pub channels: MidiChannelsMidiPage,
    // control_midi_turbo: todo!(),
}

impl TryFrom<&HashMap<String, String>> for MidiSubMenu {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        let control = MidiControlMidiPage::try_from(value)?;
        let sync = MidiSyncMidiPage::try_from(value)?;
        let channels = MidiChannelsMidiPage::try_from(value)?;
        Ok(Self {
            control,
            sync,
            channels,
        })
    }
}

/// `PROJECT` -> `CONTROL` -> `AUDIO` UI menu.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioControlPage {
    /// `TRACK 8` setting. Whether Track 8 is a master audio track or not:
    /// - **NORMAL**: `false`
    /// - **MASTER**: `true`
    pub master_track: bool,

    /// `CUE CFG` setting. Behaviour for audio routing to CUE outputs.
    /// - **NORMAL** -> **CUE+TRACK** button combo sends audio to CUE out.
    /// - **STUDIO** -> Individual track volume controls for CUE out (unable to **CUE+TRACK**).
    pub cue_studio_mode: bool,
}

#[allow(clippy::derivable_impls)] // clear documentation for non-rustaceans
impl Default for AudioControlPage {
    fn default() -> Self {
        Self {
            master_track: false,
            cue_studio_mode: false,
        }
    }
}

impl TryFrom<&HashMap<String, String>> for AudioControlPage {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        let master_track = parse_hashmap_string_value_bool(value, "master_track", None)?;
        let cue_studio_mode = parse_hashmap_string_value_bool(value, "cue_studio_mode", None)?;

        Ok(Self {
            master_track,
            cue_studio_mode,
        })
    }
}

/// `PROJECT` -> `CONTROL` -> `INPUT` UI menu.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct InputControlPage {
    /// dB level of noise gate for the AB external audio inputs.
    /// See Manual section 8.8 MIXER MENU
    pub gate_ab: u8,

    /// dB level of noise gate for the CD external audio inputs.
    /// See Manual section 8.8 MIXER MENU
    pub gate_cd: u8,

    /// See Manual section 8.6.2. INPUT.
    /// Adds a delay to incoming external audio signals. Controlled by the DIR setting on the MIXER page.
    pub input_delay_compensation: bool,
}

impl Default for InputControlPage {
    fn default() -> Self {
        Self {
            gate_ab: 127,
            gate_cd: 127,
            input_delay_compensation: false,
        }
    }
}

impl TryFrom<&HashMap<String, String>> for InputControlPage {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        let gate_ab = parse_hashmap_string_value::<u8>(value, "gate_ab", None)?;
        let gate_cd = parse_hashmap_string_value::<u8>(value, "gate_cd", None)?;
        let input_delay_compensation =
            parse_hashmap_string_value_bool(value, "input_delay_compensation", None)?;

        Ok(Self {
            gate_ab,
            gate_cd,
            input_delay_compensation,
        })
    }
}

/// `PROJECT` -> `CONTROL` -> `SEQUENCER` UI menu.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct SequencerControlPage {
    /// `CHAIN AFTER` setting.
    /// When chained patterns start playing once the pattern is chosen.
    /// This is the global project level setting, but can be overidden for each pattern.
    /// Default setting is "PATTERN LENGTH".
    /// See Manual section 8.6.3. SEQUENCER.
    pub pattern_change_chain_behaviour: u8, // bool?

    /// `SILENCE TRACKS` setting
    /// Silence tracks when switching to a new pattern.
    /// See Manual section 8.6.3. SEQUENCER.
    pub pattern_change_auto_silence_tracks: bool,

    /// `LFO AUTO CHANGE` setting.
    /// Whether to retrigger LFOs when swtiching to a new pattern
    /// See Manual section 8.6.3. SEQUENCER.
    pub pattern_change_auto_trig_lfos: bool,
}

#[allow(clippy::derivable_impls)] // clear documentation for non-rustaceans
impl Default for SequencerControlPage {
    fn default() -> Self {
        SequencerControlPage {
            pattern_change_chain_behaviour: 0,
            pattern_change_auto_silence_tracks: false,
            pattern_change_auto_trig_lfos: false,
        }
    }
}

impl TryFrom<&HashMap<String, String>> for SequencerControlPage {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        let pattern_change_chain_behaviour =
            parse_hashmap_string_value::<u8>(value, "pattern_change_chain_behavior", None)?;
        let pattern_change_auto_silence_tracks =
            parse_hashmap_string_value_bool(value, "pattern_change_auto_trig_lfos", None)?;
        let pattern_change_auto_trig_lfos =
            parse_hashmap_string_value_bool(value, "pattern_change_auto_trig_lfos", None)?;

        Ok(Self {
            pattern_change_chain_behaviour,
            pattern_change_auto_silence_tracks,
            pattern_change_auto_trig_lfos,
        })
    }
}

/// `PROJECT` -> `CONTROL` -> `MIDI SEQUENCER` UI menu.
// TODO: ?!?!?!?! Where is the value for this??!?!?!
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiSequencerControlPage {}

#[allow(clippy::derivable_impls)] // clear documentation for non-rustaceans
impl Default for MidiSequencerControlPage {
    fn default() -> Self {
        Self {}
    }
}

/// `PROJECT` -> `CONTROL` -> `MEMORY` UI menu.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MemoryControlPage {
    /// Whether samples can be loaded in 24-bit depth (16 bit depth samples are always oaded as 16 bit).
    /// Setting this to false loads all samples as 16 bit depth.
    /// See Manual section 8.6.5. MEMORY.
    pub load_24bit_flex: bool,

    /// Disabled forces all recorders to use track recorder memory (16 seconds per track).
    /// When enabled, track recorders can use free Flex RAM memory.
    /// See Manual section 8.6.5. MEMORY.
    pub dynamic_recorders: bool,

    /// Whether to record in 24 bit depth (`true`) or 16 bit depth (`false`).
    /// See Manual section 8.6.5. MEMORY.
    pub record_24bit: bool,

    /// How many active track recorders are available in a project. Controls whether TR1 through to TR8 are enabled / disabled.
    /// See Manual section 8.6.5. MEMORY.
    pub reserved_recorder_count: u8,

    /// How many 'sequencer steps' should be reserved for track recorders in RAM.
    /// See Manual section 8.6.5. MEMORY.
    pub reserved_recorder_length: u32,
}

impl Default for MemoryControlPage {
    fn default() -> Self {
        Self {
            load_24bit_flex: false,
            dynamic_recorders: false,
            record_24bit: false,
            reserved_recorder_count: 8,
            reserved_recorder_length: 16,
        }
    }
}

impl TryFrom<&HashMap<String, String>> for MemoryControlPage {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        let load_24bit_flex = parse_hashmap_string_value_bool(value, "load_24bit_flex", None)?;
        let dynamic_recorders = parse_hashmap_string_value_bool(value, "dynamic_recorders", None)?;
        let record_24bit = parse_hashmap_string_value_bool(value, "record_24bit", None)?;
        let reserved_recorder_count =
            parse_hashmap_string_value::<u8>(value, "reserved_recorder_count", None)?;
        let reserved_recorder_length =
            parse_hashmap_string_value::<u32>(value, "reserved_recorder_length", None)?;

        Ok(Self {
            load_24bit_flex,
            dynamic_recorders,
            record_24bit,
            reserved_recorder_count,
            reserved_recorder_length,
        })
    }
}

/// `PROJECT` -> `CONTROL` -> `METRONOME` UI menu.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MetronomeControlPage {
    /// `TIME SIG. NUMER` setting in `PROJECT` -> `CONTROL` -> `METRONOME` UI menu.
    /// Controls the numerator for time signature (the 3 in 3/4).
    /// See Manual section 8.6.6 METRONOME
    pub metronome_time_signature: u8,

    /// `TIME SIG. DENOM` setting in `PROJECT` -> `CONTROL` -> `METRONOME` UI menu.
    /// Controls the numerator for time signature (the 3 in 3/4).
    /// See Manual section 8.6.6 METRONOME
    pub metronome_time_signature_denominator: u8,

    /// `PREROLL` setting in `PROJECT` -> `CONTROL` -> `METRONOME` UI menu.
    /// How many bars to prerolls with the metronome before playing a pattern.
    /// See Manual section 8.6.6 METRONOME
    pub metronome_preroll: u8,

    /// How loud to play the metronome on CUE outputs. Default is 32.
    /// See Manual section 8.6.6 METRONOME
    pub metronome_cue_volume: u8,

    /// How loud to play the metronome on MAIN outputs. Default is 0.
    /// See Manual section 8.6.6 METRONOME
    pub metronome_main_volume: u8,

    /// Pitch of the metronome clicks. Default is 12.
    /// See Manual section 8.6.6 METRONOME
    pub metronome_pitch: u8,

    /// Whether the metronome click has tonal characteristics or not. Default is `true` (enabled).
    /// See Manual section 8.6.6 METRONOME
    pub metronome_tonal: bool,

    /// Whether the metronome is active. Default is `false`.
    /// See Manual section 8.6.6 METRONOME
    pub metronome_enabled: bool,
}

impl Default for MetronomeControlPage {
    fn default() -> Self {
        Self {
            metronome_time_signature: 3,
            metronome_time_signature_denominator: 2,
            metronome_preroll: 0,
            metronome_cue_volume: 32,
            metronome_main_volume: 0,
            metronome_pitch: 12,
            metronome_tonal: true,
            metronome_enabled: false,
        }
    }
}

impl TryFrom<&HashMap<String, String>> for MetronomeControlPage {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        let metronome_time_signature =
            parse_hashmap_string_value::<u8>(value, "metronome_time_signature", None)?;
        let metronome_time_signature_denominator =
            parse_hashmap_string_value::<u8>(value, "metronome_time_signature_denominator", None)?;
        let metronome_preroll = parse_hashmap_string_value::<u8>(value, "metronome_preroll", None)?;
        let metronome_cue_volume =
            parse_hashmap_string_value::<u8>(value, "metronome_cue_volume", None)?;
        let metronome_main_volume =
            parse_hashmap_string_value::<u8>(value, "metronome_main_volume", None)?;
        let metronome_pitch = parse_hashmap_string_value::<u8>(value, "metronome_pitch", None)?;
        let metronome_tonal = parse_hashmap_string_value_bool(value, "metronome_tonal", None)?;
        let metronome_enabled = parse_hashmap_string_value_bool(value, "metronome_enabled", None)?;

        Ok(Self {
            metronome_time_signature,
            metronome_time_signature_denominator,
            metronome_preroll,
            metronome_cue_volume,
            metronome_main_volume,
            metronome_pitch,
            metronome_tonal,
            metronome_enabled,
        })
    }
}

/// `PROJECT` -> `CONTROL` -> `MIDI` -> `CONTROL` UI menu.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiControlMidiPage {
    /// Whether samples can be loaded in 24-bit depth (16 bit depth samples are always odded as 16 bit).
    /// `AUDIO CC IN` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CONTROL` UI menu.
    /// Whether audio tracks respond to MIDI CC IN messages.
    ///
    /// See manual section 8.7.1 CONTROL.
    pub midi_audio_track_cc_in: bool,

    /// `AUDIO CC OUT` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CONTROL` UI menu.
    /// Whether audio tracks send MIDI CC OUT messages.
    /// Three options:
    /// - `INT`: No messages sent, knobs only affect Octatrack settings.
    /// - `EXT`: Sends CC OUT messages but they don't alter any Octatrack settings.
    /// - `INT+EXT`: Simultaneously affects Octatrack settings and sends CC OUT messages.
    ///
    /// See manual section 8.7.1 CONTROL.
    pub midi_audio_track_cc_out: u8,

    /// `AUDIO NOTE IN` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CONTROL` UI menu.
    /// Whether to receive MIDI NOTE IN messages on Audio tracks and how the audio tracks
    /// respond to those MIDI NOTE IN messages.
    /// - **OFF**: midi note has no effect.
    /// - **STANDARD**: standard note mapping (default).
    /// - **FOLLOW TM**: Track's current trig mode affects audio tracks (track/chromatic/slots).
    /// - **MAP/TRACK**: Uses MIDI MAP configuration on a per-track basis (track/chromatic/slots
    ///   disconnected from user trig mode of track).
    pub midi_audio_track_note_in: u8,

    /// `AUDIO NOTE OUT` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CONTROL` UI menu.
    /// Whether audio tracks send MIDI NOTE OUT messages. Three options:
    /// - `INT`: No messages sent, knobs only affect Octatrack settings.
    /// - `EXT`: Sends NOTE OUT messages but they don't alter any Octatrack settings.
    /// - `INT+EXT`: Simultaneously affects Octatrack settings and sends NOTE OUT messages.
    ///
    /// See manual section 8.7.1 CONTROL.
    pub midi_audio_track_note_out: u8,

    /// Unknown. MIDI channel to MIDI Track CC In messages n (1 - 16) ?
    pub midi_midi_track_cc_in: u8,
}

impl Default for MidiControlMidiPage {
    fn default() -> Self {
        Self {
            midi_audio_track_cc_in: true,
            midi_audio_track_cc_out: 3,
            midi_audio_track_note_in: 1,
            midi_audio_track_note_out: 3,
            midi_midi_track_cc_in: 1,
        }
    }
}

impl TryFrom<&HashMap<String, String>> for MidiControlMidiPage {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        let midi_audio_track_cc_in =
            parse_hashmap_string_value_bool(value, "midi_audio_trk_cc_in", None)?;

        let midi_audio_track_cc_out =
            parse_hashmap_string_value::<u8>(value, "midi_audio_trk_cc_out", None)?;

        let midi_audio_track_note_in =
            parse_hashmap_string_value::<u8>(value, "midi_audio_trk_note_in", None)?;

        let midi_audio_track_note_out =
            parse_hashmap_string_value::<u8>(value, "midi_audio_trk_note_out", None)?;

        let midi_midi_track_cc_in =
            parse_hashmap_string_value::<u8>(value, "midi_midi_trk_cc_in", None)?;

        Ok(Self {
            midi_audio_track_cc_in,
            midi_audio_track_cc_out,
            midi_audio_track_note_in,
            midi_audio_track_note_out,
            midi_midi_track_cc_in,
        })
    }
}

/// `PROJECT` -> `CONTROL` -> `MIDI` -> `SYNC` UI menu.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiSyncMidiPage {
    /// `CLOCK SEND` setting.
    /// Whether MIDI clock sending is enabled/disabled
    /// See manual section 8.7.2 SYNC.
    pub midi_clock_send: bool,

    /// `CLOCK RECV` setting.
    /// Whether MIDI clock receiving is enabled/disabled
    /// See manual section 8.7.2 SYNC.
    pub midi_clock_receive: bool,

    /// `TRANS SEND` setting.
    /// Whether MIDI transport sending is enabled/disabled
    /// See manual section 8.7.2 SYNC.
    pub midi_transport_send: bool,

    /// `TRANS RECV` setting.
    /// Whether MIDI transport receiving is enabled/disabled
    /// See manual section 8.7.2 SYNC.
    pub midi_transport_receive: bool,

    /// `PROG CH SEND` setting.
    /// Whether MIDI Program Change sending is enabled/disabled
    /// See manual section 8.7.2 SYNC.
    pub midi_progchange_send: bool,

    /// `CHANNEL` setting.
    /// Channel to send MIDI Program Change messages on. `-1` = Auto, `0`-`15` = CH 1-16.
    /// See manual section 8.7.2 SYNC.
    pub midi_progchange_send_channel: ProgChMidiChannel,

    /// `PROG CH RECEIVE` setting.
    /// Whether MIDI Program Change receiving is enabled/disabled.
    /// See manual section 8.7.2 SYNC.
    pub midi_progchange_receive: bool,

    /// `CHANNEL` setting.
    /// Channel to receive MIDI Program Change messages on. `-1` = Auto, `0`-`15` = CH 1-16.
    /// See manual section 8.7.2 SYNC.
    pub midi_progchange_receive_channel: ProgChMidiChannel,
}

impl Default for MidiSyncMidiPage {
    fn default() -> Self {
        Self {
            midi_clock_send: false,
            midi_clock_receive: false,
            midi_transport_send: false,
            midi_transport_receive: false,
            midi_progchange_send: false,
            midi_progchange_send_channel: ProgChMidiChannel::Auto,
            midi_progchange_receive: false,
            midi_progchange_receive_channel: ProgChMidiChannel::Auto,
        }
    }
}

impl TryFrom<&HashMap<String, String>> for MidiSyncMidiPage {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        /*
        WONTFIX: older OS versions seem to use non-boolean values for boolean settings.

        Some older projects seem to use different settings values for this.
        I had an OS 1.25E project (`ROMANT_DELETING`) where `MIDI_CLOCK_SEND=2`.
        But this is definitely boolean so `2` doesn't make sense here
        (see manual p. 40 and/or settings menu page).

        This probably applies to the other boolean values here. I probably won't fix
        this as it's an OS patching issue which can easily be fixed by users.
        */
        let midi_clock_send = parse_hashmap_string_value_bool(value, "midi_clock_send", None)?;

        // See WONTFIX note above. Observed in an old 1.25E project.
        let midi_clock_receive =
            parse_hashmap_string_value_bool(value, "midi_clock_receive", None)?;

        // See WONTFIX note above. Observed in an old 1.25E project.
        let midi_transport_send =
            parse_hashmap_string_value_bool(value, "midi_transport_send", None)?;

        // See WONTFIX note above. Observed in an old 1.25E project.
        let midi_transport_receive =
            parse_hashmap_string_value_bool(value, "midi_transport_receive", None)?;

        let midi_progchange_send =
            parse_hashmap_string_value_bool(value, "midi_program_change_send", None)?;

        let midi_progchange_send_channel = ProgChMidiChannel::try_from(
            &parse_hashmap_string_value::<i8>(value, "midi_program_change_send_ch", None)?,
        )?;

        let midi_progchange_receive =
            parse_hashmap_string_value_bool(value, "midi_program_change_receive", None)?;

        let midi_progchange_receive_channel = ProgChMidiChannel::try_from(
            &parse_hashmap_string_value::<i8>(value, "midi_program_change_receive_ch", None)?,
        )?;

        Ok(Self {
            midi_clock_send,
            midi_clock_receive,
            midi_transport_send,
            midi_transport_receive,
            midi_progchange_send,
            midi_progchange_send_channel,
            midi_progchange_receive,
            midi_progchange_receive_channel,
        })
    }
}

/// `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiChannelsMidiPage {
    /// `TRIG CH 1` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
    /// MIDI Channel to send MIDI Trig 1 messages to (1 - 16)
    /// See manual section 8.7.3 CHANNELS.
    ///
    /// NOTE: Can also be -1 for DISABLED
    pub midi_trig_ch1: i8,

    /// `TRIG CH 2` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
    /// MIDI Channel to send MIDI Trig 2 messages to (1 - 16)
    /// See manual section 8.7.3 CHANNELS.
    ///
    /// NOTE: Can also be -1 for DISABLED
    pub midi_trig_ch2: i8,

    /// `TRIG CH 3` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
    /// MIDI Channel to send MIDI Trig 3 messages to (1 - 16)
    /// See manual section 8.7.3 CHANNELS.
    ///
    /// NOTE: Can also be -1 for DISABLED
    pub midi_trig_ch3: i8,

    /// `TRIG CH 4` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
    /// MIDI Channel to send MIDI Trig 4 messages to (1 - 16)
    /// See manual section 8.7.3 CHANNELS.
    ///
    /// NOTE: Can also be -1 for DISABLED
    pub midi_trig_ch4: i8,

    /// `TRIG CH 5` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
    /// MIDI Channel to send MIDI Trig 5 messages to (1 - 16)
    /// See manual section 8.7.3 CHANNELS.
    ///
    /// NOTE: Can also be -1 for DISABLED
    pub midi_trig_ch5: i8,

    /// `TRIG CH 6` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
    /// MIDI Channel to send MIDI Trig 6 messages to (1 - 16)
    /// See manual section 8.7.3 CHANNELS.
    ///
    /// NOTE: Can also be -1 for DISABLED
    pub midi_trig_ch6: i8,

    /// `TRIG CH 7` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
    /// MIDI Channel to send MIDI Trig 7 messages to (1 - 16)
    /// See manual section 8.7.3 CHANNELS.
    ///
    /// NOTE: Can also be -1 for DISABLED
    pub midi_trig_ch7: i8,

    /// `TRIG CH 8` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
    /// MIDI Channel to send MIDI Trig 8 messages to (1 - 16)
    /// See manual section 8.7.3 CHANNELS.
    ///
    /// NOTE: Can also be -1 for DISABLED
    pub midi_trig_ch8: i8,

    /// `AUTO CH` setting in `PROJECT` -> `CONTROL` -> `MIDI` -> `CHANNELS` UI menu.
    /// Auto MIDI Channel (1 - 16)
    /// See manual section 8.7.3 CHANNELS.
    ///
    /// NOTE: Can also be -1 for DISABLED
    pub midi_auto_channel: i8,
}

impl Default for MidiChannelsMidiPage {
    fn default() -> Self {
        Self {
            midi_trig_ch1: 0,
            midi_trig_ch2: 1,
            midi_trig_ch3: 2,
            midi_trig_ch4: 3,
            midi_trig_ch5: 4,
            midi_trig_ch6: 5,
            midi_trig_ch7: 6,
            midi_trig_ch8: 7,
            midi_auto_channel: 10,
        }
    }
}

impl TryFrom<&HashMap<String, String>> for MidiChannelsMidiPage {
    type Error = ProjectParseError;
    fn try_from(value: &HashMap<String, String>) -> Result<Self, Self::Error> {
        let midi_trig_ch1 = parse_hashmap_string_value::<i8>(value, "midi_trig_ch1", None)?;
        let midi_trig_ch2 = parse_hashmap_string_value::<i8>(value, "midi_trig_ch2", None)?;
        let midi_trig_ch3 = parse_hashmap_string_value::<i8>(value, "midi_trig_ch3", None)?;
        let midi_trig_ch4 = parse_hashmap_string_value::<i8>(value, "midi_trig_ch4", None)?;
        let midi_trig_ch5 = parse_hashmap_string_value::<i8>(value, "midi_trig_ch5", None)?;
        let midi_trig_ch6 = parse_hashmap_string_value::<i8>(value, "midi_trig_ch6", None)?;
        let midi_trig_ch7 = parse_hashmap_string_value::<i8>(value, "midi_trig_ch7", None)?;
        let midi_trig_ch8 = parse_hashmap_string_value::<i8>(value, "midi_trig_ch8", None)?;
        let midi_auto_channel = parse_hashmap_string_value::<i8>(value, "midi_auto_channel", None)?;
        Ok(Self {
            midi_trig_ch1,
            midi_trig_ch2,
            midi_trig_ch3,
            midi_trig_ch4,
            midi_trig_ch5,
            midi_trig_ch6,
            midi_trig_ch7,
            midi_trig_ch8,
            midi_auto_channel,
        })
    }
}