#[frame_support::pallet]

    #[pallet::pallet]

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

        NewPendingAssignment {

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::storage]

    #[pallet::call]

        pub fn assign_collators(

            current_session_index: &T::SessionIndex,

            random_seed: [u8; 32],

            collators: Vec<T::AccountId>,

        ) -> SessionChangeOutcome<T> {

            // 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);

            // 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, 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 {

                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,

                ),

            };

            // Initialize list of chains as `[container1, container2, parathread1, parathread2]`.

            // The order means priority: the first chain in the list will be the first one to get assigned collators.

            // Chains will not be assigned less than `min_collators`, except the orchestrator chain.

            // First all chains will be assigned `min_collators`, and then the first one will be assigned up to `max`,

            // then the second one, and so on.

            let mut chains = vec![];

            let collators_per_container =

                T::HostConfiguration::collators_per_container(target_session_index);

            for para_id in &container_chain_ids {

                chains.push(ChainNumCollators {

                    para_id: *para_id,

                    min_collators: collators_per_container,

                    max_collators: collators_per_container,

                });

            }

            let collators_per_parathread =

                T::HostConfiguration::collators_per_parathread(target_session_index);

            for para_id in &parathreads {

                chains.push(ChainNumCollators {

                    para_id: *para_id,

                    min_collators: collators_per_parathread,

                    max_collators: collators_per_parathread,

                });

            }

            let enough_collators_for_all_chain = collators.len() as u32

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

                    .saturating_add(

                        collators_per_container.saturating_mul(container_chain_ids.len() as u32),

                    )

                    .saturating_add(

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

                    );

            // Prioritize paras by tip on congestion

            // As of now this doesn't distinguish between parachains and parathreads

            // TODO apply different logic to parathreads

            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))

                });

            }

            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 enough_collators_for_all_chain {

                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,

                    ) {

                    }

                }

            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 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()

        }

        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

    }