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

//! Auctioning system to determine the set of Parachains in operation. This includes logic for the

//! auctioning mechanism and for reserving balance as part of the "payment". Unreserving the balance

//! happens elsewhere.

use crate::{

	slot_range::SlotRange,

	traits::{AuctionStatus, Auctioneer, LeaseError, Leaser, Registrar},

};

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

use codec::Decode;

use core::mem::swap;

use frame_support::{

	dispatch::DispatchResult,

	ensure,

	traits::{Currency, Get, Randomness, ReservableCurrency},

	weights::Weight,

};

use frame_system::pallet_prelude::BlockNumberFor;

pub use pallet::*;

use polkadot_primitives::Id as ParaId;

use sp_runtime::traits::{CheckedSub, One, Saturating, Zero};

type CurrencyOf<T> = <<T as Config>::Leaser as Leaser<BlockNumberFor<T>>>::Currency;

type BalanceOf<T> = <<<T as Config>::Leaser as Leaser<BlockNumberFor<T>>>::Currency as Currency<

	<T as frame_system::Config>::AccountId,

>>::Balance;

pub trait WeightInfo {

	fn new_auction() -> Weight;

	fn bid() -> Weight;

	fn cancel_auction() -> Weight;

	fn on_initialize() -> Weight;

}

pub struct TestWeightInfo;

impl WeightInfo for TestWeightInfo {

}

/// An auction index. We count auctions in this type.

pub type AuctionIndex = u32;

type LeasePeriodOf<T> = <<T as Config>::Leaser as Leaser<BlockNumberFor<T>>>::LeasePeriod;

// Winning data type. This encodes the top bidders of each range together with their bid.

type WinningData<T> = [Option<(<T as frame_system::Config>::AccountId, ParaId, BalanceOf<T>)>;

	SlotRange::SLOT_RANGE_COUNT];

// Winners data type. This encodes each of the final winners of a parachain auction, the parachain

// index assigned to them, their winning bid and the range that they won.

type WinnersData<T> =

	Vec<(<T as frame_system::Config>::AccountId, ParaId, BalanceOf<T>, SlotRange)>;

pub mod pallet {

	use super::*;

	use frame_support::{dispatch::DispatchClass, pallet_prelude::*, traits::EnsureOrigin};

	use frame_system::{ensure_root, ensure_signed, pallet_prelude::*};

	pub struct Pallet<T>(_);

	/// The module's configuration trait.

	#[pallet::config]

	pub trait Config: frame_system::Config {

		/// The overarching event type.

		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// The type representing the leasing system.

		type Leaser: Leaser<

			BlockNumberFor<Self>,

			AccountId = Self::AccountId,

			LeasePeriod = BlockNumberFor<Self>,

		>;

		/// The parachain registrar type.

		type Registrar: Registrar<AccountId = Self::AccountId>;

		/// The number of blocks over which an auction may be retroactively ended.

		#[pallet::constant]

		type EndingPeriod: Get<BlockNumberFor<Self>>;

		/// The length of each sample to take during the ending period.

		///

		/// `EndingPeriod` / `SampleLength` = Total # of Samples

		#[pallet::constant]

		type SampleLength: Get<BlockNumberFor<Self>>;

		/// Something that provides randomness in the runtime.

		type Randomness: Randomness<Self::Hash, BlockNumberFor<Self>>;

		/// The origin which may initiate auctions.

		type InitiateOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Weight Information for the Extrinsics in the Pallet

		type WeightInfo: WeightInfo;

	}

	pub enum Event<T: Config> {

		/// close and the first lease period of the quadruplet that is auctioned.

