use crate::*;
pub mod audio;  #[allow(unused)] pub use self::audio::*;
pub mod bind;   pub use self::bind::*;
pub mod cli;    pub use self::cli::*;
pub mod config; pub use self::config::*;
pub mod draw;   pub use self::draw::*;
pub mod size;   pub use self::size::*;

/// Total application state.
///
/// ```
/// use tek::{HasTracks, HasScenes, TracksView, ScenesView};
/// let mut app = tek::App::default();
/// let _ = app.scene_add(None, None).unwrap();
/// let _ = app.update_clock();
/// app.project.editor = Some(Default::default());
/// //let _: Vec<_> = app.project.inputs_with_sizes().collect();
/// //let _: Vec<_> = app.project.outputs_with_sizes().collect();
/// let _: Vec<_> = app.project.tracks_with_sizes().collect();
/// //let _: Vec<_> = app.project.scenes_with_sizes(true, 10, 10).collect();
/// //let _: Vec<_> = app.scenes_with_colors(true, 10).collect();
/// //let _: Vec<_> = app.scenes_with_track_colors(true, 10, 10).collect();
/// let _ = app.project.w();
/// //let _ = app.project.w_sidebar();
/// //let _ = app.project.w_tracks_area();
/// let _ = app.project.h();
/// //let _ = app.project.h_tracks_area();
/// //let _ = app.project.h_inputs();
/// //let _ = app.project.h_outputs();
/// let _ = app.project.h_scenes();
/// ```
#[derive(Default, Debug)] pub struct App {
    /// Base color.
    pub color:   ItemTheme,
    /// Must not be dropped for the duration of the process
    pub jack:    Jack<'static>,
    /// Display size
    pub size:    Sizer,
    /// Performance counter
    pub perf:    PerfModel,
    /// Available view modes and input bindings
    pub config:  Config,
    /// Currently selected mode
    pub mode:    Arc<Mode<Arc<str>>>,
    /// Undo history
    pub history: Vec<(AppCommand, Option<AppCommand>)>,
    /// Dialog overlay
    pub dialog:  Dialog,
    /// Contains all recently created clips.
    pub pool:    Pool,
    /// Contains the currently edited musical arrangement
    pub project: Arrangement,
    /// Error, if any
    pub error:   Arc<RwLock<Option<Arc<str>>>>
}

impl App {

    /// Create a new application instance from a backend, project, config, and mode
    ///
    /// ```
    /// let jack = tek::tengri::Jack::new(&"test_tek").expect("failed to connect to jack");
    /// let proj = tek::Arrangement::default();
    /// let mut conf = tek::Config::default();
    /// conf.add("(mode hello)");
    /// let tek = tek::App::new(&jack, proj, conf, "hello");
    /// ```
    pub fn new (
        jack: &Jack<'static>, project: Arrangement, config: Config, mode: impl AsRef<str>
    ) -> Self {
        let mode: &str = mode.as_ref();
        App {
            color:  ItemTheme::random(),
            dialog: Dialog::welcome(),
            jack:   jack.clone(),
            mode:   config.get_mode(mode).expect(&format!("failed to find mode '{mode}'")),
            config,
            project,
            ..Default::default()
        }
    }

    pub fn confirm (&mut self) -> Perhaps<AppCommand> {
        Ok(match &self.dialog {
            Dialog::Menu(index, items) => {
                let callback = items.0[*index].1.clone();
                callback(self)?;
                None
            },
            _ => todo!(),
        })
    }

    pub fn inc (&mut self, axis: &ControlAxis) -> Perhaps<AppCommand> {
        Ok(match (&self.dialog, axis) {
            (Dialog::None, _) => todo!(),
            (Dialog::Menu(_, _), ControlAxis::Y) =>
                AppCommand::SetDialog { dialog: self.dialog.menu_next() }.act(self)?,
            _ => todo!()
        })
    }

    pub fn dec (&mut self, axis: &ControlAxis) -> Perhaps<AppCommand> {
        Ok(match (&self.dialog, axis) {
            (Dialog::None, _) => None,
            (Dialog::Menu(_, _), ControlAxis::Y) =>
                AppCommand::SetDialog { dialog: self.dialog.menu_prev() }.act(self)?,
            _ => todo!()
        })
    }

