guitarpro/writers/

gp.rs

// gp_writer.rs - Guitar Pro modern format (.gp) writer

use super::{FileWriter, Result};
use crate::*;
use byteorder::{LittleEndian, WriteBytesExt};
use std::io::{Cursor, Write};

/// Guitar Pro modern format writer
pub struct GpWriter;

impl FileWriter for GpWriter {
    fn write_score(score: &Score) -> Result<Vec<u8>> {
        let mut buffer = Vec::new();
        let mut cursor = Cursor::new(&mut buffer);

        // Write magic header
        cursor.write_all(b"BCFZ")?;

        // Write file chunks
        write_file_chunks(&mut cursor, score)?;

        Ok(buffer)
    }
}

/// Write all file chunks
fn write_file_chunks(cursor: &mut Cursor<&mut Vec<u8>>, score: &Score) -> Result<()> {
    // Write score information chunk
    write_chunk(cursor, 0x01, |chunk_cursor| {
        write_score_info(chunk_cursor, score)
    })?;

    // Write tracks information chunk
    write_chunk(cursor, 0x02, |chunk_cursor| {
        write_tracks_info(chunk_cursor, score)
    })?;

    // Write measures data chunk
    write_chunk(cursor, 0x03, |chunk_cursor| {
        write_measures_data(chunk_cursor, score)
    })?;

    // Write automation data chunk (minimal)
    write_chunk(cursor, 0x04, |chunk_cursor| {
        write_automation_data(chunk_cursor, score)
    })?;

    Ok(())
}

/// Write a chunk with header
fn write_chunk<F>(cursor: &mut Cursor<&mut Vec<u8>>, chunk_type: u32, write_fn: F) -> Result<()>
where
    F: FnOnce(&mut Cursor<&mut Vec<u8>>) -> Result<()>,
{
    // Create temporary buffer for chunk data
    let mut chunk_data = Vec::new();
    let mut chunk_cursor = Cursor::new(&mut chunk_data);

    // Write chunk content
    write_fn(&mut chunk_cursor)?;

    // Write chunk header
    cursor.write_u32::<LittleEndian>(chunk_type)?;
    cursor.write_u32::<LittleEndian>(chunk_data.len() as u32)?;

    // Write chunk data
    cursor.write_all(&chunk_data)?;

    Ok(())
}

/// Write score information
fn write_score_info(cursor: &mut Cursor<&mut Vec<u8>>, score: &Score) -> Result<()> {
    // Write metadata strings
    write_gp_string(cursor, &score.metadata.title)?;
    write_gp_string(cursor, &score.metadata.subtitle)?;
    write_gp_string(cursor, &score.metadata.artist)?;
    write_gp_string(cursor, &score.metadata.album)?;
    write_gp_string(cursor, &score.metadata.author)?;
    write_gp_string(cursor, &score.metadata.copyright)?;
    write_gp_string(cursor, &score.metadata.tab_author)?;
    write_gp_string(cursor, &score.metadata.instructions)?;

    // Write tempo and master volume
    cursor.write_u32::<LittleEndian>(score.tempo as u32)?;
    cursor.write_u8(score.master_volume)?;

    Ok(())
}

/// Write tracks information
fn write_tracks_info(cursor: &mut Cursor<&mut Vec<u8>>, score: &Score) -> Result<()> {
    cursor.write_u8(score.tracks.len() as u8)?;

    for track in &score.tracks {
        write_track_info(cursor, track)?;
    }

    Ok(())
}

/// Write individual track information
fn write_track_info(cursor: &mut Cursor<&mut Vec<u8>>, track: &Track) -> Result<()> {
    // Write track flags
    let mut flags = 0u8;
    if track.is_percussion {
        flags |= 0x01;
    }
    if track.is_twelve_string {
        flags |= 0x02;
    }
    cursor.write_u8(flags)?;

    // Write track name
    write_gp_string(cursor, &track.name)?;

    // Write tuning
    cursor.write_u8(track.tuning.len() as u8)?;
    for &note in &track.tuning {
        cursor.write_u8(note)?;
    }

    // Write channel and capo
    cursor.write_u8(track.channel)?;
    cursor.write_u8(track.capo)?;

    // Write color
    if let Some((r, g, b)) = track.color {
        cursor.write_u8(r)?;
        cursor.write_u8(g)?;
        cursor.write_u8(b)?;
    } else {
        cursor.write_u8(255)?; // Default red
        cursor.write_u8(0)?; // Default green
        cursor.write_u8(0)?; // Default blue
    }

    Ok(())
}

/// Write measures data
fn write_measures_data(cursor: &mut Cursor<&mut Vec<u8>>, score: &Score) -> Result<()> {
    let measure_count = score.measure_count();
    cursor.write_u16::<LittleEndian>(measure_count as u16)?;

    for measure_idx in 0..measure_count {
        write_measure_data(cursor, score, measure_idx)?;
    }

    Ok(())
}

