use crate::*;
pub(crate) use std::fmt::Write;
pub(crate) use ::tengri::tui::ratatui::prelude::Position;

mod view_output; pub use self::view_output::*;

#[tengri_proc::view(TuiOut)]
impl App {
    pub fn view_nil (&self) -> impl Content<TuiOut> + use<'_> {
        "nil"
    }
    pub fn view_status (&self) -> impl Content<TuiOut> + use<'_> {
        self.update_clock();
        let cache = self.view_cache.read().unwrap();
        view_status(self.selected.describe(&self.tracks, &self.scenes),
            cache.sr.view.clone(), cache.buf.view.clone(), cache.lat.view.clone())
    }
    pub fn view_transport (&self) -> impl Content<TuiOut> + use<'_> {
        self.update_clock();
        let cache = self.view_cache.read().unwrap();
        view_transport(self.clock.is_rolling(),
            cache.bpm.view.clone(), cache.beat.view.clone(), cache.time.view.clone())
    }
    pub fn view_arranger (&self) -> impl Content<TuiOut> + use<'_> {
        ArrangerView::new(self)
    }
    pub fn view_pool (&self) -> impl Content<TuiOut> + use<'_> {
        self.pool().map(|p|Fixed::x(self.w_sidebar(), PoolView(self.is_editing(), p)))
    }
    pub fn view_editor (&self) -> impl Content<TuiOut> + use<'_> {
        self.editor().map(|e|Bsp::n(Bsp::e(e.clip_status(), e.edit_status()), e))
    }
    pub fn view_samples_keys (&self) -> impl Content<TuiOut> + use<'_> {
        self.sampler().map(|s|s.view_list(false, self.editor().unwrap()))
    }
    pub fn view_samples_grid (&self) -> impl Content<TuiOut> + use<'_> {
        self.sampler().map(|s|s.view_grid())
    }
    pub fn view_sample_viewer (&self) -> impl Content<TuiOut> + use<'_> {
        self.sampler().map(|s|s.view_sample(self.editor().unwrap().get_note_pos()))
    }
    pub fn view_sample_info (&self) -> impl Content<TuiOut> + use<'_> {
        self.sampler().map(|s|s.view_sample_info(self.editor().unwrap().get_note_pos()))
    }
    pub fn view_meters_input (&self) -> impl Content<TuiOut> + use<'_> {
        self.sampler().map(|s|s.view_meters_input())
    }
    pub fn view_meters_output (&self) -> impl Content<TuiOut> + use<'_> {
        self.sampler().map(|s|s.view_meters_output())
    }
    pub fn view_dialog (&self) -> impl Content<TuiOut> + use<'_> {
        When::new(self.dialog.is_some(), Bsp::b(
            Fill::xy(Tui::fg_bg(Rgb(64,64,64), Rgb(32,32,32), "")),
            Fixed::xy(30, 15, Tui::fg_bg(Rgb(255,255,255), Rgb(16,16,16), Bsp::b(
                Repeat(" "),
                Outer(true, Style::default().fg(Tui::g(96)))
                    .enclose(self.dialog.as_ref().map(|dialog|match dialog {
                        Dialog::Menu => self.view_dialog_menu().boxed(),
                        Dialog::Help => self.view_dialog_help().boxed(),
                        Dialog::Save => self.view_dialog_save().boxed(),
                        Dialog::Load => self.view_dialog_load().boxed(),
                        Dialog::Options => self.view_dialog_options().boxed(),
                        Dialog::Device(index) => self.view_dialog_device(*index).boxed(),
                        Dialog::Message(message) => self.view_dialog_message(message).boxed(),
                    }))
            )))
        ))
    }
}

