// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

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

// Tanssi 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 Tanssi.  If not, see <http://www.gnu.org/licenses/>

//! # Author Noting Pallet

//!

//! This pallet notes the author of the different containerChains that have registered:

//!

//! The set of container chains is retrieved thanks to the GetContainerChains trait

//! For each containerChain, we inspect the Header stored in the relayChain as

//! a generic header. This is the first requirement for containerChains.

//!

//! The second requirement is that an Aura digest with the slot number for the containerChains

//! needs to exist

//!  

//! Using those two requirements we can select who the author was based on the collators assigned

//! to that containerChain, by simply assigning the slot position.

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

extern crate alloc;

use {

    alloc::borrow::Cow,

    alloc::vec::Vec,

    cumulus_pallet_parachain_system::RelaychainStateProvider,

    cumulus_primitives_core::{

        relay_chain::{BlakeTwo256, BlockNumber, HeadData},

        ParaId,

    },

    dp_core::well_known_keys::PARAS_HEADS_INDEX,

    frame_support::{dispatch::PostDispatchInfo, pallet_prelude::*, Hashable},

    frame_system::pallet_prelude::*,

    nimbus_primitives::SlotBeacon,

    parity_scale_codec::{Decode, Encode},

    sp_consensus_aura::{inherents::InherentType, Slot, AURA_ENGINE_ID},

    sp_inherents::{InherentIdentifier, IsFatalError},

    sp_runtime::{traits::Header, DigestItem, DispatchResult},

    tp_author_noting_inherent::INHERENT_IDENTIFIER,

    tp_traits::{

        AuthorNotingHook, AuthorNotingInfo, ContainerChainBlockInfo, ForSession, GenericStateProof,

        GenericStorageReader, GetContainerChainAuthor, GetContainerChainsWithCollators,

        LatestAuthorInfoFetcher, NativeStorageReader, ReadEntryErr,

    },

};

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

pub mod weights;

pub use weights::WeightInfo;

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

mod benchmarks;

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

mod mock_proof;

pub use pallet::*;

#[frame_support::pallet]

pub mod pallet {

    use super::*;

    #[pallet::config]

    pub trait Config: frame_system::Config {

        type ContainerChains: GetContainerChainsWithCollators<Self::AccountId>;

        type SlotBeacon: SlotBeacon;

        type ContainerChainAuthor: GetContainerChainAuthor<Self::AccountId>;

        /// An entry-point for higher-level logic to react to containers chains authoring.

        ///

        /// Typically, this can be a hook to reward block authors.

        type AuthorNotingHook: AuthorNotingHook<Self::AccountId>;

        type RelayOrPara: RelayOrPara;

        /// Max length of para id list, should be the same value as in other pallets.

        #[pallet::constant]

        type MaxContainerChains: Get<u32>;

        /// Weight information for extrinsics in this pallet.

        type WeightInfo: WeightInfo;

    }

    #[pallet::error]

    pub enum Error<T> {

        /// The new value for a configuration parameter is invalid.

        FailedReading,

        FailedDecodingHeader,

        AuraDigestFirstItem,

        AsPreRuntimeError,

        NonDecodableSlot,

        AuthorNotFound,

        NonAuraDigest,

    }

    #[pallet::pallet]

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

    #[pallet::hooks]

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

            // We clear this storage item to make sure its always included

