ot-tools-io 0.11.2

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

use super::{
    ArrangementError, ArrangementState, ARRANGEMENT_FILE_HEADER, ARRANGEMENT_FILE_VERSION,
};
use crate::identifiers::SavedState;
use crate::{
    Defaults, HasChecksumField, HasFileVersionField, HasHeaderField, IsDefault, OctatrackFileIO,
    OtToolsIoError,
};
use ot_tools_io_derive::{
    ArrayDefaults, AsMutDerive, AsRefDerive, BoxedArrayDefaults, IntegrityChecks,
};
use serde::{Deserialize, Serialize};
use std::array::from_fn;

// max length: 11336 bytes
// note: fields are ordered according to the order they appear in the binary data
// might change that at some point but for now leaving as is.
/// Arrangement files (`arr??.*` file names)
#[derive(
    Clone,
    Debug,
    Eq,
    Hash,
    Ord,
    PartialEq,
    PartialOrd,
    Deserialize,
    Serialize,
    IntegrityChecks,
    ArrayDefaults,
    BoxedArrayDefaults,
    AsRefDerive,
    AsMutDerive,
)]
pub struct ArrangementFile {
    /// Header data
    ///
    /// # Validation
    ///
    /// Checked by the [`Self::validate`] method via the
    /// [`HasHeaderField::check_header`] trait method.
    pub header: [u8; 21],

    /// Patch version of this data type. Is inspected on project load to determine if
    /// the octatrack is able to load a project from current OS, or whether the project
    /// files need to be patched and updated.
    ///
    /// # Validation
    ///
    /// Checked by the [`Self::validate`] method via the
    /// [`HasFileVersionField::check_file_version`] trait method.
    pub datatype_version: u8,

    /// Dunno. Example data:
    /// ```text
    /// [0, 0]
    /// ```
    ///
    /// # Validation
    ///
    /// Not checked by the [`Self::validate`] method.
    pub unk1: [u8; 2],

    /// Current arrangement data in active use.
    /// This block is written when saving via Project Menu -> SYNC TO CARD.
    ///
    /// The second block is written when saving the arrangement via Arranger Menu -> SAVE.
    ///
    /// # Validation
    ///
    /// Checked by the [`Self::validate`] method.
    pub working_state: ArrangementState,

    /// Dunno.
    ///
    /// # Validation
    ///
    /// Not checked by the [`Self::validate`] method.
    pub unk2: u8,

    /// Whether the arrangement has been saved within the arrangement menu.
    ///
    /// # Validation
    ///
    /// Checked by the [`Self::validate`] method.
    pub saved_state: u8,

    /// Arrangement data from the previous saved state.
    /// This block is written when saving the arrangement via Arranger Menu -> SAVE.
    ///
    /// # Validation
    ///
    /// Checked by the [`Self::validate`] method.
    pub stored_state: ArrangementState,

    /// The current save/unsaved state of **all** loaded arrangements.
    /// 'Saved' means there's been at least one ARRANGER MENU save operation performed,
    /// and [`ArrangementState`] data has been written to the `arrangement_state_previous` field.
    ///
    /// Example data:
    /// ```text
    /// Arrangement 1 has been saved: [1, 0, 0, 0, 0, 0, 0, 0]
    /// Arrangement 2 has been saved: [0, 1, 0, 0, 0, 0, 0, 0]
    /// Arrangement 2, 7 & 8 have been saved: [0, 1, 0, 0, 0, 0, 1, 1]
    /// ```
    ///
    /// # Validation
    ///
    /// Checked by the [`Self::validate`] method.
    pub other_saved_states: [u8; 8],

