#[derive(Clone, Copy, RuntimeDebug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)]

#[derive(Clone, RuntimeDebug, Encode, Decode)]

#[derive(Clone, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]

	pub fn as_retry(&self) -> Self {

		Self {

			maybe_id: None,

			priority: self.priority,

			call: self.call.clone(),

			maybe_periodic: None,

			origin: self.origin.clone(),

			_phantom: Default::default(),

		}

	}

	fn service_task(maybe_lookup_len: Option<usize>, named: bool, periodic: bool) -> Weight {

		let base = Self::service_task_base();

		let mut total = match maybe_lookup_len {

			None => base,

			Some(l) => Self::service_task_fetched(l as u32),

		if named {

			total.saturating_accrue(Self::service_task_named().saturating_sub(base));

		}

		if periodic {

			total.saturating_accrue(Self::service_task_periodic().saturating_sub(base));

		}

		total

	}

	#[pallet::storage]

	#[pallet::event]

		/// Scheduled some task.

		Scheduled { when: BlockNumberFor<T>, index: u32 },

		/// Canceled some task.

		Canceled { when: BlockNumberFor<T>, index: u32 },

		/// Dispatched some task.

			task: TaskAddress<BlockNumberFor<T>>,

			id: Option<TaskName>,

			result: DispatchResult,

		},

		/// Set a retry configuration for some task.

			task: TaskAddress<BlockNumberFor<T>>,

			id: Option<TaskName>,

			period: BlockNumberFor<T>,

			retries: u8,

		},

		/// Cancel a retry configuration for some task.

		RetryCancelled { task: TaskAddress<BlockNumberFor<T>>, id: Option<TaskName> },

		/// The call for the provided hash was not found so the task has been aborted.

		CallUnavailable { task: TaskAddress<BlockNumberFor<T>>, id: Option<TaskName> },

		/// The given task was unable to be renewed since the agenda is full at that block.

		PeriodicFailed { task: TaskAddress<BlockNumberFor<T>>, id: Option<TaskName> },

		/// The given task was unable to be retried since the agenda is full at that block or there

		RetryFailed { task: TaskAddress<BlockNumberFor<T>>, id: Option<TaskName> },

		/// The given task can never be executed since it is overweight.

		PermanentlyOverweight { task: TaskAddress<BlockNumberFor<T>>, id: Option<TaskName> },

	#[pallet::error]

		/// Failed to schedule a call

		FailedToSchedule,

		/// Cannot find the scheduled call.

		NotFound,

		/// Given target block number is in the past.

		TargetBlockNumberInPast,

		/// Reschedule failed because it does not change scheduled time.

		RescheduleNoChange,

		/// Attempt to use a non-named function on a named task.

		Named,

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			Self::do_schedule(

				DispatchTime::At(when),

				maybe_periodic,

				priority,

				origin.caller().clone(),

				T::Preimages::bound(*call)?,

			)?;

			Ok(())

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			Self::do_cancel(Some(origin.caller().clone()), (when, index))?;

			Ok(())

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			Self::do_schedule_named(

				id,

				DispatchTime::At(when),

				maybe_periodic,

				priority,

				origin.caller().clone(),

				T::Preimages::bound(*call)?,

			)?;

			Ok(())

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			Self::do_cancel_named(Some(origin.caller().clone()), id)?;

			Ok(())

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			Self::do_schedule(

				DispatchTime::After(after),

				maybe_periodic,

				priority,

				origin.caller().clone(),

				T::Preimages::bound(*call)?,

			)?;

			Ok(())

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			Self::do_schedule_named(

				id,

				DispatchTime::After(after),

				maybe_periodic,

				priority,

				origin.caller().clone(),

				T::Preimages::bound(*call)?,

			)?;

			Ok(())

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			let (when, index) = task;

			let agenda = Agenda::<T>::get(when);

			let scheduled = agenda

				.get(index as usize)

				.and_then(Option::as_ref)

				.ok_or(Error::<T>::NotFound)?;

			Self::ensure_privilege(origin.caller(), &scheduled.origin)?;

			Retries::<T>::insert(

				(when, index),

				RetryConfig { total_retries: retries, remaining: retries, period },

			);

			Self::deposit_event(Event::RetrySet { task, id: None, period, retries });

			Ok(())

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			let (when, agenda_index) = Lookup::<T>::get(&id).ok_or(Error::<T>::NotFound)?;

			let agenda = Agenda::<T>::get(when);

			let scheduled = agenda

				.get(agenda_index as usize)

				.and_then(Option::as_ref)

				.ok_or(Error::<T>::NotFound)?;

			Self::ensure_privilege(origin.caller(), &scheduled.origin)?;

			Retries::<T>::insert(

				(when, agenda_index),

				RetryConfig { total_retries: retries, remaining: retries, period },

			);

			Self::deposit_event(Event::RetrySet {

				task: (when, agenda_index),

				id: Some(id),

				period,

				retries,

			});

			Ok(())

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			Self::do_cancel_retry(origin.caller(), task)?;

			Self::deposit_event(Event::RetryCancelled { task, id: None });

			Ok(())

			let origin = <T as Config>::RuntimeOrigin::from(origin);

			let task = Lookup::<T>::get(&id).ok_or(Error::<T>::NotFound)?;

			Self::do_cancel_retry(origin.caller(), task)?;

			Self::deposit_event(Event::RetryCancelled { task, id: Some(id) });

			Ok(())

	pub fn migrate_v1_to_v4() -> Weight {

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

		// Delete all undecodable values.

		// `StorageMap::translate` is not enough since it just skips them and leaves the keys in.

		let keys = old::Agenda::<T>::iter_keys().collect::<Vec<_>>();

		for key in keys {

			weight.saturating_accrue(T::DbWeight::get().reads(1));

			if let Err(_) = old::Agenda::<T>::try_get(&key) {

				weight.saturating_accrue(T::DbWeight::get().writes(1));

				old::Agenda::<T>::remove(&key);

				log::warn!("Deleted undecodable agenda");

			}

		Agenda::<T>::translate::<

			Vec<Option<ScheduledV1<<T as Config>::RuntimeCall, BlockNumberFor<T>>>>,

			_,

		>(|_, agenda| {

			Some(BoundedVec::truncate_from(

				agenda

					.into_iter()

					.map(|schedule| {

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

						schedule.and_then(|schedule| {

							if let Some(id) = schedule.maybe_id.as_ref() {

								let name = blake2_256(id);

								if let Some(item) = old::Lookup::<T>::take(id) {

									Lookup::<T>::insert(name, item);

								}

								weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));

							}

							let call = T::Preimages::bound(schedule.call).ok()?;

							if call.lookup_needed() {

								weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 1));

							}

							Some(Scheduled {

								maybe_id: schedule.maybe_id.map(|x| blake2_256(&x[..])),

								priority: schedule.priority,

								call,

								maybe_periodic: schedule.maybe_periodic,

								origin: system::RawOrigin::Root.into(),

								_phantom: Default::default(),

							})

						})

					})

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

			))

		});

		#[allow(deprecated)]

		frame_support::storage::migration::remove_storage_prefix(

			Self::name().as_bytes(),

			b"StorageVersion",

			&[],

		);

		StorageVersion::new(4).put::<Self>();

		weight + T::DbWeight::get().writes(2)

	}

	pub fn migrate_v2_to_v4() -> Weight {

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

		// Delete all undecodable values.

		// `StorageMap::translate` is not enough since it just skips them and leaves the keys in.

		let keys = old::Agenda::<T>::iter_keys().collect::<Vec<_>>();

		for key in keys {

			weight.saturating_accrue(T::DbWeight::get().reads(1));

			if let Err(_) = old::Agenda::<T>::try_get(&key) {

				weight.saturating_accrue(T::DbWeight::get().writes(1));

				old::Agenda::<T>::remove(&key);

				log::warn!("Deleted undecodable agenda");

			}

		Agenda::<T>::translate::<Vec<Option<ScheduledV2Of<T>>>, _>(|_, agenda| {

			Some(BoundedVec::truncate_from(

				agenda

					.into_iter()

					.map(|schedule| {

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

						schedule.and_then(|schedule| {

							if let Some(id) = schedule.maybe_id.as_ref() {

								let name = blake2_256(id);

								if let Some(item) = old::Lookup::<T>::take(id) {

									Lookup::<T>::insert(name, item);

								}

								weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));

							}

							let call = T::Preimages::bound(schedule.call).ok()?;

							if call.lookup_needed() {

								weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 1));

							}

							Some(Scheduled {

								maybe_id: schedule.maybe_id.map(|x| blake2_256(&x[..])),

								priority: schedule.priority,

								call,

								maybe_periodic: schedule.maybe_periodic,

								origin: schedule.origin,

								_phantom: Default::default(),

							})

						})

					})

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

			))

		});

		#[allow(deprecated)]

		frame_support::storage::migration::remove_storage_prefix(

			Self::name().as_bytes(),

			b"StorageVersion",

			&[],

		);

		StorageVersion::new(4).put::<Self>();

		weight + T::DbWeight::get().writes(2)

	}

	pub fn migrate_v3_to_v4() -> Weight {

		let mut weight = T::DbWeight::get().reads_writes(2, 1);

		// Delete all undecodable values.

		// `StorageMap::translate` is not enough since it just skips them and leaves the keys in.

		let blocks = old::Agenda::<T>::iter_keys().collect::<Vec<_>>();

		for block in blocks {

			weight.saturating_accrue(T::DbWeight::get().reads(1));

			if let Err(_) = old::Agenda::<T>::try_get(&block) {

				weight.saturating_accrue(T::DbWeight::get().writes(1));

				old::Agenda::<T>::remove(&block);

				log::warn!("Deleted undecodable agenda of block: {:?}", block);

			}

		Agenda::<T>::translate::<Vec<Option<ScheduledV3Of<T>>>, _>(|block, agenda| {

			log::info!("Migrating agenda of block: {:?}", &block);

			Some(BoundedVec::truncate_from(

				agenda

					.into_iter()

					.map(|schedule| {

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

						schedule

							.and_then(|schedule| {

								if let Some(id) = schedule.maybe_id.as_ref() {

									let name = blake2_256(id);

									if let Some(item) = old::Lookup::<T>::take(id) {

										Lookup::<T>::insert(name, item);

										log::info!("Migrated name for id: {:?}", id);

										log::error!("No name in Lookup for id: {:?}", &id);

									weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));

									log::info!("Schedule is unnamed");

								let call = match schedule.call {

									MaybeHashed::Hash(h) => {

										let bounded = Bounded::from_legacy_hash(h);

										if let Err(err) = T::Preimages::peek::<

											<T as Config>::RuntimeCall,

										>(&bounded)

											log::error!(

												"Dropping undecodable call {:?}: {:?}",

												&h,

												&err

											return None

										}

										weight.saturating_accrue(T::DbWeight::get().reads(1));

										log::info!("Migrated call by hash, hash: {:?}", h);

										bounded

									MaybeHashed::Value(v) => {

										let call = T::Preimages::bound(v)

											.map_err(|e| {

												log::error!("Could not bound Call: {:?}", e)

											})

											.ok()?;

										if call.lookup_needed() {

											weight.saturating_accrue(

												T::DbWeight::get().reads_writes(0, 1),

											);

										}

										log::info!(

											"Migrated call by value, hash: {:?}",

											call.hash()

										call

								Some(Scheduled {

									maybe_id: schedule.maybe_id.map(|x| blake2_256(&x[..])),

									priority: schedule.priority,

									call,

									maybe_periodic: schedule.maybe_periodic,

									origin: schedule.origin,

									_phantom: Default::default(),

								})

							})

							.or_else(|| {

								log::info!("Schedule in agenda for block {:?} is empty - nothing to do here.", &block);

								None

							})

					})

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

			))

		});

		#[allow(deprecated)]

		frame_support::storage::migration::remove_storage_prefix(

			Self::name().as_bytes(),

			b"StorageVersion",

			&[],

		);

		StorageVersion::new(4).put::<Self>();

		weight + T::DbWeight::get().writes(2)

	}

	pub fn migrate_origin<OldOrigin: Into<T::PalletsOrigin> + codec::Decode>() {

		Agenda::<T>::translate::<

			Vec<

				Option<

					Scheduled<

						TaskName,

						BoundedCallOf<T>,

						BlockNumberFor<T>,

						OldOrigin,

						T::AccountId,

					>,

				>,

			>,

			_,

		>(|_, agenda| {

			Some(BoundedVec::truncate_from(

				agenda

					.into_iter()

					.map(|schedule| {

						schedule.map(|schedule| Scheduled {

							maybe_id: schedule.maybe_id,

							priority: schedule.priority,

							call: schedule.call,

							maybe_periodic: schedule.maybe_periodic,

							origin: schedule.origin.into(),

							_phantom: Default::default(),

						})

					})

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

			))

		});

	}

			DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one()),

			return Err(Error::<T>::TargetBlockNumberInPast.into())

			Lookup::<T>::insert(name, address)

			if let Some(hole_index) = agenda.iter().position(|i| i.is_none()) {

				agenda[hole_index] = Some(what);

				hole_index as u32

				return Err((DispatchError::Exhausted, what))

				agenda.truncate(i + 1);

				Agenda::<T>::insert(when, agenda);

			},

			// Request the call to be made available.

			T::Preimages::request(&hash);

						Self::ensure_privilege(o, &s.origin)?;

				Lookup::<T>::remove(id);

			return Err(Error::<T>::NotFound.into())

	fn do_reschedule(

		(when, index): TaskAddress<BlockNumberFor<T>>,

		new_time: DispatchTime<BlockNumberFor<T>>,

	) -> Result<TaskAddress<BlockNumberFor<T>>, DispatchError> {

		let new_time = Self::resolve_time(new_time)?;

		if new_time == when {

			return Err(Error::<T>::RescheduleNoChange.into())

		}

		let task = Agenda::<T>::try_mutate(when, |agenda| {

			let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;

			ensure!(!matches!(task, Some(Scheduled { maybe_id: Some(_), .. })), Error::<T>::Named);

			task.take().ok_or(Error::<T>::NotFound)

		})?;

		Self::cleanup_agenda(when);

		Self::deposit_event(Event::Canceled { when, index });

		Self::place_task(new_time, task).map_err(|x| x.0)

	}

	fn do_schedule_named(

		id: TaskName,

		when: DispatchTime<BlockNumberFor<T>>,

		maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,

		priority: schedule::Priority,

		origin: T::PalletsOrigin,

		call: BoundedCallOf<T>,

	) -> Result<TaskAddress<BlockNumberFor<T>>, DispatchError> {

		// ensure id it is unique

		if Lookup::<T>::contains_key(&id) {

			return Err(Error::<T>::FailedToSchedule.into())

		}

		let when = Self::resolve_time(when)?;

		let lookup_hash = call.lookup_hash();

		// sanitize maybe_periodic

		let maybe_periodic = maybe_periodic

			.filter(|p| p.1 > 1 && !p.0.is_zero())

			// Remove one from the number of repetitions since we will schedule one now.

			.map(|(p, c)| (p, c - 1));

		let task = Scheduled {

			maybe_id: Some(id),

			priority,

			call,

			maybe_periodic,

			origin,

			_phantom: Default::default(),

		};

		let res = Self::place_task(when, task).map_err(|x| x.0)?;

		if let Some(hash) = lookup_hash {

			// Request the call to be made available.

			T::Preimages::request(&hash);

		}

		Ok(res)

	}

	fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: TaskName) -> DispatchResult {

		Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {

			if let Some((when, index)) = lookup.take() {

				let i = index as usize;

				Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {

					if let Some(s) = agenda.get_mut(i) {

						if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {

							Self::ensure_privilege(o, &s.origin)?;

							Retries::<T>::remove((when, index));

							T::Preimages::drop(&s.call);

						}

						*s = None;

					}

					Ok(())

				})?;

				Self::cleanup_agenda(when);

				Self::deposit_event(Event::Canceled { when, index });

				Ok(())

				return Err(Error::<T>::NotFound.into())

		})

	}

	fn do_reschedule_named(

		id: TaskName,

		new_time: DispatchTime<BlockNumberFor<T>>,

	) -> Result<TaskAddress<BlockNumberFor<T>>, DispatchError> {

		let new_time = Self::resolve_time(new_time)?;

		let lookup = Lookup::<T>::get(id);

		let (when, index) = lookup.ok_or(Error::<T>::NotFound)?;

		if new_time == when {

			return Err(Error::<T>::RescheduleNoChange.into())

		}

		let task = Agenda::<T>::try_mutate(when, |agenda| {

			let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;

			task.take().ok_or(Error::<T>::NotFound)

		})?;

		Self::cleanup_agenda(when);

		Self::deposit_event(Event::Canceled { when, index });

		Self::place_task(new_time, task).map_err(|x| x.0)

	}

	fn do_cancel_retry(

		origin: &T::PalletsOrigin,

		(when, index): TaskAddress<BlockNumberFor<T>>,

	) -> Result<(), DispatchError> {

		let agenda = Agenda::<T>::get(when);

		let scheduled = agenda

			.get(index as usize)

			.and_then(Option::as_ref)

			.ok_or(Error::<T>::NotFound)?;

		Self::ensure_privilege(origin, &scheduled.origin)?;

		Retries::<T>::remove((when, index));

		Ok(())

	}

			return

				incomplete_since = incomplete_since.min(when);

			IncompleteSince::<T>::put(incomplete_since);

				maybe_item.as_ref().map(|item| (index as u32, item.priority))

			let task = match agenda[agenda_index as usize].take() {

				None => continue,

				Some(t) => t,

			};

			let base_weight = T::WeightInfo::service_task(

				task.call.lookup_len().map(|x| x as usize),

				task.maybe_id.is_some(),

				task.maybe_periodic.is_some(),

			);

			if !weight.can_consume(base_weight) {

				postponed += 1;

				break

			}

			let result = Self::service_task(weight, now, when, agenda_index, *executed == 0, task);

			agenda[agenda_index as usize] = match result {

				Err((Unavailable, slot)) => {

					dropped += 1;

					slot

				Err((Overweight, slot)) => {

					postponed += 1;

					slot

					*executed += 1;

					None

			Agenda::<T>::insert(when, agenda);

	fn service_task(

		weight: &mut WeightMeter,

		now: BlockNumberFor<T>,

		when: BlockNumberFor<T>,

		agenda_index: u32,

		is_first: bool,

		mut task: ScheduledOf<T>,

	) -> Result<(), (ServiceTaskError, Option<ScheduledOf<T>>)> {

		if let Some(ref id) = task.maybe_id {

			Lookup::<T>::remove(id);

		}

		let (call, lookup_len) = match T::Preimages::peek(&task.call) {

			Ok(c) => c,

				Self::deposit_event(Event::CallUnavailable {

					task: (when, agenda_index),

					id: task.maybe_id,

				});

				// It was not available when we needed it, so we don't need to have requested it

				// anymore.

				T::Preimages::drop(&task.call);

				// We don't know why `peek` failed, thus we most account here for the "full weight".

				let _ = weight.try_consume(T::WeightInfo::service_task(

					task.call.lookup_len().map(|x| x as usize),

					task.maybe_id.is_some(),

					task.maybe_periodic.is_some(),

				));

				return Err((Unavailable, Some(task)))

		let _ = weight.try_consume(T::WeightInfo::service_task(

			lookup_len.map(|x| x as usize),

			task.maybe_id.is_some(),

			task.maybe_periodic.is_some(),

		));

		match Self::execute_dispatch(weight, task.origin.clone(), call) {

			Err(()) if is_first => {

				T::Preimages::drop(&task.call);

				Self::deposit_event(Event::PermanentlyOverweight {

					task: (when, agenda_index),

					id: task.maybe_id,

				});

				Err((Unavailable, Some(task)))

			Err(()) => Err((Overweight, Some(task))),

			Ok(result) => {

				let failed = result.is_err();

				let maybe_retry_config = Retries::<T>::take((when, agenda_index));

				Self::deposit_event(Event::Dispatched {

					task: (when, agenda_index),

					id: task.maybe_id,

					result,

				});

				match maybe_retry_config {

					Some(retry_config) if failed => {

						Self::schedule_retry(weight, now, when, agenda_index, &task, retry_config);

					},

					_ => {},

				if let &Some((period, count)) = &task.maybe_periodic {

					if count > 1 {

						task.maybe_periodic = Some((period, count - 1));

					} else {

						task.maybe_periodic = None;

					}

					let wake = now.saturating_add(period);

					match Self::place_task(wake, task) {

						Ok(new_address) =>

							if let Some(retry_config) = maybe_retry_config {

								Retries::<T>::insert(new_address, retry_config);

							},

						Err((_, task)) => {