arminius_server_client/handlers/

room.rs

// SPDX-FileCopyrightText: 2025 BWI GmbH
//
// SPDX-License-Identifier: Apache-2.0

//! Implements APIs for room management from the matrix spec

use arminius_lib_component::{
	Component, ServerState,
	error::{
		FeatureNotImplemented, InputJsonError, InternalServerError, MatrixApiError, ResultExt as _,
	},
	ruma_requests::ArminiusResponse,
};
use arminius_lib_db::DefaultDb;
use arminius_lib_db_room::RoomQueries as _;
use arminius_lib_db_user::UserQueries as _;
use arminius_lib_macros::FromNatsError;
use arminius_lib_room_service_messages::EventProvenance;
use arminius_lib_roomservice_client::{
	requests::{
		AddNewEvent, AddNewEventError, AddRoomMemberEvent, AddRoomMemberEventError,
		AddRoomMemberEventRequest, CreateRoom, CreateRoomRequest, ErrorOf, ForgetRoom,
		GetRoomEvent, GetRoomMembers, GetStateEvents, GetStateEventsForKey, NewEvent,
		ReadMarkerError, ReadMarkerRequest, ReadReceipt, ReadReceiptError, ReadReceiptRequest,
		RedactEvent, SetFullyReadMarker, TransactionInformation,
	},
	roomserver_connection::RoomServerConnection,
	ruma_request_wrapper::SerializingRumaRequestWrapper,
};
use axum::{
	Router,
	extract::State,
	routing::{get, post, put},
};
use ruma::{
	OwnedRoomId, OwnedServerName, OwnedUserId, RoomId,
	api::client::{
		knock::knock_room,
		membership::{
			ban_user, forget_room, get_member_events,
			invite_user::{
				self,
				v3::{InvitationRecipient, InviteUserId},
			},
			join_room_by_id, join_room_by_id_or_alias, joined_rooms, kick_user, leave_room,
			unban_user,
		},
		message::send_message_event,
		read_marker::set_read_marker,
		receipt::create_receipt,
		redact::redact_event,
		room::{create_room, get_room_event},
		state::{get_state_event_for_key, get_state_events, send_state_event},
	},
	events::{
		receipt::ReceiptType,
		room::member::{MembershipState, RoomMemberEventContent},
	},
};
use serde::{Deserialize, Serialize};

use crate::client_request::AuthenticatedClientRequest;

/// Compute the via from the request, and append the server name
fn append_server_to_via(mut via: Vec<OwnedServerName>, room_id: &RoomId) -> Vec<OwnedServerName> {
	if let Some(room_server_name) = room_id.server_name()
		&& !via.iter().any(|server_name| server_name == room_server_name)
	{
		via.push(room_server_name.to_owned());
	}
	via
}

/// Create the event content of a membership event
///
/// Contains profile information
async fn create_member_event_content(
	mut database: DefaultDb,
	membership: MembershipState,
	user_id: OwnedUserId,
	reason: Option<String>,
) -> Result<RoomMemberEventContent, InternalServerError> {
	let mut event_content = RoomMemberEventContent::new(membership);
	// If it's a local user, we can populate their displayname from our
	// database. If we're inviting someone over federation, their username
	// won't necessarily be in our database
	if let Some(user_info) = database
		.fetch_user(&user_id)
		.await
		.unrecoverable_error("Could not fetch user from database")?
	{
		event_content.displayname = user_info.display_name;
	}

	event_content.reason = reason;
	Ok(event_content)
}

/// Handler for `POST /_matrix/client/v3/createRoom` (See
/// <https://spec.matrix.org/latest/client-server-api/#post_matrixclientv3createroom>).
///
/// This endpoint is used to create a room.
async fn create_room_handler(
	State(state): State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		create_room::v3::Request,
	>,
) -> Result<ArminiusResponse<create_room::v3::Response>, ErrorOf<CreateRoom>> {
	let request = CreateRoomRequest {
		creator: claims.user_id.clone(),
		request: SerializingRumaRequestWrapper(request),
		creator_join_event_contents: create_member_event_content(
			state.database,
			MembershipState::Join,
			claims.user_id,
			None,
		)
		.await?,
	};
	let room_id = RoomServerConnection::new(&state.nats_connection)
		.make_roomserver_request::<CreateRoom>(None, request)
		.await??;
	Ok(create_room::v3::Response::new(room_id).into())
}