    /// Checksum for the file.
    ///
    /// # Rant
    ///
    /// On the Octatrack, changing an arrangement row variant in an Arrangement
    /// **does not** clear the bytes for that row.
    /// All it does is change the byte indicating the type of row.
    ///
    /// This would be fine if the checksum calculation didn't sum these irrelevant
    /// bytes.
    /// But it does.
    ///
    /// See [`ArrangeRow`][super::ArrangeRow] for more information.
    ///
    /// # Validation
    ///
    /// Not checked by the [`Self::validate`] method.
    /// Use the [`HasChecksumField::check_checksum`] to check this field.
    pub checksum: u16,
}

impl Default for ArrangementFile {
    fn default() -> Self {
        let mut new = Self {
            header: ARRANGEMENT_FILE_HEADER,
            datatype_version: ARRANGEMENT_FILE_VERSION,
            unk1: from_fn(|_| 0),
            working_state: ArrangementState::default(),
            unk2: 0,
            saved_state: 0,
            stored_state: ArrangementState::default(),
            // TODO: by default this actually always 0, but generating test data where these things
            //       are 'inactive' is basically impossible!
            // for now, I'm setting this to default a 1-values array, but in reality it depends...
            // cba to type this out fully. gonna bite me later i know it. basically i need to check
            // if arrangement chaining affects this flag or if the arrangement has been saved.
            other_saved_states: from_fn(|_| 0),
            checksum: 0,
        };
        new.checksum = new.calculate_checksum().unwrap();
        new
    }
}

impl IsDefault for ArrangementFile {
    fn is_default(&self) -> bool {
        let default = &ArrangementFile::default();
        // check everything except the arrangement name fields (see
        // ArrangementBlock's IsDefault implementation for more details)
        self.working_state.is_default()
            && self.stored_state.is_default()
            && default.unk1 == self.unk1
            && default.unk2 == self.unk2
    }
}

#[cfg(test)]
mod is_default {
    use crate::arrangements::ArrangementFile;
    use crate::test_utils::get_arrange_dirpath;
    use crate::{IsDefault, OctatrackFileIO};

    #[test]
    fn true_not_modified_default() {
        assert!(ArrangementFile::default().is_default())
    }
    #[test]
    fn true_not_modified_file() {
        let arr =
            ArrangementFile::from_data_file(&get_arrange_dirpath().join("blank.work")).unwrap();
        assert!(arr.is_default())
    }
    #[test]
    fn false_modified_file() {
        let arr = ArrangementFile::from_data_file(&get_arrange_dirpath().join("full-options.work"))
            .unwrap();
        assert!(!arr.is_default())
    }
}

impl ArrangementFile {
    /// converts the `other_saved_states` field to an array of `bool` values.
    /// ```
    /// # use ot_tools_io::{ArrangementFile, OtToolsIoError};
    /// # fn main() -> Result<(), OtToolsIoError> {
    /// assert_eq!(
    ///     ArrangementFile::default().other_saved_states(),
    ///     [false, false, false, false, false, false, false, false]
    /// );
    /// # Ok(()) }
    /// ```
    pub fn other_saved_states(&self) -> [bool; 8] {
        from_fn(|i| self.other_saved_states[i] == 1)
    }

    /// converts the `saved_state` field to a `bool` value.
    /// ```
    /// # use ot_tools_io::{ArrangementFile, OtToolsIoError};
    /// # fn main() -> Result<(), OtToolsIoError> {
    /// assert_eq!(
    ///     ArrangementFile::default().saved_state(),
    ///     false,
    /// );
    /// # Ok(()) }
    /// ```
    pub fn saved_state(&self) -> bool {
        self.saved_state == 1
    }

    /// Owned access to the [`ArrangementState`] specified by the [`SavedState`]
    /// ```
    /// # use ot_tools_io::{ArrangementFile, OtToolsIoError};
    /// # use ot_tools_io::identifiers::SavedState;
    /// # use ot_tools_io::types::ArrangementState;
    /// # fn main() -> Result<(), OtToolsIoError> {
    /// assert_eq!(
    ///     ArrangementFile::default().arrangement_state(&SavedState::Working),
    ///     ArrangementState::default(),
    /// );
    /// # Ok(()) }
    /// ```
    pub fn arrangement_state(self, saved_state: &SavedState) -> ArrangementState {
        match saved_state {
            SavedState::Working => self.working_state,
            SavedState::Stored => self.stored_state,
        }
    }