/// Write individual measure data
fn write_measure_data(
    cursor: &mut Cursor<&mut Vec<u8>>,
    score: &Score,
    measure_idx: usize,
) -> Result<()> {
    for track in &score.tracks {
        if let Some(measure) = track.measures.get(measure_idx) {
            // Write beat count
            cursor.write_u8(measure.beats.len() as u8)?;

            // Write measure flags
            let mut flags = 0u8;
            if measure.time_signature.is_some() {
                flags |= 0x01;
            }
            if measure.key_signature.is_some() {
                flags |= 0x02;
            }
            if measure.tempo.is_some() {
                flags |= 0x04;
            }
            cursor.write_u8(flags)?;

            // Write time signature if present
            if let Some(ref time_sig) = measure.time_signature {
                cursor.write_u8(time_sig.numerator)?;
                cursor.write_u8(time_sig.denominator)?;
            }

            // Write key signature if present
            if let Some(ref key_sig) = measure.key_signature {
                cursor.write_i8(key_sig.key)?;
                cursor.write_u8(if key_sig.is_minor { 1 } else { 0 })?;
            }

            // Write tempo if present
            if let Some(tempo) = measure.tempo {
                cursor.write_u16::<LittleEndian>(tempo)?;
            }

            // Write beats
            for beat in &measure.beats {
                write_beat_data(cursor, beat)?;
            }
        } else {
            // Write empty measure
            cursor.write_u8(0)?; // No beats
            cursor.write_u8(0)?; // No flags
        }
    }

    Ok(())
}

/// Write beat data
fn write_beat_data(cursor: &mut Cursor<&mut Vec<u8>>, beat: &Beat) -> Result<()> {
    let mut beat_flags = 0u8;

    if beat.is_rest {
        beat_flags |= 0x40;
    }
    if beat.chord.is_some() {
        beat_flags |= 0x02;
    }

    cursor.write_u8(beat_flags)?;

    // Write duration
    let duration_byte = match beat.duration {
        NoteDuration::Whole => 0,
        NoteDuration::Half => 1,
        NoteDuration::Quarter => 2,
        NoteDuration::Eighth => 3,
        NoteDuration::Sixteenth => 4,
        NoteDuration::ThirtySecond => 5,
        NoteDuration::SixtyFourth => 6,
    };
    cursor.write_u8(duration_byte)?;

    // Write chord information if present
    if let Some(ref chord) = beat.chord {
        write_chord_info(cursor, chord)?;
    }

    // Write notes
    cursor.write_u8(beat.notes.len() as u8)?;
    for note in &beat.notes {
        write_note_data(cursor, note)?;
    }

    Ok(())
}

/// Write chord information
fn write_chord_info(cursor: &mut Cursor<&mut Vec<u8>>, chord: &ChordInfo) -> Result<()> {
    write_gp_string(cursor, &chord.name)?;

    // Write fret positions
    cursor.write_u8(chord.frets.len() as u8)?;
    for &fret in &chord.frets {
        cursor.write_i8(fret)?;
    }

    Ok(())
}

/// Write note data
fn write_note_data(cursor: &mut Cursor<&mut Vec<u8>>, note: &Note) -> Result<()> {
    let mut note_flags = 0u8;

    // Check if note has effects
    if has_note_effects(&note.effects) {
        note_flags |= 0x01;
    }

    cursor.write_u8(note_flags)?;
    cursor.write_u8(note.string)?;
    cursor.write_u8(note.fret)?;
    cursor.write_u8(note.velocity)?;

    // Write effects if present
    if has_note_effects(&note.effects) {
        write_note_effects(cursor, &note.effects)?;
    }

    Ok(())
}

/// Check if note has any effects
fn has_note_effects(effects: &NoteEffects) -> bool {
    effects.vibrato
        || effects.hammer_on
        || effects.pull_off
        || effects.palm_mute
        || effects.let_ring
        || effects.bend.is_some()
        || effects.slide.is_some()
}

/// Write note effects
fn write_note_effects(cursor: &mut Cursor<&mut Vec<u8>>, effects: &NoteEffects) -> Result<()> {
    let mut effect_flags = 0u8;

    if effects.vibrato {
        effect_flags |= 0x01;
    }
    if effects.hammer_on {
        effect_flags |= 0x02;
    }
    if effects.pull_off {
        effect_flags |= 0x04;
    }
    if effects.palm_mute {
        effect_flags |= 0x08;
    }
    if effects.let_ring {
        effect_flags |= 0x10;
    }
    if effects.bend.is_some() {
        effect_flags |= 0x20;
    }
    if effects.slide.is_some() {
        effect_flags |= 0x40;
    }

    cursor.write_u8(effect_flags)?;

    // Write bend effect if present
    if let Some(ref bend) = effects.bend {
        write_bend_effect(cursor, bend)?;
    }

    // Write slide effect if present
    if let Some(ref slide) = effects.slide {
        write_slide_effect(cursor, slide)?;
    }

    Ok(())
}

