#[salvo(schema(name = XXX))]

use salvo::oapi::extract::*;
use salvo::oapi::{endpoint, extract::QueryParam, ToParameters, ToSchema};
use salvo::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug, ToSchema)]
#[salvo(schema(name = Response))]
struct Response<T: ToSchema> {
    /// Code response
    code: u32,
    /// Data response
    data: T,
}

#[derive(Serialize, Deserialize, Debug, ToSchema)]
#[salvo(schema(name = Error))]
struct ResponseError {
    /// Code error
    code: String,
    /// error detail
    detail: String,
}

#[derive(Serialize, Deserialize, Debug, ToSchema)]
#[salvo(schema(name = City))]

struct CityDTO {
    /// City id
    id: u64,
    /// City name
    name: String,
}

#[endpoint(
    parameters(("msg",description = "Test param")),
    responses(
    (status_code = 200, description = "success response")
    )
)]
async fn test_generic(
    msg: QueryParam<String, true>,
) -> Result<Json<Response<CityDTO>>, Json<ResponseError>> {
    Ok(Json(Response {
        code: 50,
        data: CityDTO {
            id: 10,
            name: "Beijing".to_string(),
        },
    }))
}

#[endpoint()]
async fn test_primitive() -> Result<Json<Response<String>>, Json<ResponseError>> {
    Ok(Json(Response {
        code: 50,
        data: String::from("cool"),
    }))
}

#[tokio::main]
async fn main() {
    println!("Hello, world!");

    let router = Router::new().push(
        Router::with_path("api")
            .push(Router::with_path("<id>").get(test_generic))
            .push(Router::with_path("cool").get(test_primitive)),
    );

    let doc = OpenApi::new("test api", "0.0.1").merge_router(&router);

    let router = router
        .unshift(doc.into_router("/api-doc/openapi.json"))
        .unshift(
            SwaggerUi::new("/api-doc/openapi.json")
                .title("Test - SwaggerUI")
                .into_router("/swagger-ui"),
        );

    let acceptor = TcpListener::new("0.0.0.0:5800").bind().await;
    Server::new(acceptor).serve(router).await;
}