path: root/src/main.rs

use listenbrainz::raw::response::UserPlayingNowResponse;
use rocket::fs::{relative, FileServer};
use rocket::http::Status;
use rocket::response::Responder;
use rocket::Request;
use rocket_dyn_templates::{context, Template};
use serde::{Deserialize, Serialize};

#[macro_use]
extern crate rocket;

#[derive(Serialize, Deserialize)]
struct ScrobbleData {
    is_scrobbling: bool,
    song: Option<String>,
    artist: Option<String>,
}

impl ScrobbleData {
    fn new(playingnow: UserPlayingNowResponse) -> Self {
        let is_scrobbling = playingnow.payload.count > 0;
        if is_scrobbling {
            Self {
                is_scrobbling,
                song: Some(
                    playingnow
                        .payload
                        .listens
                        .first()
                        .unwrap()
                        .track_metadata
                        .track_name
                        .clone(),
                ),
                artist: Some(
                    playingnow
                        .payload
                        .listens
                        .first()
                        .unwrap()
                        .track_metadata
                        .artist_name
                        .clone(),
                ),
            }
        } else {
            Self {
                is_scrobbling,
                song: None,
                artist: None,
            }
        }
    }
}

#[get("/")]
async fn home() -> Template {
    let listenbrainz = listenbrainz::raw::Client::new();
    let playingnow = listenbrainz.user_playing_now("celblossom").unwrap();
    let listenbrainz_data = ScrobbleData::new(playingnow);
    println!("{}", listenbrainz_data.is_scrobbling);

    Template::render(
        "home",
        context! { is_live: false, listenbrainz: listenbrainz_data },
    )
}

#[get("/contact")]
async fn contact() -> Template {
    Template::render("contact", context! {})
}

// #[get("/test")]
// async fn test() -> Result<Template, BlossomError> {
//     let posts = reqwest::get("https://skinnyver.se/api/v1/accounts/cel/statuses").await;
//     posts
// }

#[catch(404)]
fn not_found(req: &Request) -> Template {
    let message = "i either haven't built this page yet or it looks like you're a little lost";
    Template::render(
        "error",
        context! { status: "404", req: req.uri(), message: message },
    )
}

#[catch(501)]
fn server_error(req: &Request) -> Template {
    let message = "it looks like this is not yet here!!!";
    Template::render(
        "error",
        context! { status: "501", req: req.uri(), message: message },
    )
}

#[catch(default)]
fn error(status: Status, req: &Request) -> Template {
    let status = format!("{}", status);
    let message = "there was an error";
    Template::render(
        "error",
        context! { status: status, req: req.uri(), message: message },
    )
}

#[tokio::main]
async fn main() -> Result<(), rocket::Error> {
    let _rocket = rocket::build()
        .attach(Template::fairing())
        .mount("/", routes![home, contact])
        .register("/", catchers![not_found, server_error, error])
        .mount("/", FileServer::from(relative!("static")))
        .launch()
        .await?;

    Ok(())
}

#[derive(Responder)]
enum BlossomError {
    #[response(status = 500)]
    Reqwest(&'static str, #[response(ignore)] reqwest::Error),
}

impl From<reqwest::Error> for BlossomError {
    fn from(e: reqwest::Error) -> Self {
        BlossomError::Reqwest("reqwest error", e)
    }
}