// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {
    fidl_fuchsia_bluetooth_avrcp::AvcPanelCommand,
    rustyline::{
        completion::Completer, error::ReadlineError, highlight::Highlighter, hint::Hinter, Helper,
    },
    std::{
        borrow::Cow::{self, Borrowed, Owned},
        fmt,
        str::FromStr,
    },
};

macro_rules! gen_avc_commands {
($name:ident {
    $($variant:ident = ($long:expr, $short:expr)),*,
}) => {

        static AVC_COMMAND_LONG_VARIANTS: &[&str] = &[$($long,)*];
        static AVC_COMMAND_SHORT_VARIANTS: &[&str] = &[$($short,)*];

        pub fn avc_match_string(s: &str) -> Option<AvcPanelCommand> {
            let lc = s.to_lowercase();
            match lc.as_str() {
                $($short => return Some(AvcPanelCommand::$variant)),*,
                _ => {}
            }
            match lc.as_str() {
                $($long => Some(AvcPanelCommand::$variant)),*,
                _ => None
            }
        }
    }
}

/// Macro to generate a command enum and its impl.
macro_rules! gen_commands {
    ($name:ident {
        $($variant:ident = ($val:expr, [$($arg:expr),*], $help:expr)),*,
    }) => {
        /// Enum of all possible commands
        #[derive(PartialEq)]
        pub enum $name {
            $($variant),*
        }

        impl $name {
            /// Returns a list of the string representations of all variants
            pub fn variants() -> Vec<String> {
                let mut variants = Vec::new();
                $(variants.push($val.to_string());)*
                variants
            }

            pub fn arguments(&self) -> &'static str {
                match self {
                    $(
                        $name::$variant => concat!($("<", $arg, "> ",)*)
                    ),*
                }
            }

            /// Help string for a given variant. The format is "command <arg>.. -- help message"
            pub fn cmd_help(&self) -> &'static str {
                match self {
                    $(
                        $name::$variant => concat!($val, " ", $("<", $arg, "> ",)* "-- ", $help)
                    ),*
                }
            }

            /// Multiline help string for `$name` including usage of all variants.
            pub fn help_msg() -> String {
                let command_help = concat!($(
                    "\t", $val, " ", $("<", $arg, "> ",)* "-- ", $help, "\n"
                ),*);

                format!("Commands:\n{}\nAVC keys:\n\tkey {}\n", command_help, AVC_COMMAND_LONG_VARIANTS.join("\n\tkey "))
            }

        }

        impl fmt::Display for $name {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                match *self {
                    $($name::$variant => write!(f, $val)),* ,
                }
            }
        }

        impl FromStr for $name {
            type Err = ();

            fn from_str(s: &str) -> Result<$name, ()> {
                match s {
                    $($val => Ok($name::$variant)),* ,
                    _ => Err(()),
                }
            }
        }

    }
}

gen_avc_commands! {
    AvcCommand {
        Select = ("select", "sel"),
        Up = ("up", "up"),
        Down = ("down", "do"),
        Left = ("left", "le"),
        Right = ("right", "ri"),
        RootMenu = ("rootmenu", "rm"),
        ContentsMenu = ("contentsmenu", "cm"),
        FavoriteMenu = ("favoritemenu", "fm"),
        Exit = ("exit", "ex"),
        OnDemandMenu = ("ondemandmenu", "om"),
        AppsMenu = ("appsmenu", "am"),
        Key0 = ("key0", "0"),
        Key1 = ("key1", "1"),
        Key2 = ("key2", "2"),
        Key3 = ("key3", "3"),
        Key4 = ("key4", "4"),
        Key5 = ("key5", "5"),
        Key6 = ("key6", "6"),
        Key7 = ("key7", "7"),
        Key8 = ("key8", "8"),
        Key9 = ("key9", "9"),
        Dot = ("dot", "."),
        Enter = ("enter", "en"),
        ChannelUp = ("channelup", "cu"),
        ChannelDown = ("channeldown", "cd"),
        ChannelPrevious = ("channelprevious", "cp"),
        InputSelect = ("inputselect", "ip"),
        Info = ("info", "in"),
        Help = ("help", "he"),
        PageUp = ("pageup", "pu"),
        PageDown = ("pagedown", "pd"),
        Lock = ("lock", "lo"),
        Power = ("power", "po"),
        VolumeUp = ("volumeup", "vu"),
        VolumeDown = ("volumedown", "vd"),
        Mute = ("mute", "m"),
        Play = ("play", "pl"),
        Stop = ("stop", "s"),
        Pause = ("pause", "pa"),
        Record = ("record", "rec"),
        Rewind = ("rewind", "rew"),
        FastForward = ("fastforward", "ff"),
        Eject = ("eject", "ej"),
        Forward = ("forward", "fw"),
        Backward = ("backward", "bw"),
        List = ("list", "l"),
        F1 = ("f1","f1"),
        F2 = ("f2","f2"),
        F3 = ("f3","f3"),
        F4 = ("f4","f4"),
        F5 = ("f5","f5"),
        F6 = ("f6","f6"),
        F7 = ("f7","f7"),
        F8 = ("f8","f8"),
        F9 = ("f9","f9"),
        Red = ("red", "re"),
        Green = ("green", "gr"),
        Blue = ("blue", "bl"),
        Yellow = ("yellow", "ye"),
    }
}

