// SPDX-License-Identifier: Apache-2.0
// This file is part of Frontier.
//
// Copyright (c) 2020-2022 Parity Technologies (UK) Ltd.
//
// 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.

#![cfg_attr(not(feature = "std"), no_std)]
#![warn(unused_crate_dependencies)]

extern crate alloc;

use alloc::vec::Vec;
use fp_evm::{
	ExitError, ExitSucceed, Precompile, PrecompileFailure, PrecompileHandle, PrecompileOutput,
	PrecompileResult,
};
use sp_core::U256;

/// Copy bytes from input to target.
fn read_input(source: &[u8], target: &mut [u8], offset: usize) {
	// Out of bounds, nothing to copy.
	if source.len() <= offset {
		return;
	}

	// Find len to copy up to target len, but not out of bounds.
	let len = core::cmp::min(target.len(), source.len() - offset);
	target[..len].copy_from_slice(&source[offset..][..len]);
}

fn read_fr(input: &[u8], start_inx: usize) -> Result<bn::Fr, PrecompileFailure> {
	let mut buf = [0u8; 32];
	read_input(input, &mut buf, start_inx);

	bn::Fr::from_slice(&buf).map_err(|_| PrecompileFailure::Error {
		exit_status: ExitError::Other("Invalid field element".into()),
	})
}

fn read_point(input: &[u8], start_inx: usize) -> Result<bn::G1, PrecompileFailure> {
	use bn::{AffineG1, Fq, Group, G1};

	let mut px_buf = [0u8; 32];
	let mut py_buf = [0u8; 32];
	read_input(input, &mut px_buf, start_inx);
	read_input(input, &mut py_buf, start_inx + 32);

	let px = Fq::from_slice(&px_buf).map_err(|_| PrecompileFailure::Error {
		exit_status: ExitError::Other("Invalid point x coordinate".into()),
	})?;

	let py = Fq::from_slice(&py_buf).map_err(|_| PrecompileFailure::Error {
		exit_status: ExitError::Other("Invalid point y coordinate".into()),
	})?;

	Ok(if px == Fq::zero() && py == Fq::zero() {
		G1::zero()
	} else {
		AffineG1::new(px, py)
			.map_err(|_| PrecompileFailure::Error {
				exit_status: ExitError::Other("Invalid curve point".into()),
			})?
			.into()
	})
}

/// The Bn128Add builtin
pub struct Bn128Add;

impl Bn128Add {
	const GAS_COST: u64 = 150; // https://eips.ethereum.org/EIPS/eip-1108
}

impl Precompile for Bn128Add {
	fn execute(handle: &mut impl PrecompileHandle) -> PrecompileResult {
		use bn::AffineG1;

		handle.record_cost(Bn128Add::GAS_COST)?;

		let input = handle.input();

		let p1 = read_point(input, 0)?;
		let p2 = read_point(input, 64)?;

		let mut buf = [0u8; 64];
		if let Some(sum) = AffineG1::from_jacobian(p1 + p2) {
			// point not at infinity
			sum.x()
				.to_big_endian(&mut buf[0..32])
				.map_err(|_| PrecompileFailure::Error {
					exit_status: ExitError::Other(
						"Cannot fail since 0..32 is 32-byte length".into(),
					),
				})?;
			sum.y()
				.to_big_endian(&mut buf[32..64])
				.map_err(|_| PrecompileFailure::Error {
					exit_status: ExitError::Other(
						"Cannot fail since 32..64 is 32-byte length".into(),
					),
				})?;
		}

		Ok(PrecompileOutput {
			exit_status: ExitSucceed::Returned,
			output: buf.to_vec(),
		})
	}
}

/// The Bn128Mul builtin
pub struct Bn128Mul;

impl Bn128Mul {
	const GAS_COST: u64 = 6_000; // https://eips.ethereum.org/EIPS/eip-1108
}

impl Precompile for Bn128Mul {
	fn execute(handle: &mut impl PrecompileHandle) -> PrecompileResult {
		use bn::AffineG1;

		handle.record_cost(Bn128Mul::GAS_COST)?;

		let input = handle.input();

		let p = read_point(input, 0)?;
		let fr = read_fr(input, 64)?;

		let mut buf = [0u8; 64];
		if let Some(sum) = AffineG1::from_jacobian(p * fr) {
			// point not at infinity
			sum.x()
				.to_big_endian(&mut buf[0..32])
				.map_err(|_| PrecompileFailure::Error {
					exit_status: ExitError::Other(
						"Cannot fail since 0..32 is 32-byte length".into(),
					),
				})?;
			sum.y()
				.to_big_endian(&mut buf[32..64])
				.map_err(|_| PrecompileFailure::Error {
					exit_status: ExitError::Other(
						"Cannot fail since 32..64 is 32-byte length".into(),
					),
				})?;
		}

		Ok(PrecompileOutput {
			exit_status: ExitSucceed::Returned,
			output: buf.to_vec(),
		})
	}
}

