// 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::Encode;
use cord_loom_runtime::{CheckedExtrinsic, RuntimeCall, TransactionPayment};
use cord_loom_runtime_constants::time::SLOT_DURATION;
use cord_node_testing::keyring::*;
use pallet_transaction_payment::Multiplier;
use sp_runtime::{traits::One, Perbill};

pub mod common;
use self::common::*;

#[test]
fn fee_multiplier_increases_and_decreases_on_big_weight() {
	let mut t = new_test_ext(compact_code_unwrap());

	// initial fee multiplier must be one.
	let mut prev_multiplier = Multiplier::one();

	t.execute_with(|| {
		assert_eq!(TransactionPayment::next_fee_multiplier(), prev_multiplier);
	});

	let mut tt = new_test_ext(compact_code_unwrap());

	let time1 = 42 * 1000;
	// big one in terms of weight.
	let block1 = construct_block(
		&mut tt,
		1,
		GENESIS_HASH.into(),
		vec![
			CheckedExtrinsic {
				signed: None,
				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time1 }),
			},
			CheckedExtrinsic {
				signed: Some((charlie(), signed_extra(0, 0))),
				function: RuntimeCall::Sudo(pallet_sudo::Call::sudo {
					call: Box::new(RuntimeCall::RootTesting(
						pallet_root_testing::Call::fill_block { ratio: Perbill::from_percent(60) },
					)),
				}),
			},
		],
		(time1 / SLOT_DURATION).into(),
	);

	let time2 = 52 * 1000;
	// small one in terms of weight.
	let block2 = construct_block(
		&mut tt,
		2,
		block1.1,
		vec![
			CheckedExtrinsic {
				signed: None,
				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time2 }),
			},
			CheckedExtrinsic {
				signed: Some((charlie(), signed_extra(1, 0))),
				function: RuntimeCall::System(frame_system::Call::remark { remark: vec![0; 1] }),
			},
		],
		(time2 / SLOT_DURATION).into(),
	);

	println!(
		"++ Block 1 size: {} / Block 2 size {}",
		block1.0.encode().len(),
		block2.0.encode().len(),
	);

	// execute a big block.
	executor_call(&mut t, "Core_execute_block", &block1.0).0.unwrap();

	// weight multiplier is increased for next block.
	t.execute_with(|| {
		let fm = TransactionPayment::next_fee_multiplier();
		println!("After a big block: {:?} -> {:?}", prev_multiplier, fm);
		assert!(fm > prev_multiplier);
		prev_multiplier = fm;
	});

	// execute a big block.
	executor_call(&mut t, "Core_execute_block", &block2.0).0.unwrap();

	// weight multiplier is increased for next block.
	t.execute_with(|| {
		let fm = TransactionPayment::next_fee_multiplier();
		println!("After a small block: {:?} -> {:?}", prev_multiplier, fm);
		assert!(fm < prev_multiplier);
	});
}

#[test]
#[should_panic]
#[cfg(feature = "stress-test")]
fn block_weight_capacity_report() {
	// Just report how many transfer calls you could fit into a block. The number should at least
	// be a few hundred (250 at the time of writing but can change over time). Runs until panic.
	use cord_primitives::Nonce;

	// execution ext.
	let mut t = new_test_ext(compact_code_unwrap());
	// setup ext.
	let mut tt = new_test_ext(compact_code_unwrap());

	let factor = 50;
	let mut time = 10;
	let mut nonce: Nonce = 0;
	let mut block_number = 1;
	let mut previous_hash: node_primitives::Hash = GENESIS_HASH.into();

	loop {
		let num_transfers = block_number * factor;
		let mut xts = (0..num_transfers)
			.map(|i| CheckedExtrinsic {
				signed: Some((charlie(), signed_extra(nonce + i as Nonce, 0))),
				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
					dest: bob().into(),
					value: 0,
				}),
			})
			.collect::<Vec<CheckedExtrinsic>>();

		xts.insert(
			0,
			CheckedExtrinsic {
				signed: None,
				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time * 1000 }),
			},
		);

		// NOTE: this is super slow. Can probably be improved.
		let block = construct_block(
			&mut tt,
			block_number,
			previous_hash,
			xts,
			(time * 1000 / SLOT_DURATION).into(),
		);

		let len = block.0.len();
		print!(
			"++ Executing block with {} transfers. Block size = {} bytes / {} kb / {} mb",
			num_transfers,
			len,
			len / 1024,
			len / 1024 / 1024,
		);

		let r = executor_call(&mut t, "Core_execute_block", &block.0).0;

		println!(" || Result = {:?}", r);
		assert!(r.is_ok());

		previous_hash = block.1;
		nonce += num_transfers;
		time += 10;
		block_number += 1;
	}
}

#[test]
#[should_panic]
#[cfg(feature = "stress-test")]
fn block_length_capacity_report() {
	// Just report how big a block can get. Executes until panic. Should be ignored unless if
	// manually inspected. The number should at least be a few megabytes (5 at the time of
	// writing but can change over time).
	use cord_primitives::Nonce;

	// execution ext.
	let mut t = new_test_ext(compact_code_unwrap());
	// setup ext.
	let mut tt = new_test_ext(compact_code_unwrap());

	let factor = 256 * 1024;
	let mut time = 10;
	let mut nonce: Nonce = 0;
	let mut block_number = 1;
	let mut previous_hash: node_primitives::Hash = GENESIS_HASH.into();

	loop {
		// NOTE: this is super slow. Can probably be improved.
		let block = construct_block(
			&mut tt,
			block_number,
			previous_hash,
			vec![
				CheckedExtrinsic {
					signed: None,
					function: RuntimeCall::Timestamp(pallet_timestamp::Call::set {
						now: time * 1000,
					}),
				},
				CheckedExtrinsic {
					signed: Some((charlie(), signed_extra(nonce, 0))),
					function: RuntimeCall::System(frame_system::Call::remark {
						remark: vec![0u8; (block_number * factor) as usize],
					}),
				},
			],
			(time * 1000 / SLOT_DURATION).into(),
		);

		let len = block.0.len();
		print!(
			"++ Executing block with big remark. Block size = {} bytes / {} kb / {} mb",
			len,
			len / 1024,
			len / 1024 / 1024,
		);

		let r = executor_call(&mut t, "Core_execute_block", &block.0).0;

		println!(" || Result = {:?}", r);
		assert!(r.is_ok());

		previous_hash = block.1;
		nonce += 1;
		time += 10;
		block_number += 1;
	}
}