		AuctionStarted {

		/// Second is the total.

		/// reserve but no parachain slot has been leased.

		BidAccepted {

		/// map.

	}

	pub enum Error<T> {

	}

	/// Number of auctions started so far.

	pub type AuctionCounter<T> = StorageValue<_, AuctionIndex, ValueQuery>;

	/// Information relating to the current auction, if there is one.

	///

	/// The first item in the tuple is the lease period index that the first of the four

	/// contiguous lease periods on auction is for. The second is the block number when the

	/// auction will "begin to end", i.e. the first block of the Ending Period of the auction.

	pub type AuctionInfo<T: Config> = StorageValue<_, (LeasePeriodOf<T>, BlockNumberFor<T>)>;

	/// Amounts currently reserved in the accounts of the bidders currently winning

	/// (sub-)ranges.

	pub type ReservedAmounts<T: Config> =

		StorageMap<_, Twox64Concat, (T::AccountId, ParaId), BalanceOf<T>>;

	/// The winning bids for each of the 10 ranges at each sample in the final Ending Period of

	/// the current auction. The map's key is the 0-based index into the Sample Size. The

	/// first sample of the ending period is 0; the last is `Sample Size - 1`.

	pub type Winning<T: Config> = StorageMap<_, Twox64Concat, BlockNumberFor<T>, WinningData<T>>;

	#[pallet::extra_constants]

	impl<T: Config> Pallet<T> {

		#[pallet::constant_name(SlotRangeCount)]

		#[pallet::constant_name(LeasePeriodsPerSlot)]

	}

	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {

			// If the current auction was in its ending period last block, then ensure that the

			// (sub-)range winner information is duplicated from the previous block in case no bids

			// happened in the last block.

			// Check to see if an auction just ended.

	}

	impl<T: Config> Pallet<T> {

		/// Create a new auction.

		///

		/// This can only happen when there isn't already an auction in progress and may only be

		/// called by the root origin. Accepts the `duration` of this auction and the

		/// `lease_period_index` of the initial lease period of the four that are to be auctioned.

		#[pallet::call_index(0)]

		#[pallet::weight((T::WeightInfo::new_auction(), DispatchClass::Operational))]

		pub fn new_auction(

			origin: OriginFor<T>,

			#[pallet::compact] duration: BlockNumberFor<T>,

			#[pallet::compact] lease_period_index: LeasePeriodOf<T>,

		}

		/// Make a new bid from an account (including a parachain account) for deploying a new

		/// parachain.

		///

		/// Multiple simultaneous bids from the same bidder are allowed only as long as all active

		/// bids overlap each other (i.e. are mutually exclusive). Bids cannot be redacted.

		///

		/// - `sub` is the sub-bidder ID, allowing for multiple competing bids to be made by (and

		/// funded by) the same account.

		/// - `auction_index` is the index of the auction to bid on. Should just be the present

		/// value of `AuctionCounter`.

		/// - `first_slot` is the first lease period index of the range to bid on. This is the

		/// absolute lease period index value, not an auction-specific offset.

		/// - `last_slot` is the last lease period index of the range to bid on. This is the

		/// absolute lease period index value, not an auction-specific offset.

		/// - `amount` is the amount to bid to be held as deposit for the parachain should the

		/// bid win. This amount is held throughout the range.

		#[pallet::call_index(1)]

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

		pub fn bid(

			origin: OriginFor<T>,

			#[pallet::compact] para: ParaId,

			#[pallet::compact] auction_index: AuctionIndex,

			#[pallet::compact] first_slot: LeasePeriodOf<T>,

			#[pallet::compact] last_slot: LeasePeriodOf<T>,

			#[pallet::compact] amount: BalanceOf<T>,

		}

		/// Cancel an in-progress auction.

		///

		/// Can only be called by Root origin.

		#[pallet::call_index(2)]

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

			// Unreserve all bids.

			#[allow(deprecated)]

		}

	}

}

impl<T: Config> Auctioneer<BlockNumberFor<T>> for Pallet<T> {

	type AccountId = T::AccountId;

	type LeasePeriod = BlockNumberFor<T>;

	type Currency = CurrencyOf<T>;

	// Returns the status of the auction given the current block number.

		};

		};

		} else {

			// This is safe because of the comparison operator above

		}

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

	fn lease_period_length() -> (BlockNumberFor<T>, BlockNumberFor<T>) {

		T::Leaser::lease_period_length()

	}

}

impl<T: Config> Pallet<T> {

	// A trick to allow me to initialize large arrays with nothing in them.

	const EMPTY: Option<(<T as frame_system::Config>::AccountId, ParaId, BalanceOf<T>)> = None;

	/// Create a new auction.

	///

	/// This can only happen when there isn't already an auction in progress. Accepts the `duration`

	/// of this auction and the `lease_period_index` of the initial lease period of the four that

	/// are to be auctioned.

			// If there is no active lease period, then we don't need to make this check.

		// Bump the counter.

	/// Actually place a bid in the current auction.

	///

	/// - `bidder`: The account that will be funding this bid.

	/// - `auction_index`: The auction index of the bid. For this to succeed, must equal

