// Copyright 2019-2020 Parity Technologies (UK) Ltd.
// This file is part of Parity Bridges Common.

// Parity Bridges Common 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.

// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.

//! Substrate-to-substrate relay entrypoint.

#![warn(missing_docs)]

use codec::{Decode, Encode};
use frame_support::weights::GetDispatchInfo;
use pallet_bridge_call_dispatch::{CallOrigin, MessagePayload};
use relay_kusama_client::Kusama;
use relay_millau_client::{Millau, SigningParams as MillauSigningParams};
use relay_rialto_client::{Rialto, SigningParams as RialtoSigningParams};
use relay_substrate_client::{Chain, ConnectionParams, TransactionSignScheme};
use relay_utils::initialize::initialize_relay;
use sp_core::{Bytes, Pair};
use sp_runtime::traits::IdentifyAccount;

/// Kusama node client.
pub type KusamaClient = relay_substrate_client::Client<Kusama>;
/// Millau node client.
pub type MillauClient = relay_substrate_client::Client<Millau>;
/// Rialto node client.
pub type RialtoClient = relay_substrate_client::Client<Rialto>;

mod cli;
mod headers_initialize;
mod headers_maintain;
mod headers_pipeline;
mod headers_target;
mod messages_lane;
mod messages_source;
mod messages_target;
mod millau_headers_to_rialto;
mod millau_messages_to_rialto;
mod rialto_headers_to_millau;
mod rialto_messages_to_millau;

fn main() {
	initialize_relay();

	let result = async_std::task::block_on(run_command(cli::parse_args()));
	if let Err(error) = result {
		log::error!(target: "bridge", "Failed to start relay: {}", error);
	}
}

async fn run_command(command: cli::Command) -> Result<(), String> {
	match command {
		cli::Command::InitBridge(arg) => run_init_bridge(arg).await,
		cli::Command::RelayHeaders(arg) => run_relay_headers(arg).await,
		cli::Command::RelayMessages(arg) => run_relay_messages(arg).await,
		cli::Command::SendMessage(arg) => run_send_message(arg).await,
	}
}

async fn run_init_bridge(command: cli::InitBridge) -> Result<(), String> {
	match command {
		cli::InitBridge::MillauToRialto {
			millau,
			rialto,
			rialto_sign,
			millau_bridge_params,
		} => {
			let millau_client = millau.into_client().await?;
			let rialto_client = rialto.into_client().await?;
			let rialto_sign = rialto_sign.parse()?;

			let rialto_signer_next_index = rialto_client
				.next_account_index(rialto_sign.signer.public().into())
				.await?;

			headers_initialize::initialize(
				millau_client,
				rialto_client.clone(),
				millau_bridge_params.millau_initial_header,
				millau_bridge_params.millau_initial_authorities,
				millau_bridge_params.millau_initial_authorities_set_id,
				move |initialization_data| {
					Ok(Bytes(
						Rialto::sign_transaction(
							&rialto_client,
							&rialto_sign.signer,
							rialto_signer_next_index,
							rialto_runtime::SudoCall::sudo(Box::new(
								rialto_runtime::BridgeMillauCall::initialize(initialization_data).into(),
							))
							.into(),
						)
						.encode(),
					))
				},
			)
			.await;
		}
		cli::InitBridge::RialtoToMillau {
			rialto,
			millau,
			millau_sign,
			rialto_bridge_params,
		} => {
			let rialto_client = rialto.into_client().await?;
			let millau_client = millau.into_client().await?;
			let millau_sign = millau_sign.parse()?;
			let millau_signer_next_index = millau_client
				.next_account_index(millau_sign.signer.public().into())
				.await?;

			headers_initialize::initialize(
				rialto_client,
				millau_client.clone(),
				rialto_bridge_params.rialto_initial_header,
				rialto_bridge_params.rialto_initial_authorities,
				rialto_bridge_params.rialto_initial_authorities_set_id,
				move |initialization_data| {
					Ok(Bytes(
						Millau::sign_transaction(
							&millau_client,
							&millau_sign.signer,
							millau_signer_next_index,
							millau_runtime::SudoCall::sudo(Box::new(
								millau_runtime::BridgeRialtoCall::initialize(initialization_data).into(),
							))
							.into(),
						)
						.encode(),
					))
				},
			)
			.await;
		}
	}
	Ok(())
}

