// Copyright 2024 Moonbeam foundation

// This file is part of Moonbeam.

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

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

//! # A pallet to trade weight for XCM execution

#![allow(non_camel_case_types)]

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

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

mod benchmarking;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

pub mod weights;

pub use pallet::*;

pub use weights::WeightInfo;

use frame_support::pallet_prelude::*;

use frame_support::traits::Contains;

use frame_support::weights::WeightToFee;

use frame_support::{pallet, Deserialize, Serialize};

use frame_system::pallet_prelude::*;

use sp_runtime::{

	traits::{Convert, Zero},

	DispatchError,

};

use sp_std::{vec, vec::Vec};

use xcm::v5::{Asset, AssetId as XcmAssetId, Error as XcmError, Fungibility, Location, XcmContext};

use xcm::{IntoVersion, VersionedAssetId};

use xcm_executor::traits::{TransactAsset, WeightTrader};

use xcm_primitives::XcmFeeTrader;

use xcm_runtime_apis::fees::Error as XcmPaymentApiError;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]

pub struct XcmWeightTraderAssetInfo {

	pub location: Location,

	pub relative_price: u128,

}

pub const RELATIVE_PRICE_DECIMALS: u32 = 18;

#[pallet]

pub mod pallet {

	use super::*;

	/// Pallet for multi block migrations

	#[pallet::pallet]

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

	/// Configuration trait of this pallet.

	#[pallet::config]

	pub trait Config: frame_system::Config<RuntimeEvent: From<Event<Self>>> {

		/// Convert `T::AccountId` to `Location`.

		type AccountIdToLocation: Convert<Self::AccountId, Location>;

		/// Origin that is allowed to register a supported asset

		type AddSupportedAssetOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// A filter to forbid some XCM Location to be supported for fees.

		/// if you don't use it, put "Everything".

		type AssetLocationFilter: Contains<Location>;

		/// How to withdraw and deposit an asset.

		type AssetTransactor: TransactAsset;

		/// The native balance type.

		type Balance: TryInto<u128>;

		/// Origin that is allowed to edit a supported asset units per seconds

		type EditSupportedAssetOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// XCM Location for native curreny

		type NativeLocation: Get<Location>;

		/// Origin that is allowed to pause a supported asset

		type PauseSupportedAssetOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Origin that is allowed to remove a supported asset

		type RemoveSupportedAssetOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Origin that is allowed to unpause a supported asset

		type ResumeSupportedAssetOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Weight information for extrinsics in this pallet.

		type WeightInfo: WeightInfo;

		/// Convert a weight value into deductible native balance.

		type WeightToFee: WeightToFee<Balance = Self::Balance>;

		/// Account that will receive xcm fees

		type XcmFeesAccount: Get<Self::AccountId>;

		/// The benchmarks need a location that pass the filter AssetLocationFilter

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

		type NotFilteredLocation: Get<Location>;

	}

	/// Stores all supported assets per XCM Location.

	/// The u128 is the asset price relative to native asset with 18 decimals

	/// The boolean specify if the support for this asset is active

	#[pallet::storage]

	#[pallet::getter(fn supported_assets)]

	pub type SupportedAssets<T: Config> = StorageMap<_, Blake2_128Concat, Location, (bool, u128)>;

	#[pallet::error]

	pub enum Error<T> {

		/// The given asset was already added

		AssetAlreadyAdded,

		/// The given asset was already paused

		AssetAlreadyPaused,

		/// The given asset was not found

		AssetNotFound,

		/// The given asset is not paused

		AssetNotPaused,

		/// XCM location filtered

		XcmLocationFiltered,

		/// The relative price cannot be zero

		PriceCannotBeZero,

		/// The relative price calculation overflowed

		PriceOverflow,

	}

	#[pallet::event]

	#[pallet::generate_deposit(pub(crate) fn deposit_event)]

	pub enum Event<T: Config> {

