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

// This file is part of Polkadot.

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

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

//! XCM `Junctions`/`InteriorLocation` datatype.

use super::{Junction, Location, NetworkId};

use alloc::sync::Arc;

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

use core::{mem, ops::Range, result};

use scale_info::TypeInfo;

/// Maximum number of `Junction`s that a `Junctions` can contain.

pub(crate) const MAX_JUNCTIONS: usize = 8;

/// Non-parent junctions that can be constructed, up to the length of 8. This specific `Junctions`

/// implementation uses a Rust `enum` in order to make pattern matching easier.

///

/// Parent junctions cannot be constructed with this type. Refer to `Location` for

/// instructions on constructing parent junctions.

#[derive(

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Encode,

	Debug,

	serde::Serialize,

)]

pub enum Junctions {

}

macro_rules! impl_junctions {

	($count:expr, $variant:ident) => {

		impl From<[Junction; $count]> for Junctions {

		}

		impl PartialEq<[Junction; $count]> for Junctions {

		}

	};

}

impl_junctions!(1, X1);

impl_junctions!(2, X2);

impl_junctions!(3, X3);

impl_junctions!(4, X4);

impl_junctions!(5, X5);

impl_junctions!(6, X6);

impl_junctions!(7, X7);

impl_junctions!(8, X8);

pub struct JunctionsIterator {

	junctions: Junctions,

	range: Range<usize>,

}

impl Iterator for JunctionsIterator {

	type Item = Junction;

}

impl DoubleEndedIterator for JunctionsIterator {

}

pub struct JunctionsRefIterator<'a> {

	junctions: &'a Junctions,

	range: Range<usize>,

}

impl<'a> Iterator for JunctionsRefIterator<'a> {

	type Item = &'a Junction;

}

impl<'a> DoubleEndedIterator for JunctionsRefIterator<'a> {

}

impl<'a> IntoIterator for &'a Junctions {

	type Item = &'a Junction;

	type IntoIter = JunctionsRefIterator<'a>;

}

impl IntoIterator for Junctions {

	type Item = Junction;

	type IntoIter = JunctionsIterator;

}

impl Junctions {

	/// Convert `self` into a `Location` containing 0 parents.

	///

	/// Similar to `Into::into`, except that this method can be used in a const evaluation context.

	/// Convert `self` into a `Location` containing `n` parents.

	///

	/// Similar to `Self::into_location`, with the added ability to specify the number of parent

	/// junctions.

