ot-tools-io 0.11.2

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

use crate::parts::lfos::{LfoParamsSetup1, LfoParamsSetup2, LfoParamsValues};
use crate::Defaults;
use ot_tools_io_derive::{ArrayDefaults, AsMutDerive, AsRefDerive, BoxedArrayDefaults};
use serde::{Deserialize, Serialize};
use serde_big_array::BigArray;
use std::array::from_fn;

/// Values for a MIDI Track's MIDI parameter page.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiTrackMidiParamsValues {
    pub note: u8,
    pub vel: u8,
    pub len: u8,
    pub not2: u8,
    pub not3: u8,
    pub not4: u8,
}

impl Default for MidiTrackMidiParamsValues {
    fn default() -> Self {
        Self {
            note: 48,
            vel: 100,
            len: 6,
            not2: 64,
            not3: 64,
            not4: 64,
        }
    }
}

#[cfg(test)]
mod midi_track_params_values_midi {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackMidiParamsValues;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_values.iter() {
            assert_eq!(x.midi, MidiTrackMidiParamsValues::default());
        }
        Ok(())
    }
}

/// Values for a MIDI Track's Arp parameter page.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiTrackArpParamsValues {
    pub tran: u8,
    pub leg: u8,
    pub mode: u8,
    pub spd: u8,
    pub rnge: u8,
    pub nlen: u8,
}

impl Default for MidiTrackArpParamsValues {
    fn default() -> Self {
        Self {
            tran: 64,
            leg: 0,
            mode: 0,
            spd: 5,
            rnge: 0,
            nlen: 6,
        }
    }
}

#[cfg(test)]
mod midi_track_params_values_arp {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackArpParamsValues;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_values.iter() {
            assert_eq!(x.arp, MidiTrackArpParamsValues::default());
        }
        Ok(())
    }
}

/// Values for a MIDI Track's CC1 parameter page.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiTrackCc1ParamsValues {
    pub pb: u8,
    pub at: u8,
    pub cc1: u8,
    pub cc2: u8,
    pub cc3: u8,
    pub cc4: u8,
}

impl Default for MidiTrackCc1ParamsValues {
    fn default() -> Self {
        Self {
            pb: 64,
            at: 0,
            cc1: 127,
            cc2: 0,
            cc3: 0,
            cc4: 64,
        }
    }
}

#[cfg(test)]
mod midi_track_params_values_cc1 {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackCc1ParamsValues;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_values.iter() {
            assert_eq!(x.ctrl1, MidiTrackCc1ParamsValues::default());
        }
        Ok(())
    }
}

/// Values for a MIDI Track's CC2 parameter page.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiTrackCc2ParamsValues {
    pub cc5: u8,
    pub cc6: u8,
    pub cc7: u8,
    pub cc8: u8,
    pub cc9: u8,
    pub cc10: u8,
}

#[cfg(test)]
mod midi_track_params_values_cc2 {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackCc2ParamsValues;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_values.iter() {
            assert_eq!(x.ctrl2, MidiTrackCc2ParamsValues::default());
        }
        Ok(())
    }
}

/// MIDI Track parameter values. MIDI/Note, LFO, Amp, Ctrl 1, Ctrl 2.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    ArrayDefaults,
    BoxedArrayDefaults,
)]
pub struct MidiTrackParamsValues {
    pub midi: MidiTrackMidiParamsValues,
    pub lfo: LfoParamsValues,
    pub arp: MidiTrackArpParamsValues,
    pub ctrl1: MidiTrackCc1ParamsValues,
    pub ctrl2: MidiTrackCc2ParamsValues,
    #[serde(with = "BigArray")]
    pub unknown: [u8; 2],
}

#[cfg(test)]
mod midi_track_params_values {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackParamsValues;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_values.iter() {
            assert_eq!(x, &MidiTrackParamsValues::default());
        }
        Ok(())
    }
}

/// Values for a MIDI Track's Note Setup page.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiTrackNoteParamsSetup {
    pub chan: u8,
    pub bank: u8,
    pub prog: u8,
    pub unused_1: u8,
    pub sbank: u8,
    pub unused_2: u8,
}

impl Default for MidiTrackNoteParamsSetup {
    fn default() -> Self {
        Self {
            chan: 0,
            bank: 128,
            prog: 128,
            unused_1: 0,
            sbank: 128,
            unused_2: 0,
        }
    }
}