/// The Bn128Pairing builtin
pub struct Bn128Pairing;

impl Bn128Pairing {
	// https://eips.ethereum.org/EIPS/eip-1108
	const BASE_GAS_COST: u64 = 45_000;
	const GAS_COST_PER_PAIRING: u64 = 34_000;
}

impl Precompile for Bn128Pairing {
	fn execute(handle: &mut impl PrecompileHandle) -> PrecompileResult {
		use bn::{pairing_batch, AffineG1, AffineG2, Fq, Fq2, Group, Gt, G1, G2};

		let ret_val = if handle.input().is_empty() {
			handle.record_cost(Bn128Pairing::BASE_GAS_COST)?;
			U256::one()
		} else {
			if handle.input().len() % 192 > 0 {
				return Err(PrecompileFailure::Error {
					exit_status: ExitError::Other("bad elliptic curve pairing size".into()),
				});
			}

			// (a, b_a, b_b - each 64-byte affine coordinates)
			let elements = handle.input().len() / 192;

			let gas_cost: u64 = Bn128Pairing::BASE_GAS_COST
				+ (elements as u64 * Bn128Pairing::GAS_COST_PER_PAIRING);

			handle.record_cost(gas_cost)?;

			let input = handle.input();

			let mut vals = Vec::new();
			for idx in 0..elements {
				let a_x = Fq::from_slice(&input[idx * 192..idx * 192 + 32]).map_err(|_| {
					PrecompileFailure::Error {
						exit_status: ExitError::Other("Invalid a argument x coordinate".into()),
					}
				})?;

				let a_y = Fq::from_slice(&input[idx * 192 + 32..idx * 192 + 64]).map_err(|_| {
					PrecompileFailure::Error {
						exit_status: ExitError::Other("Invalid a argument y coordinate".into()),
					}
				})?;

				let b_a_y =
					Fq::from_slice(&input[idx * 192 + 64..idx * 192 + 96]).map_err(|_| {
						PrecompileFailure::Error {
							exit_status: ExitError::Other(
								"Invalid b argument imaginary coeff x coordinate".into(),
							),
						}
					})?;

				let b_a_x =
					Fq::from_slice(&input[idx * 192 + 96..idx * 192 + 128]).map_err(|_| {
						PrecompileFailure::Error {
							exit_status: ExitError::Other(
								"Invalid b argument imaginary coeff y coordinate".into(),
							),
						}
					})?;

				let b_b_y =
					Fq::from_slice(&input[idx * 192 + 128..idx * 192 + 160]).map_err(|_| {
						PrecompileFailure::Error {
							exit_status: ExitError::Other(
								"Invalid b argument real coeff x coordinate".into(),
							),
						}
					})?;

				let b_b_x =
					Fq::from_slice(&input[idx * 192 + 160..idx * 192 + 192]).map_err(|_| {
						PrecompileFailure::Error {
							exit_status: ExitError::Other(
								"Invalid b argument real coeff y coordinate".into(),
							),
						}
					})?;

				let b_a = Fq2::new(b_a_x, b_a_y);
				let b_b = Fq2::new(b_b_x, b_b_y);
				let b = if b_a.is_zero() && b_b.is_zero() {
					G2::zero()
				} else {
					G2::from(
						AffineG2::new(b_a, b_b).map_err(|_| PrecompileFailure::Error {
							exit_status: ExitError::Other(
								"Invalid b argument - not on curve".into(),
							),
						})?,
					)
				};
				let a = if a_x.is_zero() && a_y.is_zero() {
					G1::zero()
				} else {
					G1::from(
						AffineG1::new(a_x, a_y).map_err(|_| PrecompileFailure::Error {
							exit_status: ExitError::Other(
								"Invalid a argument - not on curve".into(),
							),
						})?,
					)
				};
				vals.push((a, b));
			}

			let mul = pairing_batch(&vals);

			if mul == Gt::one() {
				U256::one()
			} else {
				U256::zero()
			}
		};

		let mut buf = [0u8; 32];
		ret_val.to_big_endian(&mut buf);

		Ok(PrecompileOutput {
			exit_status: ExitSucceed::Returned,
			output: buf.to_vec(),
		})
	}
}

#[cfg(test)]
mod tests {
	use super::*;
	use pallet_evm_test_vector_support::test_precompile_test_vectors;

	#[test]
	fn process_consensus_tests_for_add() -> Result<(), String> {
		test_precompile_test_vectors::<Bn128Add>("../testdata/common_bnadd.json")?;
		Ok(())
	}

	#[test]
	fn process_consensus_tests_for_mul() -> Result<(), String> {
		test_precompile_test_vectors::<Bn128Mul>("../testdata/common_bnmul.json")?;
		Ok(())
	}

	#[test]
	fn process_consensus_tests_for_pair() -> Result<(), String> {
		test_precompile_test_vectors::<Bn128Pairing>("../testdata/common_bnpair.json")?;
		Ok(())
	}
}