guitarpro/

lib.rs

pub mod analysis;
pub mod comparison;
pub mod error;
pub mod formats;
pub mod parsers;
pub mod utils;
pub mod writers;

use crate::formats::FileFormat;

/// Note duration
#[derive(Debug, Clone, PartialEq)]
pub enum NoteDuration {
    Whole,
    Half,
    Quarter,
    Eighth,
    Sixteenth,
    ThirtySecond,
    SixtyFourth,
}

impl NoteDuration {
    /// Get the duration value as a fraction of a whole note
    pub fn as_fraction(&self) -> f64 {
        match self {
            NoteDuration::Whole => 1.0,
            NoteDuration::Half => 0.5,
            NoteDuration::Quarter => 0.25,
            NoteDuration::Eighth => 0.125,
            NoteDuration::Sixteenth => 0.0625,
            NoteDuration::ThirtySecond => 0.03125,
            NoteDuration::SixtyFourth => 0.015625,
        }
    }
}

/// Bend point
#[derive(Debug, Clone, PartialEq)]
pub struct BendPoint {
    pub position: u8, // 0-100
    pub value: f32,   // Semitones
}

/// Bend effect
#[derive(Debug, Clone, PartialEq)]
pub struct BendEffect {
    pub points: Vec<BendPoint>,
}

/// Slide effect
#[derive(Debug, Clone, PartialEq)]
pub enum SlideEffect {
    ShiftSlideTo(u8),
    LegatoSlideTo(u8),
    SlideOutDownward,
    SlideOutUpward,
    SlideInFromBelow,
    SlideInFromAbove,
}

/// Note effects
#[derive(Debug, Clone, PartialEq, Default)]
pub struct NoteEffects {
    pub bend: Option<BendEffect>,
    pub slide: Option<SlideEffect>,
    pub vibrato: bool,
    pub hammer_on: bool,
    pub pull_off: bool,
    pub palm_mute: bool,
    pub let_ring: bool,
}

// impl Default for NoteEffects {
//     fn default() -> Self {
//         Self {
//             bend: None,
//             slide: None,
//             vibrato: false,
//             hammer_on: false,
//             pull_off: false,
//             palm_mute: false,
//             let_ring: false,
//         }
//     }
// }

/// Note representation
#[derive(Debug, Clone, PartialEq)]
pub struct Note {
    pub fret: u8,
    pub string: u8,
    pub velocity: u8,
    pub duration: NoteDuration,
    pub effects: NoteEffects,
}

impl Note {
    /// Create a new note
    pub fn new(fret: u8, string: u8) -> Self {
        Self {
            fret,
            string,
            velocity: 100,
            duration: NoteDuration::Quarter,
            effects: NoteEffects::default(),
        }
    }

    /// Create a new note with effects
    pub fn new_with_effects(fret: u8, string: u8, effects: NoteEffects) -> Self {
        Self {
            fret,
            string,
            velocity: 100,
            duration: NoteDuration::Quarter,
            effects,
        }
    }

    /// Get the actual MIDI note value given a tuning
    pub fn to_midi_note(&self, tuning: &[u8]) -> Option<u8> {
        if (self.string as usize) < tuning.len() {
            Some(tuning[self.string as usize] + self.fret)
        } else {
            None
        }
    }
}

/// Chord types
#[derive(Debug, Clone, PartialEq)]
pub enum ChordType {
    Major,
    Minor,
    Dominant7,
    Major7,
    Minor7,
    Diminished,
    Augmented,
    Sus2,
    Sus4,
    Power,
    Custom(String),
}

/// Chord information
#[derive(Debug, Clone, PartialEq)]
pub struct ChordInfo {
    pub name: String,
    pub root_note: u8, // 0-11 (C-B)
    pub chord_type: ChordType,
    pub bass_note: Option<u8>,
    pub frets: Vec<i8>, // -1 for muted, 0+ for fret
}

impl ChordInfo {
    /// Create a new chord
    pub fn new(name: String, root_note: u8, chord_type: ChordType) -> Self {
        Self {
            name,
            root_note,
            chord_type,
            bass_note: None,
            frets: Vec::new(),
        }
    }
}

