// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.

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

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

//! Transactions Confirmations rpc implementation

use std::sync::Arc;

use crypto::publickey;
use ethereum_types::{H520, U256};
use parity_runtime::Executor;
use parking_lot::Mutex;
use types::transaction::{PendingTransaction, SignedTransaction, TypedTransaction};

use jsonrpc_core::{
    futures::{future, future::Either, Future, IntoFuture},
    BoxFuture, Error, Result,
};
use jsonrpc_pubsub::{
    typed::{Sink, Subscriber},
    SubscriptionId,
};
use v1::{
    helpers::{
        deprecated::{self, DeprecationNotice},
        dispatch::{self, eth_data_hash, Dispatcher, WithToken},
        errors,
        external_signer::{SignerService, SigningQueue},
        ConfirmationPayload, FilledTransactionRequest, Subscribers,
    },
    metadata::Metadata,
    traits::Signer,
    types::{
        Bytes, ConfirmationRequest, ConfirmationResponse, ConfirmationResponseWithToken,
        TransactionModification,
    },
};

/// Transactions confirmation (personal) rpc implementation.
pub struct SignerClient<D: Dispatcher> {
    signer: Arc<SignerService>,
    accounts: Arc<dyn dispatch::Accounts>,
    dispatcher: D,
    subscribers: Arc<Mutex<Subscribers<Sink<Vec<ConfirmationRequest>>>>>,
    deprecation_notice: DeprecationNotice,
}

impl<D: Dispatcher + 'static> SignerClient<D> {
    /// Create new instance of signer client.
    pub fn new(
        accounts: Arc<dyn dispatch::Accounts>,
        dispatcher: D,
        signer: &Arc<SignerService>,
        executor: Executor,
    ) -> Self {
        let subscribers = Arc::new(Mutex::new(Subscribers::default()));
        let subs = Arc::downgrade(&subscribers);
        let s = Arc::downgrade(signer);
        signer.queue().on_event(move |_event| {
            if let (Some(s), Some(subs)) = (s.upgrade(), subs.upgrade()) {
                let requests = s
                    .requests()
                    .into_iter()
                    .map(Into::into)
                    .collect::<Vec<ConfirmationRequest>>();
                for subscription in subs.lock().values() {
                    let subscription: &Sink<_> = subscription;
                    executor.spawn(
                        subscription
                            .notify(Ok(requests.clone()))
                            .map(|_| ())
                            .map_err(
                                |e| warn!(target: "rpc", "Unable to send notification: {}", e),
                            ),
                    );
                }
            }
        });

        SignerClient {
            signer: signer.clone(),
            accounts: accounts.clone(),
            dispatcher,
            subscribers,
            deprecation_notice: Default::default(),
        }
    }

    fn confirm_internal<F, T>(
        &self,
        id: U256,
        modification: TransactionModification,
        f: F,
    ) -> BoxFuture<WithToken<ConfirmationResponse>>
    where
        F: FnOnce(D, &Arc<dyn dispatch::Accounts>, ConfirmationPayload) -> T,
        T: IntoFuture<Item = WithToken<ConfirmationResponse>, Error = Error>,
        T::Future: Send + 'static,
    {
        let dispatcher = self.dispatcher.clone();
        let signer = self.signer.clone();

        Box::new(
            signer
                .take(&id)
                .map(|sender| {
                    let mut payload = sender.request.payload.clone();
                    // Modify payload
                    if let ConfirmationPayload::SendTransaction(ref mut request) = payload {
                        if let Some(sender) = modification.sender {
                            request.from = sender;
                            // Altering sender should always reset the nonce.
                            request.nonce = None;
                        }
                        if modification.gas_price.is_some() {
                            request.gas_price = modification.gas_price;
                        }
                        if let Some(gas) = modification.gas {
                            request.gas = gas;
                        }
                        if let Some(ref condition) = modification.condition {
                            request.condition = condition.clone().map(Into::into);
                        }
                    }
                    let fut = f(dispatcher, &self.accounts, payload);
                    Either::A(fut.into_future().then(move |result| {
                        // Execute
                        if let Ok(ref response) = result {
                            signer.request_confirmed(sender, Ok((*response).clone()));
                        } else {
                            signer.request_untouched(sender);
                        }

                        result
                    }))
                })
                .unwrap_or_else(|| {
                    Either::B(future::err(errors::invalid_params("Unknown RequestID", id)))
                }),
        )
    }

    fn verify_transaction<F>(
        bytes: Bytes,
        request: FilledTransactionRequest,
        process: F,
    ) -> Result<ConfirmationResponse>
    where
        F: FnOnce(PendingTransaction) -> Result<ConfirmationResponse>,
    {
        let signed_transaction = TypedTransaction::decode(&bytes.0).map_err(errors::rlp)?;
        let signed_transaction = SignedTransaction::new(signed_transaction)
            .map_err(|e| errors::invalid_params("Invalid signature.", e))?;
        let sender = signed_transaction.sender();

        // Verification
        let sender_matches = sender == request.from;
        let data_matches = signed_transaction.tx().data == request.data;
        let value_matches = signed_transaction.tx().value == request.value;
        let nonce_matches = match request.nonce {
            Some(nonce) => signed_transaction.tx().nonce == nonce,
            None => true,
        };

        // Dispatch if everything is ok
        if sender_matches && data_matches && value_matches && nonce_matches {
            let pending_transaction =
                PendingTransaction::new(signed_transaction, request.condition.map(Into::into));
            process(pending_transaction)
        } else {
            let mut error = Vec::new();
            if !sender_matches {
                error.push("from")
            }
            if !data_matches {
                error.push("data")
            }
            if !value_matches {
                error.push("value")
            }
            if !nonce_matches {
                error.push("nonce")
            }

            Err(errors::invalid_params(
                "Sent transaction does not match the request.",
                error,
            ))
        }
    }
}