impl App {
    fn view_dialog_menu (&self) -> impl Content<TuiOut> {
        let options = ||["Projects", "Settings", "Help", "Quit"].iter();
        let option  = |a,i|Tui::fg(Rgb(255,255,255), format!("{}", a));
        Bsp::s(Tui::bold(true, "tek!"), Bsp::s("", Map::south(1, options, option)))
    }
    fn view_dialog_help (&self) -> impl Content<TuiOut> + use<'_> {
        let bindings = ||self.config.keys.layers.iter()
            .filter_map(|a|(a.0)(self).then_some(a.1))
            .flat_map(|a|a)
            .filter_map(|x|if let Value::Exp(_, iter)=x.value{
                Some(iter)
            } else {
                None
            });
        //let binding = ;[> Bsp::e(
            //Fixed::x(15, Align::w(Tui::bold(true, Tui::fg(Rgb(255,192,0), if let Some(Token {
                //value: Value::Sym(key), ..
            //}) = binding.next() {
                //Some(key.to_string())
            //} else {
                //None
            //})))),
            //Bsp::e(" ", Tui::fg(Rgb(255,255,255), if let Some(Token {
                //value: Value::Key(command), ..
            //}) = binding.next() {
                //Some(command.to_string())
            //} else {
                //None
            //})),
        //);*/
        Bsp::s(Tui::bold(true, "Help"), Bsp::s("",  Map::south(1, bindings, |b,i|format!("{i}:{b:?}"))))
            //|mut binding: TokenIter, _|Map::east(5, move||binding.clone(), |_,_|"kyp"))))
    }

    fn view_dialog_device (&self, index: usize) -> impl Content<TuiOut> + use<'_> {
        let choices = ||self.device_kinds().iter();
        let choice = move|label, i|
            Fill::x(Tui::bg(if i == index { Rgb(64,128,32) } else { Rgb(0,0,0) },
                Bsp::e(if i == index { "[ " } else { "  " },
                    Bsp::w(if i == index { " ]" } else { "  " },
                        label))));
        Bsp::s(Tui::bold(true, "Add device"), Map::south(1, choices, choice))
    }

    fn view_dialog_message <'a> (&'a self, message: &'a Message) -> impl Content<TuiOut> + use<'a> {
        Bsp::s(message, Bsp::s("", "[ OK ]"))
    }

    fn view_dialog_save <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
        "WIP: SAVE"
    }

    fn view_dialog_load <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
        "WIP: LOAD"
    }

    fn view_dialog_options <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
        "WIP: OPTIONS"
    }

    /// Spacing between tracks.
    pub(crate) const TRACK_SPACING: usize = 0;

    /// Default scene height.
    pub(crate) const H_SCENE: usize = 2;

    /// Default editor height.
    pub(crate) const H_EDITOR: usize = 15;

    pub(crate) fn inputs_with_sizes (&self) -> impl PortsSizes<'_> {
        let mut y = 0;
        self.midi_ins.iter().enumerate().map(move|(i, input)|{
            let height = 1 + input.conn().len();
            let data   = (i, input.name(), input.conn(), y, y + height);
            y += height;
            data
        })
    }

    pub(crate) fn tracks_with_sizes (&self) -> impl TracksSizes<'_> {
        use Selection::*;
        let mut x = 0;
        let editing = self.is_editing();
        let active = match self.selected() {
            Track(t) if editing => Some(t),
            TrackClip { track, .. } if editing => Some(track),
            _ => None
        };
        let bigger = self.editor_w();
        self.tracks().iter().enumerate().map(move |(index, track)|{
            let width = if Some(index) == active.copied() { bigger } else { track.width.max(8) };
            let data = (index, track, x, x + width);
            x += width + App::TRACK_SPACING;
            data
        })
    }

    pub(crate) fn scenes_with_sizes (&self, editing: bool, height: usize, larger: usize)
        -> impl ScenesSizes<'_>
    {
        use Selection::*;
        let (selected_track, selected_scene) = match self.selected() {
            Track(t) => (Some(*t), None),
            Scene(s) => (None, Some(*s)),
            TrackClip { track, scene } => (Some(*track), Some(*scene)),
            _ => (None, None)
        };
        let mut y = 0;
        self.scenes().iter().enumerate().map(move|(s, scene)|{
            let active = editing && selected_track.is_some() && selected_scene == Some(s);
            let height = if active { larger } else { height };
            let data   = (s, scene, y, y + height);
            y += height;
            data
        })
    }

    pub fn update_clock (&self) {
        ViewCache::update_clock(&self.view_cache, self.clock(), self.size.w() > 80)
    }

}

