// Copyright 2019-2021 Parity Technologies (UK) Ltd.

// This file is part of Parity Bridges Common.

// Parity Bridges Common 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.

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

#![cfg(test)]

use crate as pallet_xcm_bridge;

use bp_messages::{

	target_chain::{DispatchMessage, MessageDispatch},

	ChainWithMessages, HashedLaneId, MessageNonce,

};

use bp_runtime::{messages::MessageDispatchResult, Chain, ChainId, HashOf};

use bp_xcm_bridge::{BridgeId, BridgeLocations, LocalXcmChannelManager};

use frame_support::{

	assert_ok, derive_impl, parameter_types,

	traits::{fungible::Mutate, EitherOf, EnsureOrigin, Equals, Everything, Get, OriginTrait},

	weights::RuntimeDbWeight,

};

use frame_system::{EnsureNever, EnsureRoot, EnsureRootWithSuccess};

use pallet_xcm_bridge::congestion::{

	BlobDispatcherWithChannelStatus, CongestionLimits, HereOrLocalConsensusXcmChannelManager,

	UpdateBridgeStatusXcmChannelManager,

};

use parity_scale_codec::{Decode, Encode};

use polkadot_parachain::primitives::Sibling;

use sp_core::H256;

use sp_runtime::{

	testing::Header as SubstrateHeader,

	traits::{BlakeTwo256, ConstU32, Convert, IdentityLookup},

	AccountId32, BuildStorage, StateVersion,

};

use sp_std::{cell::RefCell, marker::PhantomData};

use xcm::latest::SendError::{MissingArgument, NotApplicable};

use xcm::prelude::*;

use xcm_builder::{

	ensure_is_remote, AllowUnpaidExecutionFrom, DispatchBlob, DispatchBlobError, FixedWeightBounds,

	InspectMessageQueues, NetworkExportTable, NetworkExportTableItem, ParentIsPreset,

	SiblingParachainConvertsVia, SovereignPaidRemoteExporter,

};

use xcm_executor::traits::{validate_export, ExportXcm};

use xcm_executor::{

	traits::{ConvertLocation, ConvertOrigin},

	XcmExecutor,

};

pub type AccountId = AccountId32;

pub type Balance = u64;

type Block = frame_system::mocking::MockBlock<TestRuntime>;

/// Lane identifier type used for tests.

pub type TestLaneIdType = HashedLaneId;

pub const SIBLING_ASSET_HUB_ID: u32 = 2001;

pub const THIS_BRIDGE_HUB_ID: u32 = 2002;

pub const BRIDGED_ASSET_HUB_ID: u32 = 1001;

parameter_types! {

	pub const DbWeight: RuntimeDbWeight = RuntimeDbWeight { read: 1, write: 2 };

	pub const ExistentialDeposit: Balance = 1;

}

#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]

impl frame_system::Config for TestRuntime {

	type AccountId = AccountId;

	type AccountData = pallet_balances::AccountData<Balance>;

	type Block = Block;

	type Lookup = IdentityLookup<Self::AccountId>;

}

#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]

impl pallet_balances::Config for TestRuntime {

	type AccountStore = System;

}

impl pallet_bridge_messages::Config for TestRuntime {

	type RuntimeEvent = RuntimeEvent;

	type WeightInfo = TestMessagesWeights;

	type ThisChain = ThisUnderlyingChain;

	type BridgedChain = BridgedUnderlyingChain;

	type BridgedHeaderChain = BridgedHeaderChain;

	type OutboundPayload = Vec<u8>;

	type InboundPayload = Vec<u8>;

	type LaneId = TestLaneIdType;

	type DeliveryPayments = ();

	type DeliveryConfirmationPayments = ();

	type OnMessagesDelivered = ();

	type MessageDispatch = TestMessageDispatch;

}

pub struct TestMessagesWeights;

impl pallet_bridge_messages::WeightInfo for TestMessagesWeights {

}

impl pallet_bridge_messages::WeightInfoExt for TestMessagesWeights {

}

