use http_body_util::{BodyExt, Full};
use hyper::body::Bytes;
use hyper::{Method, Request, Response};

use super::Or5xx;
use crate::http::{empty_204_request, malformed_request, player_not_found, room_not_found};
use lavina_core::clustering::room::{paths, JoinRoomReq, SendMessageReq};
use lavina_core::player::PlayerId;
use lavina_core::repo::Storage;
use lavina_core::room::RoomId;
use lavina_core::LavinaCore;

// TODO move this into core

pub async fn route(
    core: &LavinaCore,
    storage: &Storage,
    request: Request<hyper::body::Incoming>,
) -> Option<Response<Full<Bytes>>> {
    match (request.method(), request.uri().path()) {
        (&Method::POST, paths::JOIN) => Some(endpoint_cluster_join_room(request, core, storage).await.or5xx()),
        (&Method::POST, paths::ADD_MESSAGE) => Some(endpoint_cluster_add_message(request, core).await.or5xx()),
        _ => None,
    }
}

#[tracing::instrument(skip_all, name = "endpoint_cluster_join_room")]
async fn endpoint_cluster_join_room(
    request: Request<hyper::body::Incoming>,
    core: &LavinaCore,
    storage: &Storage,
) -> lavina_core::prelude::Result<Response<Full<Bytes>>> {
    let str = request.collect().await?.to_bytes();
    let Ok(req) = serde_json::from_slice::<JoinRoomReq>(&str[..]) else {
        return Ok(malformed_request());
    };
    tracing::info!("Incoming request: {:?}", &req);
    let Ok(room_id) = RoomId::from(req.room_id) else {
        dbg!(&req.room_id);
        return Ok(room_not_found());
    };
    let Ok(player_id) = PlayerId::from(req.player_id) else {
        dbg!(&req.player_id);
        return Ok(player_not_found());
    };
    let room_handle = core.rooms.get_or_create_room(room_id).await.unwrap();
    let storage_id = storage.create_or_retrieve_user_id_by_name(req.player_id).await?;
    room_handle.add_member(&player_id, storage_id).await;
    Ok(empty_204_request())
}

#[tracing::instrument(skip_all, name = "endpoint_cluster_add_message")]
async fn endpoint_cluster_add_message(
    request: Request<hyper::body::Incoming>,
    core: &LavinaCore,
) -> lavina_core::prelude::Result<Response<Full<Bytes>>> {
    let str = request.collect().await?.to_bytes();
    let Ok(req) = serde_json::from_slice::<SendMessageReq>(&str[..]) else {
        return Ok(malformed_request());
    };
    tracing::info!("Incoming request: {:?}", &req);
    let Ok(created_at) = chrono::DateTime::parse_from_rfc3339(req.created_at) else {
        dbg!(&req.created_at);
        return Ok(malformed_request());
    };
    let Ok(room_id) = RoomId::from(req.room_id) else {
        dbg!(&req.room_id);
        return Ok(room_not_found());
    };
    let Ok(player_id) = PlayerId::from(req.player_id) else {
        dbg!(&req.player_id);
        return Ok(player_not_found());
    };
    let Some(room_handle) = core.rooms.get_room(&room_id).await else {
        dbg!(&room_id);
        return Ok(room_not_found());
    };
    room_handle.send_message(&player_id, req.message.into(), created_at.to_utc()).await;
    Ok(empty_204_request())
}