pub fn assign_collators_always_keep_old<TShuffle>(

        collators: Vec<T::AccountId>,

        orchestrator_chain: ChainNumCollators,

        mut chains: Vec<ChainNumCollators>,

        mut old_assigned: AssignedCollators<T::AccountId>,

        mut shuffle: Option<TShuffle>,

        full_rotation_mode: FullRotationModes,

    ) -> Result<AssignedCollators<T::AccountId>, AssignmentError>

    where

        TShuffle: FnMut(&mut Vec<T::AccountId>),

    {

        if collators.is_empty() && !T::ForceEmptyOrchestrator::get() {

            return Err(AssignmentError::ZeroCollators);

        }

        // The rest of this function mostly treats orchestrator chain as another container chain, so move it into

        // `old_assigned.container_chains`

        let old_orchestrator_assigned = mem::take(&mut old_assigned.orchestrator_chain);

        old_assigned

            .container_chains

            .insert(orchestrator_chain.para_id, old_orchestrator_assigned);

        let mut old_assigned = old_assigned.container_chains;

        // Orchestrator chain must be the first one in the list because it always has priority

        chains.insert(0, orchestrator_chain);

        let all_para_ids: Vec<ParaId> = chains.iter().map(|cc| cc.para_id).collect();

        let collators_set = BTreeSet::from_iter(collators.iter().cloned());

        let chains_with_collators =

            Self::select_chains_with_collators(collators.len() as u32, &chains);

        let chains_with_collators_set: BTreeSet<ParaId> = chains_with_collators

            .iter()

            .map(|(para_id, _num_collators)| *para_id)

            .collect();

        Self::retain_valid_old_assigned(

            &mut old_assigned,

            &chains_with_collators_set,

            &collators_set,

        );

        for chain in chains.iter() {

            let mode = if chain.para_id == orchestrator_chain.para_id {

                full_rotation_mode.orchestrator.clone()

            } else if chain.parathread {

                full_rotation_mode.parathread.clone()

                full_rotation_mode.parachain.clone()

            let collators = old_assigned.get_mut(&chain.para_id);

            Self::keep_collator_subset(collators, mode, chain.max_collators, shuffle.as_mut());

        Self::prioritize_invulnerables(&collators, orchestrator_chain, &mut old_assigned);

        let new_assigned_chains =

            Self::assign_full(collators, chains_with_collators, old_assigned, shuffle)?;

        let mut new_assigned = AssignedCollators {

            container_chains: new_assigned_chains,

            ..Default::default()

        };

        for para_id in all_para_ids {

            new_assigned.container_chains.entry(para_id).or_default();

        }

        let orchestrator_assigned = new_assigned

            .container_chains

            .remove(&orchestrator_chain.para_id)

            .unwrap();

        // Sanity check to avoid bricking orchestrator chain

        if orchestrator_assigned.is_empty() && !T::ForceEmptyOrchestrator::get() {

        }

        new_assigned.orchestrator_chain = orchestrator_assigned;

        Ok(new_assigned)

    }

    pub fn keep_collator_subset<TShuffle>(

        collators: Option<&mut Vec<T::AccountId>>,

        full_rotation_mode: FullRotationMode,

        max_collators: u32,

        shuffle: Option<&mut TShuffle>,

    ) where

        TShuffle: FnMut(&mut Vec<T::AccountId>),

    {

        let collators = match collators {

            Some(x) => x,

            None => return,

        let num_to_keep = match full_rotation_mode {

            FullRotationMode::RotateAll => 0,

                return;

            FullRotationMode::KeepCollators { keep } => keep,

            FullRotationMode::KeepPerbill { percentage: keep } => keep * max_collators,

        if num_to_keep == 0 {

            collators.clear();

            return;

        }

        // Less than N collators, no need to shuffle

        if collators.len() as u32 <= num_to_keep {

            return;

        }

        if let Some(shuffle) = shuffle {

            shuffle(collators);

        }

        collators.truncate(num_to_keep as usize);

    }

    pub fn select_chains_with_collators(

        num_collators: u32,

        chains: &[ChainNumCollators],

    ) -> Vec<(ParaId, u32)> {

        if chains.is_empty() {

        }

        // Let's count how many container chains we can support with the current number of collators

        let mut available_collators = num_collators;

        // Handle orchestrator chain in a special way, we always want to assign collators to it, even if we don't

        // reach the min.

        let min_orchestrator_collators = chains[0].min_collators;

        available_collators = available_collators.saturating_sub(min_orchestrator_collators);

        let mut container_chains_with_collators = vec![chains[0]];

        for cc in chains.iter().skip(1) {

            if available_collators >= cc.min_collators {

                available_collators -= cc.min_collators;

                container_chains_with_collators.push(*cc);

            } else if available_collators == 0 {

                break;

            }

        let mut required_collators_min = 0;

        for cc in &container_chains_with_collators {

            required_collators_min += cc.min_collators;

        }

        if num_collators < min_orchestrator_collators {

            vec![(chains[0].para_id, num_collators)]

            let mut required_collators_remainder = num_collators - required_collators_min;

            let mut container_chains_variable = vec![];

            for cc in &container_chains_with_collators {

                // Each chain will have `min + extra` collators, where extra is capped so `min + extra <= max`.

                let extra = cmp::min(

                    required_collators_remainder,

                    cc.max_collators.saturating_sub(cc.min_collators),

                );

                let num = cc.min_collators + extra;

                required_collators_remainder -= extra;

                container_chains_variable.push((cc.para_id, num));

            }

            container_chains_variable

    }

    pub fn remove_invulnerables(

        collators: &[T::AccountId],

        orchestrator_chain: ChainNumCollators,

        old_assigned: &mut BTreeMap<ParaId, Vec<T::AccountId>>,

    ) -> Vec<T::AccountId> {

        // TODO: clean this up, maybe change remove_invulnerables trait into something more ergonomic

        let min_orchestrator_collators = orchestrator_chain.min_collators as usize;

        let invulnerables_already_assigned = T::RemoveInvulnerables::remove_invulnerables(

            &mut old_assigned

                .get(&orchestrator_chain.para_id)

                .cloned()

                .unwrap_or_default(),

            min_orchestrator_collators,

        );

        let mut new_invulnerables = invulnerables_already_assigned;

        if new_invulnerables.len() >= min_orchestrator_collators {

            return new_invulnerables;

        }

        // Not enough invulnerables currently assigned, get rest from new_collators

        let mut new_collators = collators.to_vec();

        for (_id, cs) in old_assigned.iter() {

            new_collators.retain(|c| !cs.contains(c));

        }

        let num_missing_invulnerables = min_orchestrator_collators - new_invulnerables.len();

        let invulnerables_not_assigned = T::RemoveInvulnerables::remove_invulnerables(

            &mut new_collators,

            num_missing_invulnerables,

        );

        new_invulnerables.extend(invulnerables_not_assigned);

        if new_invulnerables.len() >= min_orchestrator_collators {

            return new_invulnerables;

        }

        // Still not enough invulnerables, try to get an invulnerable that is currently assigned somewhere else

        let num_missing_invulnerables = min_orchestrator_collators - new_invulnerables.len();

        let mut collators = collators.to_vec();

        let new_invulnerables_set = BTreeSet::from_iter(new_invulnerables.iter().cloned());

        collators.retain(|c| {

            // Remove collators already selected

            !new_invulnerables_set.contains(c)

        });

        let invulnerables_assigned_elsewhere =

            T::RemoveInvulnerables::remove_invulnerables(&mut collators, num_missing_invulnerables);

        if invulnerables_assigned_elsewhere.is_empty() {

            return new_invulnerables;

        }

        new_invulnerables.extend(invulnerables_assigned_elsewhere.iter().cloned());

        // In this case we must delete the old assignment of the invulnerables

        let reassigned_invulnerables_set = BTreeSet::from_iter(invulnerables_assigned_elsewhere);

        for (_id, cs) in old_assigned.iter_mut() {

            cs.retain(|c| !reassigned_invulnerables_set.contains(c));

        }

        new_invulnerables

    }

    pub fn prioritize_invulnerables(

        collators: &[T::AccountId],

        orchestrator_chain: ChainNumCollators,

        old_assigned: &mut BTreeMap<ParaId, Vec<T::AccountId>>,

    ) -> usize {

        let new_invulnerables =

            Self::remove_invulnerables(collators, orchestrator_chain, old_assigned);

        if !new_invulnerables.is_empty() {

            Self::insert_invulnerables(

                old_assigned.entry(orchestrator_chain.para_id).or_default(),

                &new_invulnerables,

            );

        }

        new_invulnerables.len()

    }

    pub fn assign_full<TShuffle>(

        collators: Vec<T::AccountId>,

        chains: Vec<(ParaId, u32)>,

        mut old_assigned: BTreeMap<ParaId, Vec<T::AccountId>>,

        shuffle: Option<TShuffle>,

    ) -> Result<BTreeMap<ParaId, Vec<T::AccountId>>, AssignmentError>

    where

        TShuffle: FnOnce(&mut Vec<T::AccountId>),

    {

        let mut required_collators = 0usize;

        for (_para_id, num_collators) in chains.iter() {

            let num_collators =

                usize::try_from(*num_collators).map_err(|_| AssignmentError::NotEnoughCollators)?;

            required_collators = required_collators

                .checked_add(num_collators)

                .ok_or(AssignmentError::NotEnoughCollators)?;

        if collators.len() < required_collators {

            return Err(AssignmentError::NotEnoughCollators);

        }

        // We checked that the sum of all `num_collators` fits in `usize`, so we can safely use `as usize`.

        // Remove invalid collators and para ids from `old_assigned`

        let para_ids_set =

            BTreeSet::from_iter(chains.iter().map(|(para_id, _num_collators)| *para_id));

        let collators_set = BTreeSet::from_iter(collators.iter().cloned());

        Self::retain_valid_old_assigned(&mut old_assigned, &para_ids_set, &collators_set);

        for (para_id, num_collators) in chains.iter() {

            let entry = old_assigned.entry(*para_id).or_default();

            entry.truncate(*num_collators as usize);

        }

        let mut needed_new_collators = 0;

        for (para_id, num_collators) in chains.iter() {

            let cs = old_assigned.entry(*para_id).or_default();

            needed_new_collators += (*num_collators as usize).saturating_sub(cs.len());

        }

        let assigned_collators: BTreeSet<T::AccountId> = old_assigned

            .iter()

            .flat_map(|(_para_id, para_collators)| para_collators.iter().cloned())

            .collect();

        // Truncate list of new_collators to `needed_new_collators` and shuffle it.

        // This has the effect of keeping collator priority (the first collator of that list is more

        // likely to be assigned to a chain than the last collator of that list), while also

        // ensuring randomness (the original order does not directly affect which chain the

        // collators are assigned to).

        let mut new_collators: Vec<_> = collators

            .into_iter()

            .filter(|x| {

                // Keep collators not already assigned

                !assigned_collators.contains(x)

            })

            .take(needed_new_collators)

            .collect();

        if let Some(shuffle) = shuffle {

            shuffle(&mut new_collators);

        }

        let mut new_collators = new_collators.into_iter();

        for (para_id, num_collators) in chains.iter() {

            let cs = old_assigned.entry(*para_id).or_default();

            while cs.len() < *num_collators as usize {

                let nc = new_collators

                    .next()

                    .ok_or(AssignmentError::NotEnoughCollators)?;

                cs.push(nc);

        Ok(old_assigned)

    }

    pub fn insert_invulnerables(assigned: &mut Vec<T::AccountId>, invulnerables: &[T::AccountId]) {

        assigned.retain(|item| !invulnerables.contains(item));

        let mut new_assigned = invulnerables.to_vec();

        new_assigned.extend(mem::take(assigned));

        *assigned = new_assigned;

    }

    pub fn retain_valid_old_assigned(

        old_assigned: &mut BTreeMap<ParaId, Vec<T::AccountId>>,

        chains_with_collators: &BTreeSet<ParaId>,

        collators: &BTreeSet<T::AccountId>,

    ) {

        // old_assigned.remove_container_chains_not_in_set

        old_assigned.retain(|id, _cs| chains_with_collators.contains(id));

        for (_id, cs) in old_assigned.iter_mut() {

            cs.retain(|c| collators.contains(c));

        }

    }