    /// Update memoized render of clock values.
    /// ```
    /// tek::App::default().update_clock();
    /// ```
    pub fn update_clock (&self) {
        ClockView::update_clock(&self.project.clock.view_cache, self.clock(), self.size.w() > 80)
    }

    /// Set modal dialog.
    ///
    /// ```
    /// let previous: tek::Dialog = tek::App::default().set_dialog(tek::Dialog::welcome());
    /// ```
    pub fn set_dialog (&mut self, mut dialog: Dialog) -> Dialog {
        std::mem::swap(&mut self.dialog, &mut dialog);
        dialog
    }

    /// FIXME: generalize. Set picked device in device pick dialog.
    ///
    /// ```
    /// tek::App::default().device_pick(0);
    /// ```
    pub fn device_pick (&mut self, index: usize) {
        self.dialog = Dialog::Device(index);
    }

    /// FIXME: generalize. Add device to current track.
    pub fn add_device (&mut self, index: usize) -> Usually<()> {
        match index {
            0 => {
                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 = Dialog::None;
                    Device::Sampler(sampler)
                } else {
                    self.dialog = 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(())
            },
            1 => {
                todo!();
                //Ok(())
            },
            _ => unreachable!(),
        }
    }

    /// Return reference to content browser if open.
    ///
    /// ```
    /// assert_eq!(tek::App::default().browser(), None);
    /// ```
    pub fn browser (&self) -> Option<&Browse> {
        if let Dialog::Browse(_, ref b) = self.dialog { Some(b) } else { None }
    }

    /// Is a MIDI editor currently focused?
    ///
    /// ```
    /// tek::App::default().editor_focused();
    /// ```
    pub fn editor_focused (&self) -> bool {
        false
    }

    /// Toggle MIDI editor.
    ///
    /// ```
    /// tek::App::default().toggle_editor(None);
    /// ```
    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 {
            // Create new clip in pool when entering empty cell
            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, 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(editor) = &mut self.project.editor {
                    editor.set_clip(Some(&clip));
                }
                *slot = Some(clip.clone());
                //Some(clip)
            } else {
                //None
            }
        } else 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()
        {
            // Remove clip from arrangement when exiting empty clip editor
            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());
            }
        }
    }
}

