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

// This file is part of Polkadot.

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

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

//! Cross-Consensus Message format asset data structures.

//!

//! This encompasses four types for representing assets:

//! - `MultiAsset`: A description of a single asset, either an instance of a non-fungible or some

//!   amount of a fungible.

//! - `MultiAssets`: A collection of `MultiAsset`s. These are stored in a `Vec` and sorted with

//!   fungibles first.

//! - `Wild`: A single asset wildcard, this can either be "all" assets, or all assets of a specific

//!   kind.

//! - `MultiAssetFilter`: A combination of `Wild` and `MultiAssets` designed for efficiently

//!   filtering an XCM holding account.

use super::{InteriorMultiLocation, MultiLocation};

use crate::{

	v2::{

		AssetId as OldAssetId, AssetInstance as OldAssetInstance, Fungibility as OldFungibility,

		MultiAsset as OldMultiAsset, MultiAssetFilter as OldMultiAssetFilter,

		MultiAssets as OldMultiAssets, WildFungibility as OldWildFungibility,

		WildMultiAsset as OldWildMultiAsset,

	},

	v4::{

		Asset as NewMultiAsset, AssetFilter as NewMultiAssetFilter, AssetId as NewAssetId,

		AssetInstance as NewAssetInstance, Assets as NewMultiAssets, Fungibility as NewFungibility,

		WildAsset as NewWildMultiAsset, WildFungibility as NewWildFungibility,

	},

};

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

use bounded_collections::{BoundedVec, ConstU32};

use codec::{self as codec, Decode, Encode, MaxEncodedLen};

use core::cmp::Ordering;

use scale_info::TypeInfo;

/// A general identifier for an instance of a non-fungible asset class.

#[derive(

	Copy,

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Encode,

	Debug,

	serde::Serialize,

)]

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum AssetInstance {

	/// supports only values up to `2**128 - 1`.

}

impl TryFrom<OldAssetInstance> for AssetInstance {

	type Error = ();

		use OldAssetInstance::*;

		})

}

impl TryFrom<NewAssetInstance> for AssetInstance {

	type Error = ();

		use NewAssetInstance::*;

		})

}

impl From<()> for AssetInstance {

}

impl From<[u8; 4]> for AssetInstance {

}

impl From<[u8; 8]> for AssetInstance {

}

impl From<[u8; 16]> for AssetInstance {

}

impl From<[u8; 32]> for AssetInstance {

}

impl From<u8> for AssetInstance {

}

impl From<u16> for AssetInstance {

}

impl From<u32> for AssetInstance {

}

impl From<u64> for AssetInstance {

}

impl TryFrom<AssetInstance> for () {

	type Error = ();

		}

}

impl TryFrom<AssetInstance> for [u8; 4] {

	type Error = ();

		}

}

impl TryFrom<AssetInstance> for [u8; 8] {

	type Error = ();

		}

}

impl TryFrom<AssetInstance> for [u8; 16] {

	type Error = ();

		}

}

impl TryFrom<AssetInstance> for [u8; 32] {

	type Error = ();

		}

}

impl TryFrom<AssetInstance> for u8 {

	type Error = ();

		}

}

impl TryFrom<AssetInstance> for u16 {

	type Error = ();

		}

}

impl TryFrom<AssetInstance> for u32 {

	type Error = ();

		}

}

impl TryFrom<AssetInstance> for u64 {

	type Error = ();

		}

}

impl TryFrom<AssetInstance> for u128 {

	type Error = ();

		}

}

/// Classification of whether an asset is fungible or not, along with a mandatory amount or

/// instance.

#[derive(

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Debug,

	Encode,

	serde::Serialize,

)]

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum Fungibility {

	/// A fungible asset; we record a number of units, as a `u128` in the inner item.

	Fungible(#[codec(compact)] u128),

	/// A non-fungible asset. We record the instance identifier in the inner item. Only one asset

	/// of each instance identifier may ever be in existence at once.

	NonFungible(AssetInstance),

}

enum UncheckedFungibility {

}

impl Decode for Fungibility {

			UncheckedFungibility::Fungible(_) =>

		}

}

impl Fungibility {

		use Fungibility::*;

		use WildFungibility::{Fungible as WildFungible, NonFungible as WildNonFungible};

}

impl From<i32> for Fungibility {

}

impl From<u128> for Fungibility {

}

impl<T: Into<AssetInstance>> From<T> for Fungibility {

}

impl TryFrom<OldFungibility> for Fungibility {

	type Error = ();

		use OldFungibility::*;

		})

}

impl TryFrom<NewFungibility> for Fungibility {

	type Error = ();

		use NewFungibility::*;

		})

}