    /// Reference access to the [`ArrangementState`] specified by the [`SavedState`]
    /// ```
    /// # use ot_tools_io::{ArrangementFile, OtToolsIoError};
    /// # use ot_tools_io::identifiers::SavedState;
    /// # use ot_tools_io::types::ArrangementState;
    /// # fn main() -> Result<(), OtToolsIoError> {
    /// assert_eq!(
    ///     ArrangementFile::default().arrangement_state_ref(&SavedState::Working),
    ///     &ArrangementState::default(),
    /// );
    /// # Ok(()) }
    /// ```
    pub fn arrangement_state_ref(&self, saved_state: &SavedState) -> &ArrangementState {
        match saved_state {
            SavedState::Working => &self.working_state,
            SavedState::Stored => &self.stored_state,
        }
    }

    /// Mutable reference access to the [`ArrangementState`] specified by the [`SavedState`]
    /// ```
    /// # use ot_tools_io::{ArrangementFile, OtToolsIoError};
    /// # use ot_tools_io::identifiers::SavedState;
    /// # use ot_tools_io::types::ArrangementState;
    /// # fn main() -> Result<(), OtToolsIoError> {
    /// assert_eq!(
    ///     ArrangementFile::default().arrangement_state_mut(&SavedState::Working),
    ///     &mut ArrangementState::default(),
    /// );
    /// # Ok(()) }
    /// ```
    pub fn arrangement_state_mut(&mut self, saved_state: &SavedState) -> &mut ArrangementState {
        match saved_state {
            SavedState::Working => &mut self.working_state,
            SavedState::Stored => &mut self.stored_state,
        }
    }

    /// Run validation on relevant fields, see the documentation on fields in
    /// [`Self`] to find out what is actually validated.
    /// ```
    /// # use ot_tools_io::{ArrangementFile, OtToolsIoError};
    /// # use ot_tools_io::types::ArrangementState;
    /// # fn main() -> Result<(), OtToolsIoError> {
    /// ArrangementFile::default().validate()?;
    ///
    /// assert!(ArrangementFile { saved_state: 5, ..Default::default() }.validate().is_err());
    /// assert!(
    ///     ArrangementFile {
    ///         working_state: ArrangementState { n_rows: 10, ..Default::default() },
    ///         ..Default::default()
    ///     }.validate().is_err()
    /// );
    /// # Ok(()) }
    /// ```
    pub fn validate(&self) -> Result<(), OtToolsIoError> {
        // WARNING: DO NOT CALL ANYTHING RELATED TO CHECKSUMS HERE!
        // YOU WILL GET RECURSION!
        self.check_header()?;
        self.check_file_version()?;

        if !self.other_saved_states.iter().all(|x| (0..=1).contains(x)) {
            return Err(ArrangementError::SavedStates(self.other_saved_states).into());
        }
        if !(0..=1).contains(&self.saved_state) {
            return Err(ArrangementError::SaveState(self.saved_state).into());
        }
        self.working_state.validate()?;
        self.stored_state.validate()?;
        Ok(())
    }

