// ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄
//██Let me play the world's tiniest piano for you. ██
//█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█
//█▙▙█▙▙▙█▙▙█▙▙▙█▙▙█▙▙▙█▙▙█▙▙▙█▙▙█▙▙▙█▙▙█▙▙▙█▙▙█▙▙▙██
//█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█
//███████████████████████████████████████████████████
//█                      ▀ ▀ ▀                      █
#![allow(unused)]
#![allow(clippy::unit_arg)]
#![feature(adt_const_params)]
#![feature(associated_type_defaults)]
#![feature(if_let_guard)]
#![feature(impl_trait_in_assoc_type)]
#![feature(type_alias_impl_trait)]
#![feature(trait_alias)]
#![feature(type_changing_struct_update)]
#![feature(let_chains)]
#![feature(closure_lifetime_binder)]
pub use ::tek_engine:: *;
pub use ::tek_device::{self, *};
pub use ::tengri::{Usually, Perhaps, Has, MaybeHas};
pub use ::tengri::{has, maybe_has};
pub use ::tengri::dsl::*;
pub use ::tengri::input::*;
pub use ::tengri::output::*;
pub use ::tengri::tui::*;
pub use ::tengri::tui::ratatui;
pub use ::tengri::tui::ratatui::prelude::buffer::Cell;
pub use ::tengri::tui::ratatui::prelude::Color::{self, *};
pub use ::tengri::tui::ratatui::prelude::{Style, Stylize, Buffer, Modifier};
pub use ::tengri::tui::crossterm;
pub use ::tengri::tui::crossterm::event::{Event, KeyCode::{self, *}};
use std::path::{Path, PathBuf};
use std::sync::{Arc, RwLock};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::Relaxed};
use std::error::Error;
use std::collections::BTreeMap;
use std::fmt::Write;
use ::tengri::tui::ratatui::prelude::Position;
use xdg::BaseDirectories;
#[cfg(test)] mod app_test;
/// Total state
#[derive(Default, Debug)]
pub struct App {
    /// Must not be dropped for the duration of the process
    pub jack:    Jack<'static>,
    /// Display size
    pub size:    Measure<TuiOut>,
    /// Performance counter
    pub perf:    PerfModel,
    /// Available view profiles and input bindings
    pub config:  Config,
    /// Currently selected profile
    pub profile: Option<Profile>,
    /// Contains the currently edited musical arrangement
    pub project: Arrangement,
    /// Contains all recently created clips.
    pub pool:    Pool,
    /// Undo history
    pub history: Vec<(AppCommand, Option<AppCommand>)>,
    /// Dialog overlay
    pub dialog:  Option<Dialog>,
    /// Base color.
    pub color:   ItemTheme,
}
/// Configuration
#[derive(Default, Debug)]
pub struct Config {
    /// XDG basedirs
    pub dirs:     BaseDirectories,
    /// Available view profiles
    pub profiles: Arc<RwLock<BTreeMap<Arc<str>, Profile>>>,
    /// Available input bindings
    pub bindings: Arc<RwLock<BTreeMap<Arc<str>, Arc<str>>>>,
}
/// Profile
#[derive(Default, Debug)]
pub struct Profile {
    /// Path of configuration entrypoint
    pub path: PathBuf,
    /// Name of configuration
    pub name: Option<Arc<str>>,
    /// Description of configuration
    pub info: Option<Arc<str>>,
    /// View definition
    pub view: Arc<str>,
    // Input keymap
    pub keys: EventMap<TuiEvent, AppCommand>,
}
/// Various possible dialog modes.
#[derive(Debug, Clone)]
pub enum Dialog {
    Help(usize),
    Menu(usize),
    Device(usize),
    Message(Arc<str>),
    Browser(BrowserTarget, Browser),
    Options,
}
impl App {
    pub fn view (&self) -> impl Content<TuiOut> + '_ {
        Fill::xy(Bsp::a(
            Fill::xy(ErrorBoundary::new(Ok(Some(Tui::bg(Black, self.view_dialog()))))),
            Fill::xy(ErrorBoundary::new(Ok(Some(self.view_nil())))),
        ))
    }
    fn handle_tui_key_with_history (&mut self, input: &TuiIn) -> Perhaps<bool> {
        Ok(if let Some(binding) = self.profile.as_ref()
            .map(|c|c.keys.dispatch(input.event())).flatten()
        {
            let binding = binding.clone();
            let undo = binding.command.clone().execute(self)?;
            // FIXME failed commands are not persisted in undo history
            //self.history.push((binding.command.clone(), undo));
            Some(true)
        } else {
            None
        })
    }
    pub fn update_clock (&self) {
        ViewCache::update_clock(&self.project.clock.view_cache, self.clock(), self.size.w() > 80)
    }
    pub fn toggle_dialog (&mut self, mut dialog: Option<Dialog>) -> Option<Dialog> {
        std::mem::swap(&mut self.dialog, &mut dialog);
        dialog
    }
    pub fn toggle_editor (&mut self, value: Option<bool>) {
        //FIXME: self.editing.store(value.unwrap_or_else(||!self.is_editing()), Relaxed);
        let value = value.unwrap_or_else(||!self.editor().is_some());
        if value {
            self.clip_auto_create();
        } else {
            self.clip_auto_remove();
        }
    }
    pub fn browser (&self) -> Option<&Browser> {
        self.dialog.as_ref().and_then(|dialog|match dialog {
            Dialog::Browser(_, b) => Some(b),
            _ => None
        })
    }
    pub fn device_pick (&mut self, index: usize) {
        self.dialog = Some(Dialog::Device(index));
    }
    pub fn device_add (&mut self, index: usize) -> Usually<()> {
        match index {
            0 => self.device_add_sampler(),
            1 => self.device_add_lv2(),
            _ => unreachable!(),
        }
    }
    fn device_add_lv2 (&mut self) -> Usually<()> {
        todo!();
        Ok(())
    }
    fn device_add_sampler (&mut self) -> Usually<()> {
        let name    = self.jack.with_client(|c|c.name().to_string());
        let midi    = self.project.track().expect("no active track").sequencer.midi_outs[0].port_name();
        let track   = self.track().expect("no active track");
        let port    = format!("{}/Sampler", &track.name);
        let connect = Connect::exact(format!("{name}:{midi}"));
        let sampler = if let Ok(sampler) = Sampler::new(
            &self.jack, &port, &[connect], &[&[], &[]], &[&[], &[]]
        ) {
            self.dialog = None;
            Device::Sampler(sampler)
        } else {
            self.dialog = Some(Dialog::Message("Failed to add device.".into()));
            return Err("failed to add device".into())
        };
        let track   = self.track_mut().expect("no active track");
        track.devices.push(sampler);
        Ok(())
    }
    // Create new clip in pool when entering empty cell
    fn clip_auto_create (&mut self) -> Option<Arc<RwLock<MidiClip>>> {
        if let Selection::TrackClip { track, scene } = *self.selection()
        && let Some(scene) = self.project.scenes.get_mut(scene)
        && let Some(slot)  = scene.clips.get_mut(track)
        && slot.is_none()
        && let Some(track) = self.project.tracks.get_mut(track)
        {
            let (index, mut clip) = self.pool.add_new_clip();
            // autocolor: new clip colors from scene and track color
            let color = track.color.base.mix(scene.color.base, 0.5);
            clip.write().unwrap().color = ItemColor::random_near(color, 0.2).into();
            if let Some(ref mut editor) = &mut self.project.editor {
                editor.set_clip(Some(&clip));
            }
            *slot = Some(clip.clone());
            Some(clip)
        } else {
            None
        }
    }
    // Remove clip from arrangement when exiting empty clip editor
    fn clip_auto_remove (&mut self) {
        if let Selection::TrackClip { track, scene } = *self.selection()
        && let Some(scene) = self.project.scenes.get_mut(scene)
        && let Some(slot) = scene.clips.get_mut(track)
        && let Some(clip) = slot.as_mut()
        {
            let mut swapped = None;
            if clip.read().unwrap().count_midi_messages() == 0 {
                std::mem::swap(&mut swapped, slot);
            }
            if let Some(clip) = swapped {
                self.pool.delete_clip(&clip.read().unwrap());
            }
        }
    }
}
macro_rules!dsl_expose(($Struct:ident { $($fn:ident: $ret:ty = |$self:ident|$body:expr);* $(;)? })=>{
    #[tengri_proc::expose] impl $Struct { $(fn $fn (&$self) -> $ret { $body })* }
});
dsl_expose!(App {
    _isize_stub:          isize          = |self|todo!();
    _item_theme_stub:     ItemTheme      = |self|todo!();
    w_sidebar:            u16            = |self|self.project.w_sidebar(self.editor().is_some());
    h_sample_detail:      u16            = |self|6.max(self.height() as u16 * 3 / 9);
    focus_editor:         bool           = |self|self.project.editor.is_some();
    focus_dialog:         bool           = |self|self.dialog.is_some();
    focus_message:        bool           = |self|matches!(self.dialog, Some(Dialog::Message(..)));
    focus_device_add:     bool           = |self|matches!(self.dialog, Some(Dialog::Device(..)));
    focus_browser:        bool           = |self|self.browser().is_some();
    focus_clip:           bool           = |self|!self.focus_editor() && matches!(self.selection(), Selection::TrackClip{..});
    focus_track:          bool           = |self|!self.focus_editor() && matches!(self.selection(), Selection::Track(..));
    focus_scene:          bool           = |self|!self.focus_editor() && matches!(self.selection(), Selection::Scene(..));
    focus_mix:            bool           = |self|!self.focus_editor() && matches!(self.selection(), Selection::Mix);
    focus_pool_import:    bool           = |self|matches!(self.pool.mode, Some(PoolMode::Import(..)));
    focus_pool_export:    bool           = |self|matches!(self.pool.mode, Some(PoolMode::Export(..)));
    focus_pool_rename:    bool           = |self|matches!(self.pool.mode, Some(PoolMode::Rename(..)));
    focus_pool_length:    bool           = |self|matches!(self.pool.mode, Some(PoolMode::Length(..)));
    dialog_none:          Option<Dialog> = |self|None;
    dialog_device:        Option<Dialog> = |self|Some(Dialog::Device(0)); // TODO
    dialog_device_prev:   Option<Dialog> = |self|Some(Dialog::Device(0)); // TODO
    dialog_device_next:   Option<Dialog> = |self|Some(Dialog::Device(0)); // TODO
    dialog_help:          Option<Dialog> = |self|Some(Dialog::Help(0));
    dialog_menu:          Option<Dialog> = |self|Some(Dialog::Menu(0));
    dialog_save:          Option<Dialog> = |self|Some(Dialog::Browser(BrowserTarget::SaveProject, Browser::new(None).unwrap()));
    dialog_load:          Option<Dialog> = |self|Some(Dialog::Browser(BrowserTarget::LoadProject, Browser::new(None).unwrap()));
    dialog_import_clip:   Option<Dialog> = |self|Some(Dialog::Browser(BrowserTarget::ImportClip(Default::default()), Browser::new(None).unwrap()));
    dialog_export_clip:   Option<Dialog> = |self|Some(Dialog::Browser(BrowserTarget::ExportClip(Default::default()), Browser::new(None).unwrap()));
    dialog_import_sample: Option<Dialog> = |self|Some(Dialog::Browser(BrowserTarget::ImportSample(Default::default()), Browser::new(None).unwrap()));
    dialog_export_sample: Option<Dialog> = |self|Some(Dialog::Browser(BrowserTarget::ExportSample(Default::default()), Browser::new(None).unwrap()));
    dialog_options:       Option<Dialog> = |self|Some(Dialog::Options);
    editor_pitch:         Option<u7>     = |self|Some((self.editor().as_ref().map(|e|e.get_note_pos()).unwrap() as u8).into());
    scene_count:          usize          = |self|self.scenes().len();
    scene_selected:       Option<usize>  = |self|self.selection().scene();
    track_count:          usize          = |self|self.tracks().len();
    track_selected:       Option<usize>  = |self|self.selection().track();
    select_scene:         Selection      = |self|self.selection().select_scene(self.tracks().len());
    select_scene_next:    Selection      = |self|self.selection().select_scene_next(self.scenes().len());
    select_scene_prev:    Selection      = |self|self.selection().select_scene_prev();
    select_track:         Selection      = |self|self.selection().select_track(self.tracks().len());
    select_track_next:    Selection      = |self|self.selection().select_track_next(self.tracks().len());
    select_track_prev:    Selection      = |self|self.selection().select_track_prev();
    clip_selected: Option<Arc<RwLock<MidiClip>>> = |self|match self.selection() {
        Selection::TrackClip { track, scene } => self.scenes()[*scene].clips[*track].clone(),
        _ => None
    };
    device_kind: usize = |self|if let Some(Dialog::Device(index)) = self.dialog {
        index } else { 0 };
    device_kind_next: usize = |self|if let Some(Dialog::Device(index)) = self.dialog {
        (index + 1) % device_kinds().len() } else { 0 };
    device_kind_prev: usize = |self|if let Some(Dialog::Device(index)) = self.dialog {
        index.overflowing_sub(1).0.min(device_kinds().len().saturating_sub(1))
    } else { 0 };
});
macro_rules!dsl_view(($Struct:ident { $($fn:ident = |$self:ident|$body:expr);* $(;)? })=>{
    content!(TuiOut: |self: $Struct| { ErrorBoundary::new(Ok(Some(Tui::bg(Black, self.view())))) });
    #[tengri_proc::view(TuiOut)] impl $Struct { $(fn $fn (&$self) -> impl Content<TuiOut> + '_ { $body })* }
});
dsl_view!(App {
    view_nil    = |self|"·";
    view_dialog = |self|self.dialog.as_ref().map(|dialog|wrap_dialog(match dialog {
        Dialog::Menu(selected) => wrap_dialog_menu({
            let profiles = self.config.profiles.clone();
            Stack::south(move|add: &mut dyn FnMut(&dyn Render<TuiOut>)|{
                for (index, (id, profile)) in profiles.read().unwrap().iter().enumerate() {
                    let bg   = if index == 0 { Rgb(64,64,64) } else { Rgb(32,32,32) };
                    let name = profile.name.as_ref().map(|x|unquote(unquote(x.as_ref())));
                    let info = profile.info.as_ref().map(|x|unquote(unquote(x.as_ref())));
                    add(&Fixed::y(3, Tui::bg(bg, Bsp::s(
                        Fill::x(Bsp::a(
                            Fill::x(Align::w(Tui::fg(Rgb(224,192,128), name))),
                            Fill::x(Align::e(Tui::fg(Rgb(224,128,32), &id)))
                        )),
                        Fill::x(Align::w(info))
                    ))));
                }
            })
        }).boxed(),
        //Self::Help(offset) =>
            //self.view_dialog_help(*offset).boxed(),
        //Self::Browser(target, browser) =>
            //self.view_dialog_browser(target, browser).boxed(),
        //Self::Options =>
            //self.view_dialog_options().boxed(),
        //Self::Device(index) =>
            //self.view_dialog_device(*index).boxed(),
        //Self::Message(message) =>
            //self.view_dialog_message(message).boxed(),
        _ => "kyp".boxed()
    }));
});
fn wrap_dialog (dialog: Box<dyn Render<TuiOut>>) -> impl Content<TuiOut> {
    Fixed::xy(70, 23, Tui::fg_bg(Rgb(255,255,255), Rgb(16,16,16), Bsp::b(
        Repeat(" "), Outer(true, Style::default().fg(Tui::g(96))).enclose(dialog))))
}
fn wrap_dialog_menu (content: impl Content<TuiOut>) -> impl Content<TuiOut> {
    Tui::bg(Rgb(0,0,0), Bsp::s(
        Fill::x(Fixed::y(3, Tui::bg(Rgb(33,33,33), Tui::bold(true, "tek 0.3.0-rc0")))),
        Bsp::n(
            Fill::x(Fixed::y(3, Tui::bg(Rgb(33,33,33), Bsp::e(Tui::fg(Rgb(255,192,48), "[Enter]"), " new session")))),
            Fill::y(Align::n(Fill::x(content))))))
}
has!(Jack<'static>:      |self: App|self.jack);
has!(Pool:               |self: App|self.pool);
has!(Option<Dialog>:     |self: App|self.dialog);
has!(Clock:              |self: App|self.project.clock);
has!(Option<MidiEditor>: |self: App|self.project.editor);
has!(Selection:          |self: App|self.project.selection);
has!(Vec<MidiInput>:     |self: App|self.project.midi_ins);
has!(Vec<MidiOutput>:    |self: App|self.project.midi_outs);
has!(Vec<Scene>:         |self: App|self.project.scenes);
has!(Vec<Track>:         |self: App|self.project.tracks);
has!(Measure<TuiOut>:    |self: App|self.size);
maybe_has!(Track: |self: App|
    { MaybeHas::<Track>::get(&self.project) };
    { MaybeHas::<Track>::get_mut(&mut self.project) });
impl HasTrackScroll for App { fn track_scroll (&self) -> usize { self.project.track_scroll() } }
maybe_has!(Scene: |self: App|
    { MaybeHas::<Scene>::get(&self.project) };
    { MaybeHas::<Scene>::get_mut(&mut self.project) });
impl HasSceneScroll for App { fn scene_scroll (&self) -> usize { self.project.scene_scroll() } }
has_clips!(|self: App|self.pool.clips);
impl HasClipsSize for App { fn clips_size (&self) -> &Measure<TuiOut> { &self.project.inner_size } }
//take!(ClockCommand       |state: App, iter|Take::take(state.clock(), iter));
//take!(MidiEditCommand    |state: App, iter|Ok(state.editor().map(|x|Take::take(x, iter)).transpose()?.flatten()));
//take!(PoolCommand        |state: App, iter|Take::take(&state.pool, iter));
//take!(SamplerCommand     |state: App, iter|Ok(state.project.sampler().map(|x|Take::take(x, iter)).transpose()?.flatten()));
//take!(ArrangementCommand |state: App, iter|Take::take(&state.project, iter));
//take!(DialogCommand      |state: App, iter|Take::take(&state.dialog, iter));
//has_editor!(|self: App|{
    //editor = self.editor;
    //editor_w = {
        //let size      = self.size.w();
        //let editor    = self.editor.as_ref().expect("missing editor");
        //let time_len  = editor.time_len().get();
        //let time_zoom = editor.time_zoom().get().max(1);
        //(5 + (time_len / time_zoom)).min(size.saturating_sub(20)).max(16)
    //};
    //editor_h = 15;
    //is_editing = self.editor.is_some();
//});
impl Profile {
    fn from_dsl (dsl: impl Dsl) -> Usually<Self> {
        let mut profile = Self { ..Default::default() };
        dsl.each(|dsl|{
            let head = dsl.head();
            let exp  = dsl.exp();
            Ok(if exp.head().key() == Ok(Some("name")) {
                profile.name = Some(exp.tail()?.unwrap_or_default().into());
            } else if exp.head().key() == Ok(Some("info")) {
                profile.info = Some(exp.tail()?.unwrap_or_default().into());
            })
        })?;
        Ok(profile)
    }
}
impl Config {
    const PROFILES: &'static str = "profiles.edn";
    const BINDINGS: &'static str = "bindings.edn";
    const DEFAULT_PROFILES: &'static str = include_str!("../../config/profiles.edn");
    const DEFAULT_BINDINGS: &'static str = include_str!("../../config/bindings.edn");
    pub fn init () -> Usually<Self> {
        let mut dirs = BaseDirectories::with_profile("tek", "v0");
        let mut cfgs = Self { dirs, ..Default::default() };
        cfgs.init_file(Self::PROFILES, Self::DEFAULT_PROFILES)?;
        cfgs.load_file(Self::PROFILES, |cfgs, dsl|{
            Ok(if dsl.exp().head().key() == Ok(Some("module")) {
                let exp  = dsl.exp()?;
                let tail = exp.tail()?;
                let head = tail.head()?;
                if let Some(id) = head.sym()? {
                    cfgs.profiles.write().unwrap().insert(
                        id.into(),
                        Profile::from_dsl(tail.tail()?)?
                    );
                }
            } else {
                return Err("unexpected: {exp:?}".into());
            })
        })?;
        //cfgs.init_file(Self::BINDINGS, Self::DEFAULT_BINDINGS)?;
        //cfgs.load_file(Self::BINDINGS, |cfgs, dsl|Ok(
            //if let Some(exp) = dsl.head()?.exp()? && exp.head()?.key()? == Some("module") {
                //let name = exp.tail()?.head()?.unwrap_or_default().into();
                //println!("name = {name}");
                //let body = exp.tail()?.tail()?.unwrap_or_default().into();
                //println!("body = {body}");
                //cfgs.bindings.write().unwrap().insert(name, body);
            //} else {
                //return Err("unexpected: {exp:?}".into());
            //}
        //))?;
        println!("{cfgs:#?}");
        Ok(cfgs)
    }
    fn init_file (&mut self, path: &str, val: &str) -> Usually<()> {
        if self.dirs.find_config_file(path).is_none() {
            std::fs::write(self.dirs.place_config_file("profiles.edn")?, Self::DEFAULT_PROFILES);
        }
        Ok(())
    }
    fn load_file (
        &mut self,
        path: &str,
        mut each: impl FnMut(&mut Self, &str)->Usually<()>
    ) -> Usually<()> {
        Ok(if let Some(path) = self.dirs.find_config_file(path) {
            let src = std::fs::read_to_string(&path)?;
            src.as_str().each(move|item|each(self, item))?;
        } else {
            return Err(format!("{path}: not found").into())
        })
    }
}
impl Profile {
    fn load_template (&mut self, dsl: impl Dsl) -> Usually<&mut Self> {
        dsl.src()?.unwrap_or_default().each(|item|Ok(match () {
            _ if let Some(exp) = dsl.exp()? => match exp.head()?.key()? {
                Some("name") => match exp.tail()?.text()? {
                    Some(name) => self.name = Some(name.into()),
                    _ => return Err(format!("missing name definition").into())
                },
                Some("info") => match exp.tail()?.text()? {
                    Some(info) => self.info = Some(info.into()),
                    _ => return Err(format!("missing info definition").into())
                },
                Some("bind") => match exp.tail()? {
                    Some(keys) => self.keys = EventMap::from_dsl(&mut &keys)?,
                    _ => return Err(format!("missing keys definition").into())
                },
                Some("view") => match exp.tail()? {
                    Some(tail) => self.view = tail.src()?.unwrap_or_default().into(),
                    _ => return Err(format!("missing view definition").into())
                },
                dsl => return Err(format!("unexpected: {dsl:?}").into())
            },
            _ => return Err(format!("unexpected: {dsl:?}").into())
        }));
        Ok(self)
    }
    fn load_binding (&mut self, dsl: impl Dsl) -> Usually<&mut Self> {
        todo!();
        Ok(self)
    }
}
fn unquote (x: &str) -> &str {
    let mut chars = x.chars();
    chars.next();
    //chars.next_back();
    chars.as_str()
}
impl ScenesView for App {
    fn h_scenes (&self) -> u16 {
        (self.height() as u16).saturating_sub(20)
    }
    fn w_side (&self) -> u16 {
        20
    }
    fn w_mid (&self) -> u16 {
        (self.width() as u16).saturating_sub(self.w_side())
    }
}

impl Dialog {
    pub fn view_dialog_menu <'a> (selected: usize) -> impl Content<TuiOut> + 'a {
        //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)))
    }
    pub fn view_dialog_help <'a> (&'a self, offset: usize) -> impl Content<TuiOut> + 'a {
        Bsp::s(Tui::bold(true, "Help"), "FIXME")
        //Bsp::s(Tui::bold(true, "Help"), Bsp::s("", Map::south(1,
            //move||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 })
                //.skip(offset)
                //.take(20),
            //|mut b,i|Fixed::x(60, Align::w(Bsp::e("(", Bsp::e(
                //b.next().map(|t|Fixed::x(16, Align::w(Tui::fg(Rgb(64,224,0), format!("{}", t.value))))),
                //Bsp::e(" ", Align::w(format!("{}", b.0.0.trim()))))))))))
    }
    pub fn view_dialog_device (&self, index: usize) -> impl Content<TuiOut> + use<'_> {
        let choices = ||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))
    }
    pub fn view_dialog_message <'a> (&'a self, message: &'a Arc<str>)
        -> impl Content<TuiOut> + use<'a>
    {
        Bsp::s(message.as_ref(), Bsp::s("", "[ OK ]"))
    }
    pub fn view_dialog_browser <'a> (&'a self, target: &BrowserTarget, browser: &'a Browser) -> impl Content<TuiOut> + use<'a> {
        Bsp::s(
            Padding::xy(3, 1, Fill::x(Align::w(FieldV(
                Default::default(),
                match target {
                    BrowserTarget::SaveProject     => "Save project:",
                    BrowserTarget::LoadProject     => "Load project:",
                    BrowserTarget::ImportSample(_) => "Import sample:",
                    BrowserTarget::ExportSample(_) => "Export sample:",
                    BrowserTarget::ImportClip(_)   => "Import clip:",
                    BrowserTarget::ExportClip(_)   => "Export clip:",
                },
                Shrink::x(3, Fixed::y(1, Tui::fg(Tui::g(96), RepeatH("🭻")))))))),
            Outer(true, Style::default().fg(Tui::g(96)))
                .enclose(Fill::xy(browser)))
    }
    pub fn view_dialog_load <'a> (&'a self, browser: &'a Browser) -> impl Content<TuiOut> + use<'a> {
        Bsp::s(
            Fill::x(Align::w(Margin::xy(1, 1, Bsp::e(
                Tui::bold(true, " Load project: "),
                Shrink::x(3, Fixed::y(1, RepeatH("🭻"))))))),
            Outer(true, Style::default().fg(Tui::g(96)))
                .enclose(Fill::xy(browser)))
    }
    pub fn view_dialog_export <'a> (&'a self, browser: &'a Browser) -> impl Content<TuiOut> + use<'a> {
        Bsp::s(
            Fill::x(Align::w(Margin::xy(1, 1, Bsp::e(
                Tui::bold(true, " Export: "),
                Shrink::x(3, Fixed::y(1, RepeatH("🭻"))))))),
            Outer(true, Style::default().fg(Tui::g(96)))
                .enclose(Fill::xy(browser)))
    }
    pub fn view_dialog_import <'a> (&'a self, browser: &'a Browser) -> impl Content<TuiOut> + use<'a> {
        Bsp::s(
            Fill::x(Align::w(Margin::xy(1, 1, Bsp::e(
                Tui::bold(true, " Import: "),
                Shrink::x(3, Fixed::y(1, RepeatH("🭻"))))))),
            Outer(true, Style::default().fg(Tui::g(96)))
                .enclose(Fill::xy(browser)))
    }
    pub fn view_dialog_options <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
        "TODO"
    }
}
type MaybeClip = Option<Arc<RwLock<MidiClip>>>;
macro_rules! ns { ($C:ty, $s:expr, $a:expr, $W:expr) => { <$C>::try_from_expr($s, $a).map($W) } }
macro_rules! cmd { ($cmd:expr) => {{ $cmd; None }}; }
macro_rules! cmd_todo { ($msg:literal) => {{ println!($msg); None }}; }
handle!(TuiIn: |self: App, input|self.handle_tui_key_with_history(input));
#[tengri_proc::command(App)] impl AppCommand {
    fn toggle_editor (app: &mut App, value: bool) -> Perhaps<Self> {
        app.toggle_editor(Some(value));
        Ok(None)
    }
    fn editor (app: &mut App, command: MidiEditCommand) -> Perhaps<Self> {
        Ok(if let Some(editor) = app.editor_mut() {
            let undo = command.clone().delegate(editor, |command|AppCommand::Editor{command})?;
            // update linked sampler after editor action
            app.project.sampler_mut().map(|sampler|match command {
                // autoselect: automatically select sample in sampler
                MidiEditCommand::SetNotePos { pos } => { sampler.set_note_pos(pos); },
                _ => {}
            });
            undo
        } else {
            None
        })
    }
    fn dialog (app: &mut App, command: DialogCommand) -> Perhaps<Self> {
        panic!("dialog");
        Ok(command.delegate(&mut app.dialog, |command|Self::Dialog{command})?)
    }
    fn project (app: &mut App, command: ArrangementCommand) -> Perhaps<Self> {
        Ok(command.delegate(&mut app.project, |command|Self::Project{command})?)
    }
    fn clock (app: &mut App, command: ClockCommand) -> Perhaps<Self> {
        Ok(command.execute(app.clock_mut())?.map(|command|Self::Clock{command}))
    }
    fn sampler (app: &mut App, command: SamplerCommand) -> Perhaps<Self> {
        Ok(app.project.sampler_mut()
            .map(|s|command.delegate(s, |command|Self::Sampler{command}))
            .transpose()?
            .flatten())
    }
    fn pool (app: &mut App, command: PoolCommand) -> Perhaps<Self> {
        let undo = command.clone().delegate(&mut app.pool, |command|AppCommand::Pool{command})?;
        // update linked editor after pool action
        match command {
            // autoselect: automatically load selected clip in editor
            PoolCommand::Select { .. } |
            // autocolor: update color in all places simultaneously
            PoolCommand::Clip { command: PoolClipCommand::SetColor { .. } } => {
                let clip = app.pool.clip().clone();
                app.editor_mut().map(|editor|editor.set_clip(clip.as_ref()))
            },
            _ => None
        };
        Ok(undo)
    }
    fn enqueue (app: &mut App, clip: Option<Arc<RwLock<MidiClip>>>) -> Perhaps<Self> {
        todo!()
    }
    fn history (app: &mut App, delta: isize) -> Perhaps<Self> {
        todo!()
    }
    fn zoom (app: &mut App, zoom: usize) -> Perhaps<Self> {
        todo!()
    }
    fn select (app: &mut App, selection: Selection) -> Perhaps<Self> {
        *app.project.selection_mut() = selection;
        //todo!
        //if let Some(ref mut editor) = app.editor_mut() {
            //editor.set_clip(match selection {
                //Selection::TrackClip { track, scene } if let Some(Some(Some(clip))) = app
                    //.project
                    //.scenes.get(scene)
                    //.map(|s|s.clips.get(track))
                //=>
                    //Some(clip),
                //_ =>
                    //None
            //});
        //}
        Ok(None)
        //("select"  [t: usize, s: usize] Some(match (t.expect("no track"), s.expect("no scene")) {
            //(0, 0) => Self::Select(Selection::Mix),
            //(t, 0) => Self::Select(Selection::Track(t)),
            //(0, s) => Self::Select(Selection::Scene(s)),
            //(t, s) => Self::Select(Selection::TrackClip { track: t, scene: s }) })))
        // autoedit: load focused clip in editor.
    }
    fn stop_all (app: &mut App) -> Perhaps<Self> {
        app.tracks_stop_all();
        Ok(None)
    }
    //fn color (app: &mut App, theme: ItemTheme) -> Perhaps<Self> {
        //Ok(app.set_color(Some(theme)).map(|theme|Self::Color{theme}))
    //}
    //fn launch (app: &mut App) -> Perhaps<Self> {
        //app.project.launch();
        //Ok(None)
    //}
}

