// This file is part of Substrate.

// Copyright (C) Parity Technologies (UK) Ltd.

// SPDX-License-Identifier: Apache-2.0

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// 	http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//! Migrations for the scheduler pallet.

use super::*;

use frame_support::traits::OnRuntimeUpgrade;

use frame_system::pallet_prelude::BlockNumberFor;

#[cfg(feature = "try-runtime")]

use sp_runtime::TryRuntimeError;

/// The log target.

const TARGET: &'static str = "runtime::scheduler::migration";

pub mod v1 {

	use super::*;

	use frame_support::pallet_prelude::*;

	pub(crate) type Agenda<T: Config> = StorageMap<

		Pallet<T>,

		Twox64Concat,

		BlockNumberFor<T>,

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

		ValueQuery,

	>;

	pub(crate) type Lookup<T: Config> =

		StorageMap<Pallet<T>, Twox64Concat, Vec<u8>, TaskAddress<BlockNumberFor<T>>>;

}

pub mod v2 {

	use super::*;

	use frame_support::pallet_prelude::*;

	pub(crate) type Agenda<T: Config> = StorageMap<

		Pallet<T>,

		Twox64Concat,

		BlockNumberFor<T>,

		Vec<Option<ScheduledV2Of<T>>>,

		ValueQuery,

	>;

	pub(crate) type Lookup<T: Config> =

		StorageMap<Pallet<T>, Twox64Concat, Vec<u8>, TaskAddress<BlockNumberFor<T>>>;

}

pub mod v3 {

	use super::*;

	use frame_support::pallet_prelude::*;

	pub(crate) type Agenda<T: Config> = StorageMap<

		Pallet<T>,

		Twox64Concat,

		BlockNumberFor<T>,

		Vec<Option<ScheduledV3Of<T>>>,

		ValueQuery,

	>;

	pub(crate) type Lookup<T: Config> =

		StorageMap<Pallet<T>, Twox64Concat, Vec<u8>, TaskAddress<BlockNumberFor<T>>>;

	/// Migrate the scheduler pallet from V3 to V4.

	pub struct MigrateToV4<T>(core::marker::PhantomData<T>);

	impl<T: Config> OnRuntimeUpgrade for MigrateToV4<T> {

		#[cfg(feature = "try-runtime")]

				// This is not necessarily an error, but can happen when there are Calls

				// in an Agenda that are not valid anymore with the new runtime.

					target: TARGET,

					decodable_agendas,

					agendas

				);

			// Check that no agenda overflows `MaxScheduledPerBlock`.

						target: TARGET,

						max_scheduled_per_block,

					);

			}

			// Check that bounding the calls will not overflow `MAX_LENGTH`.

									target: TARGET,

									block_number,

									l,

								);

						},

					}

				}

			}

					target: TARGET,

					version,

				);

		#[cfg(feature = "try-runtime")]

			// Check that everything decoded fine.

			}

				// This is not necessarily an error, but can happen when there are Calls

				// in an Agenda that are not valid anymore in the new runtime.

					target: TARGET,

					old_agendas,

					new_agendas,

				);

			} else {

			}

	}

}

pub mod v4 {

	use super::*;

	use frame_support::pallet_prelude::*;

	/// This migration cleans up empty agendas of the V4 scheduler.

	///

	/// This should be run on a scheduler that does not have

	/// <https://github.com/paritytech/substrate/pull/12989> since it piles up `None`-only agendas. This does not modify the pallet version.

	pub struct CleanupAgendas<T>(core::marker::PhantomData<T>);

	impl<T: Config> OnRuntimeUpgrade for CleanupAgendas<T> {

		#[cfg(feature = "try-runtime")]

				4,

			);

				target: TARGET,

				agendas,

				non_empty_agendas

			);

					Some(0) => {

							k,

							all_schedules

						);

					},

							suffix_none_schedules,

							all_schedules,

							ne,

							k

						);

					},

					Some(_) => {

					},

					None => {

					},

				}

			}

			// We don't modify the pallet version.

		#[cfg(feature = "try-runtime")]

					target: TARGET,

				),

				},

			}

	}

}

#[cfg(test)]

#[cfg(feature = "try-runtime")]

mod test {

	use super::*;

	use crate::mock::*;

	use alloc::borrow::Cow;

	use frame_support::Hashable;

	use substrate_test_utils::assert_eq_uvec;

	#[test]

	#[allow(deprecated)]