pub(crate) struct ArrangerView<'a> {
    app:            &'a App,

    is_editing:     bool,

    width:          u16,
    width_mid:      u16,
    width_side:     u16,

    inputs_count:   usize,
    inputs_height:  u16,

    outputs_count:  usize,
    outputs_height: u16,

    scene_last:     usize,
    scene_count:    usize,
    scene_scroll:   Fill<Fixed<u16, ScrollbarV>>,
    scene_selected: Option<usize>,
    scenes_height:  u16,

    track_scroll:   Fill<Fixed<u16, ScrollbarH>>,
    track_count:    usize,
    track_selected: Option<usize>,
    tracks_height:  u16,

    show_debug_info: bool,
}

impl<'a> Content<TuiOut> for ArrangerView<'a> {
    fn content (&self) -> impl Render<TuiOut> {
        let ins     = |x|Bsp::n(self.inputs(), x);
        let tracks  = |x|Bsp::s(self.tracks(), x);
        let devices = |x|Bsp::s(self.devices(), x);
        let outs    = |x|Bsp::s(self.outputs(), x);
        let bg      = |x|Tui::bg(Reset, x);
        //let track_scroll = |x|Bsp::s(&self.track_scroll, x);
        //let scene_scroll = |x|Bsp::e(&self.scene_scroll, x);
        outs(tracks(devices(ins(bg(self.scenes())))))
    }
}

impl<'a> ArrangerView<'a> {
    pub fn new (app: &'a App) -> Self {
        Self {
            app,
            is_editing:     app.is_editing(),

            width:          app.w(),
            width_mid:      app.w_tracks_area(),
            width_side:     app.w_sidebar(),

            inputs_height:  app.h_inputs(),
            inputs_count:   app.midi_ins.len(),

            outputs_height: app.h_outputs(),
            outputs_count:  app.midi_outs.len(),

            scenes_height:  app.h_scenes_area(),
            scene_selected: app.selected().scene(),
            scene_count:    app.scenes.len(),
            scene_last:     app.scenes.len().saturating_sub(1),
            scene_scroll:   Fill::y(Fixed::x(1, ScrollbarV {
                offset: app.scene_scroll,
                length: app.h_scenes_area() as usize,
                total:  app.h_scenes() as usize,
            })),

            tracks_height:  app.h_tracks_area(),
            track_count:    app.tracks.len(),
            track_selected: app.selected().track(),
            track_scroll:   Fill::x(Fixed::y(1, ScrollbarH {
                offset: app.track_scroll,
                length: app.h_tracks_area() as usize,
                total:  app.h_scenes() as usize,
            })),

            show_debug_info: false
        }
    }

