// Copyright 2019-2022 PureStake Inc.

// This file is part of Moonbeam.

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

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

//! # Crowdloan Rewards Pallet

//!

//! This pallet is DEPRECATED, the remaining code handle only unclaimed rewards.

//!

//! ## Payout Mechanism

//!

//! The current payout mechanism requires contributors to claim their payouts. Because they are

//! paying the transaction fees for this themselves, they can do it as often as every block, or

//! wait and claim the entire thing once it is fully vested. We could consider auto payouts if we

//! want.

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

pub use crate::weights::WeightInfo;

use frame_support::pallet;

pub use pallet::*;

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

mod benchmarks;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

pub mod weights;

pub mod pallet {

	use super::*;

	use frame_support::{

		pallet_prelude::*,

		traits::{Currency, ExistenceRequirement::AllowDeath, WithdrawReasons},

		PalletId,

	};

	use frame_system::pallet_prelude::*;

	use parity_scale_codec::{Decode, Encode};

	use sp_core::crypto::AccountId32;

	use sp_runtime::traits::{

		AccountIdConversion, AtLeast32BitUnsigned, BlockNumberProvider, Saturating, Verify,

	};

	use sp_runtime::{MultiSignature, Perbill};

	use sp_std::collections::btree_map::BTreeMap;

	use sp_std::vec;

	use sp_std::vec::Vec;

	// The crowdloan rewards pallet

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

	pub const PALLET_ID: PalletId = PalletId(*b"Crowdloa");

	// The wrapper around which the reward changing message needs to be wrapped

	pub const WRAPPED_BYTES_PREFIX: &[u8] = b"<Bytes>";

	pub const WRAPPED_BYTES_POSTFIX: &[u8] = b"</Bytes>";

	/// Configuration trait of this pallet.

	#[pallet::config]

	pub trait Config: frame_system::Config {

		/// The overarching event type

		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// Checker for the reward vec, is it initalized already?

		type Initialized: Get<bool>;

		/// Percentage to be payed at initialization

		#[pallet::constant]

		type InitializationPayment: Get<Perbill>;

		// Max number of contributors that can be inserted at once in initialize_reward_vec

		#[pallet::constant]

		type MaxInitContributors: Get<u32>;

		/// The minimum contribution to which rewards will be paid.

		type MinimumReward: Get<BalanceOf<Self>>;

		/// A fraction representing the percentage of proofs

		/// that need to be presented to change a reward address through the relay keys

		#[pallet::constant]

		type RewardAddressRelayVoteThreshold: Get<Perbill>;

		/// The currency in which the rewards will be paid (probably the parachain native currency)

		type RewardCurrency: Currency<Self::AccountId>;

		/// The AccountId type contributors used on the relay chain.

		type RelayChainAccountId: Parameter

			//TODO these AccountId32 bounds feel a little extraneous. I wonder if we can remove them.

			+ Into<AccountId32>

			+ From<AccountId32>

			+ Ord

			+ sp_runtime::serde::Serialize

			+ for<'a> sp_runtime::serde::Deserialize<'a>;

		// The origin that is allowed to change the reward address with relay signatures

		type RewardAddressChangeOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Network Identifier to be appended into the signatures for reward address change/association

		/// Prevents replay attacks from one network to the other

		#[pallet::constant]

		type SignatureNetworkIdentifier: Get<&'static [u8]>;

		// The origin that is allowed to change the reward address with relay signatures

		type RewardAddressAssociateOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// The type that will be used to track vesting progress

		type VestingBlockNumber: AtLeast32BitUnsigned

			+ Parameter

			+ Default

			+ Into<BalanceOf<Self>>

			+ sp_runtime::serde::Serialize

			+ for<'a> sp_runtime::serde::Deserialize<'a>;

		/// The notion of time that will be used for vesting. Probably

		/// either the relay chain or sovereign chain block number.

		type VestingBlockProvider: BlockNumberProvider<BlockNumber = Self::VestingBlockNumber>;

		type WeightInfo: WeightInfo;

	}

	pub type BalanceOf<T> = <<T as Config>::RewardCurrency as Currency<

		<T as frame_system::Config>::AccountId,

	>>::Balance;

	/// Type alias for contributor data: (relay_account, optional_native_account, reward)

	pub type ContributorData<T> = (

		<T as Config>::RelayChainAccountId,

		Option<<T as frame_system::Config>::AccountId>,

		BalanceOf<T>,

	);

	/// Stores info about the rewards owed as well as how much has been vested so far.