	fn migration_v3_to_v4_works() {

		new_test_ext().execute_with(|| {

			// Assume that we are at V3.

			StorageVersion::new(3).put::<Scheduler>();

			// Call that will be bounded to a `Lookup`.

			let large_call =

				RuntimeCall::System(frame_system::Call::remark { remark: vec![0; 1024] });

			// Call that can be inlined.

			let small_call =

				RuntimeCall::System(frame_system::Call::remark { remark: vec![0; 10] });

			// Call that is already hashed and can will be converted to `Legacy`.

			let hashed_call =

				RuntimeCall::System(frame_system::Call::remark { remark: vec![0; 2048] });

			let bound_hashed_call = Preimage::bound(hashed_call.clone()).unwrap();

			assert!(bound_hashed_call.lookup_needed());

			// A Call by hash that will fail to decode becomes `None`.

			let trash_data = vec![255u8; 1024];

			let undecodable_hash = Preimage::note(Cow::Borrowed(&trash_data)).unwrap();

			for i in 0..2u64 {

				let k = i.twox_64_concat();

				let old = vec![

					Some(ScheduledV3Of::<Test> {

						maybe_id: None,

						priority: i as u8 + 10,

						call: small_call.clone().into(),

						maybe_periodic: None, // 1

						origin: root(),

						_phantom: PhantomData::<u64>::default(),

					}),

					None,

					Some(ScheduledV3Of::<Test> {

						maybe_id: Some(vec![i as u8; 32]),

						priority: 123,

						call: large_call.clone().into(),

						maybe_periodic: Some((4u64, 20)),

						origin: signed(i),

						_phantom: PhantomData::<u64>::default(),

					}),

					Some(ScheduledV3Of::<Test> {

						maybe_id: Some(vec![255 - i as u8; 320]),

						priority: 123,

						call: MaybeHashed::Hash(bound_hashed_call.hash()),

						maybe_periodic: Some((8u64, 10)),

						origin: signed(i),

						_phantom: PhantomData::<u64>::default(),

					}),

					Some(ScheduledV3Of::<Test> {

						maybe_id: Some(vec![i as u8; 320]),

						priority: 123,

						call: MaybeHashed::Hash(undecodable_hash),

						maybe_periodic: Some((4u64, 20)),

						origin: root(),

						_phantom: PhantomData::<u64>::default(),

					}),

				];

				frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);

			}

			let state = v3::MigrateToV4::<Test>::pre_upgrade().unwrap();

			let _w = v3::MigrateToV4::<Test>::on_runtime_upgrade();

			v3::MigrateToV4::<Test>::post_upgrade(state).unwrap();

			let mut x = Agenda::<Test>::iter().map(|x| (x.0, x.1.into_inner())).collect::<Vec<_>>();

			x.sort_by_key(|x| x.0);

			let bound_large_call = Preimage::bound(large_call).unwrap();

			assert!(bound_large_call.lookup_needed());

			let bound_small_call = Preimage::bound(small_call).unwrap();

			assert!(!bound_small_call.lookup_needed());

			let expected = vec![

				(

					0,

					vec![

						Some(ScheduledOf::<Test> {

							maybe_id: None,

							priority: 10,

							call: bound_small_call.clone(),

							maybe_periodic: None,

							origin: root(),

							_phantom: PhantomData::<u64>::default(),

						}),

						None,

						Some(ScheduledOf::<Test> {

							maybe_id: Some(blake2_256(&[0u8; 32])),

							priority: 123,

							call: bound_large_call.clone(),

							maybe_periodic: Some((4u64, 20)),

							origin: signed(0),

							_phantom: PhantomData::<u64>::default(),

						}),

						Some(ScheduledOf::<Test> {

							maybe_id: Some(blake2_256(&[255u8; 320])),

							priority: 123,

							call: Bounded::from_legacy_hash(bound_hashed_call.hash()),

							maybe_periodic: Some((8u64, 10)),

							origin: signed(0),

							_phantom: PhantomData::<u64>::default(),

						}),

						None,

					],

				),

				(

					1,

					vec![

						Some(ScheduledOf::<Test> {

							maybe_id: None,

							priority: 11,

							call: bound_small_call.clone(),

							maybe_periodic: None,

							origin: root(),

							_phantom: PhantomData::<u64>::default(),

						}),

						None,

						Some(ScheduledOf::<Test> {

							maybe_id: Some(blake2_256(&[1u8; 32])),

							priority: 123,

							call: bound_large_call.clone(),

							maybe_periodic: Some((4u64, 20)),

							origin: signed(1),

							_phantom: PhantomData::<u64>::default(),

						}),

						Some(ScheduledOf::<Test> {

							maybe_id: Some(blake2_256(&[254u8; 320])),

							priority: 123,

							call: Bounded::from_legacy_hash(bound_hashed_call.hash()),

							maybe_periodic: Some((8u64, 10)),

							origin: signed(1),

							_phantom: PhantomData::<u64>::default(),

						}),

						None,

					],

				),

			];

			for (outer, (i, j)) in x.iter().zip(expected.iter()).enumerate() {

				assert_eq!(i.0, j.0);

				for (inner, (x, y)) in i.1.iter().zip(j.1.iter()).enumerate() {

					assert_eq!(x, y, "at index: outer {} inner {}", outer, inner);

				}

			}

			assert_eq_uvec!(x, expected);

			assert_eq!(StorageVersion::get::<Scheduler>(), 4);

		});

	}

	#[test]

	#[allow(deprecated)]

	fn migration_v3_to_v4_too_large_calls_are_ignored() {

		new_test_ext().execute_with(|| {

			// Assume that we are at V3.

			StorageVersion::new(3).put::<Scheduler>();

			let too_large_call = RuntimeCall::System(frame_system::Call::remark {

				remark: vec![0; <Test as Config>::Preimages::MAX_LENGTH + 1],

			});

			let i = 0u64;

			let k = i.twox_64_concat();

			let old = vec![Some(ScheduledV3Of::<Test> {

				maybe_id: None,

				priority: 1,

				call: too_large_call.clone().into(),

				maybe_periodic: None,

				origin: root(),

				_phantom: PhantomData::<u64>::default(),

			})];

			frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);

			// The pre_upgrade hook fails:

			let err = v3::MigrateToV4::<Test>::pre_upgrade().unwrap_err();

			assert_eq!(DispatchError::from("Call is too large."), err);

			// But the migration itself works:

			let _w = v3::MigrateToV4::<Test>::on_runtime_upgrade();

			let mut x = Agenda::<Test>::iter().map(|x| (x.0, x.1.into_inner())).collect::<Vec<_>>();

			x.sort_by_key(|x| x.0);

			// The call becomes `None`.

			let expected = vec![(0, vec![None])];

			assert_eq_uvec!(x, expected);

			assert_eq!(StorageVersion::get::<Scheduler>(), 4);

		});

	}

	#[test]

	fn cleanup_agendas_works() {

		use sp_core::bounded_vec;

		new_test_ext().execute_with(|| {

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

			let call = RuntimeCall::System(frame_system::Call::remark { remark: vec![] });

			let bounded_call = Preimage::bound(call).unwrap();

			let some = Some(ScheduledOf::<Test> {

				maybe_id: None,

				priority: 1,

				call: bounded_call,

				maybe_periodic: None,

				origin: root(),

				_phantom: Default::default(),

			});

			// Put some empty, and some non-empty agendas in there.

			let test_data: Vec<(

				BoundedVec<Option<ScheduledOf<Test>>, <Test as Config>::MaxScheduledPerBlock>,

				Option<

					BoundedVec<Option<ScheduledOf<Test>>, <Test as Config>::MaxScheduledPerBlock>,

				>,

			)> = vec![

				(bounded_vec![some.clone()], Some(bounded_vec![some.clone()])),

				(bounded_vec![None, some.clone()], Some(bounded_vec![None, some.clone()])),

				(bounded_vec![None, some.clone(), None], Some(bounded_vec![None, some.clone()])),

				(bounded_vec![some.clone(), None, None], Some(bounded_vec![some.clone()])),

				(bounded_vec![None, None], None),

				(bounded_vec![None, None, None], None),

				(bounded_vec![], None),

			];

			// Insert all the agendas.

			for (i, test) in test_data.iter().enumerate() {

				Agenda::<Test>::insert(i as u64, test.0.clone());

			}

			// Run the migration.

			let data = v4::CleanupAgendas::<Test>::pre_upgrade().unwrap();

			let _w = v4::CleanupAgendas::<Test>::on_runtime_upgrade();

			v4::CleanupAgendas::<Test>::post_upgrade(data).unwrap();

			// Check that the post-state is correct.

			for (i, test) in test_data.iter().enumerate() {

				match test.1.clone() {

					None => assert!(

						!Agenda::<Test>::contains_key(i as u64),

						"Agenda {} should be removed",

						i

					),

					Some(new) => {

						assert_eq!(Agenda::<Test>::get(i as u64), new, "Agenda wrong {}", i)

					},

				}

			}

		});

	}

	fn signed(i: u64) -> OriginCaller {

		system::RawOrigin::Signed(i).into()

	}

}