    /// Render input matrix.
    pub(crate) fn inputs (&'a self) -> impl Content<TuiOut> + 'a {
        Tui::bg(Reset, Bsp::s(
            self.input_intos(),
            Bsp::s(self.input_routes(), self.input_ports()),
        ))
    }

    /// Render device switches.
    pub(crate) fn devices (&'a self) -> impl Content<TuiOut> + 'a {
        let Self { width_side, width_mid, track_count, track_selected, is_editing, .. } = self;
        Tryptich::top(1)
            .left(*width_side, button_3("d", "devices", format!("{}", 0), *is_editing))
            .right(*width_side, button_2("D", "add device", *is_editing))
            .middle(*width_mid, per_track_top(*width_mid, ||self.tracks_with_sizes_scrolled(),
                move|index, track|{
                    let bg = if *track_selected == Some(index) {
                        track.color.light
                    } else {
                        track.color.base
                    };
                    let fg = Tui::g(224);
                    track.devices.get(0).map(|device|wrap(bg.rgb, fg, device.name()))
                }))
    }

    /// 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(),
                |index, track|wrap(
                    if *track_selected == Some(index) {
                        track.color.light
                    } else {
                        track.color.base
                    }.rgb,
                    track.color.lightest.rgb,
                    Tui::bold(true, Fill::xy(Align::nw(&track.name)))
                )))
    }

    fn input_routes (&'a self) -> impl Content<TuiOut> + 'a {
        Tryptich::top(self.inputs_height)
            .left(self.width_side,
                io_ports(Tui::g(224), Tui::g(32), ||self.app.inputs_with_sizes()))
            .middle(self.width_mid,
                per_track_top(self.width_mid, ||self.tracks_with_sizes_scrolled(),
                    move|_, &Track { color, .. }|io_conns(
                        color.dark.rgb,
                        color.darker.rgb,
                        ||self.app.inputs_with_sizes()
                    )))
    }

    fn input_ports (&'a self) -> impl Content<TuiOut> + 'a {
        Tryptich::top(1)
            .left(self.width_side,
                button_3("i", "midi ins", format!("{}", self.inputs_count), self.is_editing))
            .right(self.width_side,
                button_2("I", "add midi in", self.is_editing))
            .middle(self.width_mid,
                per_track_top(
                    self.width_mid,
                    ||self.tracks_with_sizes_scrolled(),
                    move|t, track|{
                        let rec = track.sequencer.recording;
                        let mon = track.sequencer.monitoring;
                        let rec = if rec { White } else { track.color.darkest.rgb };
                        let mon = if mon { White } else { track.color.darkest.rgb };
                        let bg  = if self.track_selected == Some(t) {
                            track.color.light.rgb
                        } else {
                            track.color.base.rgb
                        };
                        //let bg2 = if t > 0 { track.color.base.rgb } else { Reset };
                        wrap(bg, Tui::g(224), Tui::bold(true, Fill::x(Bsp::e(
                            Tui::fg_bg(rec, bg, "Rec  "),
                            Tui::fg_bg(mon, bg, "Mon  "),
                        ))))
                    }))
    }

    fn input_intos (&'a self) -> impl Content<TuiOut> + 'a {
        Tryptich::top(2)
            .left(self.width_side,
                Bsp::s(Align::e("Input:"), Align::e("Into clip:")))
            .middle(self.width_mid,
                per_track_top(
                    self.width_mid,
                    ||self.tracks_with_sizes_scrolled(),
                    |_, _|Tui::bg(Reset, Align::c(Bsp::s(OctaveVertical::default(), " ------ ")))))
    }

    /// 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: App { editor, .. }, ..
        } = self;

        let scene_headers = Map::new(||self.scenes_with_scene_colors(),
            move|(s, scene, y1, y2, previous): SceneWithColor, _|{
                let height     = (1 + y2 - y1) as u16;
                let name       = Some(scene.name.clone());
                let content    = Fill::x(Align::w(Tui::bold(true, Bsp::e(" ⯈ ", name))));
                let same_track = true;
                let selected   = same_track && *scene_selected == Some(s);
                let neighbor   = same_track && s > 0 && *scene_selected == Some(s - 1);
                let is_last    = *scene_last == s;
                let theme      = scene.color;
                let fg = theme.lightest.rgb;
                let bg = if selected { theme.light } else { theme.base }.rgb;
                let hi = if let Some(previous) = previous {
                    if neighbor {
                        previous.light.rgb
                    } else {
                        previous.base.rgb
                    }
                } else {
                    Reset
                };
                let lo = if is_last {
                    Reset
                } else if selected {
                    theme.light.rgb
                } else {
                    theme.base.rgb
                };
                Fill::x(map_south(y1 as u16, height, Fixed::y(height, Phat {
                    width: 0, height: 0, content, colors: [fg, bg, hi, lo]
                })))
            });

        let scene_track_clips = per_track(*width_mid, ||self.tracks_with_sizes_scrolled(),
            move|track_index, track|Map::new(move||self.scenes_with_track_colors(track_index),
                move|(s, scene, y1, y2, previous): SceneWithColor<'a>, _|{
                    let (name, theme) = if let Some(clip) = &scene.clips[track_index] {
                        let clip = clip.read().unwrap();
                        (Some(clip.name.clone()), clip.color)
                    } else {
                        (None, ItemTheme::G[32])
                    };
                    let height     = (1 + y2 - y1) as u16;
                    let content    = Fill::x(Align::w(Tui::bold(true, Bsp::e(" ⏹ ", name))));
                    let same_track = *track_selected == Some(track_index);
                    let selected   = same_track && *scene_selected == Some(s);
                    let neighbor   = same_track && s > 0 && *scene_selected == Some(s - 1);
                    let is_last    = *scene_last == s;
                    let fg = theme.lightest.rgb;
                    let bg = if selected { theme.light } else { theme.base }.rgb;
                    let hi = if let Some(previous) = previous {
                        if neighbor {
                            previous.light.rgb
                        } else {
                            previous.base.rgb
                        }
                    } else {
                        Reset
                    };
                    let lo = if is_last {
                        Reset
                    } else if selected {
                        theme.light.rgb
                    } else {
                        theme.base.rgb
                    };
                    map_south(y1 as u16, height, Bsp::b(Fixed::y(height, Phat {
                        width: 0, height: 0, content, colors: [fg, bg, hi, lo]
                    }), When(
                        *is_editing && same_track && *scene_selected == Some(s),
                        editor
                    )))
                }));

        Tryptich::center(*scenes_height)
            .left(*width_side, scene_headers)
            .middle(*width_mid, scene_track_clips)
    }

    pub(crate) fn tracks_with_sizes_scrolled (&'a self)
        -> impl TracksSizes<'a>
    {
        let width = self.width_mid;
        self.app.tracks_with_sizes().map_while(move|(t, track, x1, x2)|{
            (width > x2 as u16).then_some((t, track, x1, x2))
        })
    }

    pub(crate) fn scenes_with_scene_colors (&self)
        -> impl ScenesColors<'_>
    {
        self.app.scenes_with_sizes(self.is_editing, App::H_SCENE, App::H_EDITOR).map_while(
            move|(s, scene, y1, y2)|if y2 as u16 > self.scenes_height {
                None
            } else {
                Some((s, scene, y1, y2, if s == 0 {
                    None
                } else {
                    Some(self.app.scenes()[s-1].color)
                }))
            })
    }

    pub(crate) fn scenes_with_track_colors (&self, track: usize)
        -> impl ScenesColors<'_>
    {
        self.app.scenes_with_sizes(self.is_editing, App::H_SCENE, App::H_EDITOR).map_while(
            move|(s, scene, y1, y2)|if y2 as u16 > self.scenes_height {
                None
            } else {
                Some((s, scene, y1, y2, if s == 0 {
                    None
                } else {
                    Some(self.app.scenes[s-1].clips[track].as_ref()
                        .map(|c|c.read().unwrap().color)
                        .unwrap_or(ItemTheme::G[32]))
                }))
            }
        )
    }

}

