wmgr.crs

#!/usr/bin/env rust-script
//! ```cargo
//! [dependencies]
//! clap = { version = "4", features = ["derive"] }
//! url = "2"
//! ureq = { version = "2", features = ["json"] }
//! anyhow = "1"
//! serde = { version = "1", features = ["derive"] }
//! whoami = "=1.5.1"
//! ```

use anyhow::{bail, Context};
use clap::{Args, Parser};
use std::{
    env,
    ffi::OsStr,
    fs::{read_dir, File},
    path::{Path, PathBuf},
    process::{Command, ExitStatus},
};
use url::Url;

#[derive(Parser, Debug)]
enum Wmgr {
    Add {
        #[command(flatten)]
        placement: WallPlacement,

        #[arg(short, long, value_parser = name_parser)]
        name: Option<PathBuf>,

        wallpaper: String,
    },
    Replace {
        #[command(flatten)]
        placement: WallPlacement,

        #[arg(short, long, required = true, value_parser = name_parser)]
        name: PathBuf,

        wallpaper: String,
    },
    Delete {
        name: String,
    },
    Sync,
}

#[derive(Args, Debug)]
#[group(required = true, multiple = false)]
struct WallPlacement {
    #[arg(short, long)]
    all: bool,
    #[arg(short = 'T', long)]
    tolaria_only: bool,
    #[arg(short = 'P', long)]
    powerstone_only: bool,
}

impl WallPlacement {
    fn base_wall_dir(&self) -> &'static str {
        match self {
            Self { all: true, .. }
            | Self {
                tolaria_only: true, ..
            } => "all",
            Self {
                powerstone_only: true,
                ..
            } => "phone",
            Self {
                all: false,
                tolaria_only: false,
                powerstone_only: false,
            } => unreachable!("at least one of these has to be true"),
        }
    }

    fn non_base_dirs(&self) -> &'static [&'static str] {
        match self {
            Self { all: true, .. } => &["small", "phone"],
            Self {
                tolaria_only: true, ..
            } => &[],
            Self {
                powerstone_only: true,
                ..
            } => &[],
            Self {
                all: false,
                tolaria_only: false,
                powerstone_only: false,
            } => unreachable!("at least one of these has to be true"),
        }
    }
}

const HOST: &str = "mendess@mendess.xyz";
const WALLPAPER_ROOT: &str = "core/mirari/mirrodin/walls";

const GREEN: &str = "\x1b[32m";
const BLUE: &str = "\x1b[34m";
const RESET: &str = "\x1b[0m";
const CLEAN_LINE: &str = "\r\x1b[2K";

fn name_parser(s: &str) -> Result<PathBuf, String> {
    if s.contains('/') {
        return Err(format!("name can't contain '/'"));
    }
    Ok(PathBuf::from(s))
}

fn wall_dir() -> anyhow::Result<PathBuf> {
    Ok(PathBuf::from(
        env::var_os("WALLPAPERS").context("$WALLPAPERS var unset")?,
    ))
}

fn run_remote_impl<I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
    args: I,
    log: bool,
) -> anyhow::Result<ExitStatus> {
    let mut command = Command::new("ssh");
    command.arg(HOST).arg("--").args(args);
    if log {
        eprintln!(
            "running remotely {}",
            command
                .get_args()
                .skip(2)
                .collect::<Vec<_>>()
                .join(std::ffi::OsStr::new(" "))
                .to_str()
                .unwrap()
        );
    }
    let code = command.spawn()?.wait()?;
    Ok(code)
}

fn run_remote_logged<I: IntoIterator<Item = S>, S: AsRef<OsStr>>(
    args: I,
) -> anyhow::Result<ExitStatus> {
    run_remote_impl(args, true)
}

fn run_remote<I: IntoIterator<Item = S>, S: AsRef<OsStr>>(args: I) -> anyhow::Result<ExitStatus> {
    run_remote_impl(args, false)
}

fn yn_prompt(prompt: &str, default: bool) -> std::io::Result<bool> {
    eprint!("{prompt}? {} ", if default { "[Y/n]" } else { "[y/N]" });
    let mut buf = String::new();
    std::io::stdin().read_line(&mut buf)?;
    Ok(match buf.trim() {
        "N" | "n" => false,
        "Y" | "y" => true,
        _ => default,
    })
}