parameter_types! {

	pub const HereLocation: Location = Location::here();

	pub const RelayNetwork: NetworkId = NetworkId::Kusama;

	pub UniversalLocation: InteriorLocation = [

		GlobalConsensus(RelayNetwork::get()),

		Parachain(THIS_BRIDGE_HUB_ID),

	].into();

	pub SiblingLocation: Location = Location::new(1, [Parachain(SIBLING_ASSET_HUB_ID)]);

	pub SiblingUniversalLocation: InteriorLocation = [GlobalConsensus(RelayNetwork::get()), Parachain(SIBLING_ASSET_HUB_ID)].into();

	pub const BridgedRelayNetwork: NetworkId = NetworkId::ByGenesis([1; 32]);

	pub BridgedRelayNetworkLocation: Location = (Parent, GlobalConsensus(BridgedRelayNetwork::get())).into();

	pub BridgedRelativeDestination: InteriorLocation = [Parachain(BRIDGED_ASSET_HUB_ID)].into();

	pub BridgedUniversalDestination: InteriorLocation = [GlobalConsensus(BridgedRelayNetwork::get()), Parachain(BRIDGED_ASSET_HUB_ID)].into();

	pub const NonBridgedRelayNetwork: NetworkId = NetworkId::Rococo;

	pub const BridgeDeposit: Balance = 100_000;

	// configuration for pallet_xcm_bridge_hub_router

	pub BridgeHubLocation: Location = Here.into();

	pub BridgeTable: Vec<NetworkExportTableItem>

		= vec![

			NetworkExportTableItem::new(

				BridgedRelayNetwork::get(),

				None,

				BridgeHubLocation::get(),

				None

			)

		];

	pub UnitWeightCost: Weight = Weight::from_parts(10, 10);

}

/// Implementation of `SendXcm` which uses the given `ExportXcm` implementation in order to forward

/// the message over a bridge.

///

/// This is only useful when the local chain has bridging capabilities.

pub struct LocalExporter<Exporter, UniversalLocation>(PhantomData<(Exporter, UniversalLocation)>);

impl<Exporter: ExportXcm, UniversalLocation: Get<InteriorLocation>> SendXcm

	for LocalExporter<Exporter, UniversalLocation>

{

	type Ticket = Exporter::Ticket;

		// This `clone` ensures that `dest` is not consumed in any case.

}

/// **Universal** `InteriorLocation` of bridged asset hub.

pub(crate) type TestLocalXcmChannelManager = TestingLocalXcmChannelManager<

	BridgeId,

	HereOrLocalConsensusXcmChannelManager<

		BridgeId,

		// handles congestion for `XcmOverBridgeByExportXcmRouter`

		XcmOverBridgeByExportXcmRouter,

		// handles congestion for `XcmOverBridgeWrappedWithExportMessageRouter`

		UpdateBridgeStatusXcmChannelManager<

			TestRuntime,

			(),

			UpdateBridgeStatusXcmProvider,

			FromBridgeHubLocationXcmSender<ExecuteXcmOverSendXcm>,

		>,

	>,

>;

impl pallet_xcm_bridge::Config for TestRuntime {

	type RuntimeEvent = RuntimeEvent;

	type WeightInfo = ();

	type UniversalLocation = UniversalLocation;

	type BridgedNetwork = BridgedRelayNetworkLocation;

	type BridgeMessagesPalletInstance = ();

	type MessageExportPrice = ();

	type DestinationVersion = AlwaysLatest;

	type ForceOrigin = EnsureNever<()>;

	type OpenBridgeOrigin = EitherOf<

		// We want to translate `RuntimeOrigin::root()` to the `Location::here()`

		EnsureRootWithSuccess<AccountId, HereLocation>,

		OpenBridgeOrigin,

	>;

	type BridgeOriginAccountIdConverter = LocationToAccountId;

	type BridgeDeposit = BridgeDeposit;

	type Currency = Balances;

	type RuntimeHoldReason = RuntimeHoldReason;

	type AllowWithoutBridgeDeposit = (Equals<ParentRelayChainLocation>, Equals<HereLocation>);

	type LocalXcmChannelManager = TestLocalXcmChannelManager;

	type BlobDispatcher = BlobDispatcherWithChannelStatus<TestBlobDispatcher, TestBlobDispatcher>;

	type CongestionLimits = TestCongestionLimits;

}

#[cfg(feature = "runtime-benchmarks")]

impl crate::benchmarking::Config<()> for TestRuntime {

	fn open_bridge_origin() -> Option<(RuntimeOrigin, Balance)> {

		Some((

			OpenBridgeOrigin::sibling_parachain_origin(),

			ExistentialDeposit::get(),

		))

	}

}

/// A router instance simulates a scenario where the router is deployed on a different chain than

/// the `MessageExporter`. This means that the router sends an `ExportMessage`.

pub type XcmOverBridgeWrappedWithExportMessageRouterInstance = ();

#[derive_impl(pallet_xcm_bridge_router::config_preludes::TestDefaultConfig)]

impl pallet_xcm_bridge_router::Config<XcmOverBridgeWrappedWithExportMessageRouterInstance>

	for TestRuntime