	/// the current value of `AuctionCounter`.

	/// - `first_slot`: The first lease period index of the range to be bid on.

	/// - `last_slot`: The last lease period index of the range to be bid on (inclusive).

	/// - `amount`: The total amount to be the bid for deposit over the range.

		// Bidding on latest auction.

		// Assume it's actually an auction (this should never fail because of above).

		// Get the auction status and the current sample block. For the starting period, the sample

		// block is zero.

		// The offset into the ending samples of the auction.

		};

		// We also make sure that the bid is not for any existing leases the para already has.

		);

		// Our range.

		// Range as an array index.

			// Ok; we are the new winner of this range - reserve the additional amount and record.

			// Get the amount already held on deposit if this is a renewal bid (i.e. there's

			// an existing lease on the same para by the same leaser).

			// If these don't already cover the bid...

				// ...then reserve some more funds from their account, failing if there's not

				// enough funds.

				// ...and record the amount reserved.

			// Return any funds reserved for the previous winner if we are not in the ending period

			// and they no longer have any active bids.

				{

					// Previous bidder is no longer winning any ranges: unreserve their funds.

						// It really should be reserved; there's not much we can do here on fail.

			// Update the range winner.

	/// Some when the auction's end is known (with the end block number). None if it is unknown.

	/// If `Some` then the block number must be at most the previous block and at least the

	/// previous block minus `T::EndingPeriod::get()`.

	///

	/// This mutates the state, cleaning up `AuctionInfo` and `Winning` in the case of an auction

	/// ending. An immediately subsequent call with the same argument will always return `None`.

				// auction definitely ended.

				// check to see if we can determine the actual ending point.

					// Our random seed was known only after the auction ended. Good to use.

	/// Auction just ended. We have the current lease period, the auction's lease period (which

	/// is guaranteed to be at least the current period) and the bidders that were winning each

	/// range at the time of the auction's close.

		// First, unreserve all amounts that were reserved for the bids. We will later re-reserve

		// the amounts from the bidders that ended up being assigned the slot so there's no need to

		// special-case them here.

		// Next, calculate the winning combination of slots and thus the final winners of the

		// auction.

		// Go through those winners and re-reserve their bid, updating our table of deposits

		// accordingly.

				Err(LeaseError::ReserveFailed) |

				Err(LeaseError::AlreadyEnded) |

				Err(LeaseError::AlreadyLeased) => {

					// The leaser attempted to get a second lease on the same para ID, possibly

					// griefing us. Let's keep the amount reserved and let governance sort it out.

				},

			}

		}

	/// Calculate the final winners from the winning slots.

	///

	/// This is a simple dynamic programming algorithm designed by Al, the original code is at:

	/// `https://github.com/w3f/consensus/blob/master/NPoS/auctiondynamicthing.py`

					} else {

					}

				}

			}

}

/// tests for this module

#[cfg(test)]

mod tests {

	use super::*;

	use crate::{auctions, mock::TestRegistrar};

	use frame_support::{

		assert_noop, assert_ok, assert_storage_noop, derive_impl, ord_parameter_types,

		parameter_types,

		traits::{EitherOfDiverse, OnFinalize, OnInitialize},

	};

	use frame_system::{EnsureRoot, EnsureSignedBy};

	use pallet_balances;

	use polkadot_primitives::{BlockNumber, Id as ParaId};

	use polkadot_primitives_test_helpers::{dummy_hash, dummy_head_data, dummy_validation_code};

	use sp_core::H256;

	use sp_runtime::{

		traits::{BlakeTwo256, IdentityLookup},

		BuildStorage,

		DispatchError::BadOrigin,

	};

	use std::{cell::RefCell, collections::BTreeMap};

	type Block = frame_system::mocking::MockBlockU32<Test>;

	frame_support::construct_runtime!(

		pub enum Test

		{

			System: frame_system,

			Balances: pallet_balances,

			Auctions: auctions,

		}

	);

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

	impl frame_system::Config for Test {

		type BaseCallFilter = frame_support::traits::Everything;

		type BlockWeights = ();

		type BlockLength = ();

		type DbWeight = ();

		type RuntimeOrigin = RuntimeOrigin;

		type RuntimeCall = RuntimeCall;

		type Nonce = u64;

		type Hash = H256;

		type Hashing = BlakeTwo256;

		type AccountId = u64;

		type Lookup = IdentityLookup<Self::AccountId>;