/// Classification of whether an asset is fungible or not.

#[derive(

	Copy,

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Debug,

	Encode,

	serde::Serialize,

)]

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum WildFungibility {

}

impl TryFrom<OldWildFungibility> for WildFungibility {

	type Error = ();

		use OldWildFungibility::*;

		})

}

impl TryFrom<NewWildFungibility> for WildFungibility {

	type Error = ();

		use NewWildFungibility::*;

		})

}

/// Classification of an asset being concrete or abstract.

#[derive(

	Copy,

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Debug,

	Encode,

	serde::Serialize,

)]

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum AssetId {

	/// different chains at different times.

}

impl<T: Into<MultiLocation>> From<T> for AssetId {

}

impl From<[u8; 32]> for AssetId {

}

impl TryFrom<OldAssetId> for AssetId {

	type Error = ();

		use OldAssetId::*;

			},

		})

}

impl TryFrom<NewAssetId> for AssetId {

	type Error = ();

}

impl AssetId {

	/// Prepend a `MultiLocation` to a concrete asset, giving it a new root location.

	/// Mutate the asset to represent the same value from the perspective of a new `target`

	/// location. The local chain's location is provided in `context`.

	/// Use the value of `self` along with a `fun` fungibility specifier to create the corresponding

	/// `MultiAsset` value.

	/// Use the value of `self` along with a `fun` fungibility specifier to create the corresponding

	/// `WildMultiAsset` wildcard (`AllOf`) value.

}

/// Either an amount of a single fungible asset, or a single well-identified non-fungible asset.

#[derive(

	Clone,

	Eq,

	PartialEq,

	Debug,

	Encode,

	Decode,

	serde::Serialize,

)]

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub struct MultiAsset {

	/// The overall asset identity (aka *class*, in the case of a non-fungible).

	pub id: AssetId,

	/// The fungibility of the asset, which contains either the amount (in the case of a fungible

	/// asset) or the *instance ID*, the secondary asset identifier.

	pub fun: Fungibility,

}

impl PartialOrd for MultiAsset {

}

impl Ord for MultiAsset {

		}

}

impl<A: Into<AssetId>, B: Into<Fungibility>> From<(A, B)> for MultiAsset {

}

impl MultiAsset {

		use Fungibility::*;

		use Fungibility::*;

	/// Prepend a `MultiLocation` to a concrete asset, giving it a new root location.

	/// Mutate the location of the asset identifier if concrete, giving it the same location

	/// relative to a `target` context. The local context is provided as `context`.

	/// Mutate the location of the asset identifier if concrete, giving it the same location

	/// relative to a `target` context. The local context is provided as `context`.

	/// Returns true if `self` is a super-set of the given `inner` asset.

		use Fungibility::*;

			}

}

impl TryFrom<OldMultiAsset> for MultiAsset {

	type Error = ();

}

impl TryFrom<NewMultiAsset> for MultiAsset {

	type Error = ();

}

/// A `Vec` of `MultiAsset`s.

///

/// There are a number of invariants which the construction and mutation functions must ensure are

/// maintained in order to maintain polynomial time complexity during iteration:

/// - It may contain no items of duplicate asset class;

/// - All items must be ordered;

/// - The number of items should grow no larger than `MAX_ITEMS_IN_MULTIASSETS`.

#[derive(

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Debug,

	Encode,

	Default,

	serde::Serialize,

)]

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub struct MultiAssets(Vec<MultiAsset>);

/// Maximum number of items in a single `MultiAssets` value that can be decoded.

pub const MAX_ITEMS_IN_MULTIASSETS: usize = 20;

impl MaxEncodedLen for MultiAssets {

}

impl Decode for MultiAssets {

}

impl TryFrom<OldMultiAssets> for MultiAssets {

	type Error = ();

}

impl TryFrom<NewMultiAssets> for MultiAssets {

	type Error = ();

}

impl From<Vec<MultiAsset>> for MultiAssets {

						(

						(

						},

					}

}

impl<T: Into<MultiAsset>> From<T> for MultiAssets {

}

impl MultiAssets {

	/// A new (empty) value.

	/// Create a new instance of `MultiAssets` from a `Vec<MultiAsset>` whose contents are sorted

	/// and which contain no duplicates.

	///

	/// Returns `Ok` if the operation succeeds and `Err` if `r` is out of order or had duplicates.

	/// If you can't guarantee that `r` is sorted and deduplicated, then use

