path: root/src/api/users.rs

use crate::{
    public::docs::{EndpointDocumentation, EndpointMethod},
    types::{
        extract::{AuthorizedUser, Check, CheckResult, Database, Json, Log, Png},
        http::ResponseCode,
        user::User,
    },
};
use axum::{
    response::Response,
    routing::{post, put},
    Router,
};
use serde::Deserialize;

pub const USERS_LOAD: EndpointDocumentation = EndpointDocumentation {
    uri: "/api/users/load",
    method: EndpointMethod::Post,
    description: "Loads a requested set of users",
    body: Some(
        r#"
    {
        "ids": [0, 3, 7]
    }
    "#,
    ),
    responses: &[
        (200, "Returns users in <span>application/json</span>"),
        (400, "Body does not match parameters"),
        (401, "Unauthorized"),
        (500, "Failed to fetch users"),
    ],
    cookie: Some("auth"),
};

#[derive(Deserialize)]
struct UserLoadRequest {
    ids: Vec<u64>,
}

impl Check for UserLoadRequest {
    fn check(&self) -> CheckResult {
        Ok(())
    }
}

async fn load_batch(
    AuthorizedUser(_user): AuthorizedUser,
    Database(db): Database,
    Json(body): Json<UserLoadRequest>,
) -> Response {
    let users = User::from_user_ids(&db, body.ids);
    let Ok(json) = serde_json::to_string(&users) else {
        return ResponseCode::InternalServerError.text("Failed to fetch users")
    };

    ResponseCode::Success.json(&json)
}

pub const USERS_PAGE: EndpointDocumentation = EndpointDocumentation {
    uri: "/api/users/page",
    method: EndpointMethod::Post,
    description: "Load a section of users from newest to oldest",
    body: Some(
        r#"
    {
        "user_id": 3,
        "page": 0
    }
    "#,
    ),
    responses: &[
        (200, "Returns users in <span>application/json</span>"),
        (400, "Body does not match parameters"),
        (401, "Unauthorized"),
        (500, "Failed to fetch users"),
    ],
    cookie: Some("auth"),
};

#[derive(Deserialize)]
struct UserPageReqiest {
    page: u64,
}

impl Check for UserPageReqiest {
    fn check(&self) -> CheckResult {
        Ok(())
    }
}

async fn load_page(
    AuthorizedUser(_user): AuthorizedUser,
    Database(db): Database,
    Json(body): Json<UserPageReqiest>,
) -> Response {
    let Ok(users) = User::from_user_page(&db, body.page) else {
        return ResponseCode::InternalServerError.text("Failed to fetch users")
    };

    let Ok(json) = serde_json::to_string(&users) else {
        return ResponseCode::InternalServerError.text("Failed to fetch users")
    };

    ResponseCode::Success.json(&json)
}

pub const USERS_SELF: EndpointDocumentation = EndpointDocumentation {
    uri: "/api/users/self",
    method: EndpointMethod::Post,
    description: "Returns current authenticated user (whoami)",
    body: None,
    responses: &[
        (200, "Successfully executed SQL query"),
        (401, "Unauthorized"),
        (500, "Failed to fetch user"),
    ],
    cookie: Some("auth"),
};

async fn load_self(AuthorizedUser(user): AuthorizedUser, _: Log) -> Response {
    let Ok(json) = serde_json::to_string(&user) else {
        return ResponseCode::InternalServerError.text("Failed to fetch user")
    };

    ResponseCode::Success.json(&json)
}

pub const USERS_AVATAR: EndpointDocumentation = EndpointDocumentation {
    uri: "/api/users/avatar",
    method: EndpointMethod::Put,
    description: "Set your current profile avatar",
    body: Some("PNG sent as a binary blob"),
    responses: &[
        (200, "Successfully updated avatar"),
        (400, "Invalid PNG or disallowed size"),
        (401, "Unauthorized"),
        (500, "Failed to update avatar"),
    ],
    cookie: Some("auth"),
};

async fn avatar(AuthorizedUser(user): AuthorizedUser, Png(img): Png) -> Response {
    let path = format!("./public/image/custom/avatar/{}.png", user.user_id);

    if img.save(path).is_err() {
        return ResponseCode::InternalServerError.text("Failed to update avatar");
    }

    ResponseCode::Success.text("Successfully updated avatar")
}

pub const USERS_BANNER: EndpointDocumentation = EndpointDocumentation {
    uri: "/api/users/banner",
    method: EndpointMethod::Put,
    description: "Set your current profile banner",
    body: Some("PNG sent as a binary blob"),
    responses: &[
        (200, "Successfully updated banner"),
        (400, "Invalid PNG or disallowed size"),
        (401, "Unauthorized"),
        (500, "Failed to update banner"),
    ],
    cookie: Some("auth"),
};

