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

//! A pallet that can be used as an alternative in the XCM router configuration — see the `SendXcm`

//! implementation for details.

//!

//! ## Features

//!

//! This pallet offers several optional features to customize functionality:

//!

//! ### Message Size Fee

//! An optional fee based on `T::FeeAsset` and `T::ByteFee`. If `T::FeeAsset` is not specified, this

//! fee is not calculated.

//!

//! ### Dynamic Fees and Congestion

//!

//! This pallet supports storing the congestion status of bridge outbound queues. The fee increases

//! exponentially if the queue between this chain and a sibling or child bridge hub becomes

//! congested. All other bridge hub queues provide backpressure mechanisms, so if any of these

//! queues are congested, it will eventually lead to increased queuing on this chain.

//!

//! There are two methods for storing congestion status:

//! 1. A dedicated extrinsic `update_bridge_status`, which relies on `T::UpdateBridgeStatusOrigin`.

//!    This allows the message exporter to send, for example, an XCM `Transact`.

//! 2. An implementation of `bp_xcm_bridge::LocalXcmChannelManager`.

//!

//! ## Usage

//!

//! This pallet provides several implementations, such as `ViaLocalBridgeExporter` and

//! `ViaRemoteBridgeExporter`, which can expose or access these features.

//!

//! This router can be used in two main scenarios, depending on where the router and message

//! exporter (e.g., `pallet_xcm_bridge_hub` or another pallet with an `ExportXcm` implementation)

//! are deployed:

//!

//! ### On the Same Chain as the Message Exporter

//! In this setup, the router directly calls an `ExportXcm` implementation. In this case,

//! `ViaLocalBridgeExporter` can be used as a wrapper with `T::MessageExporter`.

//!

//! ### On a Different Chain than the Message Exporter

//! In this setup, we need to provide a `SendXcm` implementation for `T::MessageExporter`, which

//! sends `ExportMessage`. For example, `SovereignPaidRemoteExporter` can be used with

//! `ViaRemoteBridgeExporter`.

//!

//! **Note on Terminology**: When we refer to the bridge hub, we mean the chain that has the

//! `pallet-bridge-messages` with an `ExportXcm` implementation deployed, such as

//! `pallet-xcm-bridge`. Depending on the deployment setup, `T::MessageExporter` can be

//! configured accordingly — see `T::MessageExporter` for additional documentation.

#![cfg_attr(not(feature = "std"), no_std)]

pub use bp_xcm_bridge_router::{BridgeState, ResolveBridgeId};

use frame_support::traits::{EnsureOriginWithArg, Get};

use parity_scale_codec::Encode;

use sp_runtime::{FixedPointNumber, FixedU128, Saturating};

use sp_std::vec::Vec;

use xcm::prelude::*;

use xcm_builder::InspectMessageQueues;

pub use pallet::*;

pub use weights::WeightInfo;

pub mod benchmarking;

pub mod impls;

pub mod weights;

mod mock;

#[cfg(test)]

mod tests;

/// Minimal delivery fee factor.

pub const MINIMAL_DELIVERY_FEE_FACTOR: FixedU128 = FixedU128::from_u32(1);

/// The factor that is used to increase current message fee factor when bridge experiencing

/// some lags.

const EXPONENTIAL_FEE_BASE: FixedU128 = FixedU128::from_rational(105, 100); // 1.05

/// The factor that is used to increase current message fee factor for every sent kilobyte.

const MESSAGE_SIZE_FEE_BASE: FixedU128 = FixedU128::from_rational(1, 1000); // 0.001

/// Maximal size of the XCM message that may be sent over bridge.

///

/// This should be less than the maximal size, allowed by the messages pallet, because

/// the message itself is wrapped in other structs and is double encoded.

pub const HARD_MESSAGE_SIZE_LIMIT: u32 = 32 * 1024;

/// The target that will be used when publishing logs related to this pallet.

pub const LOG_TARGET: &str = "xcm::bridge-router";

pub mod pallet {

	use super::*;

	use frame_support::pallet_prelude::*;

	use frame_system::pallet_prelude::*;