	/// Casts `self` into a slice containing `Junction`s.

		}

	/// Casts `self` into a mutable slice containing `Junction`s.

		}

	/// Remove the `NetworkId` value in any `Junction`s.

	/// Treating `self` as the universal context, return the location of the local consensus system

	/// from the point of view of the given `target`.

		}

	/// Execute a function `f` on every junction. We use this since we cannot implement a mutable

	/// `Iterator` without unsafe code.

	/// Extract the network ID treating this value as a universal location.

	///

	/// This will return an `Err` if the first item is not a `GlobalConsensus`, which would indicate

	/// that this value is not a universal location.

		} else {

		}

	/// Extract the network ID and the interior consensus location, treating this value as a

	/// universal location.

	///

	/// This will return an `Err` if the first item is not a `GlobalConsensus`, which would indicate

	/// that this value is not a universal location.

		}

	/// Treat `self` as a universal location and the context of `relative`, returning the universal

	/// location of relative.

	///

	/// This will return an error if `relative` has as many (or more) parents than there are

	/// junctions in `self`, implying that relative refers into a different global consensus.

		}

	/// Consumes `self` and returns how `viewer` would address it locally.

		// AUDIT NOTES:

		// - above loop ensures that `i <= viewer.len()`.

		// - `viewer.len()` is at most `MAX_JUNCTIONS`, so won't overflow a `u8`.

	/// Returns first junction, or `None` if the location is empty.

	/// Returns last junction, or `None` if the location is empty.

	/// Splits off the first junction, returning the remaining suffix (first item in tuple) and the

	/// first element (second item in tuple) or `None` if it was empty.

			},

			},

			},

			},

			},

			},

			},

			},

		}

	/// Splits off the last junction, returning the remaining prefix (first item in tuple) and the

	/// last element (second item in tuple) or `None` if it was empty.

			},

			},

			},

			},

			},

			},

			},

			},

		}

	/// Removes the first element from `self`, returning it (or `None` if it was empty).

	/// Removes the last element from `self`, returning it (or `None` if it was empty).

	/// Mutates `self` to be appended with `new` or returns an `Err` with `new` if would overflow.

			},

			},

		}

	/// Mutates `self` to be prepended with `new` or returns an `Err` with `new` if would overflow.

			},

			},

		}

	/// Consumes `self` and returns a `Junctions` suffixed with `new`, or an `Err` with the

	/// original value of `self` and `new` in case of overflow.

			},

			},

			},

			},

			},

			},

			},

		})

	/// Consumes `self` and returns a `Junctions` prefixed with `new`, or an `Err` with the

	/// original value of `self` and `new` in case of overflow.

			},

			},

			},

			},

			},

			},

			},

		})

	/// Mutate `self` so that it is suffixed with `suffix`.

	///

	/// Does not modify `self` and returns `Err` with `suffix` in case of overflow.

	///

	/// # Example

	/// ```rust

	/// # use staging_xcm::v4::{Junctions, Junction::*, Location};

	/// # fn main() {

	/// let mut m = Junctions::from([Parachain(21)]);

	/// assert_eq!(m.append_with([PalletInstance(3)]), Ok(()));

	/// assert_eq!(m, [Parachain(21), PalletInstance(3)]);

	/// # }

	/// ```

		}

	/// Returns the number of junctions in `self`.

	/// Returns the junction at index `i`, or `None` if the location doesn't contain that many

	/// elements.

	/// Returns a mutable reference to the junction at index `i`, or `None` if the location doesn't

	/// contain that many elements.

	/// Returns a reference iterator over the junctions.

	/// Ensures that self begins with `prefix` and that it has a single `Junction` item following.

	/// If so, returns a reference to this `Junction` item.

	///

	/// # Example

	/// ```rust

	/// # use staging_xcm::v4::{Junctions, Junction::*};

	/// # fn main() {

	/// let mut m = Junctions::from([Parachain(2), PalletInstance(3), OnlyChild]);

	/// assert_eq!(m.match_and_split(&[Parachain(2), PalletInstance(3)].into()), Some(&OnlyChild));

	/// assert_eq!(m.match_and_split(&[Parachain(2)].into()), None);

	/// # }

	/// ```

		}

}

impl TryFrom<Location> for Junctions {

	type Error = Location;

		} else {

		}

}

impl<T: Into<Junction>> From<T> for Junctions {

}

impl From<[Junction; 0]> for Junctions {

}

impl From<()> for Junctions {

}

#[cfg(test)]

mod tests {

	use super::{super::prelude::*, *};

	#[test]

	fn inverting_works() {

		let context: InteriorLocation = (Parachain(1000), PalletInstance(42)).into();

		let target = (Parent, PalletInstance(69)).into();

		let expected = (Parent, PalletInstance(42)).into();

		let inverted = context.invert_target(&target).unwrap();

		assert_eq!(inverted, expected);

		let context: InteriorLocation =

			(Parachain(1000), PalletInstance(42), GeneralIndex(1)).into();

		let target = (Parent, Parent, PalletInstance(69), GeneralIndex(2)).into();

		let expected = (Parent, Parent, PalletInstance(42), GeneralIndex(1)).into();

		let inverted = context.invert_target(&target).unwrap();

		assert_eq!(inverted, expected);

	}

	#[test]