		type Block = Block;

		type RuntimeEvent = RuntimeEvent;

		type Version = ();

		type PalletInfo = PalletInfo;

		type AccountData = pallet_balances::AccountData<u64>;

		type OnNewAccount = ();

		type OnKilledAccount = ();

		type SystemWeightInfo = ();

		type SS58Prefix = ();

		type OnSetCode = ();

		type MaxConsumers = frame_support::traits::ConstU32<16>;

	}

	#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]

	impl pallet_balances::Config for Test {

		type AccountStore = System;

	}

	#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Debug)]

	pub struct LeaseData {

		leaser: u64,

		amount: u64,

	}

	thread_local! {

		pub static LEASES:

			RefCell<BTreeMap<(ParaId, BlockNumber), LeaseData>> = RefCell::new(BTreeMap::new());

	}

	fn leases() -> Vec<((ParaId, BlockNumber), LeaseData)> {

		LEASES.with(|p| (&*p.borrow()).clone().into_iter().collect::<Vec<_>>())

	}

	pub struct TestLeaser;

	impl Leaser<BlockNumber> for TestLeaser {

		type AccountId = u64;

		type LeasePeriod = BlockNumber;

		type Currency = Balances;

		fn lease_out(

			para: ParaId,

			leaser: &Self::AccountId,

			amount: <Self::Currency as Currency<Self::AccountId>>::Balance,

			period_begin: Self::LeasePeriod,

			period_count: Self::LeasePeriod,

		) -> Result<(), LeaseError> {

			LEASES.with(|l| {

				let mut leases = l.borrow_mut();

				let now = System::block_number();

				let (current_lease_period, _) =

					Self::lease_period_index(now).ok_or(LeaseError::NoLeasePeriod)?;

				if period_begin < current_lease_period {

					return Err(LeaseError::AlreadyEnded)

				}

				for period in period_begin..(period_begin + period_count) {

					if leases.contains_key(&(para, period)) {

						return Err(LeaseError::AlreadyLeased)

					}

					leases.insert((para, period), LeaseData { leaser: *leaser, amount });

				}

				Ok(())

			})

		}

		fn deposit_held(

			para: ParaId,

			leaser: &Self::AccountId,

		) -> <Self::Currency as Currency<Self::AccountId>>::Balance {

			leases()

				.iter()

				.filter_map(|((id, _period), data)| {

					if id == &para && &data.leaser == leaser {

						Some(data.amount)

					} else {

						None

					}

				})

				.max()

				.unwrap_or_default()

		}

		fn lease_period_length() -> (BlockNumber, BlockNumber) {

			(10, 0)

		}

		fn lease_period_index(b: BlockNumber) -> Option<(Self::LeasePeriod, bool)> {

			let (lease_period_length, offset) = Self::lease_period_length();

			let b = b.checked_sub(offset)?;

			let lease_period = b / lease_period_length;

			let first_block = (b % lease_period_length).is_zero();

			Some((lease_period, first_block))

		}

		fn already_leased(

			para_id: ParaId,

			first_period: Self::LeasePeriod,

			last_period: Self::LeasePeriod,

		) -> bool {

			leases().into_iter().any(|((para, period), _data)| {

				para == para_id && first_period <= period && period <= last_period

			})

		}

	}

	ord_parameter_types! {

		pub const Six: u64 = 6;

	}

	type RootOrSix = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<Six, u64>>;

	thread_local! {

		pub static LAST_RANDOM: RefCell<Option<(H256, u32)>> = RefCell::new(None);

	}

	fn set_last_random(output: H256, known_since: u32) {

		LAST_RANDOM.with(|p| *p.borrow_mut() = Some((output, known_since)))

	}

	pub struct TestPastRandomness;

	impl Randomness<H256, BlockNumber> for TestPastRandomness {

		fn random(_subject: &[u8]) -> (H256, u32) {

			LAST_RANDOM.with(|p| {

				if let Some((output, known_since)) = &*p.borrow() {

					(*output, *known_since)

				} else {

					(H256::zero(), frame_system::Pallet::<Test>::block_number())

				}

			})

		}

	}

	parameter_types! {

		pub static EndingPeriod: BlockNumber = 3;

		pub static SampleLength: BlockNumber = 1;

	}

	impl Config for Test {

		type RuntimeEvent = RuntimeEvent;

		type Leaser = TestLeaser;

