// Copyright Moonsong Labs

// This file is part of Moonkit.

// Moonkit is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Moonkit is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Moonkit.  If not, see <http://www.gnu.org/licenses/>.

//! Pallet that allows block authors to include their identity in a block via an inherent.

//! Currently the author does not _prove_ their identity, just states it. So it should not be used,

//! for things like equivocation slashing that require authenticated authorship information.

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

use frame_support::traits::{FindAuthor, Get};

use nimbus_primitives::{

	AccountLookup, CanAuthor, NimbusId, SlotBeacon, INHERENT_IDENTIFIER, NIMBUS_ENGINE_ID,

};

use parity_scale_codec::{Decode, Encode, FullCodec};

use sp_inherents::{InherentIdentifier, IsFatalError};

use sp_runtime::{ConsensusEngineId, RuntimeString};

pub use crate::weights::WeightInfo;

pub use exec::BlockExecutor;

pub use pallet::*;

#[cfg(any(test, feature = "runtime-benchmarks"))]

mod benchmarks;

pub mod weights;

mod exec;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

pub mod pallet {

	use super::*;

	use frame_support::pallet_prelude::*;

	use frame_system::pallet_prelude::*;

	/// The Author Inherent pallet. The core of the nimbus consensus framework's runtime presence.

	pub struct Pallet<T>(PhantomData<T>);

	#[pallet::config]

	pub trait Config: frame_system::Config {

		/// Type used to refer to a block author.

		type AuthorId: sp_std::fmt::Debug + PartialEq + Clone + FullCodec + TypeInfo + MaxEncodedLen;

		/// A type to convert between NimbusId and AuthorId. This is useful when you want to associate

		/// Block authoring behavior with an AuthorId for rewards or slashing. If you do not need to

		/// hold an AuthorId responsible for authoring use `()` which acts as an identity mapping.

		type AccountLookup: AccountLookup<Self::AuthorId>;

		/// The final word on whether the reported author can author at this height.

		/// This will be used when executing the inherent. This check is often stricter than the

		/// Preliminary check, because it can use more data.

		/// If the pallet that implements this trait depends on an inherent, that inherent **must**

		/// be included before this one.

		type CanAuthor: CanAuthor<Self::AuthorId>;

		/// Some way of determining the current slot for purposes of verifying the author's eligibility

		type SlotBeacon: SlotBeacon;

		type WeightInfo: WeightInfo;

	}

	impl<T> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {

		type Public = NimbusId;

	}

	pub enum Error<T> {

	}

	/// Author of current block.

	pub type Author<T: Config> = StorageValue<_, T::AuthorId, OptionQuery>;

	/// Check if the inherent was included

	pub type InherentIncluded<T: Config> = StorageValue<_, bool, ValueQuery>;

	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {

			// on_initialize: 1 write

			// on_finalize: 1 read + 1 write

			);

	}

	impl<T: Config> Pallet<T> {

		/// This inherent is a workaround to run code after the "real" inherents have executed,

		/// but before transactions are executed.

		// This should go into on_post_inherents when it is ready https://github.com/paritytech/substrate/pull/10128

		// TODO better weight. For now we just set a somewhat conservative fudge factor

		#[pallet::call_index(0)]

		#[pallet::weight((T::WeightInfo::kick_off_authorship_validation(), DispatchClass::Mandatory))]

			// First check that the slot number is valid (greater than the previous highest)

			);

		}

	}

	#[pallet::inherent]

	impl<T: Config> ProvideInherent for Pallet<T> {

		type Call = Call<T>;

		type Error = InherentError;

		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;

		// Regardless of whether the client is still supplying the author id,

		// we will create the new empty-payload inherent extrinsic.

	}

	impl<T: Config> FindAuthor<T::AuthorId> for Pallet<T> {

			}

	}

	impl<T: Config> Get<T::AuthorId> for Pallet<T> {

	}

	/// To learn whether a given NimbusId can author, as opposed to an account id, you

	/// can ask this pallet directly. It will do the mapping for you.

	impl<T: Config> CanAuthor<NimbusId> for Pallet<T> {

		fn can_author(author: &NimbusId, slot: &u32) -> bool {

			let account = match T::AccountLookup::lookup_account(author) {

				Some(account) => account,

				// Authors whose account lookups fail will not be eligible

				None => {

					return false;

				}

			};

			T::CanAuthor::can_author(&account, slot)

		}

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

		fn set_eligible_author(slot: &u32) {

			let eligible_authors = T::CanAuthor::get_authors(slot);

			if let Some(author) = eligible_authors.first() {

				Author::<T>::put(author)

			}

		}

	}

}

#[derive(Encode)]

#[cfg_attr(feature = "std", derive(Debug, Decode))]

pub enum InherentError {

	Other(RuntimeString),

}

impl IsFatalError for InherentError {

}

impl InherentError {

	/// Try to create an instance ouf of the given identifier and data.

	#[cfg(feature = "std")]

	pub fn try_from(id: &InherentIdentifier, data: &[u8]) -> Option<Self> {

		if id == &INHERENT_IDENTIFIER {

			<InherentError as parity_scale_codec::Decode>::decode(&mut &data[..]).ok()

		} else {

			None

		}

	}

}