async fn run_relay_headers(command: cli::RelayHeaders) -> Result<(), String> {
	match command {
		cli::RelayHeaders::MillauToRialto {
			millau,
			rialto,
			rialto_sign,
			prometheus_params,
		} => {
			let millau_client = millau.into_client().await?;
			let rialto_client = rialto.into_client().await?;
			let rialto_sign = rialto_sign.parse()?;
			millau_headers_to_rialto::run(millau_client, rialto_client, rialto_sign, prometheus_params.into()).await;
		}
		cli::RelayHeaders::RialtoToMillau {
			rialto,
			millau,
			millau_sign,
			prometheus_params,
		} => {
			let rialto_client = rialto.into_client().await?;
			let millau_client = millau.into_client().await?;
			let millau_sign = millau_sign.parse()?;
			rialto_headers_to_millau::run(rialto_client, millau_client, millau_sign, prometheus_params.into()).await;
		}
	}
	Ok(())
}

async fn run_relay_messages(command: cli::RelayMessages) -> Result<(), String> {
	match command {
		cli::RelayMessages::MillauToRialto {
			millau,
			millau_sign,
			rialto,
			rialto_sign,
			prometheus_params,
			lane,
		} => {
			let millau_client = millau.into_client().await?;
			let millau_sign = millau_sign.parse()?;
			let rialto_client = rialto.into_client().await?;
			let rialto_sign = rialto_sign.parse()?;

			millau_messages_to_rialto::run(
				millau_client,
				millau_sign,
				rialto_client,
				rialto_sign,
				lane.into(),
				prometheus_params.into(),
			);
		}
		cli::RelayMessages::RialtoToMillau {
			rialto,
			rialto_sign,
			millau,
			millau_sign,
			prometheus_params,
			lane,
		} => {
			let rialto_client = rialto.into_client().await?;
			let rialto_sign = rialto_sign.parse()?;
			let millau_client = millau.into_client().await?;
			let millau_sign = millau_sign.parse()?;

			rialto_messages_to_millau::run(
				rialto_client,
				rialto_sign,
				millau_client,
				millau_sign,
				lane.into(),
				prometheus_params.into(),
			);
		}
	}
	Ok(())
}

async fn run_send_message(command: cli::SendMessage) -> Result<(), String> {
	match command {
		cli::SendMessage::MillauToRialto {
			millau,
			millau_sign,
			rialto_sign,
			lane,
			message,
			fee,
			origin,
			..
		} => {
			let millau_client = millau.into_client().await?;
			let millau_sign = millau_sign.parse()?;
			let rialto_sign = rialto_sign.parse()?;
			let rialto_call = message.into_call();

			let payload = millau_to_rialto_message_payload(&millau_sign, &rialto_sign, &rialto_call, origin);

			let lane = lane.into();
			let fee = get_fee(fee, || {
				estimate_message_delivery_and_dispatch_fee(
					&millau_client,
					bp_rialto::TO_RIALTO_ESTIMATE_MESSAGE_FEE_METHOD,
					lane,
					payload.clone(),
				)
			})
			.await?;

			log::info!(target: "bridge", "Sending message to Rialto. Fee: {}", fee);

			let millau_call = millau_runtime::Call::BridgeRialtoMessageLane(
				millau_runtime::MessageLaneCall::send_message(lane, payload, fee),
			);

			let signed_millau_call = Millau::sign_transaction(
				&millau_client,
				&millau_sign.signer,
				millau_client
					.next_account_index(millau_sign.signer.public().clone().into())
					.await?,
				millau_call,
			);

			millau_client
				.submit_extrinsic(Bytes(signed_millau_call.encode()))
				.await?;
		}
		cli::SendMessage::RialtoToMillau {
			rialto,
			rialto_sign,
			millau_sign,
			lane,
			message,
			fee,
			origin,
			..
		} => {
			let rialto_client = rialto.into_client().await?;
			let rialto_sign = rialto_sign.parse()?;
			let millau_sign = millau_sign.parse()?;
			let millau_call = message.into_call();

			let payload = rialto_to_millau_message_payload(&rialto_sign, &millau_sign, &millau_call, origin);

			let lane = lane.into();
			let fee = get_fee(fee, || {
				estimate_message_delivery_and_dispatch_fee(
					&rialto_client,
					bp_millau::TO_MILLAU_ESTIMATE_MESSAGE_FEE_METHOD,
					lane,
					payload.clone(),
				)
			})
			.await?;

			log::info!(target: "bridge", "Sending message to Millau. Fee: {}", fee);

			let rialto_call = rialto_runtime::Call::BridgeMillauMessageLane(
				rialto_runtime::MessageLaneCall::send_message(lane, payload, fee),
			);

			let signed_rialto_call = Rialto::sign_transaction(
				&rialto_client,
				&rialto_sign.signer,
				rialto_client
					.next_account_index(rialto_sign.signer.public().clone().into())
					.await?,
				rialto_call,
			);

			rialto_client
				.submit_extrinsic(Bytes(signed_rialto_call.encode()))
				.await?;
		}
	}
	Ok(())
}

