use crate::*;

impl<'a> ArrangerView<'a> {

    /// Render track headers
    pub(crate) fn tracks (&'a self) -> impl Content<TuiOut> + 'a {
        let Self { width_side, width_mid, track_count, track_selected, is_editing, .. } = self;
        Tryptich::center(3)
            .left(*width_side,  button_3("t", "track", format!("{}", *track_count), *is_editing))
            .right(*width_side, button_2("T", "add track", *is_editing))
            .middle(*width_mid, per_track(*width_mid,
                ||self.tracks_with_sizes_scrolled(),
                |t, track|view_track_header(t, track, *track_selected == Some(t))))
    }

    /// Render scenes with clips
    pub(crate) fn scenes (&'a self) -> impl Content<TuiOut> + 'a {
        let Self {
            width, width_side, width_mid,
            scenes_height, scene_last, scene_selected,
            track_selected, is_editing, app: Tek { editor, .. }, ..
        } = self;
        Tryptich::center(*scenes_height)
            .left(*width_side, Map::new(||self.scenes_with_scene_colors(),
                move|(index, scene, y1, y2, previous): SceneWithColor, _|view_scene_name(
                    *width,
                    (1 + y2 - y1) as u16,
                    y1 as u16,
                    index,
                    scene,
                    previous,
                    *scene_last == index,
                    *scene_selected
                )))
            .middle(*width_mid, per_track(*width_mid, ||self.tracks_with_sizes_scrolled(),
                move|track_index, track|Map::new(||self.scenes_with_track_colors(),
                    move|(scene_index, scene, y1, y2, prev_scene): SceneWithColor<'a>, _|
                        view_scene_clip(
                            *width_mid,
                            (1 + y2 - y1) as u16,
                            y1 as u16,
                            scene,
                            prev_scene,
                            scene_index,
                            track_index,
                            *is_editing,
                            *track_selected == Some(track_index),
                            *scene_selected,
                            *scene_last == scene_index,
                            editor
                        ))))
    }

    fn scene_add (&'a self) -> impl Content<TuiOut> + 'a {
        ViewCache::scene_add(
            &self.app.view_cache,
            self.scene_selected.unwrap_or(0),
            self.scene_count,
            self.is_editing,
        )
    }

    fn track_counter (&'a self) -> Arc<RwLock<String>> {
        ViewCache::track_counter(
            &self.app.view_cache,
            self.track_selected.unwrap_or(0),
            self.track_count,
        )
    }

}

fn view_track_header <'a> (
    index: usize, track: &'a Track, active: bool
) -> impl Content<TuiOut> + use<'a> {
    let fg = track.color.lightest.rgb;
    let bg = if active { track.color.light.rgb } else { track.color.base.rgb };
    let bg2 = Reset;//if index > 0 { self.tracks()[index - 1].color.base.rgb } else { Reset };
    wrap(bg, fg, Tui::bold(true, Fill::x(Align::nw(&track.name))))
}

pub(crate) fn view_scene_name (
    width:  u16,
    height: u16,
    offset: u16,
    index:  usize,
    scene:  &Scene,
    prev:   Option<ItemPalette>,
    last:   bool,
    select: Option<usize>,
) -> impl Content<TuiOut> {
    Fill::x(map_south(offset, height, Fixed::y(height, view_scene_cell(
        " ⯈ ", Some(scene.name.clone()), &scene.color, prev, last, select, true, index,
    ))))
}

pub(crate) fn view_scene_clip <'a> (
    width:          u16,
    height:         u16,
    offset:         u16,
    scene:          &'a Scene,
    prev_bg:        Option<ItemPalette>,
    scene_index:    usize,
    track_index:    usize,
    editing:        bool,
    same_track:     bool,
    scene_selected: Option<usize>,
    scene_is_last:  bool,
    editor:         &'a Option<MidiEditor>,
) -> impl Content<TuiOut> + use<'a> {
    let (name, _fg, bg) = if let Some(clip) = &scene.clips[track_index] {
        let clip = clip.read().unwrap();
        (Some(clip.name.clone()), clip.color.lightest.rgb, clip.color)
    } else {
        (None, Tui::g(96), ItemPalette::G[32])
    };
    let active = editing && same_track && scene_selected == Some(scene_index);
    let with_editor = |x|Bsp::b(x, When(active, editor));
    map_south(offset, height, with_editor(Fixed::y(height, view_scene_cell(
        " ⏹ ", name, &bg, prev_bg,
        scene_is_last, scene_selected, same_track, scene_index,
    ))))
}

pub(crate) fn view_scene_cell <'a> (
    icon:       &'a str,
    name:       Option<Arc<str>>,
    color:      &ItemPalette,
    prev_color: Option<ItemPalette>,
    is_last:    bool,
    selected:   Option<usize>,
    same_track: bool,
    scene:      usize,
) -> impl Content<TuiOut> + use<'a> {
    Phat {
        width:   0,
        height:  0,
        content: Fill::x(Align::w(Tui::bold(true, Bsp::e(icon, name)))),
        colors:  Tek::colors(
            color,
            prev_color,
            same_track && selected == Some(scene),
            same_track && scene > 0 && selected == Some(scene - 1),
            is_last
        )
    }
}