	/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].

	pub mod config_preludes {

		use super::*;

		use frame_support::{derive_impl, traits::ConstU128};

		/// A type providing default configurations for this pallet in testing environment.

		pub struct TestDefaultConfig;

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

		impl frame_system::DefaultConfig for TestDefaultConfig {}

		#[frame_support::register_default_impl(TestDefaultConfig)]

		impl DefaultConfig for TestDefaultConfig {

			#[inject_runtime_type]

			type RuntimeEvent = ();

			type WeightInfo = ();

			type DestinationVersion = AlwaysLatest;

			// We don't need (optional) message_size fees.

			type ByteFee = ConstU128<0>;

			// We don't need (optional) message_size fees.

			type FeeAsset = ();

		}

	}

	#[pallet::config(with_default)]

	pub trait Config<I: 'static = ()>: frame_system::Config {

		/// The overarching event type.

		#[pallet::no_default_bounds]

		type RuntimeEvent: From<Event<Self, I>>

			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// Benchmarks results from runtime we're plugged into.

		type WeightInfo: WeightInfo;

		/// Checks the XCM version for the destination.

		type DestinationVersion: GetVersion;

		/// The bridge hub may be:

		/// - A system (sibling) bridge hub parachain (or another chain), in which case we need an

		///   implementation for `T::MessageExporter` that sends `ExportMessage`, e.g.,

		///   `SovereignPaidRemoteExporter`.

		/// - The local chain, in which case we need an implementation for `T::MessageExporter` that

		///   does not use `ExportMessage` but instead directly calls the `ExportXcm`

		///   implementation.

		#[pallet::no_default]

		type MessageExporter: SendXcm;

		/// Resolves a specific `BridgeId` for `dest`, used for identifying the bridge in cases of

		/// congestion and dynamic fees. If it resolves to `None`, it means no congestion or

		/// dynamic fees are handled for `dest`.

		#[pallet::no_default]

		type BridgeIdResolver: ResolveBridgeId;

		/// Origin that is allowed to update bridge status,

		/// e.g. the sibling bridge hub or governance as root.

		#[pallet::no_default]

		type UpdateBridgeStatusOrigin: EnsureOriginWithArg<Self::RuntimeOrigin, BridgeIdOf<Self, I>>;

		/// Additional fee that is paid for every byte of the outbound message.

		/// See `calculate_message_size_fee` for more details.

		type ByteFee: Get<u128>;

		/// Asset used to pay the `ByteFee`.

		/// If not specified, the `ByteFee` is ignored.

		/// See `calculate_fees` for more details.

		type FeeAsset: Get<Option<AssetId>>;

	}

	/// An alias for the `BridgeId` of configured `T::BridgeIdResolver`.

	pub type BridgeIdOf<T, I> = <<T as Config<I>>::BridgeIdResolver as ResolveBridgeId>::BridgeId;

	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);

	impl<T: Config<I>, I: 'static> Pallet<T, I> {

		/// Notification about congested bridge queue.

		#[pallet::call_index(0)]

		#[pallet::weight(T::WeightInfo::update_bridge_status())]

		pub fn update_bridge_status(

			origin: OriginFor<T>,

			bridge_id: BridgeIdOf<T, I>,

			is_congested: bool,

				bridge_id,

				is_congested,

			);

			// update status

		}

	}

	/// Stores `BridgeState` for congestion control and dynamic fees for each resolved bridge ID

	/// associated with a destination.

	pub type Bridges<T: Config<I>, I: 'static = ()> =

		StorageMap<_, Blake2_128Concat, BridgeIdOf<T, I>, BridgeState, OptionQuery>;

	impl<T: Config<I>, I: 'static> Pallet<T, I> {

		/// Called when new message is sent to the `dest` (queued to local outbound XCM queue).

				// not supported bridge id, so do nothing

			};

			// handle congestion and fee factor (if detected)

						bridge_id,

						previous_factor,

						bridge_state.delivery_fee_factor,

						dest

					);

				}

		/// Returns the recalculated dynamic fee for a given asset based on the bridge state.

		///

		/// This function adjusts the amount of a fungible asset according to the delivery fee

		/// factor specified in the `bridge_state`. If the asset is fungible, the

		/// `delivery_fee_factor` is applied to the asset’s amount, potentially altering its

		/// value.

				}

			}

		/// Calculates an (optional) fee for message size based on `T::ByteFee` and `T::FeeAsset`.

			// Apply message size `T::ByteFee/T::FeeAsset` feature (if configured).

		/// Updates the congestion status of a bridge for a given `bridge_id`.

		///

		/// If the bridge does not exist and:

		/// - `is_congested` is true, a new `BridgeState` is created with a default

		///   `delivery_fee_factor`.

		/// - `is_congested` is false, does nothing and no `BridgeState` is created.

				}

				None => {

				}

	}

	pub enum Event<T: Config<I>, I: 'static = ()> {

		DeliveryFeeFactorDecreased {

			/// Previous value of the `DeliveryFeeFactor`.

			previous_value: FixedU128,

			/// New value of the `DeliveryFeeFactor`.

			new_value: FixedU128,

			/// Bridge identifier.

			bridge_id: BridgeIdOf<T, I>,

		},

		DeliveryFeeFactorIncreased {

			/// Previous value of the `DeliveryFeeFactor`.

			previous_value: FixedU128,

			/// New value of the `DeliveryFeeFactor`.

			new_value: FixedU128,

			/// Bridge identifier.

			bridge_id: BridgeIdOf<T, I>,

		},

	}

}

// This pallet acts as the `SendXcm` to the sibling/child bridge hub instead of regular

// XCMP/DMP transport. This allows injecting dynamic message fees into XCM programs that

// are going to the bridged network.

impl<T: Config<I>, I: 'static> SendXcm for Pallet<T, I> {

	type Ticket = (u32, Location, <T::MessageExporter as SendXcm>::Ticket);

		// In case of success, the `T::MessageExporter` can modify XCM instructions and consume

		// `dest` / `xcm`, so we retain the clone of original message and the destination for later

		// `DestinationVersion` validation.

				// If the ticket is ok, it means we are routing with this router, so we need to

				// apply more validations to the cloned `dest` and `xcm`, which are required here.

				// We won't have access to `dest` and `xcm` in the `deliver` method, so we need to

				// precompute everything required here. However, `dest` and `xcm` were consumed by

				// `T::MessageExporter`, so we need to use their clones.

				// We need to ensure that the known `dest`'s XCM version can comprehend the current

				// `xcm` program. This may seem like an additional, unnecessary check, but it is

				// not. A similar check is probably performed by the `T::MessageExporter`, which

				// attempts to send a versioned message to the sibling bridge hub. However, the

				// local bridge hub may have a higher XCM version than the remote `dest`. Once

				// again, it is better to discard such messages here than at the bridge hub (e.g.,

				// to avoid losing funds).

				);

			}

			}

		}

		);

		// increase delivery fee factor (if required)

}

impl<T: Config<I>, I: 'static> InspectMessageQueues for Pallet<T, I> {

	/// This router needs to implement `InspectMessageQueues` but doesn't have to

	/// return any messages, since it just reuses the `XcmpQueue` router.

}