ot-tools-io 0.9.0

/*
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 std::array::from_fn;

/// Audio Track MAIN and CUE volume.
/// Both are 108 by default.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    ArrayDefaults,
    BoxedArrayDefaults,
)]
pub struct AudioTrackVolume {
    pub main: u8,
    pub cue: u8,
}

// TODO: Double check values
impl Default for AudioTrackVolume {
    fn default() -> Self {
        Self {
            main: 0x6c, // 108
            cue: 0x6c,  // 108
        }
    }
}

#[cfg(test)]
mod audio_track_volume {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackVolume, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_volumes.iter() {
            assert_eq!(x, &AudioTrackVolume::default());
        }
        Ok(())
    }
}

/// An Audio Track's Setup values for the Static and Flex machine on the track (loop setting/slice setting/len setting etc.).
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackMachineParamsSetupStd {
    pub xloop: u8,
    pub slic: u8,
    pub len: u8,
    pub rate: u8,
    pub tstr: u8,
    pub tsns: u8,
}

impl Default for AudioTrackMachineParamsSetupStd {
    fn default() -> Self {
        Self {
            xloop: 1,
            slic: 0,
            len: 0,
            rate: 0,
            tstr: 1,
            tsns: 64,
        }
    }
}

#[cfg(test)]
mod audio_track_machines_params_setup_std {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachineParamsSetupStd, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_setup.iter() {
            assert_eq!(x.static_machine, AudioTrackMachineParamsSetupStd::default());
            assert_eq!(x.flex_machine, AudioTrackMachineParamsSetupStd::default());
        }
        Ok(())
    }
}

/// An Audio Track's Setup values for the Thru machine on the track. Should not contain any data.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackMachineParamsSetupThru {
    pub unused_1: u8,
    pub unused_2: u8,
    pub unused_3: u8,
    pub unused_4: u8,
    pub unused_5: u8,
    pub unused_6: u8,
}

#[cfg(test)]
mod audio_track_machines_params_setup_thru {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachineParamsSetupThru, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_setup.iter() {
            assert_eq!(x.thru_machine, AudioTrackMachineParamsSetupThru::default());
        }
        Ok(())
    }
}

/// An Audio Track's Setup values for the Neighbor machine on the track. Should not contain any data.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackMachineParamsSetupNeighbor {
    pub unused_1: u8,
    pub unused_2: u8,
    pub unused_3: u8,
    pub unused_4: u8,
    pub unused_5: u8,
    pub unused_6: u8,
}

#[cfg(test)]
mod audio_track_machines_params_setup_neigh {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachineParamsSetupNeighbor, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_setup.iter() {
            assert_eq!(
                x.neighbor_machine,
                AudioTrackMachineParamsSetupNeighbor::default()
            );
        }
        Ok(())
    }
}

/// An Audio Track's Setup values for the Pickup machine on the track.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackMachineParamsSetupPickup {
    pub unused_1: u8,
    pub unused_2: u8,
    pub unused_3: u8,
    pub unused_4: u8,
    pub tstr: u8,
    pub tsns: u8,
}

impl Default for AudioTrackMachineParamsSetupPickup {
    fn default() -> Self {
        AudioTrackMachineParamsSetupPickup {
            unused_1: 0,
            unused_2: 0,
            unused_3: 0,
            unused_4: 0,
            tstr: 1,
            tsns: 64,
        }
    }
}

#[cfg(test)]
mod audio_track_machines_params_setup_pickup {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachineParamsSetupPickup, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_setup.iter() {
            assert_eq!(
                x.pickup_machine,
                AudioTrackMachineParamsSetupPickup::default()
            );
        }
        Ok(())
    }
}

/// Audio Tracks Machine Setup pages.
/// As before, separate from other Audio Track parameter fields to be persisted,
/// allowing safer audio triggering.

#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    ArrayDefaults,
    BoxedArrayDefaults,
)]
pub struct AudioTrackMachinesParamsSetup {
    pub static_machine: AudioTrackMachineParamsSetupStd,
    pub flex_machine: AudioTrackMachineParamsSetupStd,
    pub thru_machine: AudioTrackMachineParamsSetupThru,
    pub neighbor_machine: AudioTrackMachineParamsSetupNeighbor,
    pub pickup_machine: AudioTrackMachineParamsSetupPickup,
}

#[cfg(test)]
mod audio_track_machines_params_setup {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachinesParamsSetup, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_setup.iter() {
            assert_eq!(x, &AudioTrackMachinesParamsSetup::default());
        }
        Ok(())
    }
}

/// Audio Tracks Machine Slot assignments.
/// Sample Slots assigned for each machine.
/// Also tracks the recording buffer sample slot assignment.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    BoxedArrayDefaults,
)]
pub struct AudioTrackMachineSlot {
    pub static_slot_id: u8,
    pub flex_slot_id: u8,
    pub unused_1: u8,
    pub unused_2: u8,
    pub recorder_slot_id: u8,
}

impl Default for AudioTrackMachineSlot {
    fn default() -> Self {
        Self {
            static_slot_id: 0,
            flex_slot_id: 0,
            unused_1: 0,
            unused_2: 0,
            recorder_slot_id: 128,
        }
    }
}

// need to implement manually to handle id fields
impl<const N: usize> Defaults<[Self; N]> for AudioTrackMachineSlot {
    fn defaults() -> [Self; N]
    where
        Self: Default,
    {
        from_fn(|i| Self {
            static_slot_id: i as u8,
            flex_slot_id: i as u8,
            recorder_slot_id: 128 + i as u8,
            ..Default::default()
        })
    }
}

#[cfg(test)]
mod audio_track_machines_slot {
    use crate::generics::Tracks;
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachineSlot, OtToolsIoError};

    #[test]
    #[ignore]
    fn default() -> Result<(), OtToolsIoError> {
        // this test doesn't make sense to run -- each track will have a different values, so
        // testing the default method doesn't really help
        // todo: maybe manually implement a check using emumerate?
        unimplemented!();
    }

    #[test]
    fn defaults() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        let slots = b.parts_unsaved[0].audio_track_machine_slots;
        let valid: Tracks<AudioTrackMachineSlot> = Tracks::<AudioTrackMachineSlot>::default();
        assert_eq!(slots, valid);
        Ok(())
    }
}

/// Values of an Audio Track's parameters page for the Static or FLex machine on the track (pitch/slice/len etc).
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackMachineParamsValuesStd {
    pub ptch: u8,
    pub strt: u8,
    pub len: u8,
    pub rate: u8,
    pub rtrg: u8,
    pub rtim: u8,
}

impl Default for AudioTrackMachineParamsValuesStd {
    fn default() -> Self {
        Self {
            ptch: 64,
            strt: 0,
            len: 0,
            rate: 127,
            rtrg: 0,
            rtim: 79,
        }
    }
}

#[cfg(test)]
mod audio_track_machines_params_values_std {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachineParamsValuesStd, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_params.iter() {
            assert_eq!(
                x.static_machine,
                AudioTrackMachineParamsValuesStd::default()
            );
            assert_eq!(x.flex_machine, AudioTrackMachineParamsValuesStd::default());
        }
        Ok(())
    }
}

/// Values of an Audio Track's parameters page for the Flex machine on the track (in/vol etc).
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackMachineParamsValuesThru {
    pub in_ab: u8,
    pub vol_ab: u8,
    pub unused_1: u8,
    pub in_cd: u8,
    pub vol_cd: u8,
    pub unused_2: u8,
}

impl Default for AudioTrackMachineParamsValuesThru {
    fn default() -> Self {
        Self {
            in_ab: 0,
            vol_ab: 64,
            unused_1: 0,
            in_cd: 0,
            vol_cd: 64,
            unused_2: 0,
        }
    }
}

#[cfg(test)]
mod audio_track_machines_params_values_thru {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachineParamsValuesThru, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_params.iter() {
            assert_eq!(x.thru_machine, AudioTrackMachineParamsValuesThru::default());
        }
        Ok(())
    }
}

/// Values of an Audio Track's parameters page for the Neighbor machine on the track. Should not contain any data.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackMachineParamsValuesNeighbor {
    pub unused_1: u8,
    pub unused_2: u8,
    pub unused_3: u8,
    pub unused_4: u8,
    pub unused_5: u8,
    pub unused_6: u8,
}

#[cfg(test)]
mod audio_track_machines_params_values_neigh {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachineParamsValuesNeighbor, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_params.iter() {
            assert_eq!(
                x.neighbor_machine,
                AudioTrackMachineParamsValuesNeighbor::default()
            );
        }
        Ok(())
    }
}

/// Values of an Audio Track's parameters page for the Pickup machine on the track. (pitch/dir/len etc).
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackMachineParamsValuesPickup {
    pub ptch: u8,
    pub dir: u8,
    pub len: u8,
    pub unused_1: u8,
    pub gain: u8,
    pub op: u8,
}

impl Default for AudioTrackMachineParamsValuesPickup {
    fn default() -> Self {
        Self {
            ptch: 64,
            dir: 2,
            len: 1,
            unused_1: 127,
            gain: 64,
            op: 1,
        }
    }
}

#[cfg(test)]
mod audio_track_machines_params_values_pickup {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachineParamsValuesPickup, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_params.iter() {
            assert_eq!(
                x.pickup_machine,
                AudioTrackMachineParamsValuesPickup::default()
            );
        }
        Ok(())
    }
}

/// Audio Tracks Machine Parameter pages.
/// Machine parameter values persist after the machine type is changed,
/// meaning audio keeps playing until the new machine is triggered to play new audio.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    ArrayDefaults,
    BoxedArrayDefaults,
)]
pub struct AudioTrackMachinesParamsValues {
    pub static_machine: AudioTrackMachineParamsValuesStd,
    pub flex_machine: AudioTrackMachineParamsValuesStd,
    pub thru_machine: AudioTrackMachineParamsValuesThru,
    pub neighbor_machine: AudioTrackMachineParamsValuesNeighbor,
    pub pickup_machine: AudioTrackMachineParamsValuesPickup,
}

#[cfg(test)]
mod audio_track_machines_params_values {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackMachinesParamsValues, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_machine_params.iter() {
            assert_eq!(x, &AudioTrackMachinesParamsValues::default());
        }
        Ok(())
    }
}

#[cfg(test)]
mod audio_track_params_values_lfo {
    use crate::parts::lfos::LfoParamsValues;
    use crate::parts::test_helper::get_default_test_bank;
    use crate::OtToolsIoError;

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

/// Values of a Track's main AMP parameters page.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackAmpParamsValues {
    pub atk: u8,
    pub hold: u8,
    pub rel: u8,
    pub vol: u8,
    pub bal: u8,
    /// Reserved space for the \<F\> parameter used by Scenes and LFOs
    pub f: u8,
}

// allow the verbose implementation to keep things
// - (a) standardised across all types
// - (b) easier for non-rustaceans to follow when reading through data structures
#[allow(clippy::derivable_impls)]
impl Default for AudioTrackAmpParamsValues {
    fn default() -> Self {
        Self {
            atk: 0,
            hold: 127,
            rel: 127,
            vol: 64,
            bal: 64,
            f: 127,
        }
    }
}

#[cfg(test)]
mod audio_track_params_values_amp {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackAmpParamsValues, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_params_values.iter() {
            assert_eq!(x.amp, AudioTrackAmpParamsValues::default());
        }
        Ok(())
    }
}

/// Values of a Track's FX parameters page.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackFxParamsValues {
    pub param_1: u8,
    pub param_2: u8,
    pub param_3: u8,
    pub param_4: u8,
    pub param_5: u8,
    pub param_6: u8,
}

#[cfg(test)]
mod audio_track_params_values_fx {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackFxParamsValues, OtToolsIoError};
    #[test]
    fn default_fx1() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_params_values.iter() {
            assert_eq!(
                x.fx1,
                AudioTrackFxParamsValues {
                    param_1: 0,
                    param_2: 127,
                    param_3: 0,
                    param_4: 64,
                    param_5: 0,
                    param_6: 64,
                }
            );
        }
        Ok(())
    }
    #[test]
    fn default_fx2() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_params_values.iter() {
            assert_eq!(
                x.fx2,
                AudioTrackFxParamsValues {
                    param_1: 47,
                    param_2: 0,
                    param_3: 127,
                    param_4: 0,
                    param_5: 127,
                    param_6: 0,
                }
            );
        }
        Ok(())
    }
}

/// Audio Tracks Parameter Page values. LFO, Amp, FX etc.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    ArrayDefaults,
    BoxedArrayDefaults,
)]
pub struct AudioTrackParamsValues {
    pub lfo: LfoParamsValues,
    pub amp: AudioTrackAmpParamsValues,
    pub fx1: AudioTrackFxParamsValues,
    pub fx2: AudioTrackFxParamsValues,
}

impl Default for AudioTrackParamsValues {
    fn default() -> Self {
        Self {
            lfo: LfoParamsValues::default(),
            amp: AudioTrackAmpParamsValues::default(),
            fx1: AudioTrackFxParamsValues {
                param_1: 0,
                param_2: 127,
                param_3: 0,
                param_4: 64,
                param_5: 0,
                param_6: 64,
            },
            fx2: AudioTrackFxParamsValues {
                param_1: 47,
                param_2: 0,
                param_3: 127,
                param_4: 0,
                param_5: 127,
                param_6: 0,
            },
        }
    }
}

#[cfg(test)]
mod audio_track_params_values {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackParamsValues, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_params_values.iter() {
            assert_eq!(x, &AudioTrackParamsValues::default());
        }
        Ok(())
    }
}

#[cfg(test)]
mod audio_track_params_setup_lfo_1 {
    use crate::parts::lfos::LfoParamsSetup1;
    use crate::parts::test_helper::get_default_test_bank;
    use crate::OtToolsIoError;

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

#[cfg(test)]
mod audio_track_params_setup_lfo_2 {
    use crate::parts::lfos::LfoParamsSetup2;
    use crate::parts::test_helper::get_default_test_bank;
    use crate::OtToolsIoError;

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

/// Values for a Track's AMP Setup page.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackAmpParamsSetup {
    pub amp: u8,
    pub sync: u8,
    pub atck: u8,
    pub fx1: u8,
    pub fx2: u8,
    // This is the hidden <F> parameter used in LFOs and Scenes etc.
    pub unused: u8,
}

impl Default for AudioTrackAmpParamsSetup {
    fn default() -> Self {
        Self {
            amp: 1,
            sync: 1,
            atck: 0,
            fx1: 0,
            fx2: 0,
            unused: 0,
        }
    }
}

#[cfg(test)]
mod audio_track_params_setup_amp {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackAmpParamsSetup, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_params_setup.iter() {
            assert_eq!(x.amp, AudioTrackAmpParamsSetup::default());
        }
        Ok(())
    }
}

/// Values for a Track's FX Setup page.
///
/// # Default
///
/// There is no `Default` trait implemented for this type as it is shared for both FX1 and FX2,
/// which both have different default settings.
#[derive(
    Copy,
    Clone,
    Debug,
    Default,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackFxParamsSetup {
    pub setting1: u8,
    pub setting2: u8,
    pub setting3: u8,
    pub setting4: u8,
    pub setting5: u8,
    pub setting6: u8,
}

#[cfg(test)]
mod audio_track_params_setup_fx {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackFxParamsSetup, OtToolsIoError};
    #[test]
    fn default_fx1() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_params_setup.iter() {
            assert_eq!(
                x.fx1,
                AudioTrackFxParamsSetup {
                    setting1: 0,
                    setting2: 0,
                    setting3: 1,
                    setting4: 0,
                    setting5: 3,
                    setting6: 0,
                }
            );
        }
        Ok(())
    }
    #[test]
    fn default_fx2() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_params_setup.iter() {
            assert_eq!(
                x.fx2,
                AudioTrackFxParamsSetup {
                    setting1: 0,
                    setting2: 1,
                    setting3: 127,
                    setting4: 1,
                    setting5: 0,
                    setting6: 0,
                }
            );
        }
        Ok(())
    }
}

/// Audio Tracks Parameter Setup pages for LFO, Amp, FX etc.
///
/// # Field ordering
///
/// yes, `lfo_setup_2` comes after fx data fields in the binary data...
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
    ArrayDefaults,
    BoxedArrayDefaults,
)]
pub struct AudioTrackParamsSetup {
    /// Parameter Target and Wave selection for the 3x LFOs on this Audio Track.
    pub lfo_setup_1: LfoParamsSetup1,
    /// Amplitude setup page
    pub amp: AudioTrackAmpParamsSetup,
    /// FX #1 setup page
    pub fx1: AudioTrackFxParamsSetup,
    /// FX #2 setup page
    pub fx2: AudioTrackFxParamsSetup,
    /// Multiplier and Trigger type selection for the 3x LFOs on this Audio Track.
    pub lfo_setup_2: LfoParamsSetup2,
}

impl Default for AudioTrackParamsSetup {
    fn default() -> Self {
        Self {
            lfo_setup_1: LfoParamsSetup1::default(),
            amp: AudioTrackAmpParamsSetup::default(),
            fx1: AudioTrackFxParamsSetup {
                setting1: 0,
                setting2: 0,
                setting3: 1,
                setting4: 0,
                setting5: 3,
                setting6: 0,
            },
            fx2: AudioTrackFxParamsSetup {
                setting1: 0,
                setting2: 1,
                setting3: 127,
                setting4: 1,
                setting5: 0,
                setting6: 0,
            },
            lfo_setup_2: LfoParamsSetup2::default(),
        }
    }
}

#[cfg(test)]
mod audio_track_params_setup {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackParamsSetup, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for x in b.parts_unsaved[0].audio_track_params_setup.iter() {
            assert_eq!(x, &AudioTrackParamsSetup::default());
        }
        Ok(())
    }
}

// todo: merge with the Pattern parameter-lock variant of this?
/// A scene's parameter assignments on the Playback/Machine page for an Audio Track.
#[derive(
    Copy,
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Serialize,
    Deserialize,
    AsMutDerive,
    AsRefDerive,
)]
pub struct AudioTrackSceneLockPlayback {
    pub param1: u8,
    pub param2: u8,
    pub param3: u8,
    pub param4: u8,
    pub param5: u8,
    pub param6: u8,
}

impl Default for AudioTrackSceneLockPlayback {
    fn default() -> Self {
        Self {
            param1: 255,
            param2: 255,
            param3: 255,
            param4: 255,
            param5: 255,
            param6: 255,
        }
    }
}

#[cfg(test)]
mod audio_track_scene_lock_playback {
    use crate::parts::test_helper::get_default_test_bank;
    use crate::{parts::tracks::audio::AudioTrackSceneLockPlayback, OtToolsIoError};
    #[test]
    fn default() -> Result<(), OtToolsIoError> {
        let b = get_default_test_bank()?;
        for arr in b.parts_unsaved[0].scenes.iter() {
            for x in arr.iter() {
                assert_eq!(x.machine, AudioTrackSceneLockPlayback::default());
            }
        }
        Ok(())
    }
}