use crate::{
    public::docs::{EndpointDocumentation, EndpointMethod},
    types::{
        extract::{AuthorizedUser, Check, CheckResult, Json, 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,
    Json(body): Json<UserLoadRequest>,
) -> Response {
    let users = User::from_user_ids(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,
    Json(body): Json<UserPageReqiest>,
) -> Response {
    let Ok(users) = User::from_user_page(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) -> 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 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))
}