use crate::*;

use super::Arranger;

/// Track management methods
impl<E: Engine> Arranger<E> {
    pub fn track (&self) -> Option<&Sequencer<E>> {
        self.selected.track().map(|t|self.tracks.get(t)).flatten()
    }
    pub fn track_mut (&mut self) -> Option<&mut Sequencer<E>> {
        self.selected.track().map(|t|self.tracks.get_mut(t)).flatten()
    }
    pub fn track_next (&mut self) {
        self.selected.track_next(self.tracks.len() - 1)
    }
    pub fn track_prev (&mut self) {
        self.selected.track_prev()
    }
    pub fn track_add (&mut self, name: Option<&str>) -> Usually<&mut Sequencer<E>> {
        self.tracks.push(name.map_or_else(
            || Sequencer::new(&self.track_default_name()),
            |name| Sequencer::new(name),
        ));
        let index = self.tracks.len() - 1;
        Ok(&mut self.tracks[index])
    }
    pub fn track_del (&mut self) {
        unimplemented!("Arranger::track_del");
    }
    pub fn track_default_name (&self) -> String {
        format!("Track {}", self.tracks.len() + 1)
    }
}

pub fn track_name_max_len <E: Engine> (tracks: &[Sequencer<E>]) -> usize {
    tracks.iter()
        .map(|s|s.name.read().unwrap().len())
        .fold(0, usize::max)
}

pub fn track_clip_name_lengths <E: Engine> (tracks: &[Sequencer<E>]) -> Vec<(usize, usize)> {
    let mut total = 0;
    let mut lengths: Vec<(usize, usize)> = tracks.iter().map(|track|{
        let len = 4 + track.phrases
            .iter()
            .fold(track.name.read().unwrap().len(), |len, phrase|{
                len.max(phrase.read().unwrap().name.read().unwrap().len())
            });
        total = total + len;
        (len, total - len)
    }).collect();
    lengths.push((0, total));
    lengths
}