/// Beat representation
#[derive(Debug, Clone, PartialEq)]
pub struct Beat {
    pub notes: Vec<Note>,
    pub duration: NoteDuration,
    pub is_rest: bool,
    pub chord: Option<ChordInfo>,
}

impl Beat {
    /// Create a new rest beat
    pub fn new_rest(duration: NoteDuration) -> Self {
        Self {
            notes: Vec::new(),
            duration,
            is_rest: true,
            chord: None,
        }
    }

    /// Create a new beat with notes
    pub fn new_with_notes(notes: Vec<Note>, duration: NoteDuration) -> Self {
        Self {
            notes,
            duration,
            is_rest: false,
            chord: None,
        }
    }

    /// Add a note to the beat
    pub fn add_note(&mut self, note: Note) {
        self.notes.push(note);
        self.is_rest = false;
    }
}

/// Time signature
#[derive(Debug, Clone, PartialEq)]
pub struct TimeSignature {
    pub numerator: u8,
    pub denominator: u8,
}

impl Default for TimeSignature {
    fn default() -> Self {
        Self {
            numerator: 4,
            denominator: 4,
        }
    }
}

impl TimeSignature {
    /// Create a new time signature
    pub fn new(numerator: u8, denominator: u8) -> Self {
        Self {
            numerator,
            denominator,
        }
    }

    /// Get the number of beats per measure
    pub fn beats_per_measure(&self) -> f64 {
        self.numerator as f64 * (4.0 / self.denominator as f64)
    }
}

/// Key signature
#[derive(Debug, Default, Clone, PartialEq)]
pub struct KeySignature {
    pub key: i8, // -7 to 7 (flats to sharps)
    pub is_minor: bool,
}

// impl Default for KeySignature {
//     fn default() -> Self {
//         Self {
//             key: 0, // C major
//             is_minor: false,
//         }
//     }
// }

impl KeySignature {
    /// Create a new key signature
    pub fn new(key: i8, is_minor: bool) -> Self {
        Self { key, is_minor }
    }

    /// Get the key name
    pub fn key_name(&self) -> String {
        let key_names = ["C", "G", "D", "A", "E", "B", "F#", "C#"];
        let flat_names = ["C", "F", "Bb", "Eb", "Ab", "Db", "Gb", "Cb"];

        let name = if self.key >= 0 {
            key_names[self.key as usize]
        } else {
            flat_names[(-self.key) as usize]
        };

        if self.is_minor {
            format!("{}m", name)
        } else {
            name.to_string()
        }
    }
}

/// Measure
#[derive(Debug, Default, Clone)]
pub struct Measure {
    pub beats: Vec<Beat>,
    pub time_signature: Option<TimeSignature>,
    pub key_signature: Option<KeySignature>,
    pub tempo: Option<u16>,
}

impl Measure {
    /// Create a new empty measure
    pub fn new() -> Self {
        Self {
            beats: Vec::new(),
            time_signature: None,
            key_signature: None,
            tempo: None,
        }
    }

    /// Add a beat to the measure
    pub fn add_beat(&mut self, beat: Beat) {
        self.beats.push(beat);
    }

    /// Get the total duration of the measure
    pub fn total_duration(&self) -> f64 {
        self.beats
            .iter()
            .map(|beat| beat.duration.as_fraction())
            .sum()
    }
}

/// Track
#[derive(Debug, Clone)]
pub struct Track {
    pub name: String,
    pub channel: u8,
    pub measures: Vec<Measure>,
    pub tuning: Vec<u8>, // MIDI note numbers
    pub is_percussion: bool,
    pub is_twelve_string: bool,
    pub capo: u8,
    pub color: Option<(u8, u8, u8)>,
}

impl Track {
    /// Create a new track with standard guitar tuning
    pub fn new_guitar_track(name: String) -> Self {
        Self {
            name,
            channel: 0,
            measures: Vec::new(),
            tuning: vec![40, 45, 50, 55, 59, 64], // Standard guitar tuning (E-A-D-G-B-E)
            is_percussion: false,
            is_twelve_string: false,
            capo: 0,
            color: None,
        }
    }

