use crate::*;

impl Arrangement {
    /// Toggle looping for the active clip
    pub fn toggle_loop (&mut self) {
        if let Some(clip) = self.selected_clip() {
            clip.try_write().unwrap().toggle_loop()
        }
    }

    /// Put a clip in a slot
    pub fn clip_put (
        &mut self, track: usize, scene: usize, clip: Option<Arc<RwLock<MidiClip>>>
    ) -> Option<Arc<RwLock<MidiClip>>> {
        let old = self.scenes[scene].clips[track].clone();
        self.scenes[scene].clips[track] = clip;
        old
    }

    /// Change the color of a clip, returning the previous one
    pub fn clip_set_color (
        &self, track: usize, scene: usize, color: ItemTheme
    ) -> Option<ItemTheme> {
        self.scenes[scene].clips[track].as_ref().map(|clip|{
            let mut clip = clip.try_write().unwrap();
            let old = clip.color.clone();
            clip.color = color.clone();
            panic!("{color:?} {old:?}");
            //old
        })
    }
}

pub trait HasClipsSize {
    fn clips_size (&self) -> &Sizer;
}

impl HasClipsSize for App {
    fn clips_size (&self) -> &Sizer { &self.project.size_inner }
}

impl HasClipsSize for Arrangement {
    fn clips_size (&self) -> &Sizer { &self.size_inner }
}

impl<T: TracksView + ScenesView + Send + Sync> ClipsView for T {}

pub trait ClipsView: TracksView + ScenesView {
    /// Draw clips per scene
    fn view_scenes_clips (&self) -> impl Draw<Tui> {
        let select  = self.selection();
        let editor  = self.editor();
        let editing = self.is_editing();
        with_clips_size(true, self.clips_size(), iter_east(move||self.tracks_with_sizes()
            .map(move|(track_index, track, _, _)|iter_south(move||self.scenes_with_sizes()
                .map(move|(scene_index, scene, _, _)|{
                    let (name, theme): (Arc<str>, ItemTheme) = view_scene_name_theme(scene, track_index);
                    let f = theme.lightest.term;
                    let (b, o) = view_scene_bg(theme, select, track_index, scene_index);
                    let is_selected = view_scene_sel(select, track_index, scene_index, editing);
                    below(
                        Outer(true, Style::default().fg(o)).full_wh(),
                        below(
                            below(
                                fg_bg(o, b, "".full_wh()),
                                fg_bg(f, b, bold(true, name)).align_nw().full_wh(),
                            ),
                            when(is_selected, editor).full_wh()
                        ).full_wh()
                    ).exact_wh(
                        view_scene_w(track, select, track_index, editor),
                        view_scene_y(select, scene_index, editor),
                    )
                })
            )
                .full_h()
                .exact_w(track.width as u16))
        )).align_c()
    }
}

fn view_scene_name_theme (scene: &Scene, track_index: usize) -> (Arc<str>, ItemTheme) {
    if let Some(Some(clip)) = &scene.clips.get(track_index) {
        let clip = clip.try_read().unwrap();
        (format!(" ⏹ {}", &clip.name).into(), clip.color)
    } else {
        (" ⏹ -- ".into(), ItemTheme::G[32])
    }
}

fn with_clips_size (show: bool, size: &Sizer, content: impl Draw<Tui>) -> impl Draw<Tui> {
    size.of(above(
        when(show, fg(Green, east!(
            size.w() as usize, "x", size.h() as usize
        )).align_se()),
        content.align_c().full_wh()
    ))
}

fn view_scene_bg (
    theme: ItemTheme, select: &Selection, track_index: usize, scene_index: usize
) -> (Color, Color) {
    let mut outline = theme.base.term;
    (if select.track() == Some(track_index) && select.scene() == Some(scene_index) {
        outline = theme.lighter.term;
        theme.light.term
    } else if select.track() == Some(track_index) || select.scene() == Some(scene_index) {
        outline = theme.darkest.term;
        theme.base.term
    } else {
        theme.dark.term
    }, outline)
}

fn view_scene_w (
    track: &Track, select: &Selection, track_index: usize, editor: Option<&MidiEditor>
) -> u16 {
    if select.track() == Some(track_index) && let Some(editor) = editor {
        (editor.size.w() as usize).max(24).max(track.width) as u16
    } else {
        track.width as u16
    }
}

fn view_scene_y (
    select: &Selection, scene_index: usize, editor: Option<&MidiEditor>
) -> u16 {
    if select.scene() == Some(scene_index) && let Some(editor) = editor {
        editor.size.h().max(12)
    } else {
        Scene::DEFAULT_HEIGHT as u16
    }
}

fn view_scene_sel (select: &Selection, track_index: usize, scene_index: usize, editing: bool) -> bool {
    editing && select.track() == Some(track_index) && select.scene() == Some(scene_index)
}