fn process_wallpaper(
    wallpaper: String,
    name: Option<PathBuf>,
) -> anyhow::Result<(PathBuf, String)> {
    if wallpaper.starts_with("http") {
        let url = Url::parse(&wallpaper).context("invalid wallpaper url")?;
        let file_name = || {
            url.path_segments()
                .context("can't deduce wallpaper extension from url")
                .map(|segments| segments.last().unwrap())
                .map(Path::new)
        };

        let file_name = match name {
            Some(mut name) => {
                if name.extension().is_none() {
                    name.set_extension(
                        file_name()?
                            .extension()
                            .context("can't deduce wallpaper extension from url")?,
                    );
                }
                name.display().to_string()
            }
            None => {
                let name = file_name()?;
                if name.extension().is_none() {
                    bail!("can't deduce wallpaper name from url")
                }
                name.display().to_string()
            }
        };

        let target_file_path = ["/tmp", &file_name].iter().collect::<PathBuf>();
        eprintln!("downloading to {}", target_file_path.display());
        let mut target_file = File::create(&target_file_path)?;
        let mut resp = ureq::request_url("GET", &url)
            .call()
            .context("failed to GET wallpaper")?
            .into_reader();
        std::io::copy(&mut resp, &mut target_file).context("failed to download wallpaper")?;
        drop(target_file);
        Ok((target_file_path, file_name))
    } else {
        let file_name = match name {
            Some(name) => name.to_str().context("not valid utf8")?.to_owned(),
            None => Path::new(&wallpaper)
                .file_name()
                .context("not a file")?
                .to_str()
                .context("not valid utf8")?
                .to_owned(),
        };
        Ok((PathBuf::from(wallpaper), file_name))
    }
}

fn add(placement: WallPlacement, name: Option<PathBuf>, wallpaper: String) -> anyhow::Result<()> {
    let (wallpaper_path, wallpaper_name) = process_wallpaper(wallpaper, name)?;
    let wall_dir = placement.base_wall_dir();
    let status = run_remote_logged([
        "test",
        "!",
        "-e",
        &format!("{WALLPAPER_ROOT}/{wall_dir}/{wallpaper_name}"),
    ])?;
    if !status.success() {
        bail!("A wallpaper with that name already exists");
    }
    eprintln!("{GREEN}sending {wallpaper_name} to {wall_dir}{RESET}");
    let status = Command::new("scp")
        .arg(wallpaper_path)
        .arg(format!(
            "{HOST}:{WALLPAPER_ROOT}/{wall_dir}/{wallpaper_name}",
        ))
        .spawn()
        .context("running scp")?
        .wait()
        .context("waiting for scp")?;
    if !status.success() {
        bail!("scp failed with code {status}")
    }

    for dir in placement.non_base_dirs() {
        eprintln!("{BLUE}creating symlink{RESET}");
        let status = run_remote([format!(
            "cd {WALLPAPER_ROOT}; ln -svr ./all/{wallpaper_name} ./{dir}/{wallpaper_name}",
        )])?;
        if !status.success() {
            bail!("creating sym link failed with code: {status:?}")
        }
    }

    Ok(())
}

fn replace(placement: WallPlacement, name: PathBuf, wallpaper: String) -> anyhow::Result<()> {
    let (wallpaper_path, wallpaper_name) = process_wallpaper(wallpaper, Some(name))?;

    let wall_dir = placement.base_wall_dir();

    let status = run_remote_logged([
        "test",
        "-e",
        &format!("{WALLPAPER_ROOT}/{wall_dir}/{wallpaper_name}"),
    ])?;
    if !status.success() {
        bail!("A wallpaper with that name ({wallpaper_name}) doesn't exist");
    }
    let target = format!("{HOST}:{WALLPAPER_ROOT}/{wall_dir}/{wallpaper_name}");
    eprintln!(
        "{GREEN}sending {} to {target}{RESET}",
        wallpaper_path.display()
    );
    let status = Command::new("scp")
        .arg(wallpaper_path)
        .arg(target)
        .spawn()
        .context("running scp")?
        .wait()
        .context("waiting for scp")?;
    if !status.success() {
        bail!("scp failed with code {status}")
    }
    Ok(())
}