	/// For a primer on this kind of design, see the recipe on compounding interest

	/// https://substrate.dev/recipes/fixed-point.html#continuously-compounding

	#[scale_info(skip_type_params(T))]

	pub struct RewardInfo<T: Config> {

		pub total_reward: BalanceOf<T>,

		pub claimed_reward: BalanceOf<T>,

		pub contributed_relay_addresses: Vec<T::RelayChainAccountId>,

	}

	impl<T: Config> Pallet<T> {

		/// Associate a native rewards_destination identity with a crowdloan contribution.

		///

		/// The caller needs to provide the unassociated relay account and a proof to succeed

		/// with the association

		/// The proof is nothing but a signature over the reward_address using the relay keys

		#[pallet::call_index(0)]

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

		pub fn associate_native_identity(

			origin: OriginFor<T>,

			reward_account: T::AccountId,

			relay_account: T::RelayChainAccountId,

			proof: MultiSignature,

			// Check the proof:

			// 1. Is signed by an actual unassociated contributor

			// 2. Signs a valid native identity

			// Check the proof. The Proof consists of a Signature of the rewarded account with the

			// claimer key

			// The less costly checks will go first

			// The relay account should be unassociated

			// We ensure the relay chain id wast not yet associated to avoid multi-claiming

			// We dont need this right now, as it will always be true if the above check is true

			);

			// For now I prefer that we dont support providing an existing account here

			);

			// b"<Bytes>" "SignatureNetworkIdentifier" + "new_account" + b"</Bytes>"