async fn banner(AuthorizedUser(user): AuthorizedUser, Png(img): Png) -> Response {
    let path = format!("./public/image/custom/banner/{}.png", user.user_id);

    if img.save(path).is_err() {
        return ResponseCode::InternalServerError.text("Failed to update banner");
    }

    ResponseCode::Success.text("Successfully updated banner")
}

pub const USERS_FOLLOW: EndpointDocumentation = EndpointDocumentation {
    uri: "/api/users/follow",
    method: EndpointMethod::Put,
    description: "Set following status of another user",
    body: Some(
        r#"
    {
        "user_id": 13,
        "status": false
    }
    "#,
    ),
    responses: &[
        (200, "Returns new follow status if successfull, see below"),
        (400, "Body does not match parameters"),
        (401, "Unauthorized"),
        (500, "Failed to change follow status"),
    ],
    cookie: Some("auth"),
};

#[derive(Deserialize)]
struct UserFollowRequest {
    user_id: u64,
    state: bool,
}

impl Check for UserFollowRequest {
    fn check(&self) -> CheckResult {
        Ok(())
    }
}

async fn follow(
    AuthorizedUser(user): AuthorizedUser,
    Database(db): Database,
    Json(body): Json<UserFollowRequest>,
) -> Response {
    if body.state {
        if let Err(err) = User::add_following(&db, user.user_id, body.user_id) {
            return err;
        }
    } else if let Err(err) = User::remove_following(&db, user.user_id, body.user_id) {
        return err;
    }

    match User::get_following(&db, user.user_id, body.user_id) {
        Ok(status) => ResponseCode::Success.text(&format!("{status}")),
        Err(err) => err,
    }
}

pub const USERS_FOLLOW_STATUS: EndpointDocumentation = EndpointDocumentation {
    uri: "/api/users/follow",
    method: EndpointMethod::Post,
    description: "Get following status of another user",
    body: Some(
        r#"
        {
            "user_id": 13
        }
        "#,
    ),
    responses: &[
        (
            200,
            "Returns 0 if no relation, 1 if following, 2 if followed, 3 if both",
        ),
        (400, "Body does not match parameters"),
        (401, "Unauthorized"),
        (500, "Failed to retrieve follow status"),
    ],
    cookie: Some("auth"),
};

#[derive(Deserialize)]
struct UserFollowStatusRequest {
    user_id: u64,
}

impl Check for UserFollowStatusRequest {
    fn check(&self) -> CheckResult {
        Ok(())
    }
}

async fn follow_status(
    AuthorizedUser(user): AuthorizedUser,
    Database(db): Database,
    Json(body): Json<UserFollowStatusRequest>,
) -> Response {
    match User::get_following(&db, user.user_id, body.user_id) {
        Ok(status) => ResponseCode::Success.text(&format!("{status}")),
        Err(err) => err,
    }
}

pub const USERS_FRIENDS: EndpointDocumentation = EndpointDocumentation {
    uri: "/api/users/friends",
    method: EndpointMethod::Post,
    description: "Returns friends of a user",
    body: Some(
        r#"
        {
            "user_id": 13
        }
        "#,
    ),
    responses: &[
        (200, "Returns users in <span>application/json<span>"),
        (401, "Unauthorized"),
        (500, "Failed to fetch friends"),
    ],
    cookie: Some("auth"),
};

#[derive(Deserialize)]
struct UserFriendsRequest {
    user_id: u64,
}

impl Check for UserFriendsRequest {
    fn check(&self) -> CheckResult {
        Ok(())
    }
}

async fn friends(
    AuthorizedUser(_user): AuthorizedUser,
    Database(db): Database,
    Json(body): Json<UserFriendsRequest>,
) -> Response {
    let Ok(users) = User::get_friends(&db, body.user_id) else {
        return ResponseCode::InternalServerError.text("Failed to fetch user")
    };

    let Ok(json) = serde_json::to_string(&users) else {
        return ResponseCode::InternalServerError.text("Failed to fetch user")
    };

    ResponseCode::Success.json(&json)
}

pub fn router() -> Router {
    Router::new()
        .route("/load", post(load_batch))
        .route("/self", post(load_self))
        .route("/page", post(load_page))
        .route("/avatar", put(avatar))
        .route("/banner", put(banner))
        .route("/follow", put(follow).post(follow_status))
        .route("/friends", post(friends))
}