		type Registrar = TestRegistrar<Self>;

		type EndingPeriod = EndingPeriod;

		type SampleLength = SampleLength;

		type Randomness = TestPastRandomness;

		type InitiateOrigin = RootOrSix;

		type WeightInfo = crate::auctions::TestWeightInfo;

	}

	// This function basically just builds a genesis storage key/value store according to

	// our desired mock up.

	pub fn new_test_ext() -> sp_io::TestExternalities {

		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();

		pallet_balances::GenesisConfig::<Test> {

			balances: vec![(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)],

		}

		.assimilate_storage(&mut t)

		.unwrap();

		let mut ext: sp_io::TestExternalities = t.into();

		ext.execute_with(|| {

			// Register para 0, 1, 2, and 3 for tests

			assert_ok!(TestRegistrar::<Test>::register(

				1,

				0.into(),

				dummy_head_data(),

				dummy_validation_code()

			));

			assert_ok!(TestRegistrar::<Test>::register(

				1,

				1.into(),

				dummy_head_data(),

				dummy_validation_code()

			));

			assert_ok!(TestRegistrar::<Test>::register(

				1,

				2.into(),

				dummy_head_data(),

				dummy_validation_code()

			));

			assert_ok!(TestRegistrar::<Test>::register(

				1,

				3.into(),

				dummy_head_data(),

				dummy_validation_code()

			));

		});

		ext

	}

	fn run_to_block(n: BlockNumber) {

		while System::block_number() < n {

			Auctions::on_finalize(System::block_number());

			Balances::on_finalize(System::block_number());

			System::on_finalize(System::block_number());

			System::set_block_number(System::block_number() + 1);

			System::on_initialize(System::block_number());

			Balances::on_initialize(System::block_number());

			Auctions::on_initialize(System::block_number());

		}

	}

	#[test]