async fn estimate_message_delivery_and_dispatch_fee<Fee: Decode, C: Chain, P: Encode>(
	client: &relay_substrate_client::Client<C>,
	estimate_fee_method: &str,
	lane: bp_message_lane::LaneId,
	payload: P,
) -> Result<Option<Fee>, relay_substrate_client::Error> {
	let encoded_response = client
		.state_call(estimate_fee_method.into(), (lane, payload).encode().into(), None)
		.await?;
	let decoded_response: Option<Fee> =
		Decode::decode(&mut &encoded_response.0[..]).map_err(relay_substrate_client::Error::ResponseParseFailed)?;
	Ok(decoded_response)
}

fn remark_payload() -> Vec<u8> {
	format!(
		"Unix time: {}",
		std::time::SystemTime::now()
			.duration_since(std::time::SystemTime::UNIX_EPOCH)
			.unwrap_or_default()
			.as_secs(),
	)
	.as_bytes()
	.to_vec()
}

fn rialto_to_millau_message_payload(
	rialto_sign: &RialtoSigningParams,
	millau_sign: &MillauSigningParams,
	millau_call: &millau_runtime::Call,
	origin: cli::Origins,
) -> rialto_runtime::millau_messages::ToMillauMessagePayload {
	let millau_call_weight = millau_call.get_dispatch_info().weight;
	let rialto_sender_public: bp_rialto::AccountSigner = rialto_sign.signer.public().clone().into();
	let rialto_account_id: bp_rialto::AccountId = rialto_sender_public.into_account();
	let millau_origin_public = millau_sign.signer.public();

	MessagePayload {
		spec_version: millau_runtime::VERSION.spec_version,
		weight: millau_call_weight,
		origin: match origin {
			cli::Origins::Source => CallOrigin::SourceAccount(rialto_account_id),
			cli::Origins::Target => {
				let digest = rialto_runtime::millau_account_ownership_digest(
					&millau_call,
					rialto_account_id.clone(),
					millau_runtime::VERSION.spec_version,
				);

				let digest_signature = millau_sign.signer.sign(&digest);

				CallOrigin::TargetAccount(rialto_account_id, millau_origin_public.into(), digest_signature.into())
			}
		},
		call: millau_call.encode(),
	}
}

fn millau_to_rialto_message_payload(
	millau_sign: &MillauSigningParams,
	rialto_sign: &RialtoSigningParams,
	rialto_call: &rialto_runtime::Call,
	origin: cli::Origins,
) -> millau_runtime::rialto_messages::ToRialtoMessagePayload {
	let rialto_call_weight = rialto_call.get_dispatch_info().weight;
	let millau_sender_public: bp_millau::AccountSigner = millau_sign.signer.public().clone().into();
	let millau_account_id: bp_millau::AccountId = millau_sender_public.into_account();
	let rialto_origin_public = rialto_sign.signer.public();

	MessagePayload {
		spec_version: rialto_runtime::VERSION.spec_version,
		weight: rialto_call_weight,
		origin: match origin {
			cli::Origins::Source => CallOrigin::SourceAccount(millau_account_id),
			cli::Origins::Target => {
				let digest = millau_runtime::rialto_account_ownership_digest(
					&rialto_call,
					millau_account_id.clone(),
					rialto_runtime::VERSION.spec_version,
				);

				let digest_signature = rialto_sign.signer.sign(&digest);

				CallOrigin::TargetAccount(millau_account_id, rialto_origin_public.into(), digest_signature.into())
			}
		},
		call: rialto_call.encode(),
	}
}

async fn get_fee<Fee, F, R, E>(fee: Option<Fee>, f: F) -> Result<Fee, String>
where
	Fee: Decode,
	F: FnOnce() -> R,
	R: std::future::Future<Output = Result<Option<Fee>, E>>,
	E: std::fmt::Debug,
{
	match fee {
		Some(fee) => Ok(fee),
		None => match f().await {
			Ok(Some(fee)) => Ok(fee),
			Ok(None) => Err("Failed to estimate message fee. Message is too heavy?".into()),
			Err(error) => Err(format!("Failed to estimate message fee: {:?}", error)),
		},
	}
}