impl_has!(Clock:             |self: App|self.project.clock);
impl_has!(Vec<MidiInput>:    |self: App|self.project.midi_ins);
impl_has!(Vec<MidiOutput>:   |self: App|self.project.midi_outs);
impl_has!(Dialog:            |self: App|self.dialog);
impl_has!(Jack<'static>:     |self: App|self.jack);
impl_has!(Pool:              |self: App|self.pool);
impl_has!(Selection:         |self: App|self.project.selection);
impl_as_ref!(Vec<Scene>:     |self: App|self.project.as_ref());
impl_as_mut!(Vec<Scene>:     |self: App|self.project.as_mut());
impl_as_ref_opt!(MidiEditor: |self: App|self.project.as_ref_opt());
impl_as_mut_opt!(MidiEditor: |self: App|self.project.as_mut_opt());
impl_has_clips!(             |self: App|self.pool.clips);

primitive!(u8:    try_to_u8);
primitive!(u16:   try_to_u16);
primitive!(usize: try_to_usize);
primitive!(isize: try_to_isize);

namespace!(App: Arc<str> { literal = |dsl|Ok(dsl.src()?.map(|x|x.into())); });

namespace!(App: u8       { literal = |dsl|try_to_u8(dsl); });

namespace!(App: u16      { literal = |dsl|try_to_u16(dsl); symbol = |app| {
    ":w/sidebar"        => app.project.w_sidebar(app.editor().is_some()),
    ":h/sample-detail"  => 6.max(app.size.h() as u16 * 3 / 9), }; });

namespace!(App: isize    { literal = |dsl|try_to_isize(dsl); });

namespace!(App: usize    { literal = |dsl|try_to_usize(dsl); symbol = |app| {
    ":scene-count"      => app.scenes().len(),
    ":track-count"      => app.tracks().len(),
    ":device-kind"      => app.dialog.device_kind().unwrap_or(0),
    ":device-kind/next" => app.dialog.device_kind_next().unwrap_or(0),
    ":device-kind/prev" => app.dialog.device_kind_prev().unwrap_or(0), }; });

namespace!(App: bool { symbol = |app| { // Provide boolean values.
    ":mode/editor"         => app.project.editor.is_some(),
    ":focused/dialog"      => !matches!(app.dialog, Dialog::None),
    ":focused/message"     => matches!(app.dialog, Dialog::Message(..)),
    ":focused/add_device"  => matches!(app.dialog, Dialog::Device(..)),
    ":focused/browser"     => app.dialog.browser().is_some(),
    ":focused/pool/import" => matches!(app.pool.mode, Some(PoolMode::Import(..))),
    ":focused/pool/export" => matches!(app.pool.mode, Some(PoolMode::Export(..))),
    ":focused/pool/rename" => matches!(app.pool.mode, Some(PoolMode::Rename(..))),
    ":focused/pool/length" => matches!(app.pool.mode, Some(PoolMode::Length(..))),
    ":focused/clip"        => !app.editor_focused() && matches!(app.selection(), Selection::TrackClip{..}),
    ":focused/track"       => !app.editor_focused() && matches!(app.selection(), Selection::Track(..)),
    ":focused/scene"       => !app.editor_focused() && matches!(app.selection(), Selection::Scene(..)),
    ":focused/mix"         => !app.editor_focused() && matches!(app.selection(), Selection::Mix),
}; });

namespace!(App: ItemTheme {}); // TODO: provide colors here
                               //
namespace!(App: Selection { symbol = |app| {
    ":select/scene"      => app.selection().select_scene(app.tracks().len()),
    ":select/scene/next" => app.selection().select_scene_next(app.scenes().len()),
    ":select/scene/prev" => app.selection().select_scene_prev(),
    ":select/track"      => app.selection().select_track(app.tracks().len()),
    ":select/track/next" => app.selection().select_track_next(app.tracks().len()),
    ":select/track/prev" => app.selection().select_track_prev(),
}; });

namespace!(App: Color {
    symbol     = |app| {
        ":color/bg" => Color::Rgb(28, 32, 36),
    };
    expression = |app| {
        "g"   (n: u8) => Color::Rgb(n, n, n),
        "rgb" (r: u8, g: u8, b: u8) => Color::Rgb(r, g, b),
    };
});

namespace!(App: Option<u7> { symbol = |app| {
    ":editor/pitch" => Some((app.editor().as_ref().map(|e|e.get_note_pos()).unwrap() as u8).into())
}; });

namespace!(App: Option<u16> { symbol = |app| {}; });

namespace!(App: Option<usize> { symbol = |app| {
    ":selected/scene" => app.selection().scene(),
    ":selected/track" => app.selection().track(),
}; });

namespace!(App: Option<Arc<RwLock<MidiClip>>> { symbol = |app| {
    ":selected/clip" => if let Selection::TrackClip { track, scene } = app.selection() {
        app.scenes()[*scene].clips[*track].clone()
    } else {
        None
    }
}; });

pub fn swap_value <T: Clone + PartialEq, U> (
    target: &mut T, value: &T, returned: impl Fn(T)->U
) -> Perhaps<U> {
    if *target == *value {
        Ok(None)
    } else {
        let mut value = value.clone();
        std::mem::swap(target, &mut value);
        Ok(Some(returned(value)))
    }
}

pub fn toggle_bool <U> (
    target: &mut bool, value: &Option<bool>, returned: impl Fn(Option<bool>)->U
) -> Perhaps<U> {
    let mut value = value.unwrap_or(!*target);
    if value == *target {
        Ok(None)
    } else {
        std::mem::swap(target, &mut value);
        Ok(Some(returned(Some(value))))
    }
}

pub fn scan (dir: &PathBuf) -> Usually<(Vec<OsString>, Vec<OsString>)> {
    let (mut subdirs, mut files) = std::fs::read_dir(dir)?
        .fold((vec!["..".into()], vec![]), |(mut subdirs, mut files), entry|{
            let entry = entry.expect("failed to read drectory entry");
            let meta = entry.metadata().expect("failed to read entry metadata");
            if meta.is_file() {
                files.push(entry.file_name());
            } else if meta.is_dir() {
                subdirs.push(entry.file_name());
            }
            (subdirs, files)
        });
    subdirs.sort();
    files.sort();
    Ok((subdirs, files))
}