// `Cmd` is the declarative specification of all commands that bt-cli accepts.
gen_commands! {
    Cmd {
        AvcCommand = ("key", ["command"], "send an AVC passthrough keypress event"),
        GetMediaAttributes = ("get-media", [], "gets currently playing media attributes"),
        GetPlayStatus = ("get-play-status", [], "gets the status of the currently playing media at the TG"),
        GetPlayerApplicationSettings = ("get-player-application-settings",
            ["Optional: id1 id2 ..."],
            "Gets currently set attribute values if ids are specified. Otherwise, all possible attribute values on the TG."),
        SetPlayerApplicationSettings = ("set-player-application-settings", [],
            "Sets player application settings with a default Equalizer=Off setting."),
        SupportedEvents = ("get-supported-events", [], "gets the supported events of the target"),
        SendRawVendorCommand = ("send-raw-vendor-command", ["pdu_id", "payload"], "send a raw vendor AVC command"),
        SetVolume =  ("set-volume", ["volume"], "send a set absolute volume command (0-127)"),
        IsConnected = ("connection-status", [], "checks if the current device is current connected"),
        Help = ("help", [], "This message"),
        Exit = ("exit", [], "Close REPL"),
        Quit = ("quit", [], "Close REPL"),
    }
}

/// CmdHelper provides completion, hints, and highlighting for bt-cli
pub struct CmdHelper {}

impl CmdHelper {
    pub fn new() -> CmdHelper {
        CmdHelper {}
    }
}

impl Completer for CmdHelper {
    type Candidate = String;

    fn complete(&self, line: &str, _pos: usize) -> Result<(usize, Vec<String>), ReadlineError> {
        let components: Vec<_> = line.trim_start().split_whitespace().collect();

        // Check whether we have entered a command and either whitespace or a partial argument.
        // If yes, complete arguments; if no, complete commands
        let mut variants = Vec::new();
        // Check whether we have entered a command and either whitespace or a partial argument.
        // If yes, complete arguments; if no, complete commands
        let should_complete_arguments = (components.len() == 1 && line.ends_with(" "))
            || (components.len() == 2 && !line.ends_with(" "));
        if should_complete_arguments {
            let command = components[0].trim();
            let partial_argument = components.get(1).unwrap_or(&"");
            let mut candidates = vec![];
            if command == "key" {
                // connect and device have 'id|addr' arguments
                // can match against peer identifier or address
                for key in AVC_COMMAND_LONG_VARIANTS {
                    if key.starts_with(partial_argument) {
                        candidates.push(format!("{} {}", command, key));
                    }
                }
                for key in AVC_COMMAND_SHORT_VARIANTS {
                    if key.starts_with(partial_argument) {
                        candidates.push(format!("{} {}", command, key));
                    }
                }
            }
            Ok((0, candidates))
        } else {
            for variant in Cmd::variants() {
                if variant.starts_with(line) {
                    variants.push(variant)
                }
            }
            Ok((0, variants))
        }
    }
}

impl Hinter for CmdHelper {
    /// CmdHelper provides hints for commands with arguments
    fn hint(&self, line: &str, _pos: usize) -> Option<String> {
        let needs_space = !line.ends_with(" ");
        line.trim()
            .parse::<Cmd>()
            .map(|cmd| {
                format!("{}{}", if needs_space { " " } else { "" }, cmd.arguments().to_string(),)
            })
            .ok()
    }
}

impl Highlighter for CmdHelper {
    /// CmdHelper provides highlights for commands with hints
    fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
        if hint.trim().is_empty() {
            Borrowed(hint)
        } else {
            Owned(format!("\x1b[90m{}\x1b[0m", hint))
        }
    }
}

/// CmdHelper can be used as an `Editor` helper for entering input commands
impl Helper for CmdHelper {}

/// Represents either continuation or breaking out of a read-evaluate-print loop.
pub enum ReplControl {
    Break,
    Continue,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_avc_match_string() {
        assert_eq!(Some(AvcPanelCommand::Up), avc_match_string("up"));
        assert_eq!(Some(AvcPanelCommand::Up), avc_match_string("UP"));
        assert_eq!(None, avc_match_string("UPS"));
        assert_eq!(Some(AvcPanelCommand::Play), avc_match_string("play"));
        assert_eq!(Some(AvcPanelCommand::Play), avc_match_string("pl"));
        assert_eq!(None, avc_match_string("p"));
        assert_eq!(None, avc_match_string(""));
        assert_eq!(None, avc_match_string("12"));
        assert_eq!(Some(AvcPanelCommand::Dot), avc_match_string("."));
        assert_eq!(Some(AvcPanelCommand::ChannelUp), avc_match_string("channelup"));
    }

    #[test]
    fn test_completer() {
        let cmdhelper = CmdHelper::new();
        assert!(cmdhelper.complete("ke", 0).unwrap().1.contains(&"key".to_string()));
        assert!(cmdhelper.complete("get", 0).unwrap().1.contains(&"get-media".to_string()));
        assert!(cmdhelper.complete("key ex", 0).unwrap().1.contains(&"key exit".to_string()));
        assert!(cmdhelper
            .complete("conne", 0)
            .unwrap()
            .1
            .contains(&"connection-status".to_string()));
        assert!(cmdhelper
            .complete("send-ra", 0)
            .unwrap()
            .1
            .contains(&"send-raw-vendor-command".to_string()));
        assert!(cmdhelper
            .complete("get-s", 0)
            .unwrap()
            .1
            .contains(&"get-supported-events".to_string()));
        assert!(cmdhelper
            .complete("get-play-", 0)
            .unwrap()
            .1
            .contains(&"get-play-status".to_string()));
        assert!(cmdhelper
            .complete("get-playe", 0)
            .unwrap()
            .1
            .contains(&"get-player-application-settings".to_string()));
        assert!(cmdhelper
            .complete("set", 0)
            .unwrap()
            .1
            .contains(&"set-player-application-settings".to_string()));
        assert!(cmdhelper.complete("set-v", 0).unwrap().1.contains(&"set-volume".to_string()));
    }
}