use crate::*;

impl Tek {
    pub fn view_scene_add (&self) -> impl Content<TuiOut> + use<'_> {
        let editing = self.is_editing();
        let data = (self.selected().scene().unwrap_or(0), self.scenes().len());
        self.fmtd.write().unwrap().scns.update(Some(data), rewrite!(buf, "({}/{})", data.0, data.1));
        button_3("S", "add scene", self.fmtd.read().unwrap().scns.view.clone(), editing)
    }
}

pub(crate) fn view_scenes <'a> (
    w_full:                   u16,
    w_mid:                    u16,
    w_side:                   u16,
    h_scenes:                 u16,
    track_scroll:             impl Content<TuiOut>,
    track_sizes:              impl TracksSizes<'a>,
    track_selected:           Option<usize>,
    scene_scroll:             impl Content<TuiOut>,
    scenes_with_scene_colors: impl ScenesColors<'a>,
    scenes_with_track_colors: impl ScenesColors<'a>,
    scene_last:               usize,
    scene_selected:           Option<usize>,
    editor:                   &Option<MidiEditor>,
    is_editing:               bool,
) -> impl Content<TuiOut> + use<'a> {
    Tui::bg(Reset, Bsp::s(track_scroll, Bsp::e(scene_scroll, Fixed::y(h_scenes, Tryptich::center(h_scenes)
        .left(w_side, Map::new(scenes_with_scene_colors,
            move|(scene_index, scene, y1, y2, prev_scene): SceneWithColor, _|
                view_scene_name(
                    w_full,
                    (1 + y2 - y1) as u16,
                    y1 as u16,
                    scene_index,
                    scene,
                    prev_scene,
                    scene_last == scene_index,
                    scene_selected
                )))
        .middle(w_mid, per_track(w_mid, track_sizes, move|track_index, track|Map::new(
            scenes_with_track_colors,
            move|(scene_index, scene, y1, y2, prev_scene): SceneWithColor, _|
                view_scene_clip(
                    w_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
                ))))))))
}

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(
        last,
        select,
        true,
        index,
        &scene.color,
        prev,
        Some(scene.name.clone()),
        " ⯈ ",
        scene.color.lightest.rgb
    ))))
}

pub(crate) fn view_scene_clip <'a> (
    width:          u16,
    height:         u16,
    offset:         u16,
    scene:          &Scene,
    prev:           Option<ItemPalette>,
    scene_index:    usize,
    track_index:    usize,
    editing:        bool,
    same_track:     bool,
    scene_selected: Option<usize>,
    scene_is_last:  bool,
    editor:         &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 edit = |x|Bsp::b(x, When(active, editor));
    map_south(offset, height, edit(Fixed::y(height, view_scene_cell(
        scene_is_last,
        scene_selected,
        same_track,
        scene_index,
        &bg,
        prev,
        name,
        " ⏹ ",
        fg
    ))))
}

pub(crate) fn view_scene_cell <'a> (
    is_last:    bool,
    selected:   Option<usize>,
    same_track: bool,
    scene:      usize,
    color:      &ItemPalette,
    prev:       Option<ItemPalette>,
    name:       Option<Arc<str>>,
    icon:       &'a str,
    fg:         Color,
) -> 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,
            same_track && selected == Some(scene),
            same_track && scene > 0 && selected == Some(scene - 1),
            is_last
        )
    }
}

#[cfg(test)] #[test] fn test_view_scene () {
    let mut output = TuiOut::default();
    output.area[2] = 9;
    output.area[3] = 9;

    Content::render(&view_scenes(), &mut output);
}