switchbot_cli/

cli.rs

use std::{io::stdout, iter::zip};

use itertools::Itertools;
use switchbot_api::{CommandRequest, Device, DeviceList, SwitchBot};

use crate::{Args, UserInput};

#[derive(Debug, Default)]
pub struct Cli {
    args: Args,
    switch_bot: SwitchBot,
    current_device_indexes: Vec<usize>,
}

impl Cli {
    pub fn new_from_args() -> Self {
        Self {
            args: Args::new_from_args(),
            ..Default::default()
        }
    }

    #[cfg(test)]
    fn new_for_test(n_devices: usize) -> Self {
        Self {
            switch_bot: SwitchBot::new_for_test(n_devices),
            ..Default::default()
        }
    }

    fn devices(&self) -> &DeviceList {
        self.switch_bot.devices()
    }

    fn has_current_device(&self) -> bool {
        !self.current_device_indexes.is_empty()
    }

    fn current_devices_as<'a, T, F>(&'a self, f: F) -> impl Iterator<Item = T> + 'a
    where
        F: Fn(usize) -> T + 'a,
    {
        self.current_device_indexes
            .iter()
            .map(move |&index| f(index))
    }

    fn current_devices(&self) -> impl Iterator<Item = &Device> {
        self.current_devices_as(|index| &self.devices()[index])
    }

    fn current_devices_with_index(&self) -> impl Iterator<Item = (usize, &Device)> {
        self.current_devices_as(|index| (index, &self.devices()[index]))
    }

    fn first_current_device(&self) -> &Device {
        &self.devices()[self.current_device_indexes[0]]
    }

    pub async fn run(&mut self) -> anyhow::Result<()> {
        self.run_core().await?;
        self.args.save()?;
        Ok(())
    }

    async fn run_core(&mut self) -> anyhow::Result<()> {
        if !self.args.alias_updates.is_empty() {
            self.args.print_aliases();
            if self.args.commands.is_empty() {
                return Ok(());
            }
        }

        self.switch_bot = self.args.create_switch_bot()?;
        self.switch_bot.load_devices().await?;

        if !self.args.commands.is_empty() {
            self.execute_args(&self.args.commands.clone()).await?;
            return Ok(());
        }

        self.run_interactive().await?;
        Ok(())
    }

    async fn run_interactive(&mut self) -> anyhow::Result<()> {
        let mut input = UserInput::new();
        self.print_devices();
        loop {
            input.set_prompt(if self.has_current_device() {
                "Command> "
            } else {
                "Device> "
            });

            let input_text = input.read_line()?;
            match input_text {
                "q" => break,
                "" => {
                    if self.has_current_device() {
                        self.current_device_indexes.clear();
                        self.print_devices();
                        continue;
                    }
                    break;
                }
                _ => match self.execute(input_text).await {
                    Ok(true) => self.print_devices(),
                    Ok(false) => {}
                    Err(error) => log::error!("{error}"),
                },
            }
        }
        Ok(())
    }

    fn print_devices(&self) {
        if !self.has_current_device() {
            for (i, device) in self.devices().iter().enumerate() {
                println!("{}: {device}", i + 1);
            }
            return;
        }

        if self.current_device_indexes.len() >= 2 {
            for (i, device) in self.current_devices_with_index() {
                println!("{}: {device}", i + 1);
            }
            return;
        }

        let device = self.first_current_device();
        print!("{device:#}");
    }

    async fn execute_args(&mut self, list: &[String]) -> anyhow::Result<()> {
        for command in list {
            self.execute(command).await?;
        }
        Ok(())
    }

    async fn execute(&mut self, text: &str) -> anyhow::Result<bool> {
        if let Some(alias) = self.args.aliases.get(text) {
            log::debug!(r#"alias: "{text}" -> "{alias}""#);
            return self.execute_no_alias(&alias.clone()).await;
        }
        self.execute_no_alias(text).await
    }

    async fn execute_no_alias(&mut self, text: &str) -> anyhow::Result<bool> {
        let set_device_result = self.set_current_devices(text);
        if set_device_result.is_ok() {
            return Ok(true);
        }
        if self.has_current_device() {
            if text == "status" {
                self.update_status("").await?;
                return Ok(false);
            }
            if let Some(key) = text.strip_prefix("status.") {
                self.update_status(key).await?;
                return Ok(false);
            }
            if self.execute_if_expr(text).await? {
                return Ok(false);
            }
            self.execute_command(text).await?;
            return Ok(false);
        }
        Err(set_device_result.unwrap_err())
    }

    fn set_current_devices(&mut self, text: &str) -> anyhow::Result<()> {
        self.current_device_indexes = self.parse_device_indexes(text)?;
        log::debug!("current_device_indexes={:?}", self.current_device_indexes);
        Ok(())
    }

    fn parse_device_indexes(&self, value: &str) -> anyhow::Result<Vec<usize>> {
        let values = value.split(',');
        let mut indexes: Vec<usize> = Vec::new();
        for s in values {
            if let Some(alias) = self.args.aliases.get(s) {
                indexes.extend(self.parse_device_indexes(alias)?);
                continue;
            }
            indexes.push(self.parse_device_index(s)?);
        }
        indexes = indexes.into_iter().unique().collect::<Vec<_>>();
        Ok(indexes)
    }

    fn parse_device_index(&self, value: &str) -> anyhow::Result<usize> {
        if let Ok(number) = value.parse::<usize>() {
            if number > 0 && number <= self.devices().len() {
                return Ok(number - 1);
            }
        }
        self.devices()
            .index_by_device_id(value)
            .ok_or_else(|| anyhow::anyhow!("Not a valid device: \"{value}\""))
    }

    async fn execute_if_expr(&mut self, expr: &str) -> anyhow::Result<bool> {
        if let Some((condition, then_command, else_command)) = Self::parse_if_expr(expr) {
            let device = self.first_current_device();
            device.update_status().await?;
            let eval_result = device.eval_condition(condition)?;
            let command = if eval_result {
                then_command
            } else {
                else_command
            };
            log::debug!("if: {condition} is {eval_result}, execute {command}");
            if let Some(alias) = self.args.aliases.get(command) {
                self.execute_command(alias.as_str()).await?;
            } else {
                self.execute_command(command).await?;
            }
            return Ok(true);
        }
        Ok(false)
    }

    fn parse_if_expr(text: &str) -> Option<(&str, &str, &str)> {
        if let Some(text) = text.strip_prefix("if") {
            if let Some(sep) = text.chars().nth(0) {
                if sep.is_alphanumeric() {
                    return None;
                }
                let fields: Vec<&str> = text[1..].split_terminator(sep).collect();
                match fields.len() {
                    2 => return Some((fields[0], fields[1], "")),
                    3 => return Some((fields[0], fields[1], fields[2])),
                    _ => {}
                }
            }
        }
        None
    }

    async fn execute_command(&self, text: &str) -> anyhow::Result<()> {
        if text.is_empty() {
            return Ok(());
        }
        let command = CommandRequest::from(text);
        let (_, results) = async_scoped::TokioScope::scope_and_block(|s| {
            for device in self.current_devices() {
                s.spawn(device.command(&command));
            }
        });

        let results = Self::merge_join_errors(results);
        for (result, is_last_error) in results {
            if is_last_error {
                return result;
            }
            if let Err(error) = result {
                log::error!("{error}");
                continue;
            }
        }
        Ok(())
    }

    async fn update_status(&self, key: &str) -> anyhow::Result<()> {
        let (_, results) = async_scoped::TokioScope::scope_and_block(|s| {
            for device in self.current_devices() {
                s.spawn(device.update_status());
            }
        });

        let results = Self::merge_join_errors(results);
        for (device, (result, is_last_error)) in zip(self.current_devices(), results) {
            if is_last_error {
                return result;
            }
            if let Err(error) = result {
                log::error!("{error}");
                continue;
            }
            if key.is_empty() {
                device.write_status_to(stdout())?;
            } else if let Some(value) = device.status_by_key(key) {
                println!("{}", value);
            } else {
                log::error!(r#"No status key "{key}" for {device}"#);
            }
        }
        Ok(())
    }

    fn merge_join_errors(
        results: Vec<Result<anyhow::Result<()>, tokio::task::JoinError>>,
    ) -> Vec<(anyhow::Result<()>, bool)> {
        let mut output: Vec<(anyhow::Result<()>, bool)> = vec![];
        let mut last_error_index = None;
        for result in results {
            let result = result.unwrap_or_else(|error| Err(error.into()));
            if result.is_err() {
                last_error_index = Some(output.len());
            }
            output.push((result, false));
        }
        if let Some(last_error_index) = last_error_index {
            output[last_error_index].1 = true;
        }
        output
    }
}

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

    #[test]
    fn parse_device_indexes() {
        let cli = Cli::new_for_test(10);
        assert!(cli.parse_device_indexes("").is_err());
        assert_eq!(cli.parse_device_indexes("4").unwrap(), vec![3]);
        assert_eq!(cli.parse_device_indexes("device4").unwrap(), vec![3]);
        assert_eq!(cli.parse_device_indexes("2,4").unwrap(), vec![1, 3]);
        assert_eq!(cli.parse_device_indexes("2,device4").unwrap(), vec![1, 3]);
        // The result should not be sorted.
        assert_eq!(cli.parse_device_indexes("4,2").unwrap(), vec![3, 1]);
        assert_eq!(cli.parse_device_indexes("device4,2").unwrap(), vec![3, 1]);
        // The result should be unique.
        assert_eq!(cli.parse_device_indexes("2,4,2").unwrap(), vec![1, 3]);
        assert_eq!(cli.parse_device_indexes("4,2,4").unwrap(), vec![3, 1]);
    }

    #[test]
    fn parse_device_indexes_alias() {
        let mut cli = Cli::new_for_test(10);
        cli.args.aliases.insert("k".into(), "3,5".into());
        assert_eq!(cli.parse_device_indexes("k").unwrap(), vec![2, 4]);
        assert_eq!(cli.parse_device_indexes("1,k,4").unwrap(), vec![0, 2, 4, 3]);
        cli.args.aliases.insert("j".into(), "2,k".into());
        assert_eq!(
            cli.parse_device_indexes("1,j,4").unwrap(),
            vec![0, 1, 2, 4, 3]
        );
        assert_eq!(cli.parse_device_indexes("1,j,5").unwrap(), vec![0, 1, 2, 4]);
    }

    #[test]
    fn parse_if_expr() {
        assert_eq!(Cli::parse_if_expr(""), None);
        assert_eq!(Cli::parse_if_expr("a"), None);
        assert_eq!(Cli::parse_if_expr("if"), None);
        assert_eq!(Cli::parse_if_expr("if/a"), None);
        assert_eq!(Cli::parse_if_expr("if/a/b"), Some(("a", "b", "")));
        assert_eq!(Cli::parse_if_expr("if/a/b/c"), Some(("a", "b", "c")));
        assert_eq!(Cli::parse_if_expr("if/a//c"), Some(("a", "", "c")));
        // The separator can be any characters as long as they're consistent.
        assert_eq!(Cli::parse_if_expr("if;a;b;c"), Some(("a", "b", "c")));
        assert_eq!(Cli::parse_if_expr("if.a.b.c"), Some(("a", "b", "c")));
        // But non-alphanumeric.
        assert_eq!(Cli::parse_if_expr("ifXaXbXc"), None);
    }
}