            // The read onfinalizes

            );

    }

    #[pallet::call]

    impl<T: Config> Pallet<T> {

        #[pallet::call_index(0)]

        #[pallet::weight((T::WeightInfo::set_latest_author_data(T::MaxContainerChains::get()).saturating_add(T::WeightInfo::on_container_authors_noted(

            T::MaxContainerChains::get(),

        )), DispatchClass::Mandatory))]

        #[allow(clippy::useless_conversion)]

        pub fn set_latest_author_data(

            origin: OriginFor<T>,

            data: InherentDataOf<T>,

            );

            // We have two benchmarks, one for `set_latest_author_data`, which disables hooks,

            // and one benchmark only for only hooks: `on_container_authors_noted`.

            // The weight hint needs to include both of them to account for the worst case.

            // The returned weight will be lower than the hint, because we never have

            // `T::MaxContainerChains::get()` chains registered.

            // Here we initialize the weight to the base weight, without hooks, but for the real

            // number of chains. Later we will add the weight reported by the hooks.

            // The weight used by hooks is not calculated using the `on_container_authors_noted`

            // benchmark, instead it is a manual guess of the number of storage reads and writes.

            // We do this first to make sure we don't do 2 reads (parachains and relay state)

            // when we have no containers registered

            // Essentially one can pass an empty proof if no container-chains are registered

                                |maybe_old_block_info: &mut Option<

                                    ContainerChainBlockInfo<T::AccountId>,

                                    // No block number is the same as the last block number being 0:

                                    // the first block created by collators is block number 1.

                                    // We only reward author if the block increases

                                    // If there is no previous block, we should reward the author of the first block

                                    } else {

                                        // No need to mutate value if block number didn't change

                                    }

                            );

                        }

                            e,

                        ),

                    }

                }

                // Call AuthorNotingHook

                // When benchmarking, we want the possibility to not call hooks, to get the base

                // weight of this inherent.

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

                if crate::benchmarks::should_run_author_noting_hooks() {

                    total_weight

                        .saturating_accrue(T::AuthorNotingHook::on_container_authors_noted(&infos));

                }

                // not runtime-benchmarks: always call hook

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

            // We correctly set the data

        }

        #[pallet::call_index(1)]

        #[pallet::weight(T::WeightInfo::set_author())]

        pub fn set_author(

            origin: OriginFor<T>,

            para_id: ParaId,

            block_number: BlockNumber,

            author: T::AccountId,

            latest_slot_number: Slot,

            );

        }

        #[pallet::call_index(2)]

        #[pallet::weight(T::WeightInfo::kill_author_data())]

        }

    }

    #[pallet::event]

    #[pallet::generate_deposit(pub(super) fn deposit_event)]

    pub enum Event<T: Config> {

        /// Latest author changed

        LatestAuthorChanged {

            para_id: ParaId,

            block_number: BlockNumber,

            new_author: T::AccountId,

            latest_slot_number: Slot,

        },

        /// Removed author data

        RemovedAuthorData { para_id: ParaId },

    }

    #[pallet::storage]

    pub(super) type LatestAuthor<T: Config> =

        StorageMap<_, Blake2_128Concat, ParaId, ContainerChainBlockInfo<T::AccountId>, OptionQuery>;

    /// Was the containerAuthorData set?

    #[pallet::storage]

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

    #[pallet::inherent]

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

        type Call = Call<T>;

        type Error = InherentError;

        // TODO, what should we put here

        const INHERENT_IDENTIFIER: InherentIdentifier =

            tp_author_noting_inherent::INHERENT_IDENTIFIER;

            // Return Ok(Some(_)) unconditionally because this inherent is required in every block

    }

}

impl<T: Config> Pallet<T> {

    /// Fetch author and block number from a proof of header

        // CONCAT

        // We might encounter empty vecs

        // We only note if we can decode

        // In this process several errors can occur, but we will only log if such errors happen

        // We first take the HeadData

        // If the readError was that the key was not provided (identified by the Proof error),

        // then panic

        // We later take the Header decoded

        )

        // Return author from first aura log.

        // If there are no aura logs, it iterates over all the logs, then returns the error from the first element.

        // This is because it is hard to return a `Vec<Error<T>>`.

                    }

                }

            }

        }

    /// Get block author from aura digest

        // We decode the digest as pre-runtime digest

        // Match against the Aura digest

            // DecodeSlot

            // Fetch Author

        } else {

        }

}

#[derive(Encode)]

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

pub enum InherentError {

    Other(Cow<'static, str>),

}

impl IsFatalError for InherentError {

        }

}

impl InherentError {

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

    #[cfg(feature = "std")]

        } else {

        }

}

impl<T: Config> LatestAuthorInfoFetcher<T::AccountId> for Pallet<T> {

}

/// This pallet has slightly different behavior when used in a parachain vs when used in a relay chain

/// (solochain). The main difference is:

/// In relay mode, we don't need a storage proof, so the inherent doesn't need any input argument,

/// and instead of reading from a storage proof we read from storage directly.

pub trait RelayOrPara {

    type InherentArg: TypeInfo + Clone + PartialEq + Encode + Decode + core::fmt::Debug;

    type GenericStorageReader: GenericStorageReader;

    fn create_inherent_arg(data: &InherentData) -> Self::InherentArg;

    fn create_storage_reader(data: Self::InherentArg) -> Self::GenericStorageReader;

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

    fn set_current_relay_chain_state(state: cumulus_pallet_parachain_system::RelayChainState);

}

pub type InherentDataOf<T> = <<T as Config>::RelayOrPara as RelayOrPara>::InherentArg;

pub struct RelayMode;

pub struct ParaMode<RCSP: RelaychainStateProvider>(PhantomData<RCSP>);

impl RelayOrPara for RelayMode {

    type InherentArg = ();

    type GenericStorageReader = NativeStorageReader;

        // This ignores the inherent data entirely, so it is compatible with clients that don't add our inherent

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

    fn set_current_relay_chain_state(_state: cumulus_pallet_parachain_system::RelayChainState) {}

}

impl<RCSP: RelaychainStateProvider> RelayOrPara for ParaMode<RCSP> {

    type InherentArg = tp_author_noting_inherent::OwnParachainInherentData;

    type GenericStorageReader = GenericStateProof<cumulus_primitives_core::relay_chain::Block>;

        let tp_author_noting_inherent::OwnParachainInherentData {

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

    fn set_current_relay_chain_state(state: cumulus_pallet_parachain_system::RelayChainState) {

        RCSP::set_current_relay_chain_state(state)

    }

}