#[frame_support::pallet]

    #[pallet::pallet]

    #[pallet::generate_deposit(pub(super) fn deposit_event)]

        NewPendingAssignment {

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::call]

        pub(crate) fn enough_collators_for_all_chains(

            bulk_paras: &Vec<ChainNumCollators>,

            pool_paras: &Vec<ChainNumCollators>,

            target_session_index: T::SessionIndex,

            number_of_collators: u32,

            collators_per_container: u32,

            collators_per_parathread: u32,

        ) -> bool {

            number_of_collators

                >= T::HostConfiguration::min_collators_for_orchestrator(target_session_index)

                    .saturating_add(collators_per_container.saturating_mul(bulk_paras.len() as u32))

                    .saturating_add(

                        collators_per_parathread.saturating_mul(pool_paras.len() as u32),

                    )

        }

        pub(crate) fn order_paras_with_core_config(

            mut bulk_paras: Vec<ChainNumCollators>,

            mut pool_paras: Vec<ChainNumCollators>,

            core_allocation_configuration: &CoreAllocationConfiguration,

            target_session_index: T::SessionIndex,

            number_of_collators: u32,

            collators_per_container: u32,

            collators_per_parathread: u32,

        ) -> (Vec<ChainNumCollators>, bool) {

            let core_count = core_allocation_configuration.core_count;

            let max_number_of_bulk_paras = core_allocation_configuration

                .max_parachain_percentage

                .mul(core_count);

            let enough_cores_for_bulk_paras = bulk_paras.len() <= max_number_of_bulk_paras as usize;

            let enough_collators = Self::enough_collators_for_all_chains(

                &bulk_paras,

                &pool_paras,

                target_session_index,

                number_of_collators,

                collators_per_container,

                collators_per_parathread,

            );

            let should_charge_tip = !enough_cores_for_bulk_paras || !enough_collators;

            if should_charge_tip {

                bulk_paras.sort_by(|a, b| {

                    T::CollatorAssignmentTip::get_para_tip(b.para_id)

                        .cmp(&T::CollatorAssignmentTip::get_para_tip(a.para_id))

                });

                pool_paras.sort_by(|a, b| {

                    T::CollatorAssignmentTip::get_para_tip(b.para_id)

                        .cmp(&T::CollatorAssignmentTip::get_para_tip(a.para_id))

                });

            }

            bulk_paras.truncate(max_number_of_bulk_paras as usize);

            // We are not truncating pool paras, since their workload is not continuous one core

            // can be shared by many paras during the session.

            let chains: Vec<_> = bulk_paras.into_iter().chain(pool_paras).collect();

            (chains, should_charge_tip)

        }

        pub(crate) fn order_paras(

            bulk_paras: Vec<ChainNumCollators>,

            pool_paras: Vec<ChainNumCollators>,

            target_session_index: T::SessionIndex,

            number_of_collators: u32,

            collators_per_container: u32,

            collators_per_parathread: u32,

        ) -> (Vec<ChainNumCollators>, bool) {

            // Are there enough collators to satisfy the minimum demand?

            let enough_collators_for_all_chain = Self::enough_collators_for_all_chains(

                &bulk_paras,

                &pool_paras,

                target_session_index,

                number_of_collators,

                collators_per_container,

                collators_per_parathread,

            );

            let mut chains: Vec<_> = bulk_paras.into_iter().chain(pool_paras).collect();

            // Prioritize paras by tip on congestion

            // As of now this doesn't distinguish between bulk paras and pool paras

            if !enough_collators_for_all_chain {

                chains.sort_by(|a, b| {

                    T::CollatorAssignmentTip::get_para_tip(b.para_id)

                        .cmp(&T::CollatorAssignmentTip::get_para_tip(a.para_id))

                });

            }

            (chains, !enough_collators_for_all_chain)

        }

        pub fn assign_collators(

            current_session_index: &T::SessionIndex,

            random_seed: [u8; 32],

            collators: Vec<T::AccountId>,

        ) -> SessionChangeOutcome<T> {

            let maybe_core_allocation_configuration = T::CoreAllocationConfiguration::get();

            // We work with one session delay to calculate assignments

            let session_delay = T::SessionIndex::one();

            let target_session_index = current_session_index.saturating_add(session_delay);

            let collators_per_container =

                T::HostConfiguration::collators_per_container(target_session_index);

            let collators_per_parathread =

                T::HostConfiguration::collators_per_parathread(target_session_index);

            // We get the containerChains that we will have at the target session

            let container_chains =

                T::ContainerChains::session_container_chains(target_session_index);

            let num_total_registered_paras =

                (container_chains.parachains.len() + container_chains.parathreads.len()) as u32;

            let mut container_chain_ids = container_chains.parachains;

            let mut parathreads: Vec<_> = container_chains

                .parathreads

                .into_iter()

                .map(|(para_id, _)| para_id)

                .collect();

            // We read current assigned collators

            let old_assigned = Self::read_assigned_collators();

            let old_assigned_para_ids: BTreeSet<ParaId> =

                old_assigned.container_chains.keys().cloned().collect();

            // Remove the containerChains that do not have enough credits for block production

            T::RemoveParaIdsWithNoCredits::remove_para_ids_with_no_credits(

                &mut container_chain_ids,

                &old_assigned_para_ids,

            );

            // TODO: parathreads should be treated a bit differently, they don't need to have the same amount of credits

            // as parathreads because they will not be producing blocks on every slot.

            T::RemoveParaIdsWithNoCredits::remove_para_ids_with_no_credits(

                &mut parathreads,

                &old_assigned_para_ids,

            );

            let mut shuffle_collators = None;

            // If the random_seed is all zeros, we don't shuffle the list of collators nor the list

            // of container chains.

            // This should only happen in tests_without_core_config, and in the genesis block.

            if random_seed != [0; 32] {

                let mut rng: ChaCha20Rng = SeedableRng::from_seed(random_seed);

                container_chain_ids.shuffle(&mut rng);

                parathreads.shuffle(&mut rng);

                shuffle_collators = Some(move |collators: &mut Vec<T::AccountId>| {

                    collators.shuffle(&mut rng);

                })

            }

            let orchestrator_chain: ChainNumCollators = if T::ForceEmptyOrchestrator::get() {

                ChainNumCollators {

                    para_id: T::SelfParaId::get(),

                    min_collators: 0u32,

                    max_collators: 0u32,

                }

                ChainNumCollators {

                    para_id: T::SelfParaId::get(),

                    min_collators: T::HostConfiguration::min_collators_for_orchestrator(

                        target_session_index,

                    ),

                    max_collators: T::HostConfiguration::max_collators_for_orchestrator(

                        target_session_index,

                    ),

                }

            let mut bulk_paras = vec![];

            let mut pool_paras = vec![];

            for para_id in &container_chain_ids {

                bulk_paras.push(ChainNumCollators {

                    para_id: *para_id,

                    min_collators: collators_per_container,

                    max_collators: collators_per_container,

                });

            }

            for para_id in &parathreads {

                pool_paras.push(ChainNumCollators {

                    para_id: *para_id,

                    min_collators: collators_per_parathread,

                    max_collators: collators_per_parathread,

                });

            }

            let (chains, need_to_charge_tip) =

                if let Some(core_allocation_configuration) = maybe_core_allocation_configuration {

                    Self::order_paras_with_core_config(

                        bulk_paras,

                        pool_paras,

                        &core_allocation_configuration,

                        target_session_index,

                        collators.len() as u32,

                        collators_per_container,

                        collators_per_parathread,

                    )

                    Self::order_paras(

                        bulk_paras,

                        pool_paras,

                        target_session_index,

                        collators.len() as u32,

                        collators_per_container,

                        collators_per_parathread,

                    )

            let new_assigned =

                if T::ShouldRotateAllCollators::should_rotate_all_collators(target_session_index) {

                    log::debug!(

                    Self::deposit_event(Event::NewPendingAssignment {

                        random_seed,

                        full_rotation: true,

                        target_session: target_session_index,

                    });

                    Assignment::<T>::assign_collators_rotate_all(

                        collators,

                        orchestrator_chain,

                        chains,

                        shuffle_collators,

                    )

                    log::debug!(

                    Self::deposit_event(Event::NewPendingAssignment {

                        random_seed,

                        full_rotation: false,

                        target_session: target_session_index,

                    });

                    Assignment::<T>::assign_collators_always_keep_old(

                        collators,

                        orchestrator_chain,

                        chains,

                        old_assigned.clone(),

                        shuffle_collators,

                    )

            let mut new_assigned = match new_assigned {

                Ok(x) => x,

                Err(e) => {

                    log::error!(

                        "Error in collator assignment, will keep previous assignment. {:?}",

                    old_assigned.clone()

            let mut assigned_containers = new_assigned.container_chains.clone();

            assigned_containers.retain(|_, v| !v.is_empty());

            let maybe_tip: Option<BalanceOf<T>> = if !need_to_charge_tip {

                None

                assigned_containers

                    .into_keys()

                    .filter_map(T::CollatorAssignmentTip::get_para_tip)

                    .min()

            for para_id in &container_chain_ids {

                if !new_assigned

                    .container_chains

                    .get(para_id)

                    .unwrap_or(&vec![])

                    .is_empty()

                    if let Err(e) = T::CollatorAssignmentHook::on_collators_assigned(

                        *para_id,

                        maybe_tip.as_ref(),

                        false,

                    ) {

                        log::warn!(

                        new_assigned.container_chains.remove(para_id);

                    }

                }

            for para_id in &parathreads {

                if !new_assigned

                    .container_chains

                    .get(para_id)

                    .unwrap_or(&vec![])

                    .is_empty()

                    if let Err(e) = T::CollatorAssignmentHook::on_collators_assigned(

                        *para_id,

                        maybe_tip.as_ref(),

                        true,

                    ) {

                    }

                }

            Self::store_collator_fullness(

                &new_assigned,

                T::HostConfiguration::max_collators(target_session_index),

            );

            let mut pending = PendingCollatorContainerChain::<T>::get();

            let old_assigned_changed = old_assigned != new_assigned;

            let mut pending_changed = false;

            if let Some(current) = pending.take() {

                pending_changed = true;

                CollatorContainerChain::<T>::put(current);

            }

            if old_assigned_changed {

                pending = Some(new_assigned.clone());

                pending_changed = true;

            }

            if pending_changed {

                PendingCollatorContainerChain::<T>::put(pending);

            }

            if current_session_index == &T::SessionIndex::zero() {

                CollatorContainerChain::<T>::put(new_assigned.clone());

                return SessionChangeOutcome {

                    active_assignment: new_assigned.clone(),

                    next_assignment: new_assigned,

                    num_total_registered_paras,

                };

            }

            SessionChangeOutcome {

                active_assignment: old_assigned,

                next_assignment: new_assigned,

                num_total_registered_paras,

            }

        }

        fn store_collator_fullness(

            new_assigned: &AssignedCollators<T::AccountId>,

            max_collators: u32,

        ) {

            // Count number of assigned collators

            let mut num_collators = 0;

            num_collators += new_assigned.orchestrator_chain.len();

            for (_para_id, collators) in &new_assigned.container_chains {

                num_collators += collators.len();

            }

            let mut num_collators = num_collators as u32;

            if num_collators > max_collators {

                // Shouldn't happen but just in case

                num_collators = max_collators;

            }

            let ratio = Perbill::from_rational(num_collators, max_collators);

            CollatorFullnessRatio::<T>::put(ratio);

        }

        fn read_assigned_collators() -> AssignedCollators<T::AccountId> {

            let mut pending_collator_list = PendingCollatorContainerChain::<T>::get();

            if let Some(assigned_collators) = pending_collator_list.take() {

                assigned_collators

                CollatorContainerChain::<T>::get()

        }

        pub fn initializer_on_new_session(

            session_index: &T::SessionIndex,

            collators: Vec<T::AccountId>,

        ) -> SessionChangeOutcome<T> {

            let random_seed = Randomness::<T>::take();

            let num_collators = collators.len();

            let assigned_collators = Self::assign_collators(session_index, random_seed, collators);

            let num_total_registered_paras = assigned_collators.num_total_registered_paras;

            frame_system::Pallet::<T>::register_extra_weight_unchecked(

                T::WeightInfo::new_session(num_collators as u32, num_total_registered_paras),

                DispatchClass::Mandatory,

            );

            assigned_collators

        }

        pub fn collator_container_chain() -> AssignedCollators<T::AccountId> {

            CollatorContainerChain::<T>::get()

        }

        pub fn pending_collator_container_chain() -> Option<AssignedCollators<T::AccountId>> {

            PendingCollatorContainerChain::<T>::get()

        }

        pub fn randomness() -> [u8; 32] {

            Randomness::<T>::get()

        }

        fn author_for_slot(slot: Slot, para_id: ParaId) -> Option<T::AccountId> {

            let assigned_collators = Pallet::<T>::collator_container_chain();

            let collators = if para_id == T::SelfParaId::get() {

                Some(&assigned_collators.orchestrator_chain)

                assigned_collators.container_chains.get(&para_id)

            }?;

            if collators.is_empty() {

                return None;

            }

            let author_index = u64::from(slot) % collators.len() as u64;

            collators.get(author_index as usize).cloned()

        }

    #[pallet::hooks]

        fn on_initialize(n: BlockNumberFor<T>) -> Weight {

            let mut weight = Weight::zero();

            // Account reads and writes for on_finalize

            if T::GetRandomnessForNextBlock::should_end_session(n.saturating_add(One::one())) {

                weight += T::DbWeight::get().reads_writes(1, 1);

            }

            weight

        }

        fn on_finalize(n: BlockNumberFor<T>) {

            // If the next block is a session change, read randomness and store in pallet storage

            if T::GetRandomnessForNextBlock::should_end_session(n.saturating_add(One::one())) {

                let random_seed = T::GetRandomnessForNextBlock::get_randomness();

                Randomness::<T>::put(random_seed);

            }

        }

    fn should_rotate_all_collators(session_index: u32) -> bool {

        let period = Period::get();

        if period == 0 {

            false

            session_index % Period::get() == 0

    }

    fn should_end_session(_block_number: BlockNumber) -> bool {

        false

    }