/// Iterator over scenes with their sizes and colors.
pub(crate) trait ScenesColors<'a> =
    Iterator<Item=SceneWithColor<'a>>;

/// A scene with size and color.
pub(crate) type SceneWithColor<'a> =
    (usize, &'a Scene, usize, usize, Option<ItemTheme>);

/// Define a type alias for iterators of sized items (columns).
macro_rules! def_sizes_iter {
    ($Type:ident => $($Item:ty),+) => {
        pub(crate) trait $Type<'a> =
            Iterator<Item=(usize, $(&'a $Item,)+ usize, usize)> + Send + Sync + 'a;
    }
}

def_sizes_iter!(ScenesSizes  => Scene);

def_sizes_iter!(TracksSizes  => Track);

def_sizes_iter!(InputsSizes  => JackMidiIn);

def_sizes_iter!(OutputsSizes => JackMidiOut);

def_sizes_iter!(PortsSizes   => Arc<str>, [PortConnect]);

pub(crate) fn wrap (bg: Color, fg: Color, content: impl Content<TuiOut>) -> impl Content<TuiOut> {
    let left  = Tui::fg_bg(bg, Reset, Fixed::x(1, RepeatV("▐")));
    let right = Tui::fg_bg(bg, Reset, Fixed::x(1, RepeatV("▌")));
    Bsp::e(left, Bsp::w(right, Tui::fg_bg(fg, bg, content)))
}

pub(crate) fn button_2 <'a> (
    key: impl Content<TuiOut> + 'a, label: impl Content<TuiOut> + 'a, editing: bool,
) -> impl Content<TuiOut> + 'a {
    let key = Tui::fg_bg(Tui::g(0), Tui::orange(), Bsp::e(
        Tui::fg_bg(Tui::orange(), Reset, "▐"),
        Bsp::e(key, Tui::fg(Tui::g(96), "▐"))
    ));
    let label = When::new(!editing, Tui::fg_bg(Tui::g(255), Tui::g(96), label));
    Tui::bold(true, Bsp::e(key, label))
}

pub(crate) fn button_3 <'a, K, L, V> (
    key:     K,
    label:   L,
    value:   V,
    editing: bool,
) -> impl Content<TuiOut> + 'a where
    K: Content<TuiOut> + 'a,
    L: Content<TuiOut> + 'a,
    V: Content<TuiOut> + 'a,
{
    let key = Tui::fg_bg(Tui::g(0), Tui::orange(),
        Bsp::e(Tui::fg_bg(Tui::orange(), Reset, "▐"), Bsp::e(key, Tui::fg(if editing {
            Tui::g(128)
        } else {
            Tui::g(96)
        }, "▐"))));
    let label = Bsp::e(
        When::new(!editing, Bsp::e(
            Tui::fg_bg(Tui::g(255), Tui::g(96), label),
            Tui::fg_bg(Tui::g(128), Tui::g(96), "▐"),
        )),
        Bsp::e(
            Tui::fg_bg(Tui::g(224), Tui::g(128), value),
            Tui::fg_bg(Tui::g(128), Reset, "▌"),
        ));
    Tui::bold(true, Bsp::e(key, label))
}

