// This file is part of Substrate.

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

//! An opt-in utility module for reporting equivocations.

//!

//! This module defines an offence type for BEEFY equivocations

//! and some utility traits to wire together:

//! - a key ownership proof system (e.g. to prove that a given authority was part of a session);

//! - a system for reporting offences;

//! - a system for signing and submitting transactions;

//! - a way to get the current block author;

//!

//! These can be used in an offchain context in order to submit equivocation

//! reporting extrinsics (from the client that's running the BEEFY protocol).

//! And in a runtime context, so that the BEEFY pallet can validate the

//! equivocation proofs in the extrinsic and report the offences.

//!

//! IMPORTANT:

//! When using this module for enabling equivocation reporting it is required

//! that the `ValidateUnsigned` for the BEEFY pallet is used in the runtime

//! definition.

use alloc::{vec, vec::Vec};

use codec::{self as codec, Decode, Encode};

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

use frame_system::pallet_prelude::{BlockNumberFor, HeaderFor};

use log::{error, info};

use sp_consensus_beefy::{

	check_commitment_signature, AncestryHelper, DoubleVotingProof, ForkVotingProof,

	FutureBlockVotingProof, ValidatorSetId, KEY_TYPE as BEEFY_KEY_TYPE,

};

use sp_runtime::{

	transaction_validity::{

		InvalidTransaction, TransactionPriority, TransactionSource, TransactionValidity,

		TransactionValidityError, ValidTransaction,

	},

	DispatchError, KeyTypeId, Perbill, RuntimeAppPublic,

};

use sp_session::{GetSessionNumber, GetValidatorCount};

use sp_staking::{

	offence::{Kind, Offence, OffenceReportSystem, ReportOffence},

	SessionIndex,

};

use super::{Call, Config, Error, Pallet, LOG_TARGET};

/// A round number and set id which point on the time of an offence.

#[derive(Copy, Clone, PartialOrd, Ord, Eq, PartialEq, Encode, Decode)]

pub struct TimeSlot<N: Copy + Clone + PartialOrd + Ord + Eq + PartialEq + Encode + Decode> {

	// The order of these matters for `derive(Ord)`.

	/// BEEFY Set ID.

	pub set_id: ValidatorSetId,

	/// Round number.

	pub round: N,

}

/// BEEFY equivocation offence report.

pub struct EquivocationOffence<Offender, N>

where

	N: Copy + Clone + PartialOrd + Ord + Eq + PartialEq + Encode + Decode,

{

	/// Time slot at which this incident happened.

	pub time_slot: TimeSlot<N>,

	/// The session index in which the incident happened.

	pub session_index: SessionIndex,

	/// The size of the validator set at the time of the offence.

	pub validator_set_count: u32,

	/// The authority which produced this equivocation.

	pub offender: Offender,

}

impl<Offender: Clone, N> Offence<Offender> for EquivocationOffence<Offender, N>

where

	N: Copy + Clone + PartialOrd + Ord + Eq + PartialEq + Encode + Decode,

{

	const ID: Kind = *b"beefy:equivocati";

	type TimeSlot = TimeSlot<N>;

	// The formula is min((3k / n)^2, 1)

	// where k = offenders_number and n = validators_number

}

/// BEEFY equivocation offence report system.

///

/// This type implements `OffenceReportSystem` such that:

/// - Equivocation reports are published on-chain as unsigned extrinsic via

///   `offchain::SendTransactionTypes`.

/// - On-chain validity checks and processing are mostly delegated to the user provided generic

///   types implementing `KeyOwnerProofSystem` and `ReportOffence` traits.

/// - Offence reporter for unsigned transactions is fetched via the authorship pallet.

pub struct EquivocationReportSystem<T, R, P, L>(core::marker::PhantomData<(T, R, P, L)>);

/// Equivocation evidence convenience alias.

pub enum EquivocationEvidenceFor<T: Config> {

	DoubleVotingProof(

		DoubleVotingProof<

			BlockNumberFor<T>,

			T::BeefyId,

			<T::BeefyId as RuntimeAppPublic>::Signature,

		>,

		T::KeyOwnerProof,

	),

	ForkVotingProof(

		ForkVotingProof<

			HeaderFor<T>,

			T::BeefyId,

			<T::AncestryHelper as AncestryHelper<HeaderFor<T>>>::Proof,

		>,

		T::KeyOwnerProof,

	),

	FutureBlockVotingProof(FutureBlockVotingProof<BlockNumberFor<T>, T::BeefyId>, T::KeyOwnerProof),

}

impl<T: Config> EquivocationEvidenceFor<T> {

	/// Returns the authority id of the equivocator.

		}

	/// Returns the round number at which the equivocation occurred.

		}

	/// Returns the set id at which the equivocation occurred.

		}

	/// Returns the set id at which the equivocation occurred.

		}

			},

					None => {

					},

				};

			},

			},

		}

}

impl<T, R, P, L> OffenceReportSystem<Option<T::AccountId>, EquivocationEvidenceFor<T>>

	for EquivocationReportSystem<T, R, P, L>

where

	T: Config + pallet_authorship::Config + frame_system::offchain::SendTransactionTypes<Call<T>>,

	R: ReportOffence<

		T::AccountId,

		P::IdentificationTuple,

		EquivocationOffence<P::IdentificationTuple, BlockNumberFor<T>>,

	>,

	P: KeyOwnerProofSystem<(KeyTypeId, T::BeefyId), Proof = T::KeyOwnerProof>,

	P::IdentificationTuple: Clone,

	L: Get<u64>,

{

	type Longevity = L;

		use frame_system::offchain::SubmitTransaction;

		}

		// Check if the offence has already been reported, and if so then we can discard the report.

		} else {

		}

		// Check that the session id for the membership proof is within the bounds

		// of the set id reported in the equivocation.

		// Validate the key ownership proof extracting the id of the offender.

}

/// Methods for the `ValidateUnsigned` implementation:

/// It restricts calls to `report_equivocation_unsigned` to local calls (i.e. extrinsics generated

/// on this node) or that already in a block. This guarantees that only block authors can include

/// unsigned equivocation reports.

impl<T: Config> Pallet<T> {

			_ => {

					target: LOG_TARGET,

				);

			},

		}

}