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

//! Support data structures for `Location`, primarily the `Junction` datatype.

use super::Location;

pub use crate::v3::{BodyId, BodyPart};

use crate::{

	v3::{Junction as OldJunction, NetworkId as OldNetworkId},

	VersionedLocation,

};

use bounded_collections::{BoundedSlice, BoundedVec, ConstU32};

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

use scale_info::TypeInfo;

use serde::{Deserialize, Serialize};

/// A single item in a path to describe the relative location of a consensus system.

///

/// Each item assumes a pre-existing location as its context and is defined in terms of it.

#[derive(

	Copy,

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Encode,

	Debug,

	Serialize,

)]

pub enum Junction {

	///

	/// Generally used when the context is a Polkadot Relay-chain.

	/// endpoint within the context.

	///

	/// Generally used when the context is a Substrate-based chain.

	/// endpoint within the context.

	///

	/// May be used when the context is a Frame-based chain and includes e.g. an indices pallet.

	AccountIndex64 {

	/// endpoint within the context.

	///

	/// May be used when the context is an Ethereum or Bitcoin chain or smart-contract.

	///

	/// Generally used when the context is a Frame-based chain.

	// TODO XCMv4 inner should be `Compact<u32>`.

	///

	/// Usage will vary widely owing to its generality.

	///

	/// NOTE: Try to avoid using this and instead use a more specific item.

	/// location.

	///

	/// Usage will vary widely owing to its generality.

	///

	/// NOTE: Try to avoid using this and instead use a more specific item.

	// Note this is implemented as an array with a length rather than using `BoundedVec` owing to

	// the bound for `Copy`.

	///

	/// Typical to be used to represent a governance origin of a chain, but could in principle be

	/// used to represent things such as multisigs also.

	/// meaningful outside of the universal level.

}

/// A global identifier of a data structure existing within consensus.

///

/// Maintenance note: Networks with global consensus and which are practically bridgeable within the

/// Polkadot ecosystem are given preference over explicit naming in this enumeration.

#[derive(

	Copy,

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

	Encode,

	Debug,

	Serialize,

)]

pub enum NetworkId {

	Ethereum {

}

impl From<OldNetworkId> for Option<NetworkId> {

}

impl From<OldNetworkId> for NetworkId {

		use OldNetworkId::*;

		}

}

impl From<NetworkId> for Junction {

}

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

}

impl From<BoundedVec<u8, ConstU32<32>>> for Junction {

}

impl<'a> From<BoundedSlice<'a, u8, ConstU32<32>>> for Junction {

}

impl<'a> TryFrom<&'a Junction> for BoundedSlice<'a, u8, ConstU32<32>> {

	type Error = ();

		}

}

impl From<[u8; 20]> for Junction {

}

impl From<u64> for Junction {

}

impl From<u128> for Junction {

}

impl TryFrom<OldJunction> for Junction {

	type Error = ();

		use OldJunction::*;

		})

}

impl Junction {

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

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

	///

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

	/// Remove the `NetworkId` value.

		use Junction::*;

		}

}

#[cfg(test)]

mod tests {

	use super::*;

	use alloc::vec;

	#[test]

	fn junction_round_trip_works() {

		let j = Junction::GeneralKey { length: 32, data: [1u8; 32] };

		let k = Junction::try_from(OldJunction::try_from(j).unwrap()).unwrap();

		assert_eq!(j, k);

		let j = OldJunction::GeneralKey { length: 32, data: [1u8; 32] };

		let k = OldJunction::try_from(Junction::try_from(j).unwrap()).unwrap();

		assert_eq!(j, k);

		let j = Junction::from(BoundedVec::try_from(vec![1u8, 2, 3, 4]).unwrap());

		let k = Junction::try_from(OldJunction::try_from(j).unwrap()).unwrap();

		assert_eq!(j, k);

		let s: BoundedSlice<_, _> = (&k).try_into().unwrap();

		assert_eq!(s, &[1u8, 2, 3, 4][..]);

		let j = OldJunction::GeneralKey { length: 32, data: [1u8; 32] };

		let k = OldJunction::try_from(Junction::try_from(j).unwrap()).unwrap();

		assert_eq!(j, k);

	}

}