impl crate::cli::RialtoSigningParams {
	/// Parse CLI parameters into typed signing params.
	pub fn parse(self) -> Result<RialtoSigningParams, String> {
		RialtoSigningParams::from_suri(&self.rialto_signer, self.rialto_signer_password.as_deref())
			.map_err(|e| format!("Failed to parse rialto-signer: {:?}", e))
	}
}

impl crate::cli::MillauSigningParams {
	/// Parse CLI parameters into typed signing params.
	pub fn parse(self) -> Result<MillauSigningParams, String> {
		MillauSigningParams::from_suri(&self.millau_signer, self.millau_signer_password.as_deref())
			.map_err(|e| format!("Failed to parse millau-signer: {:?}", e))
	}
}

impl crate::cli::MillauConnectionParams {
	/// Convert CLI connection parameters into Millau RPC Client.
	pub async fn into_client(self) -> relay_substrate_client::Result<MillauClient> {
		MillauClient::new(ConnectionParams {
			host: self.millau_host,
			port: self.millau_port,
		})
		.await
	}
}
impl crate::cli::RialtoConnectionParams {
	/// Convert CLI connection parameters into Rialto RPC Client.
	pub async fn into_client(self) -> relay_substrate_client::Result<RialtoClient> {
		RialtoClient::new(ConnectionParams {
			host: self.rialto_host,
			port: self.rialto_port,
		})
		.await
	}
}

impl crate::cli::ToRialtoMessage {
	/// Convert CLI call request into runtime `Call` instance.
	pub fn into_call(self) -> rialto_runtime::Call {
		match self {
			cli::ToRialtoMessage::Remark => {
				rialto_runtime::Call::System(rialto_runtime::SystemCall::remark(remark_payload()))
			}
			cli::ToRialtoMessage::Transfer { recipient, amount } => {
				rialto_runtime::Call::Balances(rialto_runtime::BalancesCall::transfer(recipient, amount))
			}
		}
	}
}

impl crate::cli::ToMillauMessage {
	/// Convert CLI call request into runtime `Call` instance.
	pub fn into_call(self) -> millau_runtime::Call {
		match self {
			cli::ToMillauMessage::Remark => {
				millau_runtime::Call::System(millau_runtime::SystemCall::remark(remark_payload()))
			}
			cli::ToMillauMessage::Transfer { recipient, amount } => {
				millau_runtime::Call::Balances(millau_runtime::BalancesCall::transfer(recipient, amount))
			}
		}
	}
}

#[cfg(test)]
mod tests {
	use sp_core::Pair;
	use sp_runtime::traits::{IdentifyAccount, Verify};

	#[test]
	fn millau_signature_is_valid_on_rialto() {
		let millau_sign = relay_millau_client::SigningParams::from_suri("//Dave", None).unwrap();

		let call = rialto_runtime::Call::System(rialto_runtime::SystemCall::remark(vec![]));

		let millau_public: bp_millau::AccountSigner = millau_sign.signer.public().clone().into();
		let millau_account_id: bp_millau::AccountId = millau_public.into_account();

		let digest = millau_runtime::rialto_account_ownership_digest(
			&call,
			millau_account_id,
			rialto_runtime::VERSION.spec_version,
		);

		let rialto_signer = relay_rialto_client::SigningParams::from_suri("//Dave", None).unwrap();
		let signature = rialto_signer.signer.sign(&digest);

		assert!(signature.verify(&digest[..], &rialto_signer.signer.public()));
	}

	#[test]
	fn rialto_signature_is_valid_on_millau() {
		let rialto_sign = relay_rialto_client::SigningParams::from_suri("//Dave", None).unwrap();

		let call = millau_runtime::Call::System(millau_runtime::SystemCall::remark(vec![]));

		let rialto_public: bp_rialto::AccountSigner = rialto_sign.signer.public().clone().into();
		let rialto_account_id: bp_rialto::AccountId = rialto_public.into_account();

		let digest = rialto_runtime::millau_account_ownership_digest(
			&call,
			rialto_account_id,
			millau_runtime::VERSION.spec_version,
		);

		let millau_signer = relay_millau_client::SigningParams::from_suri("//Dave", None).unwrap();
		let signature = millau_signer.signer.sign(&digest);

		assert!(signature.verify(&digest[..], &millau_signer.signer.public()));
	}
}