// Copyright (C) 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_router;

use crate::impls::EnsureIsRemoteBridgeIdResolver;

use bp_xcm_bridge_router::{BridgeState, ResolveBridgeId};

use frame_support::{

	construct_runtime, derive_impl, parameter_types,

	traits::{Contains, Equals},

};

use frame_system::EnsureRoot;

use parity_scale_codec::Encode;

use sp_runtime::{traits::ConstU128, BuildStorage};

use sp_std::cell::RefCell;

use xcm::prelude::*;

use xcm_builder::{

	InspectMessageQueues, NetworkExportTable, NetworkExportTableItem, SovereignPaidRemoteExporter,

};

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

/// HRMP fee.

pub const HRMP_FEE: u128 = 500;

/// Base bridge fee.

pub const BASE_FEE: u128 = 1_000_000;

/// Byte bridge fee.

pub const BYTE_FEE: u128 = 1_000;

parameter_types! {

	pub ThisNetworkId: NetworkId = Polkadot;

	pub BridgedNetworkId: NetworkId = Kusama;

	pub UniversalLocation: InteriorLocation = [GlobalConsensus(ThisNetworkId::get()), Parachain(1000)].into();

	pub SiblingBridgeHubLocation: Location = ParentThen([Parachain(1002)].into()).into();

	pub BridgeFeeAsset: AssetId = Location::parent().into();

	pub BridgeTable: Vec<NetworkExportTableItem>

		= vec![

			NetworkExportTableItem::new(

				BridgedNetworkId::get(),

				None,

				SiblingBridgeHubLocation::get(),

				Some((BridgeFeeAsset::get(), BASE_FEE).into())

			)

		];

	pub UnknownXcmVersionForRoutableLocation: Location = Location::new(2, [GlobalConsensus(BridgedNetworkId::get()), Parachain(9999)]);

}

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

impl frame_system::Config for TestRuntime {

	type Block = Block;

}

/// Simple implementation where every dest resolves to the exact one `BridgeId`.

pub struct EveryDestinationToSameBridgeIdResolver;

impl ResolveBridgeId for EveryDestinationToSameBridgeIdResolver {

	type BridgeId = ();

}

/// An instance of `pallet_xcm_bridge_hub_router` configured to use a remote exporter with the

/// `ExportMessage` instruction, which will be delivered to a sibling parachain using

/// `SiblingBridgeHubLocation`.

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

impl pallet_xcm_bridge_router::Config<()> for TestRuntime {

	type DestinationVersion =

		LatestOrNoneForLocationVersionChecker<Equals<UnknownXcmVersionForRoutableLocation>>;

	type MessageExporter = SovereignPaidRemoteExporter<

		pallet_xcm_bridge_router::impls::ViaRemoteBridgeExporter<

			TestRuntime,

			(),

			NetworkExportTable<BridgeTable>,

			BridgedNetworkId,

			SiblingBridgeHubLocation,

		>,

		TestXcmRouter,

		UniversalLocation,

	>;

	type BridgeIdResolver = EnsureIsRemoteBridgeIdResolver<UniversalLocation>;

	type UpdateBridgeStatusOrigin = EnsureRoot<u64>;

	type ByteFee = ConstU128<BYTE_FEE>;

	type FeeAsset = BridgeFeeAsset;

}

pub struct LatestOrNoneForLocationVersionChecker<Location>(sp_std::marker::PhantomData<Location>);

impl<LocationValue: Contains<Location>> GetVersion

	for LatestOrNoneForLocationVersionChecker<LocationValue>

{

}

pub struct TestXcmRouter;

impl TestXcmRouter {

}

thread_local! {

	pub static SENT_XCM: RefCell<Vec<(Location, Xcm<()>)>> = RefCell::new(Vec::new());

}

impl SendXcm for TestXcmRouter {

	type Ticket = (Location, Xcm<()>);

}

impl InspectMessageQueues for TestXcmRouter {

}

/// Return test externalities to use in tests.

/// Run pallet test.

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

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

	fn ensure_bridged_target_destination() -> Result<Location, frame_benchmarking::BenchmarkError> {

		Ok(Location::new(2, [GlobalConsensus(BridgedNetworkId::get())]))

	}

	fn update_bridge_status_origin() -> Option<RuntimeOrigin> {

		Some(RuntimeOrigin::root())

	}

}