			// Make the first payment

		}

		/// Change reward account by submitting proofs from relay accounts

		///

		/// The number of valid proofs needs to be bigger than 'RewardAddressRelayVoteThreshold'

		/// The account to be changed needs to be submitted as 'previous_account'

		/// Origin must be RewardAddressChangeOrigin

		#[pallet::call_index(1)]

		#[pallet::weight(T::WeightInfo::change_association_with_relay_keys(proofs.len() as u32))]

		pub fn change_association_with_relay_keys(

			origin: OriginFor<T>,

			reward_account: T::AccountId,

			previous_account: T::AccountId,

			proofs: Vec<(T::RelayChainAccountId, MultiSignature)>,

			// For now I prefer that we dont support providing an existing account here

			);

			// To avoid replay attacks, we make sure the payload contains the previous address too

			// I am assuming no rational user will go back to a previously changed reward address

			// b"<Bytes>" + "SignatureNetworkIdentifier" + new_account" + "previous_account" + b"</Bytes>"

			// Get the reward info for the account to be changed

			// Remove fromon payable

		}

		/// Collect whatever portion of your reward are currently vested.

		#[pallet::call_index(2)]

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

			// Calculate the veted amount on demand.

			);

			// Get the current block used for vesting purposes

				// Pallet is configured with a zero vesting period.

			} else {

			};

			// If the period is bigger than whats missing to pay, then return whats missing to pay

			} else {

			};

			// Emit event

		}

		/// Update reward address, proving that the caller owns the current native key

		#[pallet::call_index(3)]

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

		pub fn update_reward_address(

			origin: OriginFor<T>,

			new_reward_account: T::AccountId,

			// Calculate the veted amount on demand.

			// For now I prefer that we dont support providing an existing account here

			);

			// Remove previous rewarded account

		}

	}

	impl<T: Config> Pallet<T> {

		/// The account ID that holds the Crowdloan's funds

		/// The Account Id's balance

		/// Verify a set of signatures made with relay chain accounts

		/// We are verifying all the signatures, and then counting

		/// We could do something more efficient like count as we verify

		/// In any of the cases the weight will need to account for all the signatures,

		/// as we dont know beforehand whether they will be valid

		#[allow(clippy::map_entry)] // Cannot use entry API due to ensure! checks before insert

				// We just count votes that we have not seen

					// Maybe I should not error here?

					);

					// I am erroring here as I think it is good to know the reason in the single-case

					// signature

					);

			}

			// Ensure the votes are sufficient

			);

			// This ensures the end vesting block (when all funds are fully vested)

			// is bigger than the init vesting block

			);

			);

			// Burn the difference

			// Ensure we are below the max number of contributors

			);

			// What is the amount initialized so far?

			);

				{

					// Dont fail as this is supposed to be called with batch calls and we

					// dont want to stall the rest of the contributions

					// Don't fail as this is supposed to be called with batch calls and we

					// dont want to stall the rest of the contributions

				// If we have a native_account, we make the payment

				} else {

				};

				// Calculate the reward info to store after the initial payment has been made.

			}

	}

	pub enum Error<T> {

		/// reward claiming provided an already associated relay chain identity

		AlreadyAssociated,

		BatchBeyondFundPot,

		FirstClaimAlreadyDone,

		RewardNotHighEnough,

		/// reward claiming provided a wrong signature

		InvalidClaimSignature,

		InvalidFreeClaimSignature,

		/// they did not contribute to the crowdloan, or they have not yet associated a native id

		/// with their contribution

		NoAssociatedClaim,

		/// identity and contribution

		RewardsAlreadyClaimed,

		RewardVecAlreadyInitialized,

		RewardVecNotFullyInitializedYet,

		RewardsDoNotMatchFund,

		TooManyContributors,

		VestingPeriodNonValid,

		NonContributedAddressProvided,

		InsufficientNumberOfValidProofs,

	}

	#[pallet::getter(fn accounts_payable)]

	pub type AccountsPayable<T: Config> =

		StorageMap<_, Blake2_128Concat, T::AccountId, RewardInfo<T>>;

	#[pallet::getter(fn claimed_relay_chain_ids)]

	pub type ClaimedRelayChainIds<T: Config> =

		StorageMap<_, Blake2_128Concat, T::RelayChainAccountId, ()>;

	#[pallet::getter(fn unassociated_contributions)]

	pub type UnassociatedContributions<T: Config> =

		StorageMap<_, Blake2_128Concat, T::RelayChainAccountId, RewardInfo<T>>;

	#[pallet::getter(fn initialized)]

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

	#[pallet::storage_prefix = "InitRelayBlock"]

	#[pallet::getter(fn init_vesting_block)]

	/// Vesting block height at the initialization of the pallet

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

		StorageValue<_, T::VestingBlockNumber, ValueQuery>;

	#[pallet::storage_prefix = "EndRelayBlock"]

	#[pallet::getter(fn end_vesting_block)]

	/// Vesting block height at the initialization of the pallet

	pub(crate) type EndVestingBlock<T: Config> = StorageValue<_, T::VestingBlockNumber, ValueQuery>;

	#[pallet::getter(fn init_reward_amount)]

	/// Total initialized amount so far. We store this to make pallet funds == contributors reward

	/// check easier and more efficient

	pub(crate) type InitializedRewardAmount<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;

	#[pallet::getter(fn total_contributors)]

	/// Total number of contributors to aid hinting benchmarking

	pub(crate) type TotalContributors<T: Config> = StorageValue<_, u32, ValueQuery>;

	#[pallet::genesis_config]

	pub struct GenesisConfig<T: Config> {

		/// List of contributors with their relay account, optional native account, and reward amount

		pub funded_accounts: Vec<ContributorData<T>>,

		/// Initial vesting block number

		pub init_vesting_block: T::VestingBlockNumber,

		/// End vesting block number

		pub end_vesting_block: T::VestingBlockNumber,

	}

	impl<T: Config> Default for GenesisConfig<T> {

	}

	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

			// Process each funded account

				// Skip if reward is less than minimum

				// Calculate the initial payment

					// Transfer the initial payment to the native account

				} else {

				};

				// Create reward info

				// Store the reward info based on whether account is associated

			}

			// Update total contributors and initialized reward amount

	}

	pub enum Event<T: Config> {

		/// The initial payment of InitializationPayment % was paid

		InitialPaymentMade(T::AccountId, BalanceOf<T>),

		/// Someone has proven they made a contribution and associated a native identity with it.

		/// Data is the relay account,  native account and the total amount of _rewards_ that will be paid

		NativeIdentityAssociated(T::RelayChainAccountId, T::AccountId, BalanceOf<T>),

		/// A contributor has claimed some rewards.

		/// Data is the account getting paid and the amount of rewards paid.

		RewardsPaid(T::AccountId, BalanceOf<T>),

		/// A contributor has updated the reward address.

		RewardAddressUpdated(T::AccountId, T::AccountId),

		/// When initializing the reward vec an already initialized account was found

		InitializedAlreadyInitializedAccount(

			T::RelayChainAccountId,

			Option<T::AccountId>,

			BalanceOf<T>,

		),

		/// When initializing the reward vec an already initialized account was found

		InitializedAccountWithNotEnoughContribution(

			T::RelayChainAccountId,

			Option<T::AccountId>,

			BalanceOf<T>,

		),

	}

}