    /// Create a new bass track with standard bass tuning
    pub fn new_bass_track(name: String) -> Self {
        Self {
            name,
            channel: 1,
            measures: Vec::new(),
            tuning: vec![28, 33, 38, 43], // Standard bass tuning (E-A-D-G)
            is_percussion: false,
            is_twelve_string: false,
            capo: 0,
            color: None,
        }
    }

    /// Create a new percussion track
    pub fn new_percussion_track(name: String) -> Self {
        Self {
            name,
            channel: 9, // Standard MIDI percussion channel
            measures: Vec::new(),
            tuning: Vec::new(),
            is_percussion: true,
            is_twelve_string: false,
            capo: 0,
            color: None,
        }
    }

    /// Add a measure to the track
    pub fn add_measure(&mut self, measure: Measure) {
        self.measures.push(measure);
    }

    /// Get the number of strings for this track
    pub fn string_count(&self) -> usize {
        self.tuning.len()
    }

    /// Get the effective tuning (accounting for capo)
    pub fn effective_tuning(&self) -> Vec<u8> {
        self.tuning.iter().map(|&note| note + self.capo).collect()
    }
}

/// Score metadata
#[derive(Debug, Default, Clone)]
pub struct ScoreMetadata {
    pub title: String,
    pub subtitle: String,
    pub artist: String,
    pub album: String,
    pub author: String,
    pub copyright: String,
    pub tab_author: String,
    pub instructions: String,
    pub notices: Vec<String>,
}

// impl Default for ScoreMetadata {
//     fn default() -> Self {
//         Self {
//             title: String::new(),
//             subtitle: String::new(),
//             artist: String::new(),
//             album: String::new(),
//             author: String::new(),
//             copyright: String::new(),
//             tab_author: String::new(),
//             instructions: String::new(),
//             notices: Vec::new(),
//         }
//     }
// }

/// Main score structure
#[derive(Debug, Clone)]
pub struct Score {
    pub metadata: ScoreMetadata,
    pub tracks: Vec<Track>,
    pub master_volume: u8,
    pub tempo: u16,
    pub format: FileFormat,
}

impl Default for Score {
    fn default() -> Self {
        Self {
            metadata: Default::default(),
            tracks: Default::default(),
            master_volume: Default::default(),
            tempo: Default::default(),
            format: FileFormat::GuitarPro5,
        }
    }
}

impl Score {
    /// Create a new empty score
    pub fn new() -> Self {
        Self {
            metadata: ScoreMetadata::default(),
            tracks: Vec::new(),
            master_volume: 200,
            tempo: 120,
            format: FileFormat::GuitarPro5,
        }
    }

    /// Add a track to the score
    pub fn add_track(&mut self, track: Track) {
        self.tracks.push(track);
    }

    /// Get track by index
    pub fn get_track(&self, index: usize) -> Option<&Track> {
        self.tracks.get(index)
    }

    /// Get mutable track by index
    pub fn get_track_mut(&mut self, index: usize) -> Option<&mut Track> {
        self.tracks.get_mut(index)
    }

    /// Get total duration in beats (based on longest track)
    pub fn get_total_beats(&self) -> u32 {
        self.tracks
            .iter()
            .map(|track| {
                track
                    .measures
                    .iter()
                    .map(|measure| measure.total_duration() as u32)
                    .sum::<u32>()
            })
            .max()
            .unwrap_or(0)
    }

    /// Get the number of measures (based on longest track)
    pub fn measure_count(&self) -> usize {
        self.tracks
            .iter()
            .map(|track| track.measures.len())
            .max()
            .unwrap_or(0)
    }
}

// /// Time signature representation
// #[derive(Debug, Clone, PartialEq)]
// pub struct TimeSignature {
//     pub numerator: u8,
//     pub denominator: u8,
// }

// /// Key signature representation
// #[derive(Debug, Clone, PartialEq)]
// pub struct KeySignature {
//     pub key: i8,     // -7 to 7 (flats to sharps)
//     pub minor: bool, // true for minor keys
// }

// /// Note representation
// #[derive(Debug, Clone, PartialEq)]
// pub struct Note {
//     pub fret: u8,
//     pub string: u8,
//     pub velocity: u8,
//     pub duration: NoteDuration,
//     pub effects: NoteEffects,
// }