	/// `From::<Vec<MultiAsset>>::from` which is infallible.

			} else {

			}

	/// Create a new instance of `MultiAssets` from a `Vec<MultiAsset>` whose contents are sorted

	/// and which contain no duplicates.

	///

	/// In release mode, this skips any checks to ensure that `r` is correct, making it a

	/// negligible-cost operation. Generally though you should avoid using it unless you have a

	/// strict proof that `r` is valid.

	#[cfg(test)]

	pub fn from_sorted_and_deduplicated_skip_checks(r: Vec<MultiAsset>) -> Self {

		Self::from_sorted_and_deduplicated(r).expect("Invalid input r is not sorted/deduped")

	}

	/// Create a new instance of `MultiAssets` from a `Vec<MultiAsset>` whose contents are sorted

	/// and which contain no duplicates.

	///

	/// In release mode, this skips any checks to ensure that `r` is correct, making it a

	/// negligible-cost operation. Generally though you should avoid using it unless you have a

	/// strict proof that `r` is valid.

	///

	/// In test mode, this checks anyway and panics on fail.

	#[cfg(not(test))]

	/// Add some asset onto the list, saturating. This is quite a laborious operation since it

	/// maintains the ordering.

				},

			}

		}

	/// Returns `true` if this definitely represents no asset.

	/// Returns true if `self` is a super-set of the given `inner` asset.

	/// Consume `self` and return the inner vec.

	#[deprecated = "Use `into_inner()` instead"]

	/// Consume `self` and return the inner vec.

	/// Return a reference to the inner vec.

	/// Return the number of distinct asset instances contained.

	/// Prepend a `MultiLocation` to any concrete asset items, giving it a new root location.

	/// Mutate the location of the asset identifier if concrete, giving it the same location

	/// relative to a `target` context. The local context is provided as `context`.

	///

	/// This will also re-sort the inner assets to preserve ordering guarantees.

	/// Return a reference to an item at a specific index or `None` if it doesn't exist.

}

/// A wildcard representing a set of assets.

#[derive(

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Debug,

	Encode,

	serde::Serialize,

)]

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum WildMultiAsset {

	/// are separate assets).

	/// (different instances of non-fungibles are separate assets).

	AllOfCounted {

}

impl TryFrom<OldWildMultiAsset> for WildMultiAsset {

	type Error = ();

		use OldWildMultiAsset::*;

		})

}

impl TryFrom<NewWildMultiAsset> for WildMultiAsset {

	type Error = ();

		use NewWildMultiAsset::*;

		})

}

impl TryFrom<(OldWildMultiAsset, u32)> for WildMultiAsset {

	type Error = ();

		use OldWildMultiAsset::*;

		})

}

impl WildMultiAsset {

	/// Returns true if `self` is a super-set of the given `inner` asset.

		use WildMultiAsset::*;

		}

	/// Returns true if the wild element of `self` matches `inner`.

	///

	/// Note that for `Counted` variants of wildcards, then it will disregard the count except for

	/// always returning `false` when equal to 0.

	#[deprecated = "Use `contains` instead"]

	/// Mutate the asset to represent the same value from the perspective of a new `target`

	/// location. The local chain's location is provided in `context`.

		use WildMultiAsset::*;

		}

	/// Maximum count of assets allowed to match, if any.

		use WildMultiAsset::*;

		}

	/// Explicit limit on number of assets allowed to match, if any.

	/// Consume self and return the equivalent version but counted and with the `count` set to the

	/// given parameter.

		use WildMultiAsset::*;

		}

}

impl<A: Into<AssetId>, B: Into<WildFungibility>> From<(A, B)> for WildMultiAsset {

}

/// `MultiAsset` collection, defined either by a number of `MultiAssets` or a single wildcard.

#[derive(

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Debug,

	Encode,

	serde::Serialize,

)]

#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]

#[scale_info(replace_segment("staging_xcm", "xcm"))]

pub enum MultiAssetFilter {

}

impl<T: Into<WildMultiAsset>> From<T> for MultiAssetFilter {

}

impl From<MultiAsset> for MultiAssetFilter {

}

impl From<Vec<MultiAsset>> for MultiAssetFilter {

}

impl From<MultiAssets> for MultiAssetFilter {

}

impl MultiAssetFilter {

	/// Returns true if `inner` would be matched by `self`.

	///

	/// Note that for `Counted` variants of wildcards, then it will disregard the count except for

	/// always returning `false` when equal to 0.

		}

	/// Mutate the location of the asset identifier if concrete, giving it the same location

	/// relative to a `target` context. The local context is provided as `context`.

		}

	/// Maximum count of assets it is possible to match, if known.

		use MultiAssetFilter::*;

		}

	/// Explicit limit placed on the number of items, if any.

		use MultiAssetFilter::*;

		}

}

