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

// This file is part of Polkadot.

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

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

//! Various implementations for `ShouldExecute`.

use crate::{CreateMatcher, MatchXcm};

use core::{cell::Cell, marker::PhantomData, ops::ControlFlow, result::Result};

use frame_support::{

	ensure,

	traits::{Contains, Get, ProcessMessageError},

};

use polkadot_parachain_primitives::primitives::IsSystem;

use xcm::prelude::*;

use xcm_executor::traits::{CheckSuspension, OnResponse, Properties, ShouldExecute};

/// Execution barrier that just takes `max_weight` from `properties.weight_credit`.

///

/// Useful to allow XCM execution by local chain users via extrinsics.

/// E.g. `pallet_xcm::reserve_asset_transfer` to transfer a reserve asset

/// out of the local chain to another one.

pub struct TakeWeightCredit;

impl ShouldExecute for TakeWeightCredit {

			target: "xcm::barriers",

			_origin, _instructions, max_weight, properties,

		);

}

const MAX_ASSETS_FOR_BUY_EXECUTION: usize = 2;

/// Allows execution from `origin` if it is contained in `T` (i.e. `T::Contains(origin)`) taking

/// payments into account.

///

/// Only allows for `TeleportAsset`, `WithdrawAsset`, `ClaimAsset` and `ReserveAssetDeposit` XCMs

/// because they are the only ones that place assets in the Holding Register to pay for execution.

pub struct AllowTopLevelPaidExecutionFrom<T>(PhantomData<T>);

impl<T: Contains<Location>> ShouldExecute for AllowTopLevelPaidExecutionFrom<T> {

			target: "xcm::barriers",

			origin, instructions, max_weight, _properties,

		);

		// We will read up to 5 instructions. This allows up to 3 `ClearOrigin` instructions. We

		// allow for more than one since anything beyond the first is a no-op and it's conceivable

		// that composition of operations might result in more than one being appended.

					} else {

					},

				},

				},

}

/// A derivative barrier, which scans the first `MaxPrefixes` instructions for origin-alterers and

/// then evaluates `should_execute` of the `InnerBarrier` based on the remaining instructions and

/// the newly computed origin.

///

/// This effectively allows for the possibility of distinguishing an origin which is acting as a

/// router for its derivative locations (or as a bridge for a remote location) and an origin which

/// is actually trying to send a message for itself. In the former case, the message will be

/// prefixed with origin-mutating instructions.

///

/// Any barriers which should be interpreted based on the computed origin rather than the original

/// message origin should be subject to this. This is the case for most barriers since the

/// effective origin is generally more important than the routing origin. Any other barriers, and

/// especially those which should be interpreted only the routing origin should not be subject to

/// this.

///

/// E.g.

/// ```nocompile

/// type MyBarrier = (

/// 	TakeWeightCredit,

/// 	AllowTopLevelPaidExecutionFrom<DirectCustomerLocations>,

/// 	WithComputedOrigin<(

/// 		AllowTopLevelPaidExecutionFrom<DerivativeCustomerLocations>,

/// 		AllowUnpaidExecutionFrom<ParentLocation>,

/// 		AllowSubscriptionsFrom<AllowedSubscribers>,

/// 		AllowKnownQueryResponses<TheResponseHandler>,

/// 	)>,

/// );

/// ```

///

/// In the above example, `AllowUnpaidExecutionFrom` appears once underneath

/// `WithComputedOrigin`. This is in order to distinguish between messages which are notionally

/// from a derivative location of `ParentLocation` but that just happened to be sent via

/// `ParentLocation` rather than messages that were sent by the parent.

///

/// Similarly `AllowTopLevelPaidExecutionFrom` appears twice: once inside of `WithComputedOrigin`

/// where we provide the list of origins which are derivative origins, and then secondly outside

/// of `WithComputedOrigin` where we provide the list of locations which are direct origins. It's

/// reasonable for these lists to be merged into one and that used both inside and out.

///

/// Finally, we see `AllowSubscriptionsFrom` and `AllowKnownQueryResponses` are both inside of

/// `WithComputedOrigin`. This means that if a message begins with origin-mutating instructions,

/// then it must be the finally computed origin which we accept subscriptions or expect a query

/// response from. For example, even if an origin appeared in the `AllowedSubscribers` list, we

/// would ignore this rule if it began with origin mutators and they changed the origin to something

/// which was not on the list.

pub struct WithComputedOrigin<InnerBarrier, LocalUniversal, MaxPrefixes>(

	PhantomData<(InnerBarrier, LocalUniversal, MaxPrefixes)>,

);

impl<InnerBarrier: ShouldExecute, LocalUniversal: Get<InteriorLocation>, MaxPrefixes: Get<u32>>

	ShouldExecute for WithComputedOrigin<InnerBarrier, LocalUniversal, MaxPrefixes>

{

			target: "xcm::barriers",

			origin, instructions, max_weight, properties,

		);

						};

					},

				};

}

/// Sets the message ID to `t` using a `SetTopic(t)` in the last position if present.

///

/// Note that the message ID does not necessarily have to be unique; it is the

/// sender's responsibility to ensure uniqueness.

///

/// Requires some inner barrier to pass on the rest of the message.

pub struct TrailingSetTopicAsId<InnerBarrier>(PhantomData<InnerBarrier>);