// /// Note duration enumeration
// #[derive(Debug, Clone, PartialEq)]
// pub enum NoteDuration {
//     Whole,
//     Half,
//     Quarter,
//     Eighth,
//     Sixteenth,
//     ThirtySecond,
//     SixtyFourth,
// }

// /// Note effects (bends, slides, etc.)
// /// Note effects
// #[derive(Debug, Clone, PartialEq)]
// pub struct NoteEffects {
//     pub bend: Option<BendEffect>,
//     pub slide: Option<SlideEffect>,
//     pub vibrato: bool,
//     pub hammer_on: bool,
//     pub pull_off: bool,
//     pub palm_mute: bool,
//     pub let_ring: bool,
// }

// /// Bend effect
// #[derive(Debug, Clone, PartialEq)]
// pub struct BendEffect {
//     pub points: Vec<BendPoint>,
// }

// /// Bend point
// #[derive(Debug, Clone, PartialEq)]
// pub struct BendPoint {
//     pub position: u8,  // 0-100
//     pub value: f32,    // Semitones
// }

// #[derive(Debug, Clone, PartialEq)]
// pub enum SlideEffect {
//     ShiftSlideTo(u8),
//     LegatoSlideTo(u8),
//     SlideOutDownward,
//     SlideOutUpward,
//     SlideInFromBelow,
//     SlideInFromAbove,
// }

// /// Beat in a measure
// #[derive(Debug, Clone, PartialEq)]
// pub struct Beat {
//     pub notes: Vec<Note>,
//     pub duration: NoteDuration,
//     pub is_rest: bool,
//     pub chord: Option<ChordInfo>,
// }

// /// Chord information
// #[derive(Debug, Clone, PartialEq)]
// pub struct ChordInfo {
//     pub name: String,
//     pub root_note: u8,  // 0-11 (C-B)
//     pub chord_type: ChordType,
//     pub bass_note: Option<u8>,
//     pub frets: Vec<i8>,  // -1 for muted, 0+ for fret
// }

// #[repr(u8)]
// #[derive(Debug, Clone, PartialEq)]
// pub enum ChordType {
//     Major,
//     Minor,
//     Dominant7,
//     Major7,
//     Minor7,
//     Diminished,
//     Augmented,
//     Sus2,
//     Sus4,
//     Power,
//     Custom(String),
// }

// /// Measure
// #[derive(Debug, Clone)]
// pub struct Measure {
//     pub beats: Vec<Beat>,
//     pub time_signature: Option<TimeSignature>,
//     pub key_signature: Option<KeySignature>,
//     pub tempo: Option<u16>,
// }

// /// Track/instrument information
// #[derive(Debug, Clone)]
// pub struct Track {
//     pub name: String,
//     pub channel: u8,
//     pub measures: Vec<Measure>,
//     pub tuning: Vec<u8>,  // MIDI note numbers
//     pub is_percussion: bool,
//     pub is_twelve_string: bool,
//     pub capo: u8,
//     pub color: Option<(u8, u8, u8)>,
// }

// /// Complete score representation
// /// Score metadata
// #[derive(Debug, Clone)]
// pub struct ScoreMetadata {
//     pub title: String,
//     pub subtitle: String,
//     pub artist: String,
//     pub album: String,
//     pub author: String,
//     pub copyright: String,
//     pub tab_author: String,
//     pub instructions: String,
//     pub notices: Vec<String>,
// }

// /// Main score structure
// #[derive(Debug, Clone)]
// pub struct Score {
//     pub metadata: ScoreMetadata,
//     pub tracks: Vec<Track>,
//     pub master_volume: u8,
//     pub tempo: u16,
//     pub format: FileFormat,
// }

// /// Comparison result for scores
// #[derive(Debug, Clone, PartialEq)]
// pub enum ScoreComparisonResult {
//     /// Scores are identical in musical content and metadata
//     Identical,
//     /// Scores have same musical content but different metadata
//     SameContent {
//         metadata_differences: Vec<MetadataDifference>,
//     },
//     /// Scores have same structure but different notes/timing
//     SameStructure {
//         musical_differences: Vec<MusicalDifference>,
//     },
//     /// Scores are completely different
//     Different {
//         major_differences: Vec<MajorDifference>,
//     },
// }