    /// We can't just use [`bincode::deserialize`] with arrangements as we need
    /// to do some custom parsing within [`ArrangementState`]
    pub(super) fn parse_from_bytes(bytes: &[u8; 11336]) -> Result<Self, OtToolsIoError> {
        let mut shift = 0;

        let header: [u8; 21] = from_fn(|i| bytes[i + shift]);
        shift += 21;

        let datatype_version: u8 = bytes[shift];
        shift += 1;

        let unk1: [u8; 2] = from_fn(|i| bytes[i + shift]);
        shift += 2;

        let curr_arr_bytes: [u8; 5650] = from_fn(|i| bytes[i + shift]);
        shift += 5650;

        let arrangement_state_current = ArrangementState::parse_from_bytes(&curr_arr_bytes)?;

        let unk2: u8 = bytes[shift];
        shift += 1;

        let saved_flag: u8 = bytes[shift];
        shift += 1;

        let prev_arr_bytes: [u8; 5650] = from_fn(|i| bytes[i + shift]);
        shift += 5650;

        let arrangement_state_previous = ArrangementState::parse_from_bytes(&prev_arr_bytes)?;

        let arrangements_saved_state: [u8; 8] = from_fn(|i| bytes[i + shift]);
        shift += 8;

        let check_sum_arr: [u8; 2] = from_fn(|i| bytes[i + shift]);
        let checksum = u16::from_be_bytes(check_sum_arr);

        let arr = Self {
            header,
            datatype_version,
            unk1,
            working_state: arrangement_state_current,
            unk2,
            saved_state: saved_flag,
            stored_state: arrangement_state_previous,
            other_saved_states: arrangements_saved_state,
            checksum,
        };
        arr.validate()?;
        Ok(arr)
    }

    /// We can't just use [`bincode::serialize`] with arrangements as we need
    /// to do some custom parsing within [`ArrangementState`]
    pub(super) fn parse_to_bytes(&self) -> Result<Vec<u8>, OtToolsIoError> {
        self.validate()?;
        let mut v = vec![];

        v.append(&mut self.header.to_vec());
        v.append(&mut vec![self.datatype_version]);
        v.append(&mut self.unk1.to_vec());
        v.append(&mut self.working_state.parse_to_bytes()?);
        v.append(&mut vec![self.unk2]);
        v.append(&mut vec![self.saved_state]);
        v.append(&mut self.stored_state.parse_to_bytes()?);
        v.append(&mut self.other_saved_states.to_vec());
        v.append(&mut self.checksum.to_be_bytes().to_vec());
        Ok(v)
    }
}

#[cfg(test)]
mod validate {
    use crate::arrangements::ArrangementError;
    use crate::{ArrangementFile, OtToolsIoError};

    #[test]
    fn err_saved_states() -> Result<(), OtToolsIoError> {
        let arr = ArrangementFile {
            other_saved_states: [2, 2, 2, 2, 2, 2, 2, 2],
            ..Default::default()
        };
        assert_eq!(
            arr.validate().err().unwrap().to_string(),
            OtToolsIoError::Arrangement(ArrangementError::SavedStates([2, 2, 2, 2, 2, 2, 2, 2]))
                .to_string()
        );
        Ok(())
    }

    #[test]
    fn err_saved_state() -> Result<(), OtToolsIoError> {
        let arr = ArrangementFile {
            saved_state: 2,
            ..Default::default()
        };
        assert_eq!(
            arr.validate().err().unwrap().to_string(),
            OtToolsIoError::Arrangement(ArrangementError::SaveState(2)).to_string()
        );
        Ok(())
    }
}

#[cfg(test)]
mod parse_from_bytes {
    use crate::arrangements::mocks::mock_arrangement_file_empty_rows;
    use crate::ArrangementFile;
    #[test]
    fn valid_empty_rows() {
        let (expected, test_bytes) = mock_arrangement_file_empty_rows();
        let r = ArrangementFile::parse_from_bytes(&test_bytes);
        assert_eq!(expected, r.unwrap());
    }
}

#[cfg(test)]
mod parse_to_bytes {
    #[test]
    #[ignore]
    fn nope() {
        unreachable!(
            "testing this would require manipulating a 11336 length array and i'm not doing that"
        );
    }
}

impl OctatrackFileIO for ArrangementFile {
    fn from_bytes(bytes: &[u8]) -> Result<Self, OtToolsIoError> {
        ArrangementFile::parse_from_bytes(
            bytes
                .as_array()
                .ok_or(ArrangementError::ByteLength(bytes.len()))?,
        )
    }