impl<InnerBarrier: ShouldExecute> ShouldExecute for TrailingSetTopicAsId<InnerBarrier> {

			target: "xcm::barriers",

			origin, instructions, max_weight, properties,

		);

		} else {

		};

}

/// Barrier condition that allows for a `SuspensionChecker` that controls whether or not the XCM

/// executor will be suspended from executing the given XCM.

pub struct RespectSuspension<Inner, SuspensionChecker>(PhantomData<(Inner, SuspensionChecker)>);

impl<Inner, SuspensionChecker> ShouldExecute for RespectSuspension<Inner, SuspensionChecker>

where

	Inner: ShouldExecute,

	SuspensionChecker: CheckSuspension,

{

		} else {

		}

}

/// Allows execution from any origin that is contained in `T` (i.e. `T::Contains(origin)`).

///

/// Use only for executions from completely trusted origins, from which no permissionless messages

/// can be sent.

pub struct AllowUnpaidExecutionFrom<T>(PhantomData<T>);

impl<T: Contains<Location>> ShouldExecute for AllowUnpaidExecutionFrom<T> {

			target: "xcm::barriers",

			origin, instructions, _max_weight, _properties,

		);

}

/// Allows execution from any origin that is contained in `T` (i.e. `T::Contains(origin)`) if the

/// message begins with the instruction `UnpaidExecution`.

///

/// Use only for executions from trusted origin groups.

pub struct AllowExplicitUnpaidExecutionFrom<T>(PhantomData<T>);

impl<T: Contains<Location>> ShouldExecute for AllowExplicitUnpaidExecutionFrom<T> {

			target: "xcm::barriers",

			origin, instructions, max_weight, _properties,

		);

}

/// Allows a message only if it is from a system-level child parachain.

pub struct IsChildSystemParachain<ParaId>(PhantomData<ParaId>);

impl<ParaId: IsSystem + From<u32>> Contains<Location> for IsChildSystemParachain<ParaId> {

		)

}

/// Matches if the given location is a system-level sibling parachain.

pub struct IsSiblingSystemParachain<ParaId, SelfParaId>(PhantomData<(ParaId, SelfParaId)>);

impl<ParaId: IsSystem + From<u32> + Eq, SelfParaId: Get<ParaId>> Contains<Location>

	for IsSiblingSystemParachain<ParaId, SelfParaId>

{

		)

}

/// Matches if the given location contains only the specified amount of parents and no interior

/// junctions.

pub struct IsParentsOnly<Count>(PhantomData<Count>);

impl<Count: Get<u8>> Contains<Location> for IsParentsOnly<Count> {

}

/// Allows only messages if the generic `ResponseHandler` expects them via `expecting_response`.

pub struct AllowKnownQueryResponses<ResponseHandler>(PhantomData<ResponseHandler>);

impl<ResponseHandler: OnResponse> ShouldExecute for AllowKnownQueryResponses<ResponseHandler> {

			target: "xcm::barriers",

			origin, instructions, _max_weight, _properties,

		);

}

/// Allows execution from `origin` if it is just a straight `SubscribeVersion` or

/// `UnsubscribeVersion` instruction.

pub struct AllowSubscriptionsFrom<T>(PhantomData<T>);

impl<T: Contains<Location>> ShouldExecute for AllowSubscriptionsFrom<T> {

			target: "xcm::barriers",

			origin, instructions, _max_weight, _properties,

		);

}

/// Allows execution for the Relay Chain origin (represented as `Location::parent()`) if it is just

/// a straight `HrmpNewChannelOpenRequest`, `HrmpChannelAccepted`, or `HrmpChannelClosing`

/// instruction.

///

/// Note: This barrier fulfills safety recommendations for the mentioned instructions - see their

/// documentation.

pub struct AllowHrmpNotificationsFromRelayChain;

impl ShouldExecute for AllowHrmpNotificationsFromRelayChain {

			target: "xcm::barriers",

			origin, instructions, _max_weight, _properties,

		);

		// accept only the Relay Chain

		// accept only HRMP notifications and nothing else

				HrmpNewChannelOpenRequest { .. } |

				HrmpChannelAccepted { .. } |

}

/// Deny executing the XCM if it matches any of the Deny filter regardless of anything else.

/// If it passes the Deny, and matches one of the Allow cases then it is let through.

pub struct DenyThenTry<Deny, Allow>(PhantomData<Deny>, PhantomData<Allow>)

where

	Deny: ShouldExecute,

	Allow: ShouldExecute;

impl<Deny, Allow> ShouldExecute for DenyThenTry<Deny, Allow>

where

	Deny: ShouldExecute,

	Allow: ShouldExecute,

{

}

// See issue <https://github.com/paritytech/polkadot/issues/5233>

pub struct DenyReserveTransferToRelayChain;

impl ShouldExecute for DenyReserveTransferToRelayChain {

				InitiateReserveWithdraw {

					reserve: Location { parents: 1, interior: Here },

					..

				} |

				DepositReserveAsset { dest: Location { parents: 1, interior: Here }, .. } |

				TransferReserveAsset { dest: Location { parents: 1, interior: Here }, .. } => {

				},

				// An unexpected reserve transfer has arrived from the Relay Chain. Generally,

				// `IsReserve` should not allow this, but we just log it here.

				ReserveAssetDeposited { .. }

				{

						target: "xcm::barrier",

					);

				},

		// Permit everything else

}