/// Handler for `GET /_matrix/client/v3/rooms/{roomId}/event/{eventId}` (See
/// <https://spec.matrix.org/latest/client-server-api/#get_matrixclientv3roomsroomideventeventid>).
///
/// This endpoint is used to get a specific event from a room.
async fn get_room_event_handler(
	room_server: RoomServerConnection,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		get_room_event::v3::Request,
	>,
) -> Result<ArminiusResponse<get_room_event::v3::Response>, ErrorOf<GetRoomEvent>> {
	Ok(get_room_event::v3::Response::new(
		room_server
			.make_roomserver_request::<GetRoomEvent>(
				Some(request.room_id.clone()),
				(claims.user_id, claims.device_id, request.event_id),
			)
			.await
			.map_err(InternalServerError::from)??,
	)
	.into())
}

/// Errors that occur when joining a room
#[derive(thiserror::Error, MatrixApiError, Debug, Serialize, Deserialize, FromNatsError)]
enum JoinRoomByIdError {
	/// Unrecoverable error.
	/// See <https://bundesmessenger.gitlab.io/backend/neo/arminius/arminius/03-development/errors.html#unrecoverable-errors>
	#[error(transparent)]
	InternalServerError(#[from] InternalServerError),
	/// Error when joining the room
	#[error(transparent)]
	AddRoomMemberEventError(#[from] AddRoomMemberEventError),
	/// When somebody tries to use an alias
	#[error(transparent)]
	FeatureNotImplemented(#[from] FeatureNotImplemented),
}

/// Add a joined event to a room for the user, with the correct username and ID
async fn join_room(
	state: ServerState,
	user_id: OwnedUserId,
	reason: Option<String>,
	room_id: OwnedRoomId,
	via: Vec<OwnedServerName>,
) -> Result<(), JoinRoomByIdError> {
	RoomServerConnection::new(&state.nats_connection)
		.make_roomserver_request::<AddRoomMemberEvent>(
			Some(room_id),
			AddRoomMemberEventRequest {
				via,
				member_event_content: create_member_event_content(
					state.database,
					MembershipState::Join,
					user_id.clone(),
					reason,
				)
				.await?,
				member: user_id.clone(),
				sender: user_id,
			},
		)
		.await??;
	Ok(())
}

/// Handler for `POST /_matrix/client/v3/join/{roomIdOrAlias}` (See
/// <https://spec.matrix.org/latest/client-server-api/#post_matrixclientv3joinroomidoralias>).
///
/// This endpoint is used to make a user join a room with using its alias or id.
///
/// NOTE: For now, room aliases are not supported, so this endpoint will only
/// work with a room id.
async fn join_room_by_id_or_alias_handler(
	State(state): State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		join_room_by_id_or_alias::v3::Request,
	>,
) -> Result<ArminiusResponse<join_room_by_id_or_alias::v3::Response>, JoinRoomByIdError> {
	let room_id = RoomId::parse(&request.room_id_or_alias)
		// TODO(#268): Get the room by its alias once room aliases are supported.
		.map_err(|_| FeatureNotImplemented("Room Aliases".to_owned()))?;

	join_room(
		state,
		claims.user_id,
		request.reason,
		room_id.clone(),
		append_server_to_via(request.via, &room_id),
	)
	.await?;
	Ok(join_room_by_id_or_alias::v3::Response::new(room_id).into())
}

/// Handler for	`POST /_matrix/client/v3/rooms/{roomId}/join` (See
/// <https://spec.matrix.org/latest/client-server-api/#post_matrixclientv3roomsroomidjoin>).
///
/// This endpoint is used to join a room by its ID.
async fn join_room_by_id_handler(
	State(state): State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		join_room_by_id::v3::Request,
	>,
) -> Result<ArminiusResponse<join_room_by_id::v3::Response>, JoinRoomByIdError> {
	join_room(
		state,
		claims.user_id,
		request.reason,
		request.room_id.clone(),
		append_server_to_via(vec![], &request.room_id),
	)
	.await?;
	Ok(join_room_by_id::v3::Response::new(request.room_id).into())
}

/// Handler for `GET /_matrix/client/v3/rooms/{roomId}/members`
/// (See <https://spec.matrix.org/v1.14/client-server-api/#get_matrixclientv3roomsroomidmembers>)
///
/// Endpoint used to get the list of members of a room.
async fn get_member_events_handler(
	room_server: RoomServerConnection,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		get_member_events::v3::Request,
	>,
) -> Result<ArminiusResponse<get_member_events::v3::Response>, ErrorOf<GetRoomMembers>> {
	Ok(room_server
		.make_roomserver_request::<GetRoomMembers>(
			Some(request.room_id.clone()),
			(SerializingRumaRequestWrapper(request), claims.user_id),
		)
		.await??
		.0
		.into())
}

/// Handler for `POST /_matrix/client/v3/rooms/{roomId}/leave` (See
/// <https://spec.matrix.org/v1.14/client-server-api/#post_matrixclientv3roomsroomidleave>).
///
/// Endpoint used to leave a room.
async fn leave_room_handler(
	State(state): State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		leave_room::v3::Request,
	>,
) -> Result<ArminiusResponse<leave_room::v3::Response>, AddRoomMemberEventError> {
	RoomServerConnection::new(&state.nats_connection)
		.make_roomserver_request::<AddRoomMemberEvent>(
			Some(request.room_id.clone()),
			AddRoomMemberEventRequest {
				via: append_server_to_via(vec![], &request.room_id),
				member_event_content: create_member_event_content(
					state.database,
					MembershipState::Leave,
					claims.user_id.clone(),
					request.reason,
				)
				.await?,
				member: claims.user_id.clone(),
				sender: claims.user_id,
			},
		)
		.await??;

	Ok(leave_room::v3::Response::new().into())
}

/// Handler for
/// `PUT /_matrix/client/v3/rooms/{roomId}/state/{eventType}/{stateKey}` (See
/// <https://spec.matrix.org/latest/client-server-api/#put_matrixclientv3roomsroomidstateeventtypestatekey>).
///
/// Endpoint used to send a state event in a room.
async fn send_state_event_handler(
	room_server: RoomServerConnection,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		send_state_event::v3::Request,
	>,
) -> Result<ArminiusResponse<send_state_event::v3::Response>, AddNewEventError> {
	let event_id = room_server
		.make_roomserver_request::<AddNewEvent>(
			Some(request.room_id.clone()),
			NewEvent {
				event_type: request.event_type.into(),
				sender: claims.user_id,
				body: request
					.body
					.deserialize_as()
					.map_err(InputJsonError::from)
					.map_err(AddNewEventError::from)?,
				state_key: Some(request.state_key),
				timestamp: None,
				transaction_information: None,
			},
		)
		.await??;

	Ok(send_state_event::v3::Response::new(event_id).into())
}

/// Handler for `PUT /_matrix/client/v3/rooms/{roomId}/send/{eventType}/{txnId}`
/// (See <https://spec.matrix.org/latest/client-server-api/#put_matrixclientv3roomsroomidsendeventtypetxnid>).
///
/// This is the endpoint used to send message events into rooms.
async fn send_message_event_handler(
	room_server: RoomServerConnection,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		send_message_event::v3::Request,
	>,
) -> Result<ArminiusResponse<send_message_event::v3::Response>, AddNewEventError> {
	let event_id = room_server
		.make_roomserver_request::<AddNewEvent>(
			Some(request.room_id.clone()),
			NewEvent {
				event_type: request.event_type.into(),
				sender: claims.user_id,
				body: request.body.deserialize_as().map_err(InputJsonError::from)?,
				state_key: None,
				timestamp: None,
				transaction_information: Some(TransactionInformation {
					device_id: claims.device_id,
					transaction_id: request.txn_id,
				}),
			},
		)
		.await??;

	Ok(send_message_event::v3::Response::new(event_id).into())
}

/// Handler for `GET /_matrix/client/v3/rooms/{roomId}/state` (See
/// <https://spec.matrix.org/v1.15/client-server-api/#get_matrixclientv3roomsroomidstate>).
///
/// This endpoint is used to fetch the state of a room.
async fn get_state_events_handler(
	room_server: RoomServerConnection,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		get_state_events::v3::Request,
	>,
) -> Result<ArminiusResponse<get_state_events::v3::Response>, ErrorOf<GetStateEvents>> {
	Ok(room_server
		.make_roomserver_request::<GetStateEvents>(
			Some(request.room_id.clone()),
			(SerializingRumaRequestWrapper(request), claims.user_id),
		)
		.await??
		.0
		.into())
}

/// Handler for
/// `GET /_matrix/client/v3/rooms/{roomId}/state/{eventType}/{stateKey}` (See
/// <https://spec.matrix.org/v1.15/client-server-api/#get_matrixclientv3roomsroomidstateeventtypestatekey>).
///
/// This is the endpoint used to fetch a single state event of a room using its
/// type and optionally state key.
async fn get_state_events_for_key_handler(
	room_server: RoomServerConnection,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		get_state_event_for_key::v3::Request,
	>,
) -> Result<ArminiusResponse<get_state_event_for_key::v3::Response>, ErrorOf<GetStateEventsForKey>>
{
	Ok(room_server
		.make_roomserver_request::<GetStateEventsForKey>(
			Some(request.room_id.clone()),
			(SerializingRumaRequestWrapper(request), claims.user_id),
		)
		.await??
		.0
		.into())
}

/// Error when inviting a user
#[derive(thiserror::Error, Debug, MatrixApiError, FromNatsError)]
enum InviteUserError {
	/// Unrecoverable error.
	/// See <https://bundesmessenger.gitlab.io/backend/neo/arminius/arminius/03-development/errors.html#unrecoverable-errors>
	#[error(transparent)]
	InternalServerError(#[from] InternalServerError),
	/// Error when adding an event
	#[error(transparent)]
	AddRoomMemberEventError(#[from] AddRoomMemberEventError),
	/// When somebody tries to use an alias
	#[error(transparent)]
	FeatureNotImplemented(#[from] FeatureNotImplemented),
}

/// Handler for `POST /_matrix/client/v3/rooms/{roomId}/invite` (See
/// <https://spec.matrix.org/v1.15/client-server-api/#thirdparty_post_matrixclientv3roomsroomidinvite>).
///
/// This endpoint is used to invite an user to a room.
async fn invite_user_handler(
	State(state): State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		invite_user::v3::Request,
	>,
) -> Result<ArminiusResponse<invite_user::v3::Response>, InviteUserError> {
	let (user_id, reason) = match request.recipient {
		InvitationRecipient::UserId(InviteUserId { user_id, reason, .. }) => Ok((user_id, reason)),
		_ => Err(FeatureNotImplemented("Non-user-id invite subjects".to_owned())),
	}?;
	RoomServerConnection::new(&state.nats_connection)
		.make_roomserver_request::<AddRoomMemberEvent>(
			Some(request.room_id.clone()),
			AddRoomMemberEventRequest {
				via: vec![],
				member_event_content: create_member_event_content(
					state.database,
					MembershipState::Invite,
					user_id.clone(),
					reason,
				)
				.await?,
				member: user_id,
				sender: claims.user_id,
			},
		)
		.await??;

	Ok(invite_user::v3::Response::new().into())
}

/// Handler for `POST /_matrix/client/v3/rooms/{roomId}/kick` (See
/// <https://spec.matrix.org/v1.18/client-server-api/#post_matrixclientv3roomsroomidkick>).
///
/// This endpoint is used to kick a user from a room
async fn kick_user_handler(
	State(state): State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<kick_user::v3::Request>,
) -> Result<ArminiusResponse<kick_user::v3::Response>, InviteUserError> {
	RoomServerConnection::new(&state.nats_connection)
		.make_roomserver_request::<AddRoomMemberEvent>(
			Some(request.room_id.clone()),
			AddRoomMemberEventRequest {
				via: vec![],
				member_event_content: create_member_event_content(
					state.database,
					MembershipState::Leave,
					request.user_id.clone(),
					request.reason,
				)
				.await?,
				member: request.user_id,
				sender: claims.user_id,
			},
		)
		.await??;

	Ok(kick_user::v3::Response::new().into())
}

/// Handler for `POST /_matrix/client/v3/rooms/{roomId}/ban` (See
/// <https://spec.matrix.org/v1.18/client-server-api/#post_matrixclientv3roomsroomidban>).
///
/// This endpoint is used to ban a user from a room
async fn ban_user_handler(
	State(state): State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<ban_user::v3::Request>,
) -> Result<ArminiusResponse<ban_user::v3::Response>, InviteUserError> {
	RoomServerConnection::new(&state.nats_connection)
		.make_roomserver_request::<AddRoomMemberEvent>(
			Some(request.room_id.clone()),
			AddRoomMemberEventRequest {
				via: vec![],
				member_event_content: create_member_event_content(
					state.database,
					MembershipState::Ban,
					request.user_id.clone(),
					request.reason,
				)
				.await?,
				member: request.user_id,
				sender: claims.user_id,
			},
		)
		.await??;

	Ok(ban_user::v3::Response::new().into())
}

/// Handler for `POST /_matrix/client/v3/rooms/{roomId}/unban` (See
/// <https://spec.matrix.org/v1.18/client-server-api/#post_matrixclientv3roomsroomidunban>).
///
/// This endpoint is used to unban a user from a room
async fn unban_user_handler(
	State(state): State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		unban_user::v3::Request,
	>,
) -> Result<ArminiusResponse<unban_user::v3::Response>, InviteUserError> {
	RoomServerConnection::new(&state.nats_connection)
		.make_roomserver_request::<AddRoomMemberEvent>(
			Some(request.room_id.clone()),
			AddRoomMemberEventRequest {
				via: vec![],
				member_event_content: create_member_event_content(
					state.database,
					MembershipState::Leave,
					request.user_id.clone(),
					request.reason,
				)
				.await?,
				member: request.user_id,
				sender: claims.user_id,
			},
		)
		.await??;

	Ok(unban_user::v3::Response::new().into())
}

/// Handler for `POST /_matrix/client/v3/knock/{roomIdOrAlias}` (See
/// <https://spec.matrix.org/v1.15/client-server-api/#post_matrixclientv3knockroomidoralias>).
///
/// This endpoint is used to knock on a room.
///
/// NOTE: For now, only querying this endpoint with a RoomId will work, since
/// room aliases aren't implemented yet.
async fn knock_room_handler(
	State(state): State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		knock_room::v3::Request,
	>,
) -> Result<ArminiusResponse<knock_room::v3::Response>, JoinRoomByIdError> {
	let room_id = OwnedRoomId::try_from(request.room_id_or_alias.clone())
		// TODO(#268): Get the room by its alias once room aliases are supported.
		.map_err(|_| FeatureNotImplemented("Room aliases".to_owned()))?;

	RoomServerConnection::new(&state.nats_connection)
		.make_roomserver_request::<AddRoomMemberEvent>(
			Some(room_id.clone()),
			AddRoomMemberEventRequest {
				via: append_server_to_via(request.via, &room_id),
				member_event_content: create_member_event_content(
					state.database,
					MembershipState::Knock,
					claims.user_id.clone(),
					request.reason,
				)
				.await?,
				member: claims.user_id.clone(),
				sender: claims.user_id,
			},
		)
		.await??;

	Ok(knock_room::v3::Response::new(room_id).into())
}

/// Handler for `PUT /_matrix/client/v3/rooms/{roomId}/redact/{eventId}/{txnId}`
/// (See <https://spec.matrix.org/v1.16/client-server-api/#redactions>).
///
/// This endpoint is used to redact an event in a room.
async fn redact_event_handler(
	room_server: RoomServerConnection,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		redact_event::v3::Request,
	>,
) -> Result<ArminiusResponse<redact_event::v3::Response>, ErrorOf<RedactEvent>> {
	Ok(room_server
		.make_roomserver_request::<RedactEvent>(
			Some(request.room_id.clone()),
			(SerializingRumaRequestWrapper(request), claims.user_id),
		)
		.await??
		.0
		.into())
}

/// Handler for `POST /_matrix/client/v3/rooms/{roomId}/forget`
/// (See <https://spec.matrix.org/v1.14/client-server-api/#post_matrixclientv3roomsroomidforget>).
///
/// This endpoint is used to mark room as forgotten, and ready for deletion
async fn forget_room_handler(
	room_server: RoomServerConnection,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		forget_room::v3::Request,
	>,
) -> Result<ArminiusResponse<forget_room::v3::Response>, ErrorOf<ForgetRoom>> {
	room_server
		.make_roomserver_request::<ForgetRoom>(Some(request.room_id.clone()), claims.user_id)
		.await??;
	Ok(forget_room::v3::Response::new().into())
}

/// Handler for `GET /_matrix/client/v3/joined_rooms`
/// (See <https://spec.matrix.org/v1.18/client-server-api/#get_matrixclientv3joined_rooms>).
///
/// This endpoint returns the list of rooms that the user is a member of
async fn joined_rooms_handler(
	State(mut state): State<ServerState>,
	AuthenticatedClientRequest(claims, _): AuthenticatedClientRequest<joined_rooms::v3::Request>,
) -> Result<ArminiusResponse<joined_rooms::v3::Response>, InternalServerError> {
	Ok(joined_rooms::v3::Response::new(state.database.fetch_joined_rooms(&claims.user_id).await?)
		.into())
}

/// Error type for both the read receipts and the read markers endpoints.
///
/// This exists since both endpoints can produce either `ReadReceipt` or
/// `ReadMarker` roomserver requests errors (or internal server errors of
/// course).
#[derive(Debug, thiserror::Error, MatrixApiError, Serialize, Deserialize, FromNatsError)]
enum ReadReceiptOrReadMarkerError {
	/// Unrecoverable error.
	/// See <https://bundesmessenger.gitlab.io/backend/neo/arminius/arminius/03-development/errors.html#unrecoverable-errors>
	#[error(transparent)]
	InternalServerError(#[from] InternalServerError),
	/// Setting the request's read receipt failed.
	#[error(transparent)]
	ReadReceipt(#[from] ReadReceiptError),
	/// Setting the request's read marker failed.
	#[error(transparent)]
	ReadMarker(#[from] ReadMarkerError),
	/// If the received read receipt is of a custom type we do not support.
	#[error(transparent)]
	FeatureNotImplemented(#[from] FeatureNotImplemented),
}

/// Handler for `POST /_matrix/client/v3/rooms/{roomId}/receipt/{receiptType}/{eventId}` (See <https://spec.matrix.org/latest/client-server-api/#post_matrixclientv3roomsroomidreceiptreceipttypeeventid>).
///
/// This endpoint is used to update the read receipt of a specific room up to a
/// given event.
async fn create_receipt_handler(
	state: State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		create_receipt::v3::Request,
	>,
) -> Result<ArminiusResponse<create_receipt::v3::Response>, ReadReceiptOrReadMarkerError> {
	let response = create_receipt::v3::Response::new().into();
	if request.receipt_type == create_receipt::v3::ReceiptType::FullyRead {
		RoomServerConnection::new(&state.nats_connection)
			.make_roomserver_request::<SetFullyReadMarker>(
				Some(request.room_id.clone()),
				ReadMarkerRequest { user_id: claims.user_id.clone(), event_id: request.event_id },
			)
			.await??;

		return Ok(response);
	}

	let receipt_type = match request.receipt_type {
		create_receipt::v3::ReceiptType::Read => ReceiptType::Read,
		create_receipt::v3::ReceiptType::ReadPrivate => ReceiptType::ReadPrivate,
		custom => {
			return Err(FeatureNotImplemented(format!(
				"Custom receipt type '{custom}' is not handled by this server",
			))
			.into());
		}
	};

	RoomServerConnection::new(&state.nats_connection)
		.make_roomserver_request::<ReadReceipt>(
			Some(request.room_id),
			ReadReceiptRequest {
				user_id: claims.user_id,
				receipt_type,
				event_id: request.event_id,
				thread: request.thread,
				ts: chrono::Utc::now(),
				provenance: EventProvenance::Local,
			},
		)
		.await??;

	Ok(response)
}

/// Handler for `POST /_matrix/client/v3/rooms/{roomId}/read_markers` (See
/// <https://spec.matrix.org/v1.17/client-server-api/#post_matrixclientv3roomsroomidread_markers>).
///
/// This endpoints allows setting the position of the read marker for a given
/// room, and optionally the read receipts location as well.
async fn set_read_marker_handler(
	state: State<ServerState>,
	AuthenticatedClientRequest(claims, request): AuthenticatedClientRequest<
		set_read_marker::v3::Request,
	>,
) -> Result<ArminiusResponse<set_read_marker::v3::Response>, ReadReceiptOrReadMarkerError> {
	if let Some(fully_read_marker_event) = request.fully_read {
		RoomServerConnection::new(&state.nats_connection)
			.make_roomserver_request::<SetFullyReadMarker>(
				Some(request.room_id.clone()),
				ReadMarkerRequest {
					user_id: claims.user_id.clone(),
					event_id: fully_read_marker_event,
				},
			)
			.await??;
	};

	if let Some(read_receipt_event) = request.read_receipt {
		RoomServerConnection::new(&state.nats_connection)
			.make_roomserver_request::<ReadReceipt>(
				Some(request.room_id.clone()),
				ReadReceiptRequest {
					user_id: claims.user_id.clone(),
					receipt_type: ReceiptType::Read,
					event_id: read_receipt_event,
					thread: ruma::events::receipt::ReceiptThread::Unthreaded,
					ts: chrono::Utc::now(),
					provenance: EventProvenance::Local,
				},
			)
			.await??;
	};

	if let Some(private_read_receipt_event) = request.private_read_receipt {
		RoomServerConnection::new(&state.nats_connection)
			.make_roomserver_request::<ReadReceipt>(
				Some(request.room_id),
				ReadReceiptRequest {
					user_id: claims.user_id.clone(),
					receipt_type: ReceiptType::ReadPrivate,
					event_id: private_read_receipt_event,
					thread: ruma::events::receipt::ReceiptThread::Unthreaded,
					ts: chrono::Utc::now(),
					provenance: EventProvenance::Local,
				},
			)
			.await??;
	};

	Ok(set_read_marker::v3::Response::new().into())
}

/// Component implementing endpoint for client room management
#[derive(Debug)]
pub struct RoomComponent;

impl Component for RoomComponent {
	fn router() -> Router<ServerState> {
		Router::new()
			.route("/_matrix/client/v3/createRoom", post(create_room_handler))
			.route("/_matrix/client/v3/joined_rooms", get(joined_rooms_handler))
			.route(
				"/_matrix/client/v3/join/{roomIdOrAlias}",
				post(join_room_by_id_or_alias_handler),
			)
			.route("/_matrix/client/v3/knock/{roomIdOrAlias}", post(knock_room_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/ban", post(ban_user_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/event/{eventId}", get(get_room_event_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/forget", post(forget_room_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/invite", post(invite_user_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/join", post(join_room_by_id_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/kick", post(kick_user_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/leave", post(leave_room_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/members", get(get_member_events_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/read_markers", post(set_read_marker_handler))
			.route(
				"/_matrix/client/v3/rooms/{roomId}/receipt/{receiptType}/{eventId}",
				post(create_receipt_handler),
			)
			.route(
				"/_matrix/client/v3/rooms/{roomId}/redact/{eventId}/{txnId}",
				put(redact_event_handler),
			)
			.route(
				"/_matrix/client/v3/rooms/{roomId}/send/{eventType}/{txnId}",
				put(send_message_event_handler),
			)
			.route(
				"/_matrix/client/v3/rooms/{roomId}/state/{eventType}/",
				put(send_state_event_handler).get(get_state_events_for_key_handler),
			)
			.route(
				"/_matrix/client/v3/rooms/{roomId}/state/{eventType}",
				put(send_state_event_handler).get(get_state_events_for_key_handler),
			)
			.route(
				"/_matrix/client/v3/rooms/{roomId}/state/{eventType}/{stateKey}",
				put(send_state_event_handler).get(get_state_events_for_key_handler),
			)
			.route("/_matrix/client/v3/rooms/{roomId}/state", get(get_state_events_handler))
			.route("/_matrix/client/v3/rooms/{roomId}/unban", post(unban_user_handler))
	}
}