		/// New supported asset is registered

		SupportedAssetAdded {

			location: Location,

			relative_price: u128,

		},

		/// Changed the amount of units we are charging per execution second for a given asset

		SupportedAssetEdited {

			location: Location,

			relative_price: u128,

		},

		/// Pause support for a given asset

		PauseAssetSupport { location: Location },

		/// Resume support for a given asset

		ResumeAssetSupport { location: Location },

		/// Supported asset type for fee payment removed

		SupportedAssetRemoved { location: Location },

	}

	#[pallet::genesis_config]

	pub struct GenesisConfig<T: Config> {

		pub assets: Vec<XcmWeightTraderAssetInfo>,

		pub _phantom: PhantomData<T>,

	}

	impl<T: Config> Default for GenesisConfig<T> {

	}

	#[pallet::genesis_build]

	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

	}

	#[pallet::call]

	impl<T: Config> Pallet<T> {

		#[pallet::call_index(0)]

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

		pub fn add_asset(

			origin: OriginFor<T>,

			location: Location,

			relative_price: u128,

		}

		#[pallet::call_index(1)]

		#[pallet::weight(<T as pallet::Config>::WeightInfo::edit_asset())]

		pub fn edit_asset(

			origin: OriginFor<T>,

			location: Location,

			relative_price: u128,

				.0;

		}

		#[pallet::call_index(2)]

		#[pallet::weight(<T as pallet::Config>::WeightInfo::pause_asset_support())]

				}

			}

		}

		#[pallet::call_index(3)]

		#[pallet::weight(<T as pallet::Config>::WeightInfo::resume_asset_support())]

				}

			}

		}

		#[pallet::call_index(4)]

		#[pallet::weight(<T as pallet::Config>::WeightInfo::remove_asset())]

		}

	}

	impl<T: Config> Pallet<T> {

			);

			);

			);

			} else {

			}

			)

			}

			{

				{

			} else {

			}

	}

}

pub struct Trader<T: crate::Config>(Weight, Option<Asset>, core::marker::PhantomData<T>);

impl<T: crate::Config> Trader<T> {

			} else {

			}

		} else {

		}

}

impl<T: crate::Config> WeightTrader for Trader<T> {

			weight,

			payment,

			context

		);

		// Can only call one time

		// Consistency check for tests only, we should never panic in release mode

		// We support only one fee asset per buy, so we take the first one.

				// We don't need to proceed if the amount is 0

				// For cases (specially tests) where the asset is very cheap with respect

				// to the weight needed

			}

		}

			weight_to_refund,

			context,

			self.0,

			self.1

		);

		if let Some(Asset {

		{

			// `xcm-executor` passes the *surplus* weight to refund here (not the weight used).

			// We therefore refund the proportional amount that was originally charged for

			// `weight_to_refund`, and keep the remainder to be deposited to the fees account.

				refund_amount

			);

			} else {

			}

		} else {

		}

}

impl<T: crate::Config> Drop for Trader<T> {

		);

			);

}

/// Helper function to compute fee amount from weight and asset location.

/// This is used by the XcmTransactorFeeTrader adapter implementation.

/// Implementation of XcmFeeTrader for pallet-xcm-weight-trader.

/// This allows the pallet to be used directly as a fee trader.

impl<T: Config> XcmFeeTrader for Pallet<T> {

		use xcm::v5::Error as XcmError;

		// Convert xcm::latest::Location to xcm::v5::Location for internal computation

		// Use the weight-trader's compute logic

		// Note: Reserve validation is done at the pallet-xcm-transactor level,

		// as it requires access to the ReserveProvider which is configured there.

		// This implementation just computes the fee amount.

		// Convert xcm::latest::Location to xcm::v5::Location for storage lookup

		// Return the relative_price if the asset is enabled

		} else {

		}

		// Convert latest location into v5 for internal storage

		// Convert latest location into v5 for internal storage

}