// Copyright 2019-2025 PureStake Inc.

// This file is part of Moonbeam.

// Moonbeam is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Moonbeam is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

use cumulus_primitives_core::ParaId;

use cumulus_primitives_core::XcmpMessageFormat;

use jsonrpsee::{

	core::RpcResult,

	proc_macros::rpc,

	types::{

		error::{INTERNAL_ERROR_CODE, INTERNAL_ERROR_MSG},

		ErrorObjectOwned,

	},

};

use parity_scale_codec::Encode;

use xcm::opaque::lts::Weight;

use xcm::v5::prelude::*;

use xcm_primitives::DEFAULT_PROOF_SIZE;

/// This RPC interface is used to provide methods in dev mode only

#[jsonrpsee::core::async_trait]

pub trait DevApi {

	/// Inject a downward xcm message - A message that comes from the relay chain.

	/// You may provide an arbitrary message, or if you provide an empty byte array,

	/// Then a default message (DOT transfer down to ALITH) will be injected

	#[method(name = "xcm_injectDownwardMessage")]

	async fn inject_downward_message(&self, message: Vec<u8>) -> RpcResult<()>;

	/// Inject an HRMP message - A message that comes from a dedicated channel to a sibling

	/// parachain.

	///

	/// Cumulus Parachain System seems to have a constraint that at most one hrmp message will be

	/// sent on a channel per block. At least that's what this comment implies:

	/// https://github.com/paritytech/cumulus/blob/c308c01b/pallets/parachain-system/src/lib.rs#L204

	/// Neither this RPC, nor the mock inherent data provider make any attempt to enforce this

	/// constraint. In fact, violating it may be useful for testing.

	/// The method accepts a sending paraId and a bytearray representing an arbitrary message as

	/// parameters. If you provide an emtpy byte array, then a default message representing a

	/// transfer of the sending paraId's native token will be injected.

	#[method(name = "xcm_injectHrmpMessage")]

	async fn inject_hrmp_message(&self, sender: ParaId, message: Vec<u8>) -> RpcResult<()>;

	/// Skip N relay blocks, for testing purposes

	#[method(name = "test_skipRelayBlocks")]

	async fn skip_relay_blocks(&self, n: u32) -> RpcResult<()>;

}

pub struct DevRpc {

	pub downward_message_channel: flume::Sender<Vec<u8>>,

	pub hrmp_message_channel: flume::Sender<(ParaId, Vec<u8>)>,

	pub additional_relay_offset: std::sync::Arc<std::sync::atomic::AtomicU32>,

}

#[jsonrpsee::core::async_trait]

impl DevApiServer for DevRpc {

		// If no message is supplied, inject a default one.

		} else {

		};

		// Push the message to the shared channel where it will be queued up

		// to be injected into an upcoming block.

		// If no message is supplied, inject a default one.

		} else {

		};

		// Push the message to the shared channel where it will be queued up

		// to be injected into an upcoming block.

}

// This bit cribbed from frontier.