#[tengri_proc::command(Option<Dialog>)]
impl DialogCommand {
    fn open (dialog: &mut Option<Dialog>, new: Dialog) -> Perhaps<Self> {
        *dialog = Some(new);
        Ok(None)
    }
    fn close (dialog: &mut Option<Dialog>) -> Perhaps<Self> {
        *dialog = None;
        Ok(None)
    }
}
impl HasJack<'static> for App {
    fn jack (&self) -> &Jack<'static> {
        &self.jack
    }
}
audio!(
    |self: App, client, scope|{
        let t0 = self.perf.get_t0();
        self.clock().update_from_scope(scope).unwrap();
        let midi_in = self.project.midi_input_collect(scope);
        if let Some(editor) = &self.editor() {
            let mut pitch: Option<u7> = None;
            for port in midi_in.iter() {
                for event in port.iter() {
                    if let (_, Ok(LiveEvent::Midi {message: MidiMessage::NoteOn {ref key, ..}, ..}))
                        = event
                    {
                        pitch = Some(key.clone());
                    }
                }
            }
            if let Some(pitch) = pitch {
                editor.set_note_pos(pitch.as_int() as usize);
            }
        }
        let result = self.project.process_tracks(client, scope);
        self.perf.update_from_jack_scope(t0, scope);
        result
    };
    |self, event|{
        use JackEvent::*;
        match event {
            SampleRate(sr) => {
                self.clock().timebase.sr.set(sr as f64);
            },
            PortRegistration(id, true) => {
                //let port = self.jack().port_by_id(id);
                //println!("\rport add: {id} {port:?}");
                //println!("\rport add: {id}");
            },
            PortRegistration(id, false) => {
                /*println!("\rport del: {id}")*/
            },
            PortsConnected(a, b, true) => { /*println!("\rport conn: {a} {b}")*/ },
            PortsConnected(a, b, false) => { /*println!("\rport disc: {a} {b}")*/ },
            ClientRegistration(id, true) => {},
            ClientRegistration(id, false) => {},
            ThreadInit => {},
            XRun => {},
            GraphReorder => {},
            _ => { panic!("{event:?}"); }
        }
    }
);

