//! Why the server refused a write, in the server's own words.
//!
//!   cargo run -p dr-sync-nextcloud --example put_probe -- <server> <remote/path>
//!
//! `map_status` turns a response into a typed error and throws the body away,
//! which is right for the application and useless for diagnosis: a 403 from
//! Sabre carries an exception class and a sentence saying *which* rule
//! refused, and that is the whole of what distinguishes a read-only share from
//! an access-control rule from a lock.
//!
//! Reads the stored session and its keyring credential, so it exercises the
//! same account the app does. It writes a few bytes and deletes them again.

use dr_plat::PlatformSecretStore;
use dr_sync_nextcloud::session::SessionStore;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let mut args = std::env::args().skip(1);
    let (Some(server), Some(path)) = (args.next(), args.next()) else {
        eprintln!("usage: put_probe <server-url> <remote/path>");
        std::process::exit(2);
    };

    let sessions = SessionStore::open(Box::new(PlatformSecretStore::new()));
    let Some(session) = sessions
        .current()
        .filter(|s| s.server == server.trim_end_matches('/'))
    else {
        eprintln!("no stored session for {server}");
        std::process::exit(1);
    };
    let creds = match sessions.credentials(&session) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("credentials: {e}");
            std::process::exit(1);
        }
    };

    let url = format!(
        "{}/remote.php/dav/files/{}/{}",
        session.server.trim_end_matches('/'),
        session.user_id,
        path
    );
    println!("PUT {url}");

    let client = reqwest::Client::new();
    let send = |method: reqwest::Method, body: Vec<u8>| {
        let (url, user, pass) = (
            url.clone(),
            creds.login_name.clone(),
            creds.app_password.clone(),
        );
        let client = client.clone();
        async move {
            client
                .request(method, &url)
                .basic_auth(user, Some(pass))
                .body(body)
                .send()
                .await
        }
    };

    match send(reqwest::Method::PUT, b"probe".to_vec()).await {
        Ok(resp) => {
            let status = resp.status();
            let body = resp.text().await.unwrap_or_default();
            println!("status {status}");
            // The interesting part: Sabre names the exception and the reason.
            for line in body
                .lines()
                .filter(|l| l.contains("exception") || l.contains("message") || l.contains("Sabre"))
            {
                println!("  {}", line.trim());
            }
            if status.is_success() {
                let _ = send(reqwest::Method::DELETE, Vec::new()).await;
                println!("(probe file removed)");
            }
        }
        Err(e) => println!("request failed: {e}"),
    }
}