	fn basic_setup_works() {

		new_test_ext().execute_with(|| {

			assert_eq!(AuctionCounter::<Test>::get(), 0);

			assert_eq!(TestLeaser::deposit_held(0u32.into(), &1), 0);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::NotStarted

			);

			run_to_block(10);

			assert_eq!(AuctionCounter::<Test>::get(), 0);

			assert_eq!(TestLeaser::deposit_held(0u32.into(), &1), 0);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::NotStarted

			);

		});

	}

	#[test]

	fn can_start_auction() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_noop!(Auctions::new_auction(RuntimeOrigin::signed(1), 5, 1), BadOrigin);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_eq!(AuctionCounter::<Test>::get(), 1);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::StartingPeriod

			);

		});

	}

	#[test]

	fn bidding_works() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 5));

			assert_eq!(Balances::reserved_balance(1), 5);

			assert_eq!(Balances::free_balance(1), 5);

			assert_eq!(

				Winning::<Test>::get(0).unwrap()[SlotRange::ZeroThree as u8 as usize],

				Some((1, 0.into(), 5))

			);

		});

	}

	#[test]

	fn under_bidding_works() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 5));

			assert_storage_noop!({

				assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), 0.into(), 1, 1, 4, 1));

			});

		});

	}

	#[test]

	fn over_bidding_works() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 5));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), 0.into(), 1, 1, 4, 6));

			assert_eq!(Balances::reserved_balance(1), 0);

			assert_eq!(Balances::free_balance(1), 10);

			assert_eq!(Balances::reserved_balance(2), 6);

			assert_eq!(Balances::free_balance(2), 14);

			assert_eq!(

				Winning::<Test>::get(0).unwrap()[SlotRange::ZeroThree as u8 as usize],

				Some((2, 0.into(), 6))

			);

		});

	}

	#[test]

	fn auction_proceeds_correctly() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_eq!(AuctionCounter::<Test>::get(), 1);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::StartingPeriod

			);

			run_to_block(2);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::StartingPeriod

			);

			run_to_block(3);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::StartingPeriod

			);

			run_to_block(4);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::StartingPeriod

			);

			run_to_block(5);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::StartingPeriod

			);

			run_to_block(6);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::EndingPeriod(0, 0)

			);

			run_to_block(7);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::EndingPeriod(1, 0)

			);

			run_to_block(8);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::EndingPeriod(2, 0)

			);

			run_to_block(9);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::NotStarted

			);

		});

	}

	#[test]

	fn can_win_auction() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 1));

			assert_eq!(Balances::reserved_balance(1), 1);

			assert_eq!(Balances::free_balance(1), 9);

			run_to_block(9);

			assert_eq!(

				leases(),

				vec![

					((0.into(), 1), LeaseData { leaser: 1, amount: 1 }),

					((0.into(), 2), LeaseData { leaser: 1, amount: 1 }),

					((0.into(), 3), LeaseData { leaser: 1, amount: 1 }),

					((0.into(), 4), LeaseData { leaser: 1, amount: 1 }),

				]

			);

			assert_eq!(TestLeaser::deposit_held(0.into(), &1), 1);

		});

	}

	#[test]

	fn can_win_auction_with_late_randomness() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 4, 1));

			assert_eq!(Balances::reserved_balance(1), 1);

			assert_eq!(Balances::free_balance(1), 9);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::StartingPeriod

			);

			run_to_block(8);

			// Auction has not yet ended.

			assert_eq!(leases(), vec![]);

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::EndingPeriod(2, 0)

			);

			// This will prevent the auction's winner from being decided in the next block, since

			// the random seed was known before the final bids were made.

			set_last_random(H256::zero(), 8);

			// Auction definitely ended now, but we don't know exactly when in the last 3 blocks yet

			// since no randomness available yet.

			run_to_block(9);

			// Auction has now ended... But auction winner still not yet decided, so no leases yet.

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::VrfDelay(0)

			);

			assert_eq!(leases(), vec![]);

			// Random seed now updated to a value known at block 9, when the auction ended. This

			// means that the winner can now be chosen.

			set_last_random(H256::zero(), 9);

			run_to_block(10);

			// Auction ended and winner selected

			assert_eq!(

				Auctions::auction_status(System::block_number()),

				AuctionStatus::<u32>::NotStarted

			);

			assert_eq!(

				leases(),

				vec![

					((0.into(), 1), LeaseData { leaser: 1, amount: 1 }),

					((0.into(), 2), LeaseData { leaser: 1, amount: 1 }),

					((0.into(), 3), LeaseData { leaser: 1, amount: 1 }),

					((0.into(), 4), LeaseData { leaser: 1, amount: 1 }),

				]

			);

			assert_eq!(TestLeaser::deposit_held(0.into(), &1), 1);

		});

	}

	#[test]

	fn can_win_incomplete_auction() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 4, 4, 5));

			run_to_block(9);

			assert_eq!(leases(), vec![((0.into(), 4), LeaseData { leaser: 1, amount: 5 }),]);

			assert_eq!(TestLeaser::deposit_held(0.into(), &1), 5);

		});

	}

	#[test]

	fn should_choose_best_combination() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 1, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), 0.into(), 1, 2, 3, 4));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(3), 0.into(), 1, 4, 4, 2));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 1.into(), 1, 1, 4, 2));

			run_to_block(9);

			assert_eq!(

				leases(),

				vec![

					((0.into(), 1), LeaseData { leaser: 1, amount: 1 }),

					((0.into(), 2), LeaseData { leaser: 2, amount: 4 }),

					((0.into(), 3), LeaseData { leaser: 2, amount: 4 }),

					((0.into(), 4), LeaseData { leaser: 3, amount: 2 }),

				]

			);

			assert_eq!(TestLeaser::deposit_held(0.into(), &1), 1);

			assert_eq!(TestLeaser::deposit_held(1.into(), &1), 0);

			assert_eq!(TestLeaser::deposit_held(0.into(), &2), 4);

			assert_eq!(TestLeaser::deposit_held(0.into(), &3), 2);

		});

	}

	#[test]

	fn gap_bid_works() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			// User 1 will make a bid for period 1 and 4 for the same Para 0

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 1, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 4, 4, 4));

			// User 2 and 3 will make a bid for para 1 on period 2 and 3 respectively

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(2), 1.into(), 1, 2, 2, 2));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(3), 1.into(), 1, 3, 3, 3));

			// Total reserved should be the max of the two

			assert_eq!(Balances::reserved_balance(1), 4);

			// Other people are reserved correctly too

			assert_eq!(Balances::reserved_balance(2), 2);

			assert_eq!(Balances::reserved_balance(3), 3);

			// End the auction.

			run_to_block(9);

			assert_eq!(

				leases(),

				vec![

					((0.into(), 1), LeaseData { leaser: 1, amount: 1 }),

					((0.into(), 4), LeaseData { leaser: 1, amount: 4 }),

					((1.into(), 2), LeaseData { leaser: 2, amount: 2 }),

					((1.into(), 3), LeaseData { leaser: 3, amount: 3 }),

				]

			);

			assert_eq!(TestLeaser::deposit_held(0.into(), &1), 4);

			assert_eq!(TestLeaser::deposit_held(1.into(), &2), 2);

			assert_eq!(TestLeaser::deposit_held(1.into(), &3), 3);

		});

	}

	#[test]

	fn deposit_credit_should_work() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 1, 5));

			assert_eq!(Balances::reserved_balance(1), 5);

			run_to_block(10);

			assert_eq!(leases(), vec![((0.into(), 1), LeaseData { leaser: 1, amount: 5 }),]);

			assert_eq!(TestLeaser::deposit_held(0.into(), &1), 5);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 2));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 2, 2, 2, 6));

			// Only 1 reserved since we have a deposit credit of 5.

			assert_eq!(Balances::reserved_balance(1), 1);

			run_to_block(20);

			assert_eq!(

				leases(),

				vec![

					((0.into(), 1), LeaseData { leaser: 1, amount: 5 }),

					((0.into(), 2), LeaseData { leaser: 1, amount: 6 }),

				]

			);

			assert_eq!(TestLeaser::deposit_held(0.into(), &1), 6);

		});

	}

	#[test]

	fn deposit_credit_on_alt_para_should_not_count() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 0.into(), 1, 1, 1, 5));

			assert_eq!(Balances::reserved_balance(1), 5);

			run_to_block(10);

			assert_eq!(leases(), vec![((0.into(), 1), LeaseData { leaser: 1, amount: 5 }),]);

			assert_eq!(TestLeaser::deposit_held(0.into(), &1), 5);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 2));

			assert_ok!(Auctions::bid(RuntimeOrigin::signed(1), 1.into(), 2, 2, 2, 6));

			// 6 reserved since we are bidding on a new para; only works because we don't

			assert_eq!(Balances::reserved_balance(1), 6);

			run_to_block(20);

			assert_eq!(

				leases(),

				vec![

					((0.into(), 1), LeaseData { leaser: 1, amount: 5 }),

					((1.into(), 2), LeaseData { leaser: 1, amount: 6 }),

				]

			);

			assert_eq!(TestLeaser::deposit_held(0.into(), &1), 5);

			assert_eq!(TestLeaser::deposit_held(1.into(), &1), 6);

		});

	}

	#[test]

	fn multiple_bids_work_pre_ending() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 5, 1));

			for i in 1..6u64 {

				run_to_block(i as _);

				assert_ok!(Auctions::bid(RuntimeOrigin::signed(i), 0.into(), 1, 1, 4, i));

				for j in 1..6 {

					assert_eq!(Balances::reserved_balance(j), if j == i { j } else { 0 });

					assert_eq!(Balances::free_balance(j), if j == i { j * 9 } else { j * 10 });

				}

			}

			run_to_block(9);

			assert_eq!(

				leases(),

				vec![

					((0.into(), 1), LeaseData { leaser: 5, amount: 5 }),

					((0.into(), 2), LeaseData { leaser: 5, amount: 5 }),

					((0.into(), 3), LeaseData { leaser: 5, amount: 5 }),

					((0.into(), 4), LeaseData { leaser: 5, amount: 5 }),

				]

			);

		});

	}

	#[test]

	fn multiple_bids_work_post_ending() {

		new_test_ext().execute_with(|| {

			run_to_block(1);

			assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 0, 1));

			for i in 1..6u64 {

				run_to_block(((i - 1) / 2 + 1) as _);

				assert_ok!(Auctions::bid(RuntimeOrigin::signed(i), 0.into(), 1, 1, 4, i));

				for j in 1..6 {

					assert_eq!(Balances::reserved_balance(j), if j <= i { j } else { 0 });

					assert_eq!(Balances::free_balance(j), if j <= i { j * 9 } else { j * 10 });

				}

			}

			for i in 1..6u64 {

				assert_eq!(ReservedAmounts::<Test>::get((i, ParaId::from(0))).unwrap(), i);

			}

			run_to_block(5);

			assert_eq!(

				leases(),

				(1..=4)

					.map(|i| ((0.into(), i), LeaseData { leaser: 2, amount: 2 }))

					.collect::<Vec<_>>()