Programmatically changing layers about kanata HOT 9 CLOSED

#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
#![allow(clippy::missing_errors_doc)]

// [dependencies]
// color-eyre = "0.6"
// json_dotpath = "1"
// miow = "0.4"
// parking_lot = "0.12"
// serde = "1"
// serde_json = "1"

use color_eyre::Report;
use color_eyre::Result;
use json_dotpath::DotPaths;
use miow::pipe::NamedPipe;
use parking_lot::Mutex;
use serde_json::json;
use std::io::Read;
use std::io::Write;
use std::net::TcpStream;
use std::process::Command;
use std::sync::Arc;
use std::thread;
use std::thread::sleep;
use std::time::Duration;

fn main() -> Result<()> {
    let mut komokana = Komokana::init()?;
    komokana.listen()?;

    loop {
        sleep(Duration::from_secs(60));
    }
}

pub struct Komokana {
    pub komorebi: Arc<Mutex<NamedPipe>>,
    pub kanata: Arc<Mutex<TcpStream>>,
}

const PIPE: &str = r#"\\.\pipe\"#;

impl Komokana {
    pub fn init() -> Result<Self> {
        let name = "komokana";
        let pipe = format!("{}\\{}", PIPE, name);

        let named_pipe = NamedPipe::new(pipe)?;

        let mut output = Command::new("cmd.exe")
            .args(["/C", "komorebic.exe", "subscribe", name])
            .output()?;

        while !output.status.success() {
            println!(
                "komorebic.exe failed with error code {:?}, retrying in 5 seconds...",
                output.status.code()
            );

            sleep(Duration::from_secs(5));

            output = Command::new("cmd.exe")
                .args(["/C", "komorebic.exe", "subscribe", name])
                .output()?;
        }

        named_pipe.connect()?;

        let stream = TcpStream::connect("localhost:9999")?;

        Ok(Self {
            komorebi: Arc::new(Mutex::new(named_pipe)),
            kanata: Arc::new(Mutex::new(stream)),
        })
    }

    pub fn listen(&mut self) -> Result<()> {
        let pipe = self.komorebi.clone();
        let stream = self.kanata.clone();
        thread::spawn(move || -> Result<()> {
            dbg!("listening now");
            let mut buf = vec![0; 4096];
            loop {
                let mut named_pipe = pipe.lock();
                match (*named_pipe).read(&mut buf) {
                    Ok(bytes_read) => {
                        let data = String::from_utf8(buf[0..bytes_read].to_vec())?;
                        if data == "\n" {
                            continue;
                        }

                        let notification: serde_json::Value = serde_json::from_str(&data)?;

                        if notification.dot_has("event.content.1.exe") {
                            if let Some(exe) =
                                notification.dot_get::<String>("event.content.1.exe")?
                            {
                                let mut stream = stream.lock();

                                #[allow(clippy::single_match_else)]
                                match exe.as_str() {
                                    "firefox.exe" => {
                                        stream.write_all(
                                            json!({
                                                "LayerChange": {
                                                    "new": "ff"
                                                }
                                            })
                                            .to_string()
                                            .as_bytes(),
                                        )?;

                                        println!("set layer to ff");
                                    }
                                    _ => {
                                        stream.write_all(
                                            json!({
                                                "LayerChange": {
                                                    "new": "qwerty"
                                                }
                                            })
                                            .to_string()
                                            .as_bytes(),
                                        )?;

                                        println!("set layer to qwerty");
                                    }
                                }
                            }
                        }
                    }
                    Err(error) => {
                        // Broken pipe
                        if error.raw_os_error().expect("could not get raw os error") == 109 {
                            named_pipe.disconnect()?;

                            let mut output = Command::new("cmd.exe")
                                .args(["/C", "komorebic.exe", "subscribe", "bar"])
                                .output()?;

                            while !output.status.success() {
                                println!(
                                    "komorebic.exe failed with error code {:?}, retrying in 5 seconds...",
                                    output.status.code()
                                );

                                sleep(Duration::from_secs(5));

                                output = Command::new("cmd.exe")
                                    .args(["/C", "komorebic.exe", "subscribe", "bar"])
                                    .output()?;
                            }

                            named_pipe.connect()?;
                        } else {
                            return Err(Report::from(error));
                        }
                    }
                }
            }
        });

        Ok(())
    }
}