{

	// We use `SovereignPaidRemoteExporter` here to test and ensure that the `ExportMessage`

	// produced by `pallet_xcm_bridge_hub_router` is compatible with the `ExportXcm` implementation

	// of `pallet_xcm_bridge_hub`.

	type MessageExporter = SovereignPaidRemoteExporter<

		pallet_xcm_bridge_router::impls::ViaRemoteBridgeExporter<

			TestRuntime,

			// () - means `pallet_xcm_bridge_router::Config<()>`

			(),

			NetworkExportTable<BridgeTable>,

			BridgedRelayNetwork,

			BridgeHubLocation,

		>,

		// **Note**: The crucial part is that `ExportMessage` is processed by `XcmExecutor`, which

		// calls the `ExportXcm` implementation of `pallet_xcm_bridge_hub` as the

		// `MessageExporter`.

		ExecuteXcmOverSendXcm,

		ExportMessageOriginUniversalLocation,

	>;

	type BridgeIdResolver = pallet_xcm_bridge_router::impls::EnsureIsRemoteBridgeIdResolver<

		ExportMessageOriginUniversalLocation,

	>;

	// We convert to root here `BridgeHubLocationXcmOriginAsRoot`

	type UpdateBridgeStatusOrigin = EnsureRoot<AccountId>;

}

/// A router instance simulates a scenario where the router is deployed on the same chain as the

/// `MessageExporter`. This means that the router triggers `ExportXcm` trait directly.

pub type XcmOverBridgeByExportXcmRouterInstance = pallet_xcm_bridge_router::Instance2;

#[derive_impl(pallet_xcm_bridge_router::config_preludes::TestDefaultConfig)]

impl pallet_xcm_bridge_router::Config<XcmOverBridgeByExportXcmRouterInstance> for TestRuntime {

	// We use `LocalExporter` with `ViaLocalBridgeExporter` here to test and ensure that

	// `pallet_xcm_bridge_hub_router` can trigger directly `pallet_xcm_bridge_hub` as exporter.

	type MessageExporter = pallet_xcm_bridge_router::impls::ViaLocalBridgeExporter<

		TestRuntime,

		XcmOverBridgeByExportXcmRouterInstance,

		LocalExporter<XcmOverBridge, UniversalLocation>,

	>;

	type BridgeIdResolver =

		pallet_xcm_bridge_router::impls::EnsureIsRemoteBridgeIdResolver<UniversalLocation>;

	// We don't need to support here `update_bridge_status`.

	type UpdateBridgeStatusOrigin = EnsureNever<()>;

}

/// A dynamic way to set different universal location for the origin which sends `ExportMessage`.

pub struct ExportMessageOriginUniversalLocation;

impl ExportMessageOriginUniversalLocation {

}

impl Get<InteriorLocation> for ExportMessageOriginUniversalLocation {

}

pub struct BridgeHubLocationXcmOriginAsRoot<RuntimeOrigin>(PhantomData<RuntimeOrigin>);

impl<RuntimeOrigin: OriginTrait> ConvertOrigin<RuntimeOrigin>

	for BridgeHubLocationXcmOriginAsRoot<RuntimeOrigin>

{

		} else {

		}

}

pub struct XcmConfig;

impl xcm_executor::Config for XcmConfig {

	type RuntimeCall = RuntimeCall;

	type XcmSender = ();

	type AssetTransactor = ();

	type OriginConverter = BridgeHubLocationXcmOriginAsRoot<RuntimeOrigin>;

	type IsReserve = ();

	type IsTeleporter = ();

	type UniversalLocation = UniversalLocation;

	type Barrier = AllowUnpaidExecutionFrom<Everything>;

	type Weigher = FixedWeightBounds<UnitWeightCost, RuntimeCall, ConstU32<100>>;

	type Trader = ();

	type ResponseHandler = ();

	type AssetTrap = ();

	type AssetClaims = ();

	type SubscriptionService = ();

	type PalletInstancesInfo = ();

	type MaxAssetsIntoHolding = ();

	type AssetLocker = ();

	type AssetExchanger = ();

	type FeeManager = ();

	// We just set `MessageExporter` as our `pallet_xcm_bridge_hub` instance.

	type MessageExporter = (XcmOverBridge,);

	type UniversalAliases = ();

	type CallDispatcher = RuntimeCall;

	type SafeCallFilter = Everything;

	type Aliasers = ();

	type TransactionalProcessor = ();

	type HrmpNewChannelOpenRequestHandler = ();

	type HrmpChannelAcceptedHandler = ();

	type HrmpChannelClosingHandler = ();

	type XcmRecorder = ();

}

/// The `SendXcm` implementation directly executes XCM using `XcmExecutor`.

pub struct ExecuteXcmOverSendXcm;

impl SendXcm for ExecuteXcmOverSendXcm {

	type Ticket = Xcm<()>;

}

impl InspectMessageQueues for ExecuteXcmOverSendXcm {

	}

	}

}

impl ExecuteXcmOverSendXcm {

}

/// Type for specifying how a `Location` can be converted into an `AccountId`. This is used

/// when determining ownership of accounts for asset transacting and when attempting to use XCM

