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

// This file is part of Polkadot.

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

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

//! To prevent Out of Memory errors on the `DownwardMessageQueue`, an

//! exponential fee factor (`DeliveryFeeFactor`) is set. The fee factor

//! increments exponentially after the number of messages in the

//! `DownwardMessageQueue` passes a threshold. This threshold is set as:

//!

//! ```ignore

//! // Maximum max sized messages that can be send to

//! // the DownwardMessageQueue before it runs out of memory

//! max_messages = MAX_POSSIBLE_ALLOCATION / max_downward_message_size

//! threshold = max_messages / THRESHOLD_FACTOR

//! ```

//! Based on the THRESHOLD_FACTOR, the threshold is set as a fraction of the

//! total messages. The `DeliveryFeeFactor` increases for a message over the

//! threshold by:

//!

//! `DeliveryFeeFactor = DeliveryFeeFactor *

//! (EXPONENTIAL_FEE_BASE + MESSAGE_SIZE_FEE_BASE * encoded_message_size_in_KB)`

//!

//! And decreases when the number of messages in the `DownwardMessageQueue` fall

//! below the threshold by:

//!

//! `DeliveryFeeFactor = DeliveryFeeFactor / EXPONENTIAL_FEE_BASE`

//!

//! As an extra defensive measure, a `max_messages` hard

//! limit is set to the number of messages in the DownwardMessageQueue. Messages

//! that would increase the number of messages in the queue above this hard

//! limit are dropped.

use crate::{

	configuration::{self, HostConfiguration},

	initializer, FeeTracker,

};

use alloc::vec::Vec;

use core::fmt;

use frame_support::pallet_prelude::*;

use frame_system::pallet_prelude::BlockNumberFor;

use polkadot_primitives::{DownwardMessage, Hash, Id as ParaId, InboundDownwardMessage};

use sp_core::MAX_POSSIBLE_ALLOCATION;

use sp_runtime::{

	traits::{BlakeTwo256, Hash as HashT, SaturatedConversion},

	FixedU128, Saturating,

};

use xcm::latest::SendError;

pub use pallet::*;

#[cfg(test)]

mod tests;

const THRESHOLD_FACTOR: u32 = 2;

const EXPONENTIAL_FEE_BASE: FixedU128 = FixedU128::from_rational(105, 100); // 1.05

const MESSAGE_SIZE_FEE_BASE: FixedU128 = FixedU128::from_rational(1, 1000); // 0.001

/// An error sending a downward message.

#[cfg_attr(test, derive(Debug))]

pub enum QueueDownwardMessageError {

	/// The message being sent exceeds the configured max message size.

	ExceedsMaxMessageSize,

}

impl From<QueueDownwardMessageError> for SendError {

}

/// An error returned by [`Pallet::check_processed_downward_messages`] that indicates an acceptance

/// check didn't pass.

pub(crate) enum ProcessedDownwardMessagesAcceptanceErr {

	/// If there are pending messages then `processed_downward_messages` should be at least 1,

	AdvancementRule,

	/// `processed_downward_messages` should not be greater than the number of pending messages.

	Underflow { processed_downward_messages: u32, dmq_length: u32 },

}

impl fmt::Debug for ProcessedDownwardMessagesAcceptanceErr {

		use ProcessedDownwardMessagesAcceptanceErr::*;

			AdvancementRule => {

			},

		}

}

/// Routines and getters related to downward message passing.

impl<T: Config> Pallet<T> {

	/// Block initialization logic, called by initializer.

	/// Block finalization logic, called by initializer.

	/// Called by the initializer to note that a new session has started.

	/// Iterate over all paras that were noted for offboarding and remove all the data

	/// associated with them.

	/// Remove all relevant storage items for an outgoing parachain.

	/// Determine whether enqueuing a downward message to a specific recipient para would result

	/// in an error. If this returns `Ok(())` the caller can be certain that a call to

	/// `queue_downward_message` with the same parameters will be successful.

	/// Enqueue a downward message to a specific recipient para.

	///

	/// When encoded, the message should not exceed the `config.max_downward_message_size`.

	/// Otherwise, the message won't be sent and `Err` will be returned.

	///

	/// It is possible to send a downward message to a non-existent para. That, however, would lead

	/// to a dangling storage. If the caller cannot statically prove that the recipient exists

	/// then the caller should perform a runtime check.

	/// Checks if the number of processed downward messages is valid.

			// The advancement rule is for at least one downwards message to be processed

			// if the queue is non-empty at the relay-parent. Downwards messages are annotated

			// with the block number, so we compare the earliest (first) against the relay parent.

		// Note that we might be allowing a parachain to signal that it's processed

		// messages that hadn't been placed in the queue at the relay_parent.

		// only 'stupid' parachains would do it and we don't (and can't) force anyone

		// to act on messages, so the lenient approach is fine here.

	/// Prunes the specified number of messages from the downward message queue of the given para.

	/// Returns the Head of Message Queue Chain for the given para or `None` if there is none

	/// associated with it.

	#[cfg(test)]

	fn dmq_mqc_head(para: ParaId) -> Hash {

		DownwardMessageQueueHeads::<T>::get(&para)

	}

	/// Returns the number of pending downward messages addressed to the given para.

	///

	/// Returns 0 if the para doesn't have an associated downward message queue.

	/// Returns the downward message queue contents for the given para.

	///

	/// The most recent messages are the latest in the vector.

}

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

	type Id = ParaId;

}