// /// Metadata differences between scores
// #[derive(Debug, Clone, PartialEq)]
// pub enum MetadataDifference {
//     Title(String, String),
//     Artist(String, String),
//     Album(String, String),
//     Tempo(u16, u16),
//     MasterVolume(u8, u8),
//     TrackName {
//         track_index: usize,
//         old: String,
//         new: String,
//     },
// }

// /// Musical differences between scores
// #[derive(Debug, Clone, PartialEq)]
// pub enum MusicalDifference {
//     NoteChange {
//         track_index: usize,
//         measure_index: usize,
//         beat_index: usize,
//         note_index: usize,
//         old_note: Note,
//         new_note: Note,
//     },
//     BeatChange {
//         track_index: usize,
//         measure_index: usize,
//         beat_index: usize,
//         old_beat: Beat,
//         new_beat: Beat,
//     },
//     TimeSignatureChange {
//         track_index: usize,
//         measure_index: usize,
//         old: Option<TimeSignature>,
//         new: Option<TimeSignature>,
//     },
//     KeySignatureChange {
//         track_index: usize,
//         measure_index: usize,
//         old: Option<KeySignature>,
//         new: Option<KeySignature>,
//     },
// }

// /// Major structural differences
// #[derive(Debug, Clone, PartialEq)]
// pub enum MajorDifference {
//     TrackCountDifference(usize, usize),
//     MeasureCountDifference {
//         track_index: usize,
//         old_count: usize,
//         new_count: usize,
//     },
//     StringTuningDifference {
//         track_index: usize,
//         old_tuning: Vec<u8>,
//         new_tuning: Vec<u8>,
//     },
//     TrackTypeDifference {
//         track_index: usize,
//         old_is_percussion: bool,
//         new_is_percussion: bool,
//     },
// }

// #[cfg(test)]
// mod tests {
//     use super::*;

//     #[test]
//     fn test_empty_score_creation() {
//         let score = Score {
//             title: "Test Song".to_string(),
//             artist: "Test Artist".to_string(),
//             album: "Test Album".to_string(),
//             tempo: 120,
//             tracks: vec![],
//             master_volume: 127,
//         };

//         assert_eq!(score.title, "Test Song");
//         assert_eq!(score.tempo, 120);
//     }

//     #[test]
//     fn test_score_comparison_identical() {
//         let score1 = create_test_score();
//         let score2 = score1.clone();

//         let result = score1.compare(&score2);
//         assert_eq!(result, ScoreComparisonResult::Identical);
//         assert!(score1.has_same_musical_content(&score2));
//         assert!(score1.is_musically_equivalent(&score2));
//     }

//     #[test]
//     fn test_score_comparison_metadata_only() {
//         let mut score1 = create_test_score();
//         let mut score2 = score1.clone();
//         score2.title = "Different Title".to_string();

//         let result = score1.compare(&score2);
//         match result {
//             ScoreComparisonResult::SameContent {
//                 metadata_differences,
//             } => {
//                 assert_eq!(metadata_differences.len(), 1);
//             }
//             _ => panic!("Expected SameContent result"),
//         }

//         assert!(score1.has_same_musical_content(&score2));
//         assert!(score1.is_musically_equivalent(&score2));
//     }

//     #[test]
//     fn test_score_comparison_different_tracks() {
//         let mut score1 = create_test_score();
//         let mut score2 = score1.clone();
//         score2.tracks.pop(); // Remove a track

//         let result = score1.compare(&score2);
//         match result {
//             ScoreComparisonResult::Different { major_differences } => {
//                 assert!(!major_differences.is_empty());
//             }
//             _ => panic!("Expected Different result"),
//         }

//         assert!(!score1.has_same_musical_content(&score2));
//         assert!(!score1.is_musically_equivalent(&score2));
//     }

//     #[test]
//     fn test_difference_summary() {
//         let score1 = create_test_score();
//         let mut score2 = score1.clone();
//         score2.artist = "Different Artist".to_string();

//         let summary = score1.difference_summary(&score2);
//         assert!(summary.contains("metadata differences"));
//     }