pub(crate) fn heading <'a> (
    key:     &'a str,
    label:   &'a str,
    count:   usize,
    content: impl Content<TuiOut> + Send + Sync + 'a,
    editing: bool,
) -> impl Content<TuiOut> + 'a {
    let count = format!("{count}");
    Fill::xy(Align::w(Bsp::s(Fill::x(Align::w(button_3(key, label, count, editing))), content)))
}

pub(crate) fn io_ports <'a, T: PortsSizes<'a>> (
    fg: Color, bg: Color, iter: impl Fn()->T + Send + Sync + 'a
) -> impl Content<TuiOut> + 'a {
    Map::new(iter, move|(
        index, name, connections, y, y2
    ): (usize, &'a Arc<str>, &'a [PortConnect], usize, usize), _|
        map_south(y as u16, (y2-y) as u16, Bsp::s(
            Fill::x(Tui::bold(true, Tui::fg_bg(fg, bg, Align::w(Bsp::e(" 󰣲 ", name))))),
            Map::new(||connections.iter(), move|connect: &'a PortConnect, index|map_south(index as u16, 1,
                Fill::x(Align::w(Tui::bold(false, Tui::fg_bg(fg, bg,
                    &connect.info)))))))))
}

pub(crate) fn io_conns <'a, T: PortsSizes<'a>> (
    fg: Color, bg: Color, iter: impl Fn()->T + Send + Sync + 'a
) -> impl Content<TuiOut> + 'a {
    Map::new(iter, move|(
        index, name, connections, y, y2
    ): (usize, &'a Arc<str>, &'a [PortConnect], usize, usize), _|
        map_south(y as u16, (y2-y) as u16, Bsp::s(
            Fill::x(Tui::bold(true, wrap(bg, fg, Fill::x(Align::w("▞▞▞▞ ▞▞▞▞"))))),
            Map::new(||connections.iter(), move|connect, index|map_south(index as u16, 1,
                Fill::x(Align::w(Tui::bold(false, wrap(bg, fg, Fill::x(""))))))))))
}

pub(crate) fn per_track_top <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
    width:    u16,
    tracks:   impl Fn() -> U + Send + Sync + 'a,
    callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
) -> impl Content<TuiOut> + 'a {
    Align::x(Tui::bg(Reset, Map::new(tracks,
        move|(index, track, x1, x2): (usize, &'a Track, usize, usize), _|{
            let width = (x2 - x1) as u16;
            map_east(x1 as u16, width, Fixed::x(width, Tui::fg_bg(
                track.color.lightest.rgb,
                track.color.base.rgb,
                callback(index, track))))})))
}

