use axum::{
    extract::{DefaultBodyLimit, FromRequest, MatchedPath, Multipart, Path, Request},
    http::StatusCode,
    routing::put,
    Router,
};
use futures_util::TryStreamExt;
use tokio_util::io::StreamReader;
use tower_http::trace::TraceLayer;
use tracing::level_filters::LevelFilter;
use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
use uuid::Uuid;

#[tracing::instrument]
async fn upload(request: Request) -> Result<(), (StatusCode, String)> {
    tracing::debug!("creating multipart");
    let mut multipart = Multipart::from_request(request, &())
        .await
        .map_err(|err| (StatusCode::BAD_REQUEST, err.to_string()))?;

    tracing::debug!("creating field");
    let Some(reader) = multipart
        .next_field()
        .await
        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?
    else {
        return Err((StatusCode::BAD_REQUEST, "no field available".to_string()));
    };

    tracing::debug!("creating stream reader");
    let mut reader = StreamReader::new(reader.map_err(std::io::Error::other));

    tracing::debug!("creating/truncating file");
    let mut file = tokio::fs::File::create("/tmp/t/test_file")
        .await
        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;

    tracing::debug!("reading in stream");
    tokio::io::copy(&mut reader, &mut file)
        .await
        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;

    Ok(())
}

#[tokio::main]
async fn main() {
    tracing_subscriber::registry()
        .with(fmt::layer().with_file(true).with_line_number(true))
        .with(
            EnvFilter::builder()
                .with_default_directive(LevelFilter::DEBUG.into())
                .from_env()
                .unwrap(),
        )
        .init();

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
    let router = Router::new()
        .route(
            "/upload",
            put(upload), // .layer(DefaultBodyLimit::disable())
        )
        .layer(
            TraceLayer::new_for_http().make_span_with(|request: &Request<_>| {
                let matched_path = request
                    .extensions()
                    .get::<MatchedPath>()
                    .map(MatchedPath::as_str);

                tracing::info_span!(
                    "request",
                    method = ?request.method(),
                    matched_path,
                    request_id = %Uuid::new_v4()
                )
            }),
        );
    axum::serve(listener, router).await.unwrap()
}