use crate::*;

impl<'a> DslNs<'a, Arc<str>> for App {
    fn from_literal (&self, dsl: impl Dsl) -> Perhaps<Arc<str>> {
        Ok(dsl.src()?.map(|x|x.into()))
    }
}
impl<'a> DslNsWords<'a, Arc<str>> for App {}
impl<'a> DslNsExprs<'a, Arc<str>> for App {}

impl<'a> DslNs<'a, bool> for App {}
impl<'a> DslNsExprs<'a, bool> for App {}
impl<'a> DslNsWords<'a, bool> for App {
    dsl_words!('a |app| -> bool {
        ":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),
    });
}

impl<'a> DslNs<'a, ItemTheme> for App {}
impl<'a> DslNsWords<'a, ItemTheme> for App {}
impl<'a> DslNsExprs<'a, ItemTheme> for App {}

impl<'a> DslNs<'a, Dialog> for App {}
impl<'a> DslNsExprs<'a, Dialog> for App {}
impl<'a> DslNsWords<'a, Dialog> for App {
    dsl_words!('a |app| -> Dialog {
        ":dialog/none"          => Dialog::None,
        ":dialog/options"       => Dialog::Options,
        ":dialog/device"        => Dialog::Device(0),
        ":dialog/device/prev"   => Dialog::Device(0),
        ":dialog/device/next"   => Dialog::Device(0),
        ":dialog/help"          => Dialog::Help(0),
        ":dialog/save"          => Dialog::Browse(BrowseTarget::SaveProject,
            Browse::new(None).unwrap().into()),
        ":dialog/load"          => Dialog::Browse(BrowseTarget::LoadProject,
            Browse::new(None).unwrap().into()),
        ":dialog/import/clip"   => Dialog::Browse(BrowseTarget::ImportClip(Default::default()),
            Browse::new(None).unwrap().into()),
        ":dialog/export/clip"   => Dialog::Browse(BrowseTarget::ExportClip(Default::default()),
            Browse::new(None).unwrap().into()),
        ":dialog/import/sample" => Dialog::Browse(BrowseTarget::ImportSample(Default::default()),
            Browse::new(None).unwrap().into()),
        ":dialog/export/sample" => Dialog::Browse(BrowseTarget::ExportSample(Default::default()),
            Browse::new(None).unwrap().into()),
    });
}

impl<'a> DslNs<'a, Selection> for App {}
impl<'a> DslNsExprs<'a, Selection> for App {}
impl<'a> DslNsWords<'a, Selection> for App {
    dsl_words!('a |app| -> Selection {
        ":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(),
    });
}

impl<'a> DslNs<'a, Color> for App {}
impl<'a> DslNsWords<'a, Color> for App {
    dsl_words!('a |app| -> Color {
        ":color/bg" => Color::Rgb(28, 32, 36),
    });
}
impl<'a> DslNsExprs<'a, Color> for App {
    dsl_exprs!('a |app| -> Color {
        "g" (n: u8) => Color::Rgb(n, n, n),
        "rgb" (r: u8, g: u8, b: u8) => Color::Rgb(r, g, b),
    });
}

impl<'a> DslNs<'a, Option<u7>> for App {}
impl<'a> DslNsExprs<'a, Option<u7>> for App {}
impl<'a> DslNsWords<'a, Option<u7>> for App {
    dsl_words!('a |app| -> Option<u7> {
        ":editor/pitch" => Some(
            (app.editor().as_ref().map(|e|e.get_note_pos()).unwrap() as u8).into()
        )
    });
}

impl<'a> DslNs<'a, Option<usize>> for App {}
impl<'a> DslNsExprs<'a, Option<usize>> for App {}
impl<'a> DslNsWords<'a, Option<usize>> for App {
    dsl_words!('a |app| -> Option<usize> {
        ":selected/scene" => app.selection().scene(),
        ":selected/track" => app.selection().track(),
    });
}

impl<'a> DslNs<'a, Option<Arc<RwLock<MidiClip>>>> for App {}
impl<'a> DslNsExprs<'a, Option<Arc<RwLock<MidiClip>>>> for App {}
impl<'a> DslNsWords<'a, Option<Arc<RwLock<MidiClip>>>> for App {
    dsl_words!('a |app| -> Option<Arc<RwLock<MidiClip>>> {
        ":selected/clip" => if let Selection::TrackClip { track, scene } = app.selection() {
            app.scenes()[*scene].clips[*track].clone()
        } else {
            None
        }
    });
}

impl<'a> DslNs<'a, u8> for App {
    fn from_literal (&self, dsl: impl Dsl) -> Perhaps<u8> {
        Ok(if let Some(src) = dsl.src()? {
            Some(to_number(src)? as u8)
        } else {
            None
        })
    }
}
impl<'a> DslNsWords<'a, u8> for App {}
impl<'a> DslNsExprs<'a, u8> for App {}

impl<'a> DslNs<'a, u16> for App {
    fn from_literal (&self, dsl: impl Dsl) -> Perhaps<u16> {
        Ok(if let Some(src) = dsl.src()? {
            Some(to_number(src)? as u16)
        } else {
            None
        })
    }
}
impl<'a> DslNsWords<'a, u16> for App {
    dsl_words!('a |app| -> u16 {
        ":w/sidebar"       => app.project.w_sidebar(app.editor().is_some()),
        ":h/sample-detail" => 6.max(app.height() as u16 * 3 / 9),
    });
}
impl<'a> DslNsExprs<'a, u16> for App {}

impl<'a> DslNs<'a, usize> for App {
    fn from_literal (&self, dsl: impl Dsl) -> Perhaps<usize> {
        Ok(if let Some(src) = dsl.src()? {
            Some(to_number(src)? as usize)
        } else {
            None
        })
    }
}
impl<'a> DslNsWords<'a, usize> for App {
    dsl_words!('a |app| -> usize {
        ":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),
    });
}
impl<'a> DslNsExprs<'a, usize> for App {}

impl<'a> DslNs<'a, isize> for App {
    fn from_literal (&self, dsl: impl Dsl) -> Perhaps<isize> {
        Ok(if let Some(src) = dsl.src()? {
            Some(to_number(src)? as isize)
        } else {
            None
        })
    }
}
impl<'a> DslNsWords<'a, isize> for App {}
impl<'a> DslNsExprs<'a, isize> for App {}