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

//! Externalities extensions storage.

//!

//! Externalities support to register a wide variety custom extensions. The [`Extensions`] provides

//! some convenience functionality to store and retrieve these extensions.

//!

//! It is required that each extension implements the [`Extension`] trait.

use crate::Error;

use alloc::{

	boxed::Box,

	collections::btree_map::{BTreeMap, Entry},

};

use core::{

	any::{Any, TypeId},

	ops::DerefMut,

};

/// Marker trait for types that should be registered as [`Externalities`](crate::Externalities)

/// extension.

///

/// As extensions are stored as `Box<Any>`, this trait should give more confidence that the correct

/// type is registered and requested.

pub trait Extension: Send + 'static {

	/// Return the extension as `&mut dyn Any`.

	///

	/// This is a trick to make the trait type castable into an `Any`.

	fn as_mut_any(&mut self) -> &mut dyn Any;

	/// Get the [`TypeId`] of this `Extension`.

	fn type_id(&self) -> TypeId;

}

impl Extension for Box<dyn Extension> {

}

/// Macro for declaring an extension that usable with [`Extensions`].

///

/// The extension will be an unit wrapper struct that implements [`Extension`], `Deref` and

/// `DerefMut`. The wrapped type is given by the user.

///

/// # Example

/// ```

/// # use sp_externalities::decl_extension;

/// decl_extension! {

///     /// Some test extension

///     struct TestExt(String);

/// }

/// ```

#[macro_export]

macro_rules! decl_extension {

	(

		$( #[ $attr:meta ] )*

		$vis:vis struct $ext_name:ident ($inner:ty);

	) => {

		$( #[ $attr ] )*

		$vis struct $ext_name (pub $inner);

		impl $crate::Extension for $ext_name {

		}

		impl core::ops::Deref for $ext_name {

			type Target = $inner;

		}

		impl core::ops::DerefMut for $ext_name {

		}

		impl From<$inner> for $ext_name {

 		}

	};

	(

		$( #[ $attr:meta ] )*

		$vis:vis struct $ext_name:ident;

	) => {

		$( #[ $attr ] )*

		$vis struct $ext_name;

		impl $crate::Extension for $ext_name {

		}

	}

}

/// Something that provides access to the [`Extensions`] store.

///

/// This is a super trait of the [`Externalities`](crate::Externalities).

pub trait ExtensionStore {

	/// Tries to find a registered extension by the given `type_id` and returns it as a `&mut dyn

	/// Any`.

	///

	/// It is advised to use [`ExternalitiesExt::extension`](crate::ExternalitiesExt::extension)

	/// instead of this function to get type system support and automatic type downcasting.

	fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any>;

	/// Register extension `extension` with specified `type_id`.

	///

	/// It should return error if extension is already registered.

	fn register_extension_with_type_id(

		&mut self,

		type_id: TypeId,

		extension: Box<dyn Extension>,

	) -> Result<(), Error>;

	/// Deregister extension with specified 'type_id' and drop it.

	///

	/// It should return error if extension is not registered.

	fn deregister_extension_by_type_id(&mut self, type_id: TypeId) -> Result<(), Error>;

}

/// Stores extensions that should be made available through the externalities.

#[derive(Default)]

pub struct Extensions {

	extensions: BTreeMap<TypeId, Box<dyn Extension>>,

}

#[cfg(feature = "std")]

impl std::fmt::Debug for Extensions {

}

impl Extensions {

	/// Create new instance of `Self`.

	/// Register the given extension.

	/// Register extension `extension` using the given `type_id`.

			},

		}

	/// Return a mutable reference to the requested extension.

	/// Deregister extension for the given `type_id`.

	///

	/// Returns `true` when the extension was registered.

	/// Returns a mutable iterator over all extensions.

	/// Merge `other` into `self`.

	///

	/// If both contain the same extension, the extension instance of `other` will overwrite the

	/// instance found in `self`.

}

impl Extend<Extensions> for Extensions {

}

#[cfg(test)]

mod tests {

	use super::*;

	decl_extension! {

		struct DummyExt(u32);

	}

	decl_extension! {

		struct DummyExt2(u32);

	}

	#[test]

	fn register_and_retrieve_extension() {

		let mut exts = Extensions::new();

		exts.register(DummyExt(1));

		exts.register(DummyExt2(2));

		let ext = exts.get_mut(TypeId::of::<DummyExt>()).expect("Extension is registered");

		let ext_ty = ext.downcast_mut::<DummyExt>().expect("Downcasting works");

		assert_eq!(ext_ty.0, 1);

	}

	#[test]

	fn register_box_extension() {

		let mut exts = Extensions::new();

		let box1: Box<dyn Extension> = Box::new(DummyExt(1));

		let box2: Box<dyn Extension> = Box::new(DummyExt2(2));

		exts.register(box1);

		exts.register(box2);

		{

			let ext = exts.get_mut(TypeId::of::<DummyExt>()).expect("Extension 1 is registered");

			let ext_ty = ext.downcast_mut::<DummyExt>().expect("Downcasting works for Extension 1");

			assert_eq!(ext_ty.0, 1);

		}

		{

			let ext2 = exts.get_mut(TypeId::of::<DummyExt2>()).expect("Extension 2 is registered");

			let ext_ty2 =

				ext2.downcast_mut::<DummyExt2>().expect("Downcasting works for Extension 2");

			assert_eq!(ext_ty2.0, 2);

		}

	}

}