///////////////////////////////////////////////////////////////////////////////////////////////////

//#[derive(Clone, Debug)]
//pub enum DialogCommand {
    //Open { dialog: Dialog },
    //Close
//}

//impl Command<Option<Dialog>> for DialogCommand {
    //fn execute (self, state: &mut Option<Dialog>) -> Perhaps<Self> {
        //match self {
            //Self::Open { dialog } => {
                //*state = Some(dialog);
            //},
            //Self::Close => {
                //*state = None;
            //}
        //};
        //Ok(None)
    //}
//}

//dsl!(DialogCommand: |self: Dialog, iter|todo!());
//Dsl::take(&mut self.dialog, iter));

//#[tengri_proc::command(Option<Dialog>)]//Nope.
//impl DialogCommand {
    //fn open (dialog: &mut Option<Dialog>, new: Dialog) -> Perhaps<Self> {
        //*dialog = Some(new);
        //Ok(None)
    //}
    //fn close (dialog: &mut Option<Dialog>) -> Perhaps<Self> {
        //*dialog = None;
        //Ok(None)
    //}
//}
//
///////////////////////////////////////////////////////////////////////////////////////////////////
//
    //pub fn view_meters_input (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.sampler().map(|s|
            //s.view_meters_input())
    //}
    //pub fn view_meters_output (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.sampler().map(|s|
            //s.view_meters_output())
    //}
    //pub fn view_history (&self) -> impl Content<TuiOut> {
        //Fixed::y(1, Fill::x(Align::w(FieldH(self.color,
            //format!("History ({})", self.history.len()),
                //self.history.last().map(|last|Fill::x(Align::w(format!("{:?}", last.0))))))))
    //}
    //pub fn view_status_h2 (&self) -> impl Content<TuiOut> {
        //self.update_clock();
        //let theme     = self.color;
        //let clock     = self.clock();
        //let playing   = clock.is_rolling();
        //let cache     = clock.view_cache.clone();
        ////let selection = self.selection().describe(self.tracks(), self.scenes());
        //let hist_len  = self.history.len();
        //let hist_last = self.history.last();
        //Fixed::y(2, Stack::east(move|add: &mut dyn FnMut(&dyn Render<TuiOut>)|{
            //add(&Fixed::x(5, Tui::bg(if playing { Rgb(0, 128, 0) } else { Rgb(128, 64, 0) },
                //Either::new(false, // TODO
                    //Thunk::new(move||Fixed::x(9, Either::new(playing,
                        //Tui::fg(Rgb(0, 255, 0),   " PLAYING "),
                        //Tui::fg(Rgb(255, 128, 0), " STOPPED ")))
                    //),
                    //Thunk::new(move||Fixed::x(5, Either::new(playing,
                        //Tui::fg(Rgb(0, 255, 0),   Bsp::s(" 🭍🭑🬽 ", " 🭞🭜🭘 ",)),
                        //Tui::fg(Rgb(255, 128, 0), Bsp::s(" ▗▄▖ ", " ▝▀▘ ",))))
                    //)
                //)
            //)));
            //add(&" ");
            //{
                //let cache = cache.read().unwrap();
                //add(&Fixed::x(15, Align::w(Bsp::s(
                    //FieldH(theme, "Beat", cache.beat.view.clone()),
                    //FieldH(theme, "Time", cache.time.view.clone()),
                //))));
                //add(&Fixed::x(13, Align::w(Bsp::s(
                    //Fill::x(Align::w(FieldH(theme, "BPM", cache.bpm.view.clone()))),
                    //Fill::x(Align::w(FieldH(theme, "SR ", cache.sr.view.clone()))),
                //))));
                //add(&Fixed::x(12, Align::w(Bsp::s(
                    //Fill::x(Align::w(FieldH(theme, "Buf", cache.buf.view.clone()))),
                    //Fill::x(Align::w(FieldH(theme, "Lat", cache.lat.view.clone()))),
                //))));
                ////add(&Bsp::s(
                    //////Fill::x(Align::w(FieldH(theme, "Selected", Align::w(selection)))),
                    ////Fill::x(Align::w(FieldH(theme, format!("History ({})", hist_len),
                        ////hist_last.map(|last|Fill::x(Align::w(format!("{:?}", last.0))))))),
                    ////""
                ////));
                //////if let Some(last) = self.history.last() {
                    //////add(&FieldV(theme, format!("History ({})", self.history.len()),
                        //////Fill::x(Align::w(format!("{:?}", last.0)))));
                //////}
            //}
        //}))
    //}
    //pub fn view_status_v (&self) -> impl Content<TuiOut> + use<'_> {
        //self.update_clock();
        //let cache   = self.project.clock.view_cache.read().unwrap();
        //let theme   = self.color;
        //let playing = self.clock().is_rolling();
        //Tui::bg(theme.darker.rgb, Fixed::xy(20, 5, Outer(true, Style::default().fg(Tui::g(96))).enclose(
            //col!(
                //Fill::x(Align::w(Bsp::e(
                    //Align::w(Tui::bg(if playing { Rgb(0, 128, 0) } else { Rgb(128, 64, 0) },
                        //Either::new(false, // TODO
                            //Thunk::new(move||Fixed::x(9, Either::new(playing,
                                //Tui::fg(Rgb(0, 255, 0),   " PLAYING "),
                                //Tui::fg(Rgb(255, 128, 0), " STOPPED ")))
                            //),
                            //Thunk::new(move||Fixed::x(5, Either::new(playing,
                                //Tui::fg(Rgb(0, 255, 0),   Bsp::s(" 🭍🭑🬽 ", " 🭞🭜🭘 ",)),
                                //Tui::fg(Rgb(255, 128, 0), Bsp::s(" ▗▄▖ ", " ▝▀▘ ",))))
                            //)
                        //)
                    //)),
                    //Bsp::s(
                        //FieldH(theme, "Beat", cache.beat.view.clone()),
                        //FieldH(theme, "Time", cache.time.view.clone()),
                    //),
                //))),
                //Fill::x(Align::w(FieldH(theme, "BPM", cache.bpm.view.clone()))),
                //Fill::x(Align::w(FieldH(theme, "SR ", cache.sr.view.clone()))),
                //Fill::x(Align::w(FieldH(theme, "Buf", Bsp::e(cache.buf.view.clone(), Bsp::e(" = ", cache.lat.view.clone()))))),
            //))))
    //}
    //pub fn view_status (&self) -> impl Content<TuiOut> + use<'_> {
        //self.update_clock();
        //let cache = self.project.clock.view_cache.read().unwrap();
        //view_status(Some(self.project.selection.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.project.clock.view_cache.read().unwrap();
        //view_transport(self.project.clock.is_rolling(),
            //cache.bpm.view.clone(), cache.beat.view.clone(), cache.time.view.clone())
    //}
    //pub fn view_editor (&self) -> impl Content<TuiOut> + use<'_> {
        //let bg = self.editor()
            //.and_then(|editor|editor.clip().clone())
            //.map(|clip|clip.read().unwrap().color.darker)
            //.unwrap_or(self.color.darker);
        //Fill::xy(Tui::bg(bg.rgb, self.editor()))
    //}
    //pub fn view_editor_status (&self) -> impl Content<TuiOut> + use<'_> {
        //self.editor().map(|e|Fixed::x(20, Outer(true, Style::default().fg(Tui::g(96))).enclose(
            //Fill::y(Align::n(Bsp::s(e.clip_status(), e.edit_status()))))))
    //}
    //pub fn view_midi_ins_status (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.view_midi_ins_status(self.color)
    //}
    //pub fn view_midi_outs_status (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.view_midi_outs_status(self.color)
    //}
    //pub fn view_audio_ins_status (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.view_audio_ins_status(self.color)
    //}
    //pub fn view_audio_outs_status (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.view_audio_outs_status(self.color)
    //}
    //pub fn view_scenes (&self) -> impl Content<TuiOut> + use<'_> {
        //Bsp::e(
            //Fixed::x(20, Align::nw(self.project.view_scenes_names())),
            //self.project.view_scenes_clips(),
        //)
    //}
    //pub fn view_scenes_names (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.view_scenes_names()
    //}
    //pub fn view_scenes_clips (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.view_scenes_clips()
    //}
    //pub fn view_tracks_inputs <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
        //Fixed::y(1 + self.project.midi_ins.len() as u16,
            //self.project.view_inputs(self.color))
    //}
    //pub fn view_tracks_outputs <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
        //self.project.view_outputs(self.color)
    //}
    //pub fn view_tracks_devices <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
        //Fixed::y(4, self.project.view_track_devices(self.color))
    //}
    //pub fn view_tracks_names <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
        //Fixed::y(2, self.project.view_track_names(self.color))
    //}
    //pub fn view_pool (&self) -> impl Content<TuiOut> + use<'_> {
        //Fixed::x(20, Bsp::s(
            //Fill::x(Align::w(FieldH(self.color, "Clip pool:", ""))),
            //Fill::y(Align::n(Tui::bg(Rgb(0, 0, 0), Outer(true, Style::default().fg(Tui::g(96)))
                //.enclose(PoolView(&self.pool)))))))
    //}
    //pub fn view_samples_keys (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.sampler().map(|s|s.view_list(true, self.editor().unwrap()))
    //}
    //pub fn view_samples_grid (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.sampler().map(|s|s.view_grid())
    //}
    //pub fn view_sample_viewer (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.sampler().map(|s|s.view_sample(self.editor().unwrap().get_note_pos()))
    //}
    //pub fn view_sample_info (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.sampler().map(|s|s.view_sample_info(self.editor().unwrap().get_note_pos()))
    //}
    //pub fn view_sample_status (&self) -> impl Content<TuiOut> + use<'_> {
        //self.project.sampler().map(|s|Outer(true, Style::default().fg(Tui::g(96))).enclose(
            //Fill::y(Align::n(s.view_sample_status(self.editor().unwrap().get_note_pos())))))
    //}
//}