// Copyright (C) Parity Technologies (UK) Ltd.

// This file is part of Cumulus.

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

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

//! Cross-Consensus Message format data structures.

use crate::v3::Error as NewError;

use codec::{Decode, Encode};

use core::result;

use scale_info::TypeInfo;

use super::*;

// A simple trait to get the weight of some object.

pub trait GetWeight<W> {

	fn weight(&self) -> sp_weights::Weight;

}

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum Error {

	// Errors that happen due to instructions being executed. These alone are defined in the

	// XCM specification.

	#[codec(index = 21)]

	// Errors that happen prior to instructions being executed. These fall outside of the XCM

	// spec.

}

impl TryFrom<NewError> for Error {

	type Error = ();

		use NewError::*;

		})

}

impl From<SendError> for Error {

		}

}

pub type Result = result::Result<(), Error>;

/// Outcome of an XCM execution.

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum Outcome {

	/// was used.

}

impl Outcome {

		}

		}

	/// How much weight was used by the XCM execution attempt.

		}

}

/// Type of XCM message executor.

pub trait ExecuteXcm<RuntimeCall> {

	/// Execute some XCM `message` from `origin` using no more than `weight_limit` weight. The

	/// weight limit is a basic hard-limit and the implementation may place further restrictions or

	/// requirements on weight and other aspects.

			target: "xcm::execute_xcm",

			origin,

			message,

			weight_limit,

		);

	/// Execute some XCM `message` from `origin` using no more than `weight_limit` weight.

	///

	/// Some amount of `weight_credit` may be provided which, depending on the implementation, may

	/// allow execution without associated payment.

	fn execute_xcm_in_credit(

		origin: impl Into<MultiLocation>,

		message: Xcm<RuntimeCall>,

		weight_limit: Weight,

		weight_credit: Weight,

	) -> Outcome;

}

impl<C> ExecuteXcm<C> for () {

}

/// Error result value when attempting to send an XCM message.

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum SendError {

	///

	/// This is not considered fatal: if there are alternative transport routes available, then

	/// they may be attempted. For this reason, the destination and message are contained.

}

/// Result value when attempting to send an XCM message.

pub type SendResult = result::Result<(), SendError>;

/// Utility for sending an XCM message.

///

/// These can be amalgamated in tuples to form sophisticated routing systems. In tuple format, each

/// router might return `NotApplicable` to pass the execution to the next sender item. Note that

/// each `NotApplicable` might alter the destination and the XCM message for to the next router.

///

///

/// # Example

/// ```rust

/// # use staging_xcm::v2::prelude::*;

/// # use codec::Encode;

///

/// /// A sender that only passes the message through and does nothing.

/// struct Sender1;

/// impl SendXcm for Sender1 {

///     fn send_xcm(destination: impl Into<MultiLocation>, message: Xcm<()>) -> SendResult {

///         return Err(SendError::NotApplicable(destination.into(), message))

///     }

/// }

///

/// /// A sender that accepts a message that has two junctions, otherwise stops the routing.

/// struct Sender2;

/// impl SendXcm for Sender2 {

///     fn send_xcm(destination: impl Into<MultiLocation>, message: Xcm<()>) -> SendResult {

///         let destination = destination.into();

///         if destination.parents == 0 && destination.interior.len() == 2 {

///             Ok(())

///         } else {

///             Err(SendError::Unroutable)

///         }

///     }

/// }

///

/// /// A sender that accepts a message from a parent, passing through otherwise.

/// struct Sender3;

/// impl SendXcm for Sender3 {

///     fn send_xcm(destination: impl Into<MultiLocation>, message: Xcm<()>) -> SendResult {

///         let destination = destination.into();

///         match destination {

///             MultiLocation { parents: 1, interior: Here } => Ok(()),

///             _ => Err(SendError::NotApplicable(destination, message)),

///         }

///     }

/// }

///

/// // A call to send via XCM. We don't really care about this.

/// # fn main() {

/// let call: Vec<u8> = ().encode();

/// let message = Xcm(vec![Instruction::Transact {

///     origin_type: OriginKind::Superuser,

///     require_weight_at_most: 0,

///     call: call.into(),

/// }]);

///

/// assert!(

///     // Sender2 will block this.

///     <(Sender1, Sender2, Sender3) as SendXcm>::send_xcm(Parent, message.clone())

///         .is_err()

/// );

///

/// assert!(

///     // Sender3 will catch this.

///     <(Sender1, Sender3) as SendXcm>::send_xcm(Parent, message.clone())

///         .is_ok()

/// );

/// # }

/// ```

pub trait SendXcm {

	/// Send an XCM `message` to a given `destination`.

	///

	/// If it is not a destination which can be reached with this type but possibly could by others,

	/// then it *MUST* return `NotApplicable`. Any other error will cause the tuple implementation

	/// to exit early without trying other type fields.

	fn send_xcm(destination: impl Into<MultiLocation>, message: Xcm<()>) -> SendResult;

}

#[impl_trait_for_tuples::impl_for_tuples(30)]

impl SendXcm for Tuple {

}