    fn to_bytes(&self) -> Result<Vec<u8>, OtToolsIoError> {
        self.parse_to_bytes()
    }
}

#[cfg(test)]
mod from_bytes {
    use crate::{
        read_bin_file, test_utils::get_arrange_dirpath, ArrangementFile, HasChecksumField,
        OctatrackFileIO, OtToolsIoError,
    };

    const HACKED_ARR_NAME: [u8; 15] = [68, 73, 70, 70, 78, 65, 77, 69, 66, 76, 65, 78, 75, 49, 0];

    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        let path = get_arrange_dirpath().join("blank.work");
        let bytes = read_bin_file(&path)?;
        let s = ArrangementFile::from_bytes(&bytes)?;

        // TODO: having to hack the default names
        let mut x = ArrangementFile::default();
        x.working_state.name = HACKED_ARR_NAME;
        x.stored_state.name = HACKED_ARR_NAME;
        // TODO: Another hack
        x.saved_state = 1;
        x.other_saved_states = [1, 1, 1, 1, 1, 1, 1, 1];
        x.checksum = x.calculate_checksum()?;

        assert_eq!(s, x);
        Ok(())
    }
}

#[cfg(test)]
mod to_bytes {
    const HACKED_ARR_NAME: [u8; 15] = [68, 73, 70, 70, 78, 65, 77, 69, 66, 76, 65, 78, 75, 49, 0];
    use crate::{
        read_bin_file, test_utils::get_arrange_dirpath, ArrangementFile, HasChecksumField,
        OctatrackFileIO, OtToolsIoError,
    };
    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        let path = get_arrange_dirpath().join("blank.work");
        let bytes = read_bin_file(&path)?;

        // TODO: having to hack the default names
        let mut x = ArrangementFile::default();
        x.working_state.name = HACKED_ARR_NAME;
        x.stored_state.name = HACKED_ARR_NAME;
        // TODO: Another hack
        x.saved_state = 1;
        x.other_saved_states = [1, 1, 1, 1, 1, 1, 1, 1];
        x.checksum = x.calculate_checksum()?;

        let b = x.to_bytes()?;
        assert_eq!(b, bytes);
        Ok(())
    }
}

impl HasChecksumField for ArrangementFile {
    fn calculate_checksum(&self) -> Result<u16, OtToolsIoError> {
        let bytes = self.to_bytes()?;
        let payload = &bytes[16..bytes.len() - 2];
        let mut checksum: u16 = 0;
        for b in payload {
            checksum = checksum.wrapping_add(*b as u16);
        }
        Ok(checksum)
    }

    fn update_checksum(&mut self) -> Result<(), OtToolsIoError> {
        self.checksum = self.calculate_checksum()?;
        Ok(())
    }

    fn check_checksum(&self) -> Result<bool, OtToolsIoError> {
        Ok(self.checksum == self.calculate_checksum()?)
    }
}

