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

//! The vote datatype.

use crate::{Conviction, Delegations};

use codec::{Decode, Encode, EncodeLike, Input, MaxEncodedLen, Output};

use frame_support::{pallet_prelude::Get, BoundedVec};

use scale_info::TypeInfo;

use sp_runtime::{

	traits::{Saturating, Zero},

	RuntimeDebug,

};

/// A number of lock periods, plus a vote, one way or the other.

pub struct Vote {

	pub aye: bool,

	pub conviction: Conviction,

}

impl Encode for Vote {

}

impl EncodeLike for Vote {}

impl Decode for Vote {

		Ok(Vote {

		})

}

impl TypeInfo for Vote {

	type Identity = Self;

}

/// A vote for a referendum of a particular account.

pub enum AccountVote<Balance> {

	/// parachains when voting.

	/// conviction, useful for parachains when voting, other off-chain aggregate accounts and

	/// individuals who wish to abstain.

}

impl<Balance: Saturating> AccountVote<Balance> {

	/// Returns `Some` of the lock periods that the account is locked for, assuming that the

	/// referendum passed iff `approved` is `true`.

		// winning side: can only be removed after the lock period ends.

		}

	/// The total balance involved in this vote.

		}

	/// Returns `Some` with whether the vote is an aye vote if it is standard, otherwise `None` if

	/// it is split.

		}

}

/// A "prior" lock, i.e. a lock for some now-forgotten reason.

#[derive(

	Encode,

	Decode,

	Default,

	Copy,

	Clone,

	Eq,

	PartialEq,

	Ord,

	PartialOrd,

)]

pub struct PriorLock<BlockNumber, Balance>(BlockNumber, Balance);

impl<BlockNumber: Ord + Copy + Zero, Balance: Ord + Copy + Zero> PriorLock<BlockNumber, Balance> {

	/// Accumulates an additional lock.

}

/// Information concerning the delegation of some voting power.

pub struct Delegating<Balance, AccountId, BlockNumber> {

	/// The amount of balance delegated.

	pub balance: Balance,

	/// The account to which the voting power is delegated.

	pub target: AccountId,

	/// The conviction with which the voting power is delegated. When this gets undelegated, the

	/// relevant lock begins.

	pub conviction: Conviction,

	/// The total amount of delegations that this account has received, post-conviction-weighting.

	pub delegations: Delegations<Balance>,

	/// Any pre-existing locks from past voting/delegating activity.

	pub prior: PriorLock<BlockNumber, Balance>,

}

/// Information concerning the direct vote-casting of some voting power.

#[scale_info(skip_type_params(MaxVotes))]

#[codec(mel_bound(Balance: MaxEncodedLen, BlockNumber: MaxEncodedLen, PollIndex: MaxEncodedLen))]

pub struct Casting<Balance, BlockNumber, PollIndex, MaxVotes>

where

	MaxVotes: Get<u32>,

{

	/// The current votes of the account.

	pub votes: BoundedVec<(PollIndex, AccountVote<Balance>), MaxVotes>,

	/// The total amount of delegations that this account has received, post-conviction-weighting.

	pub delegations: Delegations<Balance>,

	/// Any pre-existing locks from past voting/delegating activity.

	pub prior: PriorLock<BlockNumber, Balance>,

}

/// An indicator for what an account is doing; it can either be delegating or voting.

#[scale_info(skip_type_params(MaxVotes))]

#[codec(mel_bound(

	Balance: MaxEncodedLen, AccountId: MaxEncodedLen, BlockNumber: MaxEncodedLen,

	PollIndex: MaxEncodedLen,

))]

pub enum Voting<Balance, AccountId, BlockNumber, PollIndex, MaxVotes>

where

	MaxVotes: Get<u32>,

{

}

impl<Balance: Default, AccountId, BlockNumber: Zero, PollIndex, MaxVotes> Default

	for Voting<Balance, AccountId, BlockNumber, PollIndex, MaxVotes>

where

	MaxVotes: Get<u32>,

{

}

impl<Balance, AccountId, BlockNumber, PollIndex, MaxVotes> AsMut<PriorLock<BlockNumber, Balance>>

	for Voting<Balance, AccountId, BlockNumber, PollIndex, MaxVotes>

where

	MaxVotes: Get<u32>,

{

		}

}

impl<

		Balance: Saturating + Ord + Zero + Copy,

		BlockNumber: Ord + Copy + Zero,

		AccountId,

		PollIndex,

		MaxVotes,

	> Voting<Balance, AccountId, BlockNumber, PollIndex, MaxVotes>

where

	MaxVotes: Get<u32>,

{

	/// The amount of this account's balance that must currently be locked due to voting.

		}

		};

}