pub(crate) fn per_track <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
    width:    u16,
    tracks:   impl Fn() -> U + Send + Sync + 'a,
    callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
) -> impl Content<TuiOut> + 'a {
    per_track_top(
        width,
        tracks,
        move|index, track|Fill::y(Align::y(callback(index, track)))
    )
}

/// Clear a pre-allocated buffer, then write into it.
#[macro_export] macro_rules! rewrite {
    ($buf:ident, $($rest:tt)*) => { |$buf,_,_|{ $buf.clear(); write!($buf, $($rest)*) } }
}

#[derive(Debug, Default)] pub(crate) struct ViewMemo<T, U> {
    pub(crate) value: T,
    pub(crate) view: Arc<RwLock<U>>
}

impl<T: PartialEq, U> ViewMemo<T, U> {
    fn new (value: T, view: U) -> Self {
        Self { value, view: Arc::new(view.into()) }
    }
    pub(crate) fn update <R> (
        &mut self,
        newval: T,
        render: impl Fn(&mut U, &T, &T)->R
    ) -> Option<R> {
        if newval != self.value {
            let result = render(&mut*self.view.write().unwrap(), &newval, &self.value);
            self.value = newval;
            return Some(result);
        }
        None
    }
}

#[derive(Debug)] pub struct ViewCache {
    pub(crate) sr:   ViewMemo<Option<(bool, f64)>, String>,
    pub(crate) buf:  ViewMemo<Option<f64>, String>,
    pub(crate) lat:  ViewMemo<Option<f64>, String>,
    pub(crate) bpm:  ViewMemo<Option<f64>, String>,
    pub(crate) beat: ViewMemo<Option<f64>, String>,
    pub(crate) time: ViewMemo<Option<f64>, String>,
    pub(crate) scns: ViewMemo<Option<(usize, usize)>, String>,
    pub(crate) trks: ViewMemo<Option<(usize, usize)>, String>,
    pub(crate) stop: Arc<str>,
    pub(crate) edit: Arc<str>,
}

impl Default for ViewCache {
    fn default () -> Self {
        let mut beat = String::with_capacity(16);
        write!(beat, "{}", Self::BEAT_EMPTY);
        let mut time = String::with_capacity(16);
        write!(time, "{}", Self::TIME_EMPTY);
        let mut bpm  = String::with_capacity(16);
        write!(bpm,  "{}", Self::BPM_EMPTY);
        Self {
            beat: ViewMemo::new(None, beat),
            time: ViewMemo::new(None, time),
            bpm:  ViewMemo::new(None, bpm),
            sr:   ViewMemo::new(None, String::with_capacity(16)),
            buf:  ViewMemo::new(None, String::with_capacity(16)),
            lat:  ViewMemo::new(None, String::with_capacity(16)),
            scns: ViewMemo::new(None, String::with_capacity(16)),
            trks: ViewMemo::new(None, String::with_capacity(16)),
            stop: "⏹".into(),
            edit: "edit".into(),
        }
    }
}

impl ViewCache {
    pub const BEAT_EMPTY: &'static str = "-.-.--";
    pub const TIME_EMPTY: &'static str = "-.---s";
    pub const BPM_EMPTY:  &'static str = "---.---";

    pub fn track_counter (cache: &Arc<RwLock<Self>>, track: usize, tracks: usize)
        -> Arc<RwLock<String>>
    {
        let data = (track, tracks);
        cache.write().unwrap().trks.update(Some(data), rewrite!(buf, "{}/{}", data.0, data.1));
        cache.read().unwrap().trks.view.clone()
    }

    pub fn scene_add (cache: &Arc<RwLock<Self>>, scene: usize, scenes: usize, is_editing: bool)
        -> impl Content<TuiOut>
    {
        let data = (scene, scenes);
        cache.write().unwrap().scns.update(Some(data), rewrite!(buf, "({}/{})", data.0, data.1));
        button_3("S", "add scene", cache.read().unwrap().scns.view.clone(), is_editing)
    }