impl TryFrom<OldMultiAssetFilter> for MultiAssetFilter {

	type Error = ();

		})

}

impl TryFrom<NewMultiAssetFilter> for MultiAssetFilter {

	type Error = ();

		use NewMultiAssetFilter::*;

		})

}

impl TryFrom<(OldMultiAssetFilter, u32)> for MultiAssetFilter {

	type Error = ();

		})

}

#[cfg(test)]

mod tests {

	use super::super::prelude::*;

	#[test]

	fn conversion_works() {

		let _: MultiAssets = (Here, 1u128).into();

	}

	#[test]

	fn from_sorted_and_deduplicated_works() {

		use super::*;

		use alloc::vec;

		let empty = vec![];

		let r = MultiAssets::from_sorted_and_deduplicated(empty);

		assert_eq!(r, Ok(MultiAssets(vec![])));

		let dup_fun = vec![(Here, 100).into(), (Here, 10).into()];

		let r = MultiAssets::from_sorted_and_deduplicated(dup_fun);

		assert!(r.is_err());

		let dup_nft = vec![(Here, *b"notgood!").into(), (Here, *b"notgood!").into()];

		let r = MultiAssets::from_sorted_and_deduplicated(dup_nft);

		assert!(r.is_err());

		let good_fun = vec![(Here, 10).into(), (Parent, 10).into()];

		let r = MultiAssets::from_sorted_and_deduplicated(good_fun.clone());

		assert_eq!(r, Ok(MultiAssets(good_fun)));

		let bad_fun = vec![(Parent, 10).into(), (Here, 10).into()];

		let r = MultiAssets::from_sorted_and_deduplicated(bad_fun);

		assert!(r.is_err());

		let good_abstract_fun = vec![(Here, 100).into(), ([0u8; 32], 10).into()];

		let r = MultiAssets::from_sorted_and_deduplicated(good_abstract_fun.clone());

		assert_eq!(r, Ok(MultiAssets(good_abstract_fun)));

		let bad_abstract_fun = vec![([0u8; 32], 10).into(), (Here, 10).into()];

		let r = MultiAssets::from_sorted_and_deduplicated(bad_abstract_fun);

		assert!(r.is_err());

		let good_nft = vec![(Here, ()).into(), (Here, *b"good").into()];

		let r = MultiAssets::from_sorted_and_deduplicated(good_nft.clone());

		assert_eq!(r, Ok(MultiAssets(good_nft)));

		let bad_nft = vec![(Here, *b"bad!").into(), (Here, ()).into()];

		let r = MultiAssets::from_sorted_and_deduplicated(bad_nft);

		assert!(r.is_err());

		let good_abstract_nft = vec![(Here, ()).into(), ([0u8; 32], ()).into()];

		let r = MultiAssets::from_sorted_and_deduplicated(good_abstract_nft.clone());

		assert_eq!(r, Ok(MultiAssets(good_abstract_nft)));

		let bad_abstract_nft = vec![([0u8; 32], ()).into(), (Here, ()).into()];

		let r = MultiAssets::from_sorted_and_deduplicated(bad_abstract_nft);

		assert!(r.is_err());

		let mixed_good = vec![(Here, 10).into(), (Here, *b"good").into()];

		let r = MultiAssets::from_sorted_and_deduplicated(mixed_good.clone());

		assert_eq!(r, Ok(MultiAssets(mixed_good)));

		let mixed_bad = vec![(Here, *b"bad!").into(), (Here, 10).into()];

		let r = MultiAssets::from_sorted_and_deduplicated(mixed_bad);

		assert!(r.is_err());

	}

	#[test]

