// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// This file is part of Frontier.
//
// Copyright (c) 2017-2022 Parity Technologies (UK) Ltd.
//
// This program 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.
//
// This program 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 this program. If not, see <https://www.gnu.org/licenses/>.

use std::{collections::BTreeMap, marker::PhantomData, sync::Arc};

use ethereum::BlockV2 as EthereumBlock;
use ethereum_types::{H160, H256, U256};
// Substrate
use sp_api::{ApiExt, ProvideRuntimeApi};
use sp_io::hashing::{blake2_128, twox_128};
use sp_runtime::{traits::Block as BlockT, Permill};
// Frontier
use fp_rpc::{EthereumRuntimeRPCApi, TransactionStatus};
use fp_storage::EthereumStorageSchema;

mod schema_v1_override;
mod schema_v2_override;
mod schema_v3_override;

pub use self::{
	schema_v1_override::SchemaV1Override, schema_v2_override::SchemaV2Override,
	schema_v3_override::SchemaV3Override,
};

pub struct OverrideHandle<Block: BlockT> {
	pub schemas: BTreeMap<EthereumStorageSchema, Box<dyn StorageOverride<Block>>>,
	pub fallback: Box<dyn StorageOverride<Block>>,
}

/// Something that can fetch Ethereum-related data. This trait is quite similar to the runtime API,
/// and indeed oe implementation of it uses the runtime API.
/// Having this trait is useful because it allows optimized implementations that fetch data from a
/// State Backend with some assumptions about pallet-ethereum's storage schema. Using such an
/// optimized implementation avoids spawning a runtime and the overhead associated with it.
pub trait StorageOverride<Block: BlockT>: Send + Sync {
	/// For a given account address, returns pallet_evm::AccountCodes.
	fn account_code_at(&self, block_hash: Block::Hash, address: H160) -> Option<Vec<u8>>;
	/// For a given account address and index, returns pallet_evm::AccountStorages.
	fn storage_at(&self, block_hash: Block::Hash, address: H160, index: U256) -> Option<H256>;
	/// Return the current block.
	fn current_block(&self, block_hash: Block::Hash) -> Option<EthereumBlock>;
	/// Return the current receipt.
	fn current_receipts(&self, block_hash: Block::Hash) -> Option<Vec<ethereum::ReceiptV3>>;
	/// Return the current transaction status.
	fn current_transaction_statuses(
		&self,
		block_hash: Block::Hash,
	) -> Option<Vec<TransactionStatus>>;
	/// Return the base fee at the given height.
	fn elasticity(&self, block_hash: Block::Hash) -> Option<Permill>;
	/// Return `true` if the request BlockId is post-eip1559.
	fn is_eip1559(&self, block_hash: Block::Hash) -> bool;
}

fn storage_prefix_build(module: &[u8], storage: &[u8]) -> Vec<u8> {
	[twox_128(module), twox_128(storage)].concat().to_vec()
}

fn blake2_128_extend(bytes: &[u8]) -> Vec<u8> {
	let mut ext: Vec<u8> = blake2_128(bytes).to_vec();
	ext.extend_from_slice(bytes);
	ext
}

/// A wrapper type for the Runtime API. This type implements `StorageOverride`, so it can be used
/// when calling the runtime API is desired but a `dyn StorageOverride` is required.
pub struct RuntimeApiStorageOverride<B: BlockT, C> {
	client: Arc<C>,
	_marker: PhantomData<B>,
}

impl<B: BlockT, C> RuntimeApiStorageOverride<B, C> {
	pub fn new(client: Arc<C>) -> Self {
		Self {
			client,
			_marker: PhantomData,
		}
	}
}

impl<Block, C> StorageOverride<Block> for RuntimeApiStorageOverride<Block, C>
where
	Block: BlockT,
	C: ProvideRuntimeApi<Block> + Send + Sync,
	C::Api: EthereumRuntimeRPCApi<Block>,
{
	/// For a given account address, returns pallet_evm::AccountCodes.
	fn account_code_at(&self, block_hash: Block::Hash, address: H160) -> Option<Vec<u8>> {
		self.client
			.runtime_api()
			.account_code_at(block_hash, address)
			.ok()
	}

	/// For a given account address and index, returns pallet_evm::AccountStorages.
	fn storage_at(&self, block_hash: Block::Hash, address: H160, index: U256) -> Option<H256> {
		self.client
			.runtime_api()
			.storage_at(block_hash, address, index)
			.ok()
	}

	/// Return the current block.
	fn current_block(&self, block_hash: Block::Hash) -> Option<ethereum::BlockV2> {
		let api = self.client.runtime_api();

		let api_version = if let Ok(Some(api_version)) =
			api.api_version::<dyn EthereumRuntimeRPCApi<Block>>(block_hash)
		{
			api_version
		} else {
			return None;
		};
		if api_version == 1 {
			#[allow(deprecated)]
			let old_block = api.current_block_before_version_2(block_hash).ok()?;
			old_block.map(|block| block.into())
		} else {
			api.current_block(block_hash).ok()?
		}
	}

	/// Return the current receipt.
	fn current_receipts(&self, block_hash: Block::Hash) -> Option<Vec<ethereum::ReceiptV3>> {
		let api = self.client.runtime_api();

		let api_version = if let Ok(Some(api_version)) =
			api.api_version::<dyn EthereumRuntimeRPCApi<Block>>(block_hash)
		{
			api_version
		} else {
			return None;
		};
		if api_version < 4 {
			#[allow(deprecated)]
			let old_receipts = api.current_receipts_before_version_4(block_hash).ok()?;
			old_receipts.map(|receipts| {
				receipts
					.into_iter()
					.map(|r| {
						ethereum::ReceiptV3::Legacy(ethereum::EIP658ReceiptData {
							status_code: r.state_root.to_low_u64_be() as u8,
							used_gas: r.used_gas,
							logs_bloom: r.logs_bloom,
							logs: r.logs,
						})
					})
					.collect()
			})
		} else {
			self.client
				.runtime_api()
				.current_receipts(block_hash)
				.ok()?
		}
	}

	/// Return the current transaction status.
	fn current_transaction_statuses(
		&self,
		block_hash: Block::Hash,
	) -> Option<Vec<TransactionStatus>> {
		self.client
			.runtime_api()
			.current_transaction_statuses(block_hash)
			.ok()?
	}

	/// Return the elasticity multiplier at the give post-eip1559 height.
	fn elasticity(&self, block_hash: Block::Hash) -> Option<Permill> {
		if self.is_eip1559(block_hash) {
			self.client.runtime_api().elasticity(block_hash).ok()?
		} else {
			None
		}
	}

	fn is_eip1559(&self, block_hash: Block::Hash) -> bool {
		if let Ok(Some(api_version)) = self
			.client
			.runtime_api()
			.api_version::<dyn EthereumRuntimeRPCApi<Block>>(block_hash)
		{
			return api_version >= 2;
		}
		false
	}
}