fn delete(name: String) -> anyhow::Result<()> {
    let name = if name.contains('/') {
        Path::new(&name)
            .file_name()
            .context("invalid wallpaper name")?
            .to_str()
            .unwrap()
            .to_string()
    } else {
        name
    };
    let output = Command::new("ssh")
        .arg(HOST)
        .arg("--")
        .args([
            "find",
            WALLPAPER_ROOT,
            "-type",
            "l,f",
            "-name",
            &format!("*{name}*"),
        ])
        .output()?;
    if !output.status.success() {
        bail!("failed to find that wallpaper: {:?}", output.status);
    }
    let remote_files =
        std::str::from_utf8(&output.stdout).context("files in server are not utf8")?;
    let mut files = remote_files
        .split('\n')
        .map(str::trim)
        .filter(|s| !s.is_empty())
        .peekable();
    if files.peek().is_none() {
        bail!("no files found with name {name}")
    }
    eprintln!("about to delete:");
    for f in files.clone() {
        eprintln!(" - {HOST}:{f}");
    }
    let local_files = read_dir(wall_dir()?)?
        .filter_map(Result::ok)
        .map(|e| e.path())
        .filter(|e| {
            e.file_name()
                .unwrap()
                .to_str()
                .map_or(false, |s| s.contains(&name))
        })
        .collect::<Vec<_>>();
    for f in &local_files {
        eprintln!(" - {}", f.display());
    }
    if !yn_prompt("proceed", true)? {
        return Ok(());
    }
    let status = run_remote(["rm", "-v"].into_iter().chain(files))?;
    if !status.success() {
        bail!("failed to remove files: {status:?}");
    }
    for f in local_files {
        std::fs::remove_file(&f).with_context(|| format!("removing {}", f.display()))?;
        eprintln!("removed '{}'", f.display());
    }

    Ok(())
}

fn sync() -> anyhow::Result<()> {
    #[derive(serde::Deserialize, Debug)]
    struct Wall {
        path: String,
        name: String,
    }

    const DOMAIN: &str = "mendess.xyz";

    let filter = match whoami::fallible::hostname()?.as_str() {
        "localhost" => "walls/phone",
        "tolaria" => "walls/all",
        _ => "walls",
    };

    let base = format!("https://{DOMAIN}/api/v1/{filter}");
    let walls = {
        let mut req = ureq::get(&base);
        if filter == "walls/all" {
            req = req.query("mtg", "true");
        }
        req.call()?.into_json::<Vec<Wall>>()?
    };

    let wall_paper_dir = PathBuf::from(wall_dir()?);
    std::fs::create_dir_all(&wall_paper_dir).context("failed to create wallpaper dir")?;
    let total = walls.len();
    for (i, w) in walls.iter().enumerate() {
        eprint!("[{i}/{total}] Checking {}", w.name);
        let file_name = wall_paper_dir.join(&w.path);
        let mut file = match File::options().write(true).create_new(true).open(file_name) {
            Ok(file) => file,
            Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
                eprint!("{CLEAN_LINE}");
                continue;
            }
            Err(e) => return Err(e.into()),
        };
        eprintln!("\nDownloading {}", w.name);
        let mut image = ureq::get(&format!("{base}/{}", w.path))
            .call()
            .with_context(|| format!("getting wallpaper {w:?}"))?
            .into_reader();
        std::io::copy(&mut image, &mut file)
            .with_context(|| format!("downloading wallpaper {w:?}"))?;
    }
    eprintln!("Synced");
    let outdated = std::fs::read_dir(wall_paper_dir)?
        .filter_map(Result::ok)
        .filter(|f| {
            walls
                .iter()
                .all(|w| Some(w.path.as_str()) != f.file_name().to_str())
        })
        .collect::<Vec<_>>();
    if !outdated.is_empty() {
        eprintln!("Local wallpapers found that aren't available online:");
        for p in &outdated {
            eprintln!(" - {}", p.file_name().to_str().unwrap());
        }
        if yn_prompt("delete them", false)? {
            for p in outdated {
                std::fs::remove_file(p.path())?;
            }
        }
    }

    Ok(())
}

fn main() -> anyhow::Result<()> {
    eprintln!("welcome to wmgr!");
    match Wmgr::parse() {
        Wmgr::Add {
            placement,
            name,
            wallpaper,
        } => add(placement, name, wallpaper),
        Wmgr::Replace {
            placement,
            name,
            wallpaper,
        } => replace(placement, name, wallpaper),
        Wmgr::Delete { name } => delete(name),
        Wmgr::Sync => sync(),
    }
}