#[macro_use]
extern crate slog;
extern crate slog_async;
extern crate slog_scope;
extern crate slog_scope_futures;
extern crate slog_stdlog;
extern crate slog_term;

use clap::Parser;
use slog::{Drain, Logger};
use slog_scope_futures::FutureExt;
use transmission_rpc::types::{BasicAuth, TorrentAddArgs};
use transmission_rpc::TransClient;

use std::io::BufReader;
use std::path::{Path, PathBuf};

const DEFAULT_FEED_URL: &str = "https://www.shanaproject.com/feeds/secure/user/42421/4P7Y3T5U2E/";

#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Cli {
    #[arg(short, long, default_value = "localhost:9091")]
    rpc_url: String,

    /// url to fetch feed from
    #[arg(short, long, default_value=DEFAULT_FEED_URL)]
    feed_url: String,

    /// path to load feed from
    #[arg(long)]
    feed_file: Option<PathBuf>,

    #[arg(long, default_value = "")]
    user: String,

    #[arg(long, default_value = "")]
    password: String,

    /// dump feed to stdout instead
    #[arg(long)]
    dump: bool,
}

fn setup_logger() -> slog::Logger {
    let decorator = slog_term::TermDecorator::new().stderr().build();
    let drain = slog_term::CompactFormat::new(decorator).build().fuse();
    let drain = slog::LevelFilter(drain, slog::Level::Debug).fuse();
    let drain = slog_async::Async::new(drain).build().fuse();

    slog::Logger::root(drain, o!())
}

async fn add_torrent(
    log: &Logger,
    rpc_url: &str,
    torrent_url: &str,
    user: &str,
    password: &str,
) -> Result<(), String> {
    let auth = BasicAuth {
        user: user.to_string(),
        password: password.to_string(),
    };
    let mut client = TransClient::with_auth(rpc_url.parse().unwrap(), auth);

    let add = TorrentAddArgs {
        filename: Some(torrent_url.into()),
        ..TorrentAddArgs::default()
    };

    match client.torrent_add(add).with_logger(log).await {
        Ok(_) => Ok(()),
        Err(err) => Err((*err).to_string()),
    }
}

fn fetch_feed_from_url(log: &Logger, feed_url: &str) -> Result<rss::Channel, String> {
    info!(log, "fetching {feed_url}");
    let resp = match ureq::get(feed_url).call() {
        Ok(resp) => resp,
        Err(e) => return Err(e.to_string()),
    };
    info!(log, "fetch ok");

    info!(log, "parsing feed");
    let resp_reader = BufReader::new(resp.into_reader());
    let channel = rss::Channel::read_from(resp_reader).expect("valid stream");
    info!(log, "parsing ok");

    Ok(channel)
}

fn load_feed_from_disk(_: &Logger, file_path: &Path) -> Result<rss::Channel, String> {
    let Ok(file) = std::fs::File::open(file_path) else {
        return Err("error opening file".to_string());
    };

    let feed = match rss::Channel::read_from(BufReader::new(file)) {
        Ok(feed) => feed,
        Err(e) => return Err(e.to_string()),
    };

    Ok(feed)
}

async fn add_torrents<T>(log: &Logger, args: &Cli, torrents: T)
where
    T: IntoIterator<Item = rss::Item>,
{
    // TODO replace ureq with reqwest as transmission-rpc depends on it anyway
    for e in torrents.into_iter() {
        let title = e.title().unwrap_or("<no title>").to_string();
        let log = log.new(o!("title" => title));

        info!(log, "new entry");

        if let Some(url) = e.link() {
            info!(log, "adding entry");
            if let Err(e) = add_torrent(&log, &args.rpc_url, url, &args.user, &args.password).await
            {
                error!(log, "error adding torrent: {e}");
            }
        } else {
            error!(log, "no url included, skipping");
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), String> {
    let log = setup_logger();
    slog_stdlog::init().map_err(|e| e.to_string())?;

    let args = Cli::parse();

    let feed = if let Some(filepath) = &args.feed_file {
        load_feed_from_disk(&log, filepath.as_path())?
    } else {
        fetch_feed_from_url(&log, &args.feed_url)?
    };

    info!(log, "received {} new torrents", feed.items().len());

    if args.dump {
        feed.write_to(std::io::stdout()).map_err(|e| e.to_string())?;
    } else {
        let torrents = feed.into_items().into_iter().rev();
        add_torrents(&log, &args, torrents).await;
    }

    info!(log, "done");

    Ok(())
}