// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

// Tanssi 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.

// Tanssi 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 Tanssi.  If not, see <http://www.gnu.org/licenses/>.

use {

    cumulus_primitives_core::{ParaId, XcmpMessageFormat},

    jsonrpsee::{core::RpcResult, proc_macros::rpc},

    parity_scale_codec::Encode,

    xcm::{latest::prelude::*, latest::Weight},

};

const DEFAULT_PROOF_SIZE: u64 = 64 * 1024;

/// This RPC interface is used to manually submit XCM messages that will be injected into a

/// parachain-enabled runtime. This allows testing XCM logic in a controlled way in integration

/// tests.

#[jsonrpsee::core::async_trait]

pub trait ManualXcmApi {

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

    /// You may provide an arbitrary message, or if you provide an emtpy 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<()>;

}

pub struct ManualXcm {

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

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

}

#[jsonrpsee::core::async_trait]

impl ManualXcmApiServer for ManualXcm {

        // 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 in to 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 in to an upcoming block.

}

// This bit cribbed from frontier.