impl<D: Dispatcher + 'static> Signer for SignerClient<D> {
    type Metadata = Metadata;

    fn requests_to_confirm(&self) -> Result<Vec<ConfirmationRequest>> {
        self.deprecation_notice
            .print("signer_requestsToConfirm", deprecated::msgs::ACCOUNTS);

        Ok(self.signer.requests().into_iter().map(Into::into).collect())
    }

    // TODO [ToDr] TransactionModification is redundant for some calls
    // might be better to replace it in future
    fn confirm_request(
        &self,
        id: U256,
        modification: TransactionModification,
        pass: String,
    ) -> BoxFuture<ConfirmationResponse> {
        self.deprecation_notice
            .print("signer_confirmRequest", deprecated::msgs::ACCOUNTS);

        Box::new(
            self.confirm_internal(id, modification, move |dis, accounts, payload| {
                dispatch::execute(
                    dis,
                    accounts,
                    payload,
                    dispatch::SignWith::Password(pass.into()),
                )
            })
            .map(dispatch::WithToken::into_value),
        )
    }

    fn confirm_request_with_token(
        &self,
        id: U256,
        modification: TransactionModification,
        token: String,
    ) -> BoxFuture<ConfirmationResponseWithToken> {
        self.deprecation_notice
            .print("signer_confirmRequestWithToken", deprecated::msgs::ACCOUNTS);

        Box::new(
            self.confirm_internal(id, modification, move |dis, accounts, payload| {
                dispatch::execute(
                    dis,
                    accounts,
                    payload,
                    dispatch::SignWith::Token(token.into()),
                )
            })
            .and_then(|v| match v {
                WithToken::No(_) => Err(errors::internal("Unexpected response without token.", "")),
                WithToken::Yes(response, token) => Ok(ConfirmationResponseWithToken {
                    result: response,
                    token,
                }),
            }),
        )
    }

    fn confirm_request_raw(&self, id: U256, bytes: Bytes) -> Result<ConfirmationResponse> {
        self.deprecation_notice
            .print("signer_confirmRequestRaw", deprecated::msgs::ACCOUNTS);

        self.signer
            .take(&id)
            .map(|sender| {
                let payload = sender.request.payload.clone();
                let result = match payload {
                    ConfirmationPayload::SendTransaction(request) => {
                        Self::verify_transaction(bytes, request, |pending_transaction| {
                            self.dispatcher
                                .dispatch_transaction(pending_transaction)
                                .map(Into::into)
                                .map(ConfirmationResponse::SendTransaction)
                        })
                    }
                    ConfirmationPayload::SignTransaction(request) => {
                        Self::verify_transaction(bytes, request, |pending_transaction| {
                            let rich = self.dispatcher.enrich(pending_transaction.transaction);
                            Ok(ConfirmationResponse::SignTransaction(rich))
                        })
                    }
                    ConfirmationPayload::EthSignMessage(address, data) => {
                        let expected_hash = eth_data_hash(data);
                        let signature = publickey::Signature::from_electrum(&bytes.0);
                        match publickey::verify_address(&address, &signature, &expected_hash) {
                            Ok(true) => Ok(ConfirmationResponse::Signature(H520::from_slice(
                                bytes.0.as_slice(),
                            ))),
                            Ok(false) => Err(errors::invalid_params(
                                "Sender address does not match the signature.",
                                (),
                            )),
                            Err(err) => {
                                Err(errors::invalid_params("Invalid signature received.", err))
                            }
                        }
                    }
                    ConfirmationPayload::SignMessage(address, hash) => {
                        let signature = publickey::Signature::from_electrum(&bytes.0);
                        match publickey::verify_address(&address, &signature, &hash) {
                            Ok(true) => Ok(ConfirmationResponse::Signature(H520::from_slice(
                                bytes.0.as_slice(),
                            ))),
                            Ok(false) => Err(errors::invalid_params(
                                "Sender address does not match the signature.",
                                (),
                            )),
                            Err(err) => {
                                Err(errors::invalid_params("Invalid signature received.", err))
                            }
                        }
                    }
                    ConfirmationPayload::Decrypt(_address, _data) => {
                        // TODO [ToDr]: Decrypt can we verify if the answer is correct?
                        Ok(ConfirmationResponse::Decrypt(bytes))
                    }
                };
                if let Ok(ref response) = result {
                    self.signer.request_confirmed(sender, Ok(response.clone()));
                } else {
                    self.signer.request_untouched(sender);
                }
                result
            })
            .unwrap_or_else(|| Err(errors::invalid_params("Unknown RequestID", id)))
    }

    fn reject_request(&self, id: U256) -> Result<bool> {
        self.deprecation_notice
            .print("signer_rejectRequest", deprecated::msgs::ACCOUNTS);

        let res = self
            .signer
            .take(&id)
            .map(|sender| self.signer.request_rejected(sender));
        Ok(res.is_some())
    }

    fn generate_token(&self) -> Result<String> {
        self.deprecation_notice.print(
            "signer_generateAuthorizationToken",
            deprecated::msgs::ACCOUNTS,
        );

        self.signer.generate_token().map_err(errors::token)
    }

    fn subscribe_pending(&self, _meta: Self::Metadata, sub: Subscriber<Vec<ConfirmationRequest>>) {
        self.deprecation_notice
            .print("signer_subscribePending", deprecated::msgs::ACCOUNTS);

        self.subscribers.lock().push(sub)
    }

    fn unsubscribe_pending(&self, _: Option<Self::Metadata>, id: SubscriptionId) -> Result<bool> {
        let res = self.subscribers.lock().remove(&id).is_some();
        Ok(res)
    }
}
