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

use codec::Codec;

use scale_info::TypeInfo;

use alloc::vec::Vec;

use core::fmt::Debug;

use sp_core::crypto::{CryptoType, CryptoTypeId, IsWrappedBy, KeyTypeId, Pair, Public};

/// Application-specific cryptographic object.

///

/// Combines all the core types and constants that are defined by a particular

/// cryptographic scheme when it is used in a specific application domain.

///

/// Typically, the implementers of this trait are its associated types themselves.

/// This provides a convenient way to access generic information about the scheme

/// given any of the associated types.

pub trait AppCrypto: 'static + Sized + CryptoType {

	/// Identifier for application-specific key type.

	const ID: KeyTypeId;

	/// Identifier of the crypto type of this application-specific key type.

	const CRYPTO_ID: CryptoTypeId;

	/// The corresponding public key type in this application scheme.

	type Public: AppPublic;

	/// The corresponding signature type in this application scheme.

	type Signature: AppSignature;

	/// The corresponding key pair type in this application scheme.

	type Pair: AppPair;

}

/// Type which implements Hash in std, not when no-std (std variant).

pub trait MaybeHash: core::hash::Hash {}

impl<T: core::hash::Hash> MaybeHash for T {}

/// Application-specific key pair.

pub trait AppPair:

	AppCrypto + Pair<Public = <Self as AppCrypto>::Public, Signature = <Self as AppCrypto>::Signature>

{

	/// The wrapped type which is just a plain instance of `Pair`.

	type Generic: IsWrappedBy<Self>

		+ Pair<Public = <<Self as AppCrypto>::Public as AppPublic>::Generic>

		+ Pair<Signature = <<Self as AppCrypto>::Signature as AppSignature>::Generic>;

}

/// Application-specific public key.

pub trait AppPublic: AppCrypto + Public + Debug + MaybeHash + Codec {

	/// The wrapped type which is just a plain instance of `Public`.

	type Generic: IsWrappedBy<Self> + Public + Debug + MaybeHash + Codec;

}

/// Application-specific signature.

pub trait AppSignature: AppCrypto + Eq + PartialEq + Debug + Clone {

	/// The wrapped type which is just a plain instance of `Signature`.

	type Generic: IsWrappedBy<Self> + Eq + PartialEq + Debug;

}

/// Runtime interface for a public key.

pub trait RuntimePublic: Sized {

	/// The signature that will be generated when signing with the corresponding private key.

	type Signature: Debug + Eq + PartialEq + Clone;

	/// Returns all public keys for the given key type in the keystore.

	fn all(key_type: KeyTypeId) -> crate::Vec<Self>;

	/// Generate a public/private pair for the given key type with an optional `seed` and

	/// store it in the keystore.

	///

	/// The `seed` needs to be valid utf8.

	///

	/// Returns the generated public key.

	fn generate_pair(key_type: KeyTypeId, seed: Option<Vec<u8>>) -> Self;

	/// Sign the given message with the corresponding private key of this public key.

	///

	/// The private key will be requested from the keystore using the given key type.

	///

	/// Returns the signature or `None` if the private key could not be found or some other error

	/// occurred.

	fn sign<M: AsRef<[u8]>>(&self, key_type: KeyTypeId, msg: &M) -> Option<Self::Signature>;

	/// Verify that the given signature matches the given message using this public key.

	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool;

	/// Returns `Self` as raw vec.

	fn to_raw_vec(&self) -> Vec<u8>;

}

/// Runtime interface for an application's public key.

pub trait RuntimeAppPublic: Sized {

	/// An identifier for this application-specific key type.

	const ID: KeyTypeId;

	/// The signature that will be generated when signing with the corresponding private key.

	type Signature: Debug + Eq + PartialEq + Clone + TypeInfo + Codec;

	/// Returns all public keys for this application in the keystore.

	fn all() -> crate::Vec<Self>;

	/// Generate a public/private pair with an optional `seed` and store it in the keystore.

	///

	/// The `seed` needs to be valid utf8.

	///

	/// Returns the generated public key.

	fn generate_pair(seed: Option<Vec<u8>>) -> Self;

	/// Sign the given message with the corresponding private key of this public key.

	///

	/// The private key will be requested from the keystore.

	///

	/// Returns the signature or `None` if the private key could not be found or some other error

	/// occurred.

	fn sign<M: AsRef<[u8]>>(&self, msg: &M) -> Option<Self::Signature>;

	/// Verify that the given signature matches the given message using this public key.

	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool;

	/// Returns `Self` as raw vec.

	fn to_raw_vec(&self) -> Vec<u8>;

}

impl<T> RuntimeAppPublic for T

where

	T: AppPublic + AsRef<<T as AppPublic>::Generic>,

	<T as AppPublic>::Generic: RuntimePublic,

	<T as AppCrypto>::Signature: TypeInfo

		+ Codec

		+ From<<<T as AppPublic>::Generic as RuntimePublic>::Signature>

		+ AsRef<<<T as AppPublic>::Generic as RuntimePublic>::Signature>,

{

	const ID: KeyTypeId = <T as AppCrypto>::ID;

	type Signature = <T as AppCrypto>::Signature;

}

/// Something that is bound to a fixed [`RuntimeAppPublic`].

pub trait BoundToRuntimeAppPublic {

	/// The [`RuntimeAppPublic`] this type is bound to.

	type Public: RuntimeAppPublic;

}

impl<T: RuntimeAppPublic> BoundToRuntimeAppPublic for T {

	type Public = Self;

}