/// Write bend effect
fn write_bend_effect(cursor: &mut Cursor<&mut Vec<u8>>, bend: &BendEffect) -> Result<()> {
    cursor.write_u8(bend.points.len() as u8)?;

    for point in &bend.points {
        cursor.write_u8(point.position)?;
        cursor.write_f32::<LittleEndian>(point.value)?;
    }

    Ok(())
}

/// Write slide effect
fn write_slide_effect(cursor: &mut Cursor<&mut Vec<u8>>, slide: &SlideEffect) -> Result<()> {
    let (slide_type, target_fret) = match slide {
        SlideEffect::ShiftSlideTo(fret) => (0, *fret),
        SlideEffect::LegatoSlideTo(fret) => (1, *fret),
        SlideEffect::SlideOutDownward => (2, 0),
        SlideEffect::SlideOutUpward => (3, 0),
        SlideEffect::SlideInFromBelow => (4, 0),
        SlideEffect::SlideInFromAbove => (5, 0),
    };

    cursor.write_u8(slide_type)?;
    cursor.write_u8(target_fret)?;

    Ok(())
}

/// Write automation data (minimal implementation)
fn write_automation_data(cursor: &mut Cursor<&mut Vec<u8>>, _score: &Score) -> Result<()> {
    // Write minimal automation data
    cursor.write_u8(0)?; // No automation points
    Ok(())
}

/// Write a Guitar Pro string (length-prefixed)
fn write_gp_string(cursor: &mut Cursor<&mut Vec<u8>>, s: &str) -> Result<()> {
    let bytes = s.as_bytes();
    let length = bytes.len().min(255) as u8;

    cursor.write_u8(length)?;
    cursor.write_all(&bytes[..length as usize])?;

    Ok(())
}

/// Helper function to create a basic score for testing
impl Score {
    /// Create a simple test score
    pub fn create_test_score() -> Self {
        let mut score = Score::new();
        score.format = FileFormat::GuitarPro;

        // Set metadata
        score.metadata.title = "Test Song".to_string();
        score.metadata.artist = "Test Artist".to_string();
        score.tempo = 120;
        score.master_volume = 200;

        // Create a basic guitar track
        let mut track = Track::new_guitar_track("Guitar".to_string());
        track.channel = 0;

        // Create a simple measure with a few notes
        let mut measure = Measure::new();
        measure.time_signature = Some(TimeSignature::new(4, 4));

        // Add some beats with notes
        let note1 = Note::new(0, 0); // Open E string
        let beat1 = Beat::new_with_notes(vec![note1], NoteDuration::Quarter);
        measure.add_beat(beat1);

        let note2 = Note::new(2, 0); // 2nd fret E string
        let beat2 = Beat::new_with_notes(vec![note2], NoteDuration::Quarter);
        measure.add_beat(beat2);

        let note3 = Note::new(3, 0); // 3rd fret E string
        let beat3 = Beat::new_with_notes(vec![note3], NoteDuration::Quarter);
        measure.add_beat(beat3);

        // Add a rest
        let rest_beat = Beat::new_rest(NoteDuration::Quarter);
        measure.add_beat(rest_beat);

        track.add_measure(measure);
        score.add_track(track);

        score
    }
}

#[cfg(test)]
mod tests {
    use crate::writers::FileWriter;

    use super::*;

    #[test]
    fn test_write_simple_score() -> Result<()> {
        let score = Score::create_test_score();
        let data = GpWriter::write_score(&score)?;

        // Check that we have some data
        assert!(!data.is_empty());

        // Check magic header
        assert_eq!(&data[0..4], b"BCFZ");

        Ok(())
    }

    #[test]
    fn test_round_trip() -> Result<()> {
        let original_score = Score::create_test_score();

        // Write to bytes
        let data = GpWriter::write_score(&original_score)?;

        // Read back (would need the reader implementation)
        // let restored_score = GuitarProReader::read_score(&data)?;

        // Basic checks on written data
        assert!(!data.is_empty());
        assert_eq!(&data[0..4], b"BCFZ");

        Ok(())
    }

    #[test]
    fn test_write_empty_score() -> Result<()> {
        let score = Score::new();
        let data = GpWriter::write_score(&score)?;

        assert!(!data.is_empty());
        assert_eq!(&data[0..4], b"BCFZ");

        Ok(())
    }
}