#[cfg(test)]
mod midi_track_note_params_setup {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackNoteParamsSetup;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_setup.iter() {
            assert_eq!(x.note, MidiTrackNoteParamsSetup::default());
        }
        Ok(())
    }
}

/// Values for a MIDI Track's Arp Setup page.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiTrackArpParamsSetup {
    pub unused_1: u8,
    pub unused_2: u8,
    /// Length of the arp sequence
    pub len: u8,
    pub unused_3: u8,
    pub unused_4: u8,
    /// maximum 24 -- B Min
    /// minimum 0 -- Off
    pub key: u8,
}

impl Default for MidiTrackArpParamsSetup {
    fn default() -> Self {
        Self {
            unused_1: 0,
            unused_2: 0,
            len: 7,
            unused_3: 0,
            unused_4: 0,
            key: 0,
        }
    }
}

#[cfg(test)]
mod midi_track_arp_params_setup {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackArpParamsSetup;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_setup.iter() {
            assert_eq!(x.arp, MidiTrackArpParamsSetup::default());
        }
        Ok(())
    }
}

/// Values for a MIDI Track's CC1 Setup page.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiTrackCc1ParamsSetup {
    pub unused_1: u8,
    pub unused_2: u8,
    pub cc1: u8,
    pub cc2: u8,
    pub cc3: u8,
    pub cc4: u8,
}

impl Default for MidiTrackCc1ParamsSetup {
    fn default() -> Self {
        Self {
            unused_1: 0,
            unused_2: 0,
            cc1: 7,
            cc2: 1,
            cc3: 2,
            cc4: 10,
        }
    }
}

#[cfg(test)]
mod midi_track_cc1_params_setup {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackCc1ParamsSetup;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_setup.iter() {
            assert_eq!(x.ctrl1, MidiTrackCc1ParamsSetup::default());
        }
        Ok(())
    }
}

/// Values for a MIDI Track's CC2 Setup page.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct MidiTrackCc2ParamsSetup {
    pub cc5: u8,
    pub cc6: u8,
    pub cc7: u8,
    pub cc8: u8,
    pub cc9: u8,
    pub cc10: u8,
}

impl Default for MidiTrackCc2ParamsSetup {
    fn default() -> Self {
        Self {
            cc5: 71,
            cc6: 72,
            cc7: 73,
            cc8: 74,
            cc9: 75,
            cc10: 76,
        }
    }
}

#[cfg(test)]
mod midi_track_cc2_params_setup {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackCc2ParamsSetup;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_setup.iter() {
            assert_eq!(x.ctrl2, MidiTrackCc2ParamsSetup::default());
        }
        Ok(())
    }
}

/// MIDI Tracks Parameter Setup pages for LFO, Amp, FX etc.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    ArrayDefaults,
    BoxedArrayDefaults,
)]
pub struct MidiTrackParamsSetup {
    pub note: MidiTrackNoteParamsSetup,
    pub lfo1: LfoParamsSetup1,
    pub arp: MidiTrackArpParamsSetup,
    pub ctrl1: MidiTrackCc1ParamsSetup,
    pub ctrl2: MidiTrackCc2ParamsSetup,
    pub lfo2: LfoParamsSetup2,
}

#[cfg(test)]
mod midi_track_params_setup {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiTrackParamsSetup;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_track_params_setup.iter() {
            assert_eq!(x, &MidiTrackParamsSetup::default());
        }
        Ok(())
    }
}

/// A MIDI Track's custom Arp sequence.
/// `0` -> `+63` values (above line) maps to `0` -> `63`.
/// `-1` -> `-63` values (below line) map to `255` -> `192`.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    ArrayDefaults,
    BoxedArrayDefaults,
)]
pub struct MidiArpSequence(pub [u8; 16]);

impl Default for MidiArpSequence {
    fn default() -> Self {
        Self(from_fn(|_| 0))
    }
}

#[cfg(test)]
mod midi_arp_seq {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::parts::tracks::midi::MidiArpSequence;
    use crate::OtToolsIoError;

    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].midi_tracks_arp_seqs.iter() {
            assert_eq!(x, &MidiArpSequence::default());
        }
        Ok(())
    }
}