    pub fn update_clock (cache: &Arc<RwLock<Self>>, clock: &Clock, compact: bool) {
        let rate  = clock.timebase.sr.get();
        let chunk = clock.chunk.load(Relaxed) as f64;
        let lat   = chunk / rate * 1000.;
        let delta = |start: &Moment|clock.global.usec.get() - start.usec.get();
        let mut cache = cache.write().unwrap();
        cache.buf.update(Some(chunk), rewrite!(buf, "{chunk}"));
        cache.lat.update(Some(lat),   rewrite!(buf, "{lat:.1}ms"));
        cache.sr.update(Some((compact, rate)), |buf,_,_|{
            buf.clear();
            if compact {
                write!(buf, "{:.1}kHz", rate / 1000.)
            } else {
                write!(buf, "{:.0}Hz", rate)
            }
        });
        if let Some(now) = clock.started.read().unwrap().as_ref().map(delta) {
            let pulse = clock.timebase.usecs_to_pulse(now);
            let time  = now/1000000.;
            let bpm   = clock.timebase.bpm.get();
            cache.beat.update(Some(pulse), |buf, _, _|{
                buf.clear();
                clock.timebase.format_beats_1_to(buf, pulse)
            });
            cache.time.update(Some(time), rewrite!(buf, "{:.3}s", time));
            cache.bpm.update(Some(bpm),   rewrite!(buf, "{:.3}",  bpm));
        } else {
            cache.beat.update(None, rewrite!(buf, "{}", ViewCache::BEAT_EMPTY));
            cache.time.update(None, rewrite!(buf, "{}", ViewCache::TIME_EMPTY));
            cache.bpm.update(None,  rewrite!(buf, "{}", ViewCache::BPM_EMPTY));
        }
    }
}

pub struct PoolView<'a>(pub bool, pub &'a MidiPool);

content!(TuiOut: |self: PoolView<'a>| {
    let Self(compact, model) = self;
    let MidiPool { clips, .. } = self.1;
    //let color  = self.1.clip().map(|c|c.read().unwrap().color).unwrap_or_else(||Tui::g(32).into());
    let on_bg  = |x|x;//Bsp::b(Repeat(" "), Tui::bg(color.darkest.rgb, x));
    let border = |x|x;//Outer(Style::default().fg(color.dark.rgb).bg(color.darkest.rgb)).enclose(x);
    let iter   = | |model.clips().clone().into_iter();
    let height = clips.read().unwrap().len() as u16;
    Tui::bg(Reset, Fixed::y(height, on_bg(border(Map::new(iter, move|clip: Arc<RwLock<MidiClip>>, i|{
        let item_height = 1;
        let item_offset = i as u16 * item_height;
        let selected    = i == model.clip_index();
        let MidiClip { ref name, color, length, .. } = *clip.read().unwrap();
        let bg     = if selected { color.light.rgb } else { color.base.rgb };
        let fg     = color.lightest.rgb;
        let name   = if *compact { format!(" {i:>3}") } else { format!(" {i:>3} {name}") };
        let length = if *compact { String::default()  } else { format!("{length}  ") };
        Fixed::y(1, map_south(item_offset, item_height, Tui::bg(bg, lay!(
            Fill::x(Align::w(Tui::fg(fg, Tui::bold(selected, name)))),
            Fill::x(Align::e(Tui::fg(fg, Tui::bold(selected, length)))),
            Fill::x(Align::w(When::new(selected, Tui::bold(true, Tui::fg(Tui::g(255), "▶"))))),
            Fill::x(Align::e(When::new(selected, Tui::bold(true, Tui::fg(Tui::g(255), "◀"))))),
        ))))
    })))))
});

content!(TuiOut: |self: ClipLength| {
    use ClipLengthFocus::*;
    let bars  = ||self.bars_string();
    let beats = ||self.beats_string();
    let ticks = ||self.ticks_string();
    match self.focus {
        None       => row!(" ", bars(), ".", beats(), ".", ticks()),
        Some(Bar)  => row!("[", bars(), "]", beats(), ".", ticks()),
        Some(Beat) => row!(" ", bars(), "[", beats(), "]", ticks()),
        Some(Tick) => row!(" ", bars(), ".", beats(), "[", ticks()),
    }
});