/// `Transact` in order to determine the dispatch Origin.

pub type LocationToAccountId = (

	// The parent (Relay-chain) origin converts to the parent `AccountId`.

	ParentIsPreset<AccountId>,

	// Sibling parachain origins convert to AccountId via the `ParaId::into`.

	SiblingParachainConvertsVia<Sibling, AccountId>,

);

parameter_types! {

	pub ParentRelayChainLocation: Location = Location { parents: 1, interior: Here };

}

pub struct OpenBridgeOrigin;

impl OpenBridgeOrigin {

}

impl EnsureOrigin<RuntimeOrigin> for OpenBridgeOrigin {

	type Success = Location;

	#[cfg(feature = "runtime-benchmarks")]

	fn try_successful_origin() -> Result<RuntimeOrigin, ()> {

		Ok(Self::parent_relay_chain_origin())

	}

}

pub(crate) type OpenBridgeOriginOf<T, I> = <T as pallet_xcm_bridge::Config<I>>::OpenBridgeOrigin;

/// Testing wrapper implementation of `LocalXcmChannelManager`, that supports storing flags in

/// storage to facilitate testing of `LocalXcmChannelManager` implementation.

pub struct TestingLocalXcmChannelManager<Bridge, Tested>(PhantomData<(Bridge, Tested)>);

impl<Bridge: Encode + sp_std::fmt::Debug, Tested> TestingLocalXcmChannelManager<Bridge, Tested> {

}

impl<Bridge: Encode + sp_std::fmt::Debug + Copy, Tested: LocalXcmChannelManager<Bridge>>

	LocalXcmChannelManager<Bridge> for TestingLocalXcmChannelManager<Bridge, Tested>

{

	type Error = Tested::Error;

}

/// Converts encoded call to the unpaid XCM `Transact`.

pub struct UpdateBridgeStatusXcmProvider;

impl Convert<Vec<u8>, Xcm<()>> for UpdateBridgeStatusXcmProvider {

}

/// `SendXcm` implementation which sets `BridgeHubLocation` as origin for `ExecuteXcmOverSendXcm`.

pub struct FromBridgeHubLocationXcmSender<Inner>(PhantomData<Inner>);

impl<Inner: SendXcm> SendXcm for FromBridgeHubLocationXcmSender<Inner> {

	type Ticket = Inner::Ticket;

}

pub struct TestBlobDispatcher;

impl TestBlobDispatcher {

}

impl pallet_xcm_bridge::DispatchChannelStatusProvider for TestBlobDispatcher {

}

impl DispatchBlob for TestBlobDispatcher {

}

pub struct ThisUnderlyingChain;

impl Chain for ThisUnderlyingChain {

	const ID: ChainId = *b"tuch";

	type BlockNumber = u64;

	type Hash = H256;

	type Hasher = BlakeTwo256;

	type Header = SubstrateHeader;

	type AccountId = AccountId;

	type Balance = Balance;

	type Nonce = u64;

	type Signature = sp_runtime::MultiSignature;

	const STATE_VERSION: StateVersion = StateVersion::V1;

}

impl ChainWithMessages for ThisUnderlyingChain {

	const WITH_CHAIN_MESSAGES_PALLET_NAME: &'static str = "WithThisChainBridgeMessages";

	const MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX: MessageNonce = 16;

	const MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX: MessageNonce = 128;

}

pub type BridgedHeaderHash = H256;

pub type BridgedChainHeader = SubstrateHeader;

pub struct BridgedUnderlyingChain;

impl Chain for BridgedUnderlyingChain {

	const ID: ChainId = *b"bgdc";

	type BlockNumber = u64;

	type Hash = BridgedHeaderHash;

	type Hasher = BlakeTwo256;

	type Header = BridgedChainHeader;

	type AccountId = AccountId;

	type Balance = Balance;

	type Nonce = u64;

	type Signature = sp_runtime::MultiSignature;

	const STATE_VERSION: StateVersion = StateVersion::V1;

}

impl ChainWithMessages for BridgedUnderlyingChain {

	const WITH_CHAIN_MESSAGES_PALLET_NAME: &'static str = "WithBridgedChainBridgeMessages";

	const MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX: MessageNonce = 16;

	const MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX: MessageNonce = 128;

}

pub struct BridgedHeaderChain;

impl bp_header_chain::HeaderChain<BridgedUnderlyingChain> for BridgedHeaderChain {

	}

}

/// Test message dispatcher.

pub struct TestMessageDispatch;

impl TestMessageDispatch {

}

impl MessageDispatch for TestMessageDispatch {

	type DispatchPayload = Vec<u8>;

	type DispatchLevelResult = ();

	type LaneId = TestLaneIdType;

}

/// Return test externalities to use in tests.

/// Run pallet test.