use crate::nats_types::CreateMapfixRequest;
use crate::create::CreateRequest;

#[allow(dead_code)]
#[derive(Debug)]
pub enum Error{
	Create(crate::create::Error),
	ApiActionMapfixCreate(submissions_api::Error),
}
impl std::fmt::Display for Error{
	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
		write!(f,"{self:?}")
	}
}
impl std::error::Error for Error{}

impl crate::message_handler::MessageHandler{
	async fn create_mapfix_inner(&self,create_info:CreateMapfixRequest)->Result<(),Error>{
		// call deduplicated inner code
		let create_request=self.create_inner(CreateRequest{
			ModelID:create_info.ModelID,
		}).await.map_err(Error::Create)?;

		// call create on api
		self.api.create_mapfix(submissions_api::types::CreateMapfixRequest{
			OperationID:create_info.OperationID,
			AssetOwner:create_request.AssetOwner as i64,
			DisplayName:create_request.DisplayName.as_deref().unwrap_or_default(),
			Creator:create_request.Creator.as_deref().unwrap_or_default(),
			// not great TODO: make this great
			GameID:create_request.GameID.unwrap_or(crate::rbx_util::GameID::Bhop) as i32,
			AssetID:create_info.ModelID,
			AssetVersion:create_request.AssetVersion,
			TargetAssetID:create_info.TargetAssetID,
			Description:create_info.Description.as_str(),
		}).await.map_err(Error::ApiActionMapfixCreate)?;

		Ok(())
	}
	pub async fn create_mapfix(&self,create_info:CreateMapfixRequest)->Result<(),submissions_api::Error>{
		let operation_id=create_info.OperationID;

		let create_result=self.create_mapfix_inner(create_info).await;

		if let Err(e)=create_result{
			self.api.action_operation_failed(submissions_api::types::ActionOperationFailedRequest{
				OperationID:operation_id,
				StatusMessage:e.to_string(),
			}).await?;
		}

		Ok(())
	}
}