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

// This file is part of Polkadot.

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

//! Cross-Consensus Message format data structures.

use crate::v2::Error as OldError;

use codec::{Decode, Encode, MaxEncodedLen};

use core::result;

use scale_info::TypeInfo;

pub use sp_weights::Weight;

use super::*;

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

pub trait GetWeight<W> {

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

}

/// Error codes used in XCM. The first errors codes have explicit indices and are part of the XCM

/// format. Those trailing are merely part of the XCM implementation; there is no expectation that

/// they will retain the same index over time.

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

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

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 MaxEncodedLen for Error {

}

impl TryFrom<OldError> for Error {

	type Error = ();

		use OldError::*;

		})

}

impl From<SendError> for Error {

			SendError::NotApplicable | SendError::Unroutable | SendError::MissingArgument =>

		}

}

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.

		}

}

pub trait PreparedMessage {

	fn weight_of(&self) -> Weight;

}

/// Type of XCM message executor.

pub trait ExecuteXcm<Call> {

	type Prepared: PreparedMessage;

	fn prepare(message: Xcm<Call>) -> result::Result<Self::Prepared, Xcm<Call>>;

	fn execute(

		origin: impl Into<MultiLocation>,

		pre: Self::Prepared,

		id: &mut XcmHash,

		weight_credit: Weight,

	) -> Outcome;

		};

	/// Execute some XCM `message` with the message `hash` 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` with the message `hash` 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.

		};

	/// Deduct some `fees` to the sovereign account of the given `location` and place them as per

	/// the convention for fees.

	fn charge_fees(location: impl Into<MultiLocation>, fees: MultiAssets) -> Result;

}

pub enum Weightless {}

impl PreparedMessage for Weightless {

	}

}

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

	type Prepared = Weightless;

	}

}

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

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

pub enum SendError {

}

/// A hash type for identifying messages.

pub type XcmHash = [u8; 32];

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

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

/// Utility for sending an XCM message to a given location.

///

/// 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 codec::Encode;

/// # use staging_xcm::v3::{prelude::*, Weight};

/// # use staging_xcm::VersionedXcm;

/// # use std::convert::Infallible;

///

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

/// struct Sender1;

/// impl SendXcm for Sender1 {

///     type Ticket = Infallible;

///     fn validate(_: &mut Option<MultiLocation>, _: &mut Option<Xcm<()>>) -> SendResult<Infallible> {

///         Err(SendError::NotApplicable)

///     }

///     fn deliver(_: Infallible) -> Result<XcmHash, SendError> {

///         unreachable!()

///     }

/// }

///

/// /// A sender that accepts a message that has an X2 junction, otherwise stops the routing.

/// struct Sender2;

/// impl SendXcm for Sender2 {

///     type Ticket = ();

///     fn validate(destination: &mut Option<MultiLocation>, message: &mut Option<Xcm<()>>) -> SendResult<()> {

///         match destination.as_ref().ok_or(SendError::MissingArgument)? {

///             MultiLocation { parents: 0, interior: X2(j1, j2) } => Ok(((), MultiAssets::new())),

///             _ => Err(SendError::Unroutable),

///         }

///     }

///     fn deliver(_: ()) -> Result<XcmHash, SendError> {

///         Ok([0; 32])

///     }

/// }

///

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

/// struct Sender3;

/// impl SendXcm for Sender3 {

///     type Ticket = ();

///     fn validate(destination: &mut Option<MultiLocation>, message: &mut Option<Xcm<()>>) -> SendResult<()> {

///         match destination.as_ref().ok_or(SendError::MissingArgument)? {

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

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

///         }

///     }

///     fn deliver(_: ()) -> Result<XcmHash, SendError> {

///         Ok([0; 32])

///     }

/// }

///

/// // 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_kind: OriginKind::Superuser,

///     require_weight_at_most: Weight::zero(),

///     call: call.into(),

/// }]);

/// let message_hash = message.using_encoded(sp_io::hashing::blake2_256);

///

/// // Sender2 will block this.

/// assert!(send_xcm::<(Sender1, Sender2, Sender3)>(Parent.into(), message.clone()).is_err());

///

/// // Sender3 will catch this.

/// assert!(send_xcm::<(Sender1, Sender3)>(Parent.into(), message.clone()).is_ok());

/// # }

/// ```

pub trait SendXcm {

	/// Intermediate value which connects the two phases of the send operation.

	type Ticket;

	/// Check whether the given `message` is deliverable to the given `destination` and if so

	/// determine the cost which will be paid by this chain to do so, returning a `Validated` token

	/// which can be used to enact delivery.

	///

	/// The `destination` and `message` must be `Some` (or else an error will be returned) and they

	/// may only be consumed if the `Err` is not `NotApplicable`.

	///

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

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

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

	fn validate(

		destination: &mut Option<MultiLocation>,

		message: &mut Option<Xcm<()>>,

	) -> SendResult<Self::Ticket>;

	/// Actually carry out the delivery operation for a previously validated message sending.

	fn deliver(ticket: Self::Ticket) -> result::Result<XcmHash, SendError>;

}

#[impl_trait_for_tuples::impl_for_tuples(30)]

impl SendXcm for Tuple {

	for_tuples! { type Ticket = (#( Option<Tuple::Ticket> ),* ); }

		} else {

		}

}

/// Convenience function for using a `SendXcm` implementation. Just interprets the `dest` and wraps

/// both in `Some` before passing them as as mutable references into `T::send_xcm`.

/// Convenience function for using a `SendXcm` implementation. Just interprets the `dest` and wraps

/// both in `Some` before passing them as as mutable references into `T::send_xcm`.

///

/// Returns either `Ok` with the price of the delivery, or `Err` with the reason why the message

/// could not be sent.

///

/// Generally you'll want to validate and get the price first to ensure that the sender can pay it

/// before actually doing the delivery.