// This file is part of Bizinikiwi.

// 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.

//! > Made with *Bizinikiwi*, for *DotSama*.
//!
//! [![github]](https://github.com/pezkuwichain/kurdistan-sdk/tree/main/bizinikiwi/pezframe/fast-unstake) -
//! [![pezkuwi]](https://pezkuwichain.io)
//!
//! [pezkuwi]: https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white
//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
//!
//! # Paged List Pezpallet
//!
//! A thin wrapper pezpallet around a [`paged_list::StoragePagedList`]. It provides an API for a
//! single paginated list. It can be instantiated multiple times to provide multiple lists.
//!
//! ## Overview
//!
//! The pezpallet is quite unique since it does not expose any `Call`s, `Error`s or `Event`s. All
//! interaction goes through the implemented
//! [`StorageList`][frame::deps::pezframe_support::storage::StorageList] trait.
//!
//! A fuzzer for testing is provided in crate `pezpallet-paged-list-fuzzer`.
//!
//! ## Examples
//!
//! 1. **Appending** some data to the list can happen either by [`Pezpallet::append_one`]:
#![doc = docify::embed!("src/tests.rs", append_one_works)]
//! 2. or by [`Pezpallet::append_many`]. This should always be preferred to repeated calls to
//! [`Pezpallet::append_one`]:
#![doc = docify::embed!("src/tests.rs", append_many_works)]
//! 3. If you want to append many values (ie. in a loop), then best use the [`Pezpallet::appender`]:
#![doc = docify::embed!("src/tests.rs", appender_works)]
//! 4. **Iterating** over the list can be done with [`Pezpallet::iter`]. It uses the standard
//! `Iterator` trait:
#![doc = docify::embed!("src/tests.rs", iter_works)]
//! 5. **Draining** elements happens through the [`Pezpallet::drain`] iterator. Note that even
//! *peeking* a value will already remove it.
#![doc = docify::embed!("src/tests.rs", drain_works)]
//!
//! ## Pezpallet API
//!
//! None. Only things to consider is the [`Config`] traits.
//!
//! ## Low Level / Implementation Details
//!
//! Implementation details are documented in [`paged_list::StoragePagedList`].
//! All storage entries are prefixed with a unique prefix that is generated by [`ListPrefix`].

#![cfg_attr(not(feature = "std"), no_std)]

pub use pezpallet::*;

pub mod mock;
mod paged_list;
mod tests;

extern crate alloc;

use codec::FullCodec;
use frame::{prelude::*, traits::StorageInstance};
pub use paged_list::StoragePagedList;

#[frame::pezpallet]
pub mod pezpallet {
	use super::*;

	#[pezpallet::pezpallet]
	pub struct Pezpallet<T, I = ()>(_);

	#[pezpallet::config]
	pub trait Config<I: 'static = ()>: pezframe_system::Config {
		/// The value type that can be stored in the list.
		type Value: FullCodec;

		/// The number of values that can be put into newly created pages.
		///
		/// Note that this does not retroactively affect already created pages. This value can be
		/// changed at any time without requiring a runtime migration.
		#[pezpallet::constant]
		type ValuesPerNewPage: Get<u32>;
	}

	/// A storage paged list akin to what the FRAME macros would generate.
	// Note that FRAME does natively support paged lists in storage.
	pub type List<T, I> = StoragePagedList<
		ListPrefix<T, I>,
		<T as Config<I>>::Value,
		<T as Config<I>>::ValuesPerNewPage,
	>;
}

// This exposes the list functionality to other pallets.
impl<T: Config<I>, I: 'static> StorageList<T::Value> for Pezpallet<T, I> {
	type Iterator = <List<T, I> as StorageList<T::Value>>::Iterator;
	type Appender = <List<T, I> as StorageList<T::Value>>::Appender;

	fn iter() -> Self::Iterator {
		List::<T, I>::iter()
	}

	fn drain() -> Self::Iterator {
		List::<T, I>::drain()
	}

	fn appender() -> Self::Appender {
		List::<T, I>::appender()
	}
}

/// Generates a unique storage prefix for each instance of the pezpallet.
pub struct ListPrefix<T, I>(core::marker::PhantomData<(T, I)>);

impl<T: Config<I>, I: 'static> StorageInstance for ListPrefix<T, I> {
	fn pezpallet_prefix() -> &'static str {
		crate::Pezpallet::<T, I>::name()
	}

	const STORAGE_PREFIX: &'static str = "paged_list";
}