	fn relative_to_works() {

		use NetworkId::*;

		assert_eq!(

			Junctions::from([Polkadot.into()]).relative_to(&Junctions::from([Kusama.into()])),

			(Parent, Polkadot).into()

		);

		let base = Junctions::from([Kusama.into(), Parachain(1), PalletInstance(1)]);

		// Ancestors.

		assert_eq!(Here.relative_to(&base), (Parent, Parent, Parent).into());

		assert_eq!(Junctions::from([Kusama.into()]).relative_to(&base), (Parent, Parent).into());

		assert_eq!(

			Junctions::from([Kusama.into(), Parachain(1)]).relative_to(&base),

			(Parent,).into()

		);

		assert_eq!(

			Junctions::from([Kusama.into(), Parachain(1), PalletInstance(1)]).relative_to(&base),

			Here.into()

		);

		// Ancestors with one child.

		assert_eq!(

			Junctions::from([Polkadot.into()]).relative_to(&base),

			(Parent, Parent, Parent, Polkadot).into()

		);

		assert_eq!(

			Junctions::from([Kusama.into(), Parachain(2)]).relative_to(&base),

			(Parent, Parent, Parachain(2)).into()

		);

		assert_eq!(

			Junctions::from([Kusama.into(), Parachain(1), PalletInstance(2)]).relative_to(&base),

			(Parent, PalletInstance(2)).into()

		);

		assert_eq!(

			Junctions::from([Kusama.into(), Parachain(1), PalletInstance(1), [1u8; 32].into()])

				.relative_to(&base),

			([1u8; 32],).into()

		);

		// Ancestors with grandchildren.

		assert_eq!(

			Junctions::from([Polkadot.into(), Parachain(1)]).relative_to(&base),

			(Parent, Parent, Parent, Polkadot, Parachain(1)).into()

		);

		assert_eq!(

			Junctions::from([Kusama.into(), Parachain(2), PalletInstance(1)]).relative_to(&base),

			(Parent, Parent, Parachain(2), PalletInstance(1)).into()

		);

		assert_eq!(

			Junctions::from([Kusama.into(), Parachain(1), PalletInstance(2), [1u8; 32].into()])

				.relative_to(&base),

			(Parent, PalletInstance(2), [1u8; 32]).into()

		);

		assert_eq!(

			Junctions::from([

				Kusama.into(),

				Parachain(1),

				PalletInstance(1),

				[1u8; 32].into(),

				1u128.into()

			])

			.relative_to(&base),

			([1u8; 32], 1u128).into()

		);

	}

	#[test]

	fn global_consensus_works() {

		use NetworkId::*;

		assert_eq!(Junctions::from([Polkadot.into()]).global_consensus(), Ok(Polkadot));

		assert_eq!(Junctions::from([Kusama.into(), 1u64.into()]).global_consensus(), Ok(Kusama));

		assert_eq!(Here.global_consensus(), Err(()));

		assert_eq!(Junctions::from([1u64.into()]).global_consensus(), Err(()));

		assert_eq!(Junctions::from([1u64.into(), Kusama.into()]).global_consensus(), Err(()));

	}

	#[test]

	fn test_conversion() {

		use super::{Junction::*, NetworkId::*};

		let x: Junctions = GlobalConsensus(Polkadot).into();

		assert_eq!(x, Junctions::from([GlobalConsensus(Polkadot)]));

		let x: Junctions = Polkadot.into();

		assert_eq!(x, Junctions::from([GlobalConsensus(Polkadot)]));

		let x: Junctions = (Polkadot, Kusama).into();

		assert_eq!(x, Junctions::from([GlobalConsensus(Polkadot), GlobalConsensus(Kusama)]));

	}

	#[test]

	fn encode_decode_junctions_works() {

		let original = Junctions::from([

			Polkadot.into(),

			Kusama.into(),

			1u64.into(),

			GlobalConsensus(Polkadot),

			Parachain(123),

			PalletInstance(45),

		]);

		let encoded = original.encode();

		assert_eq!(encoded, &[6, 9, 2, 9, 3, 2, 0, 4, 9, 2, 0, 237, 1, 4, 45]);

		let decoded = Junctions::decode(&mut &encoded[..]).unwrap();

		assert_eq!(decoded, original);

	}

}