pub fn session_to_block(n: u32) -> u32 {

    let block_number = dancebox_runtime::Period::get() * n;

    // Add 1 because the block that emits the NewSession event cannot contain any extrinsics,

    // so this is the first block of the new session that can actually be used

    block_number + 1

}

pub fn run_to_session(n: u32) {

    run_to_block(session_to_block(n));

}

pub fn run_to_block(n: u32) -> BTreeMap<u32, RunSummary> {

    let current_block_number = System::block_number();

    assert!(

        current_block_number < n,

    let mut summaries = BTreeMap::new();

    while System::block_number() < n {

        let summary = run_block();

        let block_number = System::block_number();

        summaries.insert(block_number, summary);

    }

    summaries

}

pub fn insert_authorities_and_slot_digests(slot: u64) {

    let authorities =

        Runtime::para_id_authorities(ParachainInfo::get()).expect("authorities should be set");

    let authority: NimbusId = authorities[slot as usize % authorities.len()].clone();

    let pre_digest = Digest {

        logs: vec![

            DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode()),

            DigestItem::PreRuntime(NIMBUS_ENGINE_ID, authority.encode()),

        ],

    };

    System::reset_events();

    System::initialize(

        &(System::block_number() + 1),

        &System::parent_hash(),

        &pre_digest,

    );

}

fn take_new_inherent_data() -> Option<MockInherentData> {

    let data: Option<MockInherentData> =

        frame_support::storage::unhashed::take(b"__mock_new_inherent_data");

    data

}

fn advance_block_state_machine(new_state: RunBlockState) {

    if frame_support::storage::unhashed::exists(b"__mock_is_xcm_test") {

        return;

}

pub fn start_block() -> RunSummary {

    let block_number = System::block_number();

    advance_block_state_machine(RunBlockState::Start(block_number + 1));

    let mut slot = current_slot() + 1;

    if block_number == 0 {

    }

    let maybe_mock_inherent = take_new_inherent_data();

    if let Some(mock_inherent_data) = maybe_mock_inherent {

    }

    insert_authorities_and_slot_digests(slot);

    // Initialize the new block

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

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

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

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

    // `Initializer::on_finalize` needs to run at least one to have

    // author mapping setup.

    let author_id = current_author();

    let current_issuance = Balances::total_issuance();

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

    let new_issuance = Balances::total_issuance();

    frame_support::storage::unhashed::put(

        &frame_support::storage::storage_prefix(b"AsyncBacking", b"SlotInfo"),

        &(Slot::from(slot), 1),

    );

    pallet_author_inherent::Pallet::<Runtime>::kick_off_authorship_validation(None.into())

        .expect("author inherent to dispatch correctly");

    RunSummary {

        author_id,

        inflation: new_issuance - current_issuance,

    }

}

pub fn end_block() {

    let block_number = System::block_number();

    advance_block_state_machine(RunBlockState::End(block_number));

    // Finalize the block

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

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

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

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

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

}

pub fn run_block() -> RunSummary {

    end_block();

    start_block()

}

pub fn empty_genesis_data() -> ContainerChainGenesisData {

    ContainerChainGenesisData {

        storage: Default::default(),

        name: Default::default(),

        id: Default::default(),

        fork_id: Default::default(),

        extensions: Default::default(),

        properties: Default::default(),

    }

}

pub fn current_slot() -> u64 {

    u64::from(

        pallet_async_backing::SlotInfo::<Runtime>::get()

            .unwrap_or_default()

            .0,

    )

}

pub fn current_author() -> AccountId {

    let current_session = Session::current_index();

    let mapping =

        pallet_authority_mapping::Pallet::<Runtime>::authority_id_mapping(current_session)

            .expect("there is a mapping for the current session");

    let author = pallet_author_inherent::Author::<Runtime>::get()

        .expect("there should be a registered author");

    mapping

        .get(&author)

        .expect("there is a mapping for the current author")

        .clone()

}

pub fn set_dummy_boot_node(para_manager: RuntimeOrigin, para_id: ParaId) {

    let profile = Profile {

        url:

            b"/ip4/127.0.0.1/tcp/33049/ws/p2p/12D3KooWHVMhQDHBpj9vQmssgyfspYecgV6e3hH1dQVDUkUbCYC9"

                .to_vec()

                .try_into()

                .expect("to fit in BoundedVec"),

        para_ids: ParaIdsFilter::AnyParaId,

        mode: ProfileMode::Bootnode,

        assignment_request: ProviderRequest::Free,

    };

    let profile_id = pallet_data_preservers::NextProfileId::<Runtime>::get();

    let profile_owner = AccountId::new([1u8; 32]);

    DataPreservers::force_create_profile(RuntimeOrigin::root(), profile, profile_owner)

        .expect("profile create to succeed");

    DataPreservers::start_assignment(para_manager, profile_id, para_id, AssignerExtra::Free)

        .expect("assignement to work");

    assert!(

        pallet_data_preservers::Assignments::<Runtime>::get(para_id).contains(&profile_id),

}