	fn reanchor_preserves_sorting() {

		use super::*;

		use alloc::vec;

		let reanchor_context = X1(Parachain(2000));

		let dest = MultiLocation::new(1, Here);

		let asset_1: MultiAsset =

			(MultiLocation::new(0, X2(PalletInstance(50), GeneralIndex(1))), 10).into();

		let mut asset_1_reanchored = asset_1.clone();

		assert!(asset_1_reanchored.reanchor(&dest, reanchor_context).is_ok());

		assert_eq!(

			asset_1_reanchored,

			(MultiLocation::new(0, X3(Parachain(2000), PalletInstance(50), GeneralIndex(1))), 10)

				.into()

		);

		let asset_2: MultiAsset = (MultiLocation::new(1, Here), 10).into();

		let mut asset_2_reanchored = asset_2.clone();

		assert!(asset_2_reanchored.reanchor(&dest, reanchor_context).is_ok());

		assert_eq!(asset_2_reanchored, (MultiLocation::new(0, Here), 10).into());

		let asset_3: MultiAsset = (MultiLocation::new(1, X1(Parachain(1000))), 10).into();

		let mut asset_3_reanchored = asset_3.clone();

		assert!(asset_3_reanchored.reanchor(&dest, reanchor_context).is_ok());

		assert_eq!(asset_3_reanchored, (MultiLocation::new(0, X1(Parachain(1000))), 10).into());

		let mut assets: MultiAssets =

			vec![asset_1.clone(), asset_2.clone(), asset_3.clone()].into();

		assert_eq!(assets.clone(), vec![asset_1.clone(), asset_2.clone(), asset_3.clone()].into());

		// decoding respects limits and sorting

		assert!(assets

			.using_encoded(|mut enc| MultiAssets::decode(&mut enc).map(|_| ()))

			.is_ok());

		assert!(assets.reanchor(&dest, reanchor_context).is_ok());

		assert_eq!(assets.0, vec![asset_2_reanchored, asset_3_reanchored, asset_1_reanchored]);

		// decoding respects limits and sorting

		assert!(assets

			.using_encoded(|mut enc| MultiAssets::decode(&mut enc).map(|_| ()))

			.is_ok());

	}

	#[test]

	fn prepend_preserves_sorting() {

		use super::*;

		use alloc::vec;

		let prefix = MultiLocation::new(0, X1(Parachain(1000)));

		let asset_1: MultiAsset =

			(MultiLocation::new(0, X2(PalletInstance(50), GeneralIndex(1))), 10).into();

		let mut asset_1_prepended = asset_1.clone();

		assert!(asset_1_prepended.prepend_with(&prefix).is_ok());

		// changes interior X2->X3

		assert_eq!(

			asset_1_prepended,

			(MultiLocation::new(0, X3(Parachain(1000), PalletInstance(50), GeneralIndex(1))), 10)

				.into()

		);

		let asset_2: MultiAsset =

			(MultiLocation::new(1, X2(PalletInstance(50), GeneralIndex(1))), 10).into();

		let mut asset_2_prepended = asset_2.clone();

		assert!(asset_2_prepended.prepend_with(&prefix).is_ok());

		// changes parent

		assert_eq!(

			asset_2_prepended,

			(MultiLocation::new(0, X2(PalletInstance(50), GeneralIndex(1))), 10).into()

		);

		let asset_3: MultiAsset =

			(MultiLocation::new(2, X2(PalletInstance(50), GeneralIndex(1))), 10).into();

		let mut asset_3_prepended = asset_3.clone();

		assert!(asset_3_prepended.prepend_with(&prefix).is_ok());

		// changes parent

		assert_eq!(

			asset_3_prepended,

			(MultiLocation::new(1, X2(PalletInstance(50), GeneralIndex(1))), 10).into()

		);

		// `From` impl does sorting.

		let mut assets: MultiAssets = vec![asset_1, asset_2, asset_3].into();

		// decoding respects limits and sorting

		assert!(assets

			.using_encoded(|mut enc| MultiAssets::decode(&mut enc).map(|_| ()))

			.is_ok());

		// let's do `prepend_with`

		assert!(assets.prepend_with(&prefix).is_ok());

		assert_eq!(assets.0, vec![asset_2_prepended, asset_1_prepended, asset_3_prepended]);

		// decoding respects limits and sorting

		assert!(assets

			.using_encoded(|mut enc| MultiAssets::decode(&mut enc).map(|_| ()))

			.is_ok());

	}

	#[test]

	fn decoding_respects_limit() {

		use super::*;

		// Having lots of one asset will work since they are deduplicated

		let lots_of_one_asset: MultiAssets =

			vec![(GeneralIndex(1), 1u128).into(); MAX_ITEMS_IN_MULTIASSETS + 1].into();

		let encoded = lots_of_one_asset.encode();

		assert!(MultiAssets::decode(&mut &encoded[..]).is_ok());

		// Fewer assets than the limit works

		let mut few_assets: MultiAssets = Vec::new().into();

		for i in 0..MAX_ITEMS_IN_MULTIASSETS {

			few_assets.push((GeneralIndex(i as u128), 1u128).into());

		}

		let encoded = few_assets.encode();

		assert!(MultiAssets::decode(&mut &encoded[..]).is_ok());

		// Having lots of different assets will not work

		let mut too_many_different_assets: MultiAssets = Vec::new().into();

		for i in 0..MAX_ITEMS_IN_MULTIASSETS + 1 {

			too_many_different_assets.push((GeneralIndex(i as u128), 1u128).into());

		}

		let encoded = too_many_different_assets.encode();

		assert!(MultiAssets::decode(&mut &encoded[..]).is_err());

	}

}