ha-now-playing/src/main.rs

use std::{io::Read, path::PathBuf};

use clap::Parser;
use serde_json::json;

/// Bert
#[derive(Parser, Debug)]
#[clap(version, author, about)]
struct Opts {
    /// Home Assistant host
    #[clap(short, long)]
    host: String,

    /// Media player entity ID
    #[clap(short, long)]
    entity: String,

    /// API token
    #[clap(short, long)]
    token: Option<String>,

    /// File with the API token
    #[clap(long)]
    token_file: Option<PathBuf>,

    /// Use HTTP instead of HTTPS
    #[clap(short, long)]
    insecure: bool,

    #[clap(subcommand)]
    cmd: Option<Command>,
}

#[derive(Parser, Debug, Clone, Copy)]
enum Command {
    /// Toggle playback
    PlayPause,
    /// Raise volume
    VolumeUp,
    /// Lower volume
    VolumeDown,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let opts = Opts::parse();

    let Opts {
        host,
        entity,
        insecure,
        cmd,
        token,
        token_file,
    } = opts;

    let token = if let Some(token) = token {
        Some(token)
    } else if let Some(token_file) = token_file {
        if let Ok(mut file) = std::fs::File::open(token_file) {
            let mut buf = String::new();
            file.read_to_string(&mut buf).ok();
            Some(buf)
        } else {
            None
        }
    } else {
        eprintln!("No API token given. Use either --token or --token-file");
        None
    };

    if let Some(token) = token {
        if let Some(cmd) = cmd {
            call_service(cmd, host, entity, insecure, token)?;
        } else {
            get_now_playing(host, entity, insecure, token)?;
        }
    }
    // println!("{:#?}", response);
    Ok(())
}
fn get_now_playing(
    host: String,
    entity: String,
    insecure: bool,
    token: String,
) -> Result<(), Box<dyn std::error::Error>> {
    let url = format!(
        "{}://{}/api/states/{}",
        if insecure { "http" } else { "https" },
        host,
        entity
    );

    let client = reqwest::blocking::Client::new();
    let response = client
        .get(url)
        .bearer_auth(token)
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .send()?
        .json::<serde_json::Value>()?;

    if response["state"] == "playing" {
        let attributes = &response["attributes"];
        let maybe_channel = attributes["media_channel"].as_str();
        let now_playing = if let Some(channel) = maybe_channel {
            format!(
                "[{}] {} - {}",
                channel,
                attributes["media_artist"]
                    .as_str()
                    .map_or("No artist", |artist| { artist }),
                attributes["media_title"]
                    .as_str()
                    .map_or("No title", |title| { title }),
            )
        } else {
            format!(
                "{} - {}",
                attributes["media_artist"]
                    .as_str()
                    .map_or("No artist", |artist| artist),
                attributes["media_title"]
                    .as_str()
                    .map_or("No title", |title| title),
            )
        };

        println!("{}", now_playing);
    } else {
        println!(
            "Sonos {}",
            response["state"]
                .as_str()
                .map_or("state unknown", |state| state)
        );
    }

    Ok(())
}

fn call_service(
    command: Command,
    host: String,
    entity: String,
    insecure: bool,
    token: String,
) -> Result<(), Box<dyn std::error::Error>> {
    let cmd = match command {
        Command::PlayPause => "media_play_pause",
        Command::VolumeUp => "volume_up",
        Command::VolumeDown => "volume_down",
    };

    let url = format!(
        "{}://{}/api/services/media_player/{}",
        if insecure { "http" } else { "https" },
        host,
        cmd
    );

    let body = json!({ "entity_id": entity }).to_string();

    let client = reqwest::blocking::Client::new();
    let response = client
        .post(url)
        .body(body)
        .bearer_auth(token)
        .header("Accept", "application/json")
        .header("Content-Type", "application/json")
        .send()?
        .json::<serde_json::Value>()?;

    println!("{:#?}", response);

    Ok(())
}