//     fn create_test_score() -> Score {
//         Score {
//             title: "Test Song".to_string(),
//             artist: "Test Artist".to_string(),
//             album: "Test Album".to_string(),
//             tempo: 120,
//             tracks: vec![Track {
//                 name: "Guitar".to_string(),
//                 channel: 1,
//                 strings: vec![64, 59, 55, 50, 45, 40],
//                 measures: vec![Measure {
//                     beats: vec![Beat {
//                         notes: vec![Note {
//                             fret: 3,
//                             string: 1,
//                             duration: NoteDuration::Quarter,
//                             effects: NoteEffects::default(),
//                         }],
//                         duration: NoteDuration::Quarter,
//                         rest: false,
//                     }],
//                     time_signature: Some(TimeSignature {
//                         numerator: 4,
//                         denominator: 4,
//                     }),
//                     key_signature: None,
//                 }],
//                 is_percussion: false,
//             }],
//             master_volume: 127,
//         }
//     }
// }

// // Example usage:
// /*
// use std::fs;

// fn main() -> Result<(), Box<dyn std::error::Error>> {
//     // Read files as bytes (async or sync, user's choice)
//     let gp3_data = fs::read("song.gp3")?;
//     let gp4_data = fs::read("song.gp4")?;

//     // Parse both files
//     let gp3_score = MusicParser::parse(gp3_data)?;
//     let gp4_score = MusicParser::parse(gp4_data)?;

//     // Compare the scores
//     let comparison = gp3_score.compare(&gp4_score);

//     match comparison {
//         ScoreComparisonResult::Identical => {
//             println!("Files contain identical musical data!");
//         },
//         ScoreComparisonResult::SameContent { metadata_differences } => {
//             println!("Same music, different metadata:");
//             for diff in metadata_differences {
//                 match diff {
//                     MetadataDifference::Title(old, new) => {
//                         println!("  Title: '{}' -> '{}'", old, new);
//                     },
//                     MetadataDifference::Artist(old, new) => {
//                         println!("  Artist: '{}' -> '{}'", old, new);
//                     },
//                     // Handle other metadata differences...
//                     _ => println!("  Other metadata difference: {:?}", diff),
//                 }
//             }
//         },
//         ScoreComparisonResult::SameStructure { musical_differences } => {
//             println!("Same structure, {} musical differences", musical_differences.len());
//         },
//         ScoreComparisonResult::Different { major_differences } => {
//             println!("Completely different scores: {} major differences", major_differences.len());
//         }
//     }

//     // Quick checks
//     if gp3_score.has_same_musical_content(&gp4_score) {
//         println!("Both files represent the same song!");
//     }

//     if gp3_score.is_musically_equivalent(&gp4_score) {
//         println!("Musically equivalent (ignoring metadata)");
//     }

//     // Get summary
//     println!("Summary: {}", gp3_score.difference_summary(&gp4_score));

//     Ok(())
// }
// */
#[cfg(test)]
mod tests {
    use crate::*;

    #[test]
    fn test_note_duration_conversion() {
        assert_eq!(NoteDuration::Whole.as_fraction(), 1.0);
        assert_eq!(NoteDuration::Half.as_fraction(), 0.5);
        assert_eq!(NoteDuration::Quarter.as_fraction(), 0.25);
        assert_eq!(NoteDuration::Eighth.as_fraction(), 0.125);
    }

    #[test]
    fn test_time_signature_beats() {
        let ts_4_4 = TimeSignature::new(4, 4);
        assert_eq!(ts_4_4.beats_per_measure(), 4.0);

        let ts_3_4 = TimeSignature::new(3, 4);
        assert_eq!(ts_3_4.beats_per_measure(), 3.0);

        let ts_6_8 = TimeSignature::new(6, 8);
        assert_eq!(ts_6_8.beats_per_measure(), 3.0); // 6/8 = 6 * (4/8) = 3.0
    }

    #[test]
    fn test_key_signature_names() {
        let c_major = KeySignature::new(0, false);
        assert_eq!(c_major.key_name(), "C");
        
        let a_minor = KeySignature::new(0, true);
        assert_eq!(a_minor.key_name(), "Cm");
        
        let g_major = KeySignature::new(1, false);
        assert_eq!(g_major.key_name(), "G");
    }
}