// NOTE: This only tests whether the trait methods work or not, not whether they are correct!
#[cfg(test)]
mod checksum_field {
    use crate::{ArrangementFile, HasChecksumField, OtToolsIoError};
    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        let mut x = ArrangementFile::default();
        x.checksum = x.calculate_checksum()?;
        assert!(x.check_checksum()?);
        Ok(())
    }

    #[test]
    fn invalid() -> Result<(), OtToolsIoError> {
        let x = ArrangementFile {
            checksum: u16::MAX,
            ..Default::default()
        };
        assert!(!x.check_checksum()?);
        Ok(())
    }

    mod files {
        use crate::arrangements::ArrangementFile;
        use crate::test_utils::{get_arrange_dirpath, get_blank_proj_dirpath};
        use crate::{HasChecksumField, OctatrackFileIO, OtToolsIoError};
        use std::path::Path;

        fn helper_test_chksum(fp: &Path) -> Result<(u16, u16), OtToolsIoError> {
            let valid = ArrangementFile::from_data_file(fp)?;
            let mut test = valid.clone();
            test.checksum = 0;
            let chk = test.calculate_checksum()?;
            Ok((chk, valid.checksum))
        }

        #[test]
        fn blank_project_file() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(&get_blank_proj_dirpath().join("arr01.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        // works with original sample attrs implementation
        #[test]
        fn blank() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(&get_arrange_dirpath().join("blank.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        // works with original sample attrs implementation
        #[test]
        fn blank_diffname1() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("blank-diffname1.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        // works with original sample attrs implementation
        #[test]
        fn blank_diffname2() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("blank-diffname2.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn one_rem_row_notext() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("1-rem-blank-txt.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn one_rem_row_wtext() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("1-rem-CHAIN-txt.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn two_rem_row_wtext() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("2-rem-CHAIN-txt.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn four_patterns() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(&get_arrange_dirpath().join("4-patterns.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn one_pattern() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(&get_arrange_dirpath().join("1-pattern.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn one_halt() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(&get_arrange_dirpath().join("1-halt.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn one_pattern_1_loop() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("1-patt-1-loop.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn one_pattern_1_jump_1_loop() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("1-patt-1-jump-1-loop.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn one_pattern_1_jump_1_loop_1_halt() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(
                &get_arrange_dirpath().join("1-patt-1-jump-1-loop-1-halt.work"),
            )?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn full_options() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("full-options.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        // FIXME: Did i not save/copy this properly? this only has empty rows
        #[test]
        fn full_options_no_rems() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("full-options-no-rems.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn no_saved_flag() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("no-saved-flag.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn with_saved_flag() -> Result<(), OtToolsIoError> {
            let (test, valid) =
                helper_test_chksum(&get_arrange_dirpath().join("with-saved-flag.work"))?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn blank_samename_saved() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(
                &get_arrange_dirpath().join("blank-samename-saved-chktest.work"),
            )?;
            assert_eq!(test, valid);
            Ok(())
        }

        #[test]
        fn blank_samename_unsaved() -> Result<(), OtToolsIoError> {
            let (test, valid) = helper_test_chksum(
                &get_arrange_dirpath().join("blank-samename-unsaved-chktest.work"),
            )?;
            assert_eq!(test, valid);
            Ok(())
        }
    }
}

impl HasHeaderField for ArrangementFile {
    fn check_header(&self) -> Result<bool, OtToolsIoError> {
        Ok(self.header == ARRANGEMENT_FILE_HEADER)
    }
}

#[cfg(test)]
mod header_field {
    use crate::{ArrangementFile, HasHeaderField, OtToolsIoError};
    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        assert!(ArrangementFile::default().check_header()?);
        Ok(())
    }

    #[test]
    fn invalid() -> Result<(), OtToolsIoError> {
        let mut mutated = ArrangementFile::default();
        mutated.header[0] = 0x00;
        mutated.header[1] = 200;
        mutated.header[2] = 126;
        assert!(!mutated.check_header()?);
        Ok(())
    }
}

impl HasFileVersionField for ArrangementFile {
    fn check_file_version(&self) -> Result<bool, OtToolsIoError> {
        Ok(self.datatype_version == ARRANGEMENT_FILE_VERSION)
    }
}

#[cfg(test)]
mod file_version_field {
    use crate::{ArrangementFile, HasFileVersionField, OtToolsIoError};
    #[test]
    fn valid() -> Result<(), OtToolsIoError> {
        assert!(ArrangementFile::default().check_file_version()?);
        Ok(())
    }

    #[test]
    fn invalid() -> Result<(), OtToolsIoError> {
        let x = ArrangementFile {
            datatype_version: 0,
            ..Default::default()
        };
        assert!(!x.check_file_version()?);
        Ok(())
    }
}