use crate::*;

#[derive(Debug, Default)] pub struct Scene {
    /// Name of scene
    pub name:  Arc<str>,
    /// Clips in scene, one per track
    pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
    /// Identifying color of scene
    pub color: ItemTheme,
}

impl Scene {
    /// Returns the pulse length of the longest clip in the scene
    pub fn pulses (&self) -> usize {
        self.clips.iter().fold(0, |a, p|{
            a.max(p.as_ref().map(|q|q.read().unwrap().length).unwrap_or(0))
        })
    }
    /// Returns true if all clips in the scene are
    /// currently playing on the given collection of tracks.
    pub fn is_playing (&self, tracks: &[Track]) -> bool {
        self.clips.iter().any(|clip|clip.is_some()) && self.clips.iter().enumerate()
            .all(|(track_index, clip)|match clip {
                Some(c) => tracks
                    .get(track_index)
                    .map(|track|{
                        if let Some((_, Some(clip))) = track.player().play_clip() {
                            *clip.read().unwrap() == *c.read().unwrap()
                        } else {
                            false
                        }
                    })
                    .unwrap_or(false),
                None => true
            })
    }
    pub fn clip (&self, index: usize) -> Option<&Arc<RwLock<MidiClip>>> {
        match self.clips.get(index) { Some(Some(clip)) => Some(clip), _ => None }
    }
}

pub trait HasScenes: HasSelection + HasEditor + Send + Sync {
    fn scenes (&self) -> &Vec<Scene>;
    fn scenes_mut (&mut self) -> &mut Vec<Scene>;
    fn scene_longest (&self) -> usize {
        self.scenes().iter().map(|s|s.name.len()).fold(0, usize::max)
    }
    fn scene (&self) -> Option<&Scene> {
        self.selected().scene().and_then(|s|self.scenes().get(s))
    }
    fn scene_mut (&mut self) -> Option<&mut Scene> {
        self.selected().scene().and_then(|s|self.scenes_mut().get_mut(s))
    }
    fn scene_del (&mut self, index: usize) {
        self.selected().scene().and_then(|s|Some(self.scenes_mut().remove(index)));
    }
    /// Set the color of a scene, returning the previous one.
    fn scene_set_color (&mut self, index: usize, color: ItemTheme) -> ItemTheme {
        let scenes = self.scenes_mut();
        let old = scenes[index].color;
        scenes[index].color = color;
        old
    }
    /// Generate the default name for a new scene
    fn scene_default_name (&self) -> Arc<str> {
        format!("Sc{:3>}", self.scenes().len() + 1).into()
    }
}

impl HasScenes for App {
    fn scenes (&self) -> &Vec<Scene> { &self.scenes }
    fn scenes_mut (&mut self) -> &mut Vec<Scene> { &mut self.scenes }
}