// Copyright (c) 2011-2016 The Bitcoin Core developers
// Copyright (c) 2017-2025 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <qt/forms/ui_signverifymessagedialog.h>
#include <qt/signverifymessagedialog.h>

#include <key_io.h>
#include <qt/addressbookpage.h>
#include <qt/guiutil.h>
#include <qt/platformstyle.h>
#include <qt/walletmodel.h>
#include <validation.h> // For strMessageMagic
#include <wallet/wallet.h>

#include <QClipboard>

#include <string>
#include <vector>

SignVerifyMessageDialog::SignVerifyMessageDialog(
    const PlatformStyle *_platformStyle, QWidget *parent)
    : QDialog(parent), ui(new Ui::SignVerifyMessageDialog), model(nullptr),
      platformStyle(_platformStyle) {
    ui->setupUi(this);

    ui->addressBookButton_SM->setIcon(
        platformStyle->SingleColorIcon(":/icons/address-book"));
    ui->pasteButton_SM->setIcon(
        platformStyle->SingleColorIcon(":/icons/editpaste"));
    ui->copySignatureButton_SM->setIcon(
        platformStyle->SingleColorIcon(":/icons/editcopy"));
    ui->signMessageButton_SM->setIcon(
        platformStyle->SingleColorIcon(":/icons/edit"));
    ui->clearButton_SM->setIcon(
        platformStyle->SingleColorIcon(":/icons/remove"));
    ui->addressBookButton_VM->setIcon(
        platformStyle->SingleColorIcon(":/icons/address-book"));
    ui->verifyMessageButton_VM->setIcon(
        platformStyle->SingleColorIcon(":/icons/transaction_0"));
    ui->clearButton_VM->setIcon(
        platformStyle->SingleColorIcon(":/icons/remove"));

    ui->signatureOut_SM->setPlaceholderText(
        tr("Click \"Sign Message\" to generate signature"));

    GUIUtil::setupAddressWidget(ui->addressIn_SM, this);
    GUIUtil::setupAddressWidget(ui->addressIn_VM, this);

    ui->addressIn_SM->installEventFilter(this);
    ui->messageIn_SM->installEventFilter(this);
    ui->signatureOut_SM->installEventFilter(this);
    ui->addressIn_VM->installEventFilter(this);
    ui->messageIn_VM->installEventFilter(this);
    ui->signatureIn_VM->installEventFilter(this);

    ui->signatureOut_SM->setFont(GUIUtil::fixedPitchFont());
    ui->signatureIn_VM->setFont(GUIUtil::fixedPitchFont());

    GUIUtil::handleCloseWindowShortcut(this);
}

SignVerifyMessageDialog::~SignVerifyMessageDialog() {
    delete ui;
}

void SignVerifyMessageDialog::setModel(WalletModel *_model) {
    this->model = _model;
}

void SignVerifyMessageDialog::setAddress_SM(const QString &address) {
    ui->addressIn_SM->setText(address);
    ui->messageIn_SM->setFocus();
}

void SignVerifyMessageDialog::setAddress_VM(const QString &address) {
    ui->addressIn_VM->setText(address);
    ui->messageIn_VM->setFocus();
}

void SignVerifyMessageDialog::showTab_SM(bool fShow) {
    ui->tabWidget->setCurrentIndex(0);
    if (fShow) {
        this->show();
    }
}

void SignVerifyMessageDialog::showTab_VM(bool fShow) {
    ui->tabWidget->setCurrentIndex(1);
    if (fShow) {
        this->show();
    }
}

void SignVerifyMessageDialog::on_addressBookButton_SM_clicked() {
    if (model && model->getAddressTableModel()) {
        AddressBookPage dlg(platformStyle, AddressBookPage::ForSelection,
                            AddressBookPage::ReceivingTab, this);
        dlg.setModel(model->getAddressTableModel());
        if (dlg.exec()) {
            setAddress_SM(dlg.getReturnValue());
        }
    }
}

void SignVerifyMessageDialog::on_pasteButton_SM_clicked() {
    setAddress_SM(QApplication::clipboard()->text());
}

void SignVerifyMessageDialog::on_signMessageButton_SM_clicked() {
    if (!model) {
        return;
    }

    /* Clear old signature to ensure users don't get confused on error with an
     * old signature displayed */
    ui->signatureOut_SM->clear();

    CTxDestination destination = DecodeDestination(
        ui->addressIn_SM->text().toStdString(), model->getChainParams());
    if (!IsValidDestination(destination)) {
        ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_SM->setText(
            tr("The entered address is invalid.") + QString(" ") +
            tr("Please check the address and try again."));
        return;
    }
    const CKeyID *keyID = std::get_if<CKeyID>(&destination);
    if (!keyID) {
        ui->addressIn_SM->setValid(false);
        ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_SM->setText(
            tr("The entered address does not refer to a key.") + QString(" ") +
            tr("Please check the address and try again."));
        return;
    }

    WalletModel::UnlockContext ctx(model->requestUnlock());
    if (!ctx.isValid()) {
        ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_SM->setText(tr("Wallet unlock was cancelled."));
        return;
    }

    CKey key;
    if (!model->wallet().getPrivKey(*keyID, key)) {
        ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_SM->setText(
            tr("Private key for the entered address is not available."));
        return;
    }

    CHashWriter ss(SER_GETHASH, 0);
    ss << strMessageMagic;
    ss << ui->messageIn_SM->document()->toPlainText().toStdString();

    std::vector<uint8_t> vchSig;
    if (!key.SignCompact(ss.GetHash(), vchSig)) {
        ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_SM->setText(QString("<nobr>") +
                                    tr("Message signing failed.") +
                                    QString("</nobr>"));
        return;
    }

    ui->statusLabel_SM->setStyleSheet("QLabel { color: green; }");
    ui->statusLabel_SM->setText(QString("<nobr>") + tr("Message signed.") +
                                QString("</nobr>"));

    ui->signatureOut_SM->setText(
        QString::fromStdString(EncodeBase64(vchSig)));
}

void SignVerifyMessageDialog::on_copySignatureButton_SM_clicked() {
    GUIUtil::setClipboard(ui->signatureOut_SM->text());
}

void SignVerifyMessageDialog::on_clearButton_SM_clicked() {
    ui->addressIn_SM->clear();
    ui->messageIn_SM->clear();
    ui->signatureOut_SM->clear();
    ui->statusLabel_SM->clear();

    ui->addressIn_SM->setFocus();
}

void SignVerifyMessageDialog::on_addressBookButton_VM_clicked() {
    if (model && model->getAddressTableModel()) {
        AddressBookPage dlg(platformStyle, AddressBookPage::ForSelection,
                            AddressBookPage::SendingTab, this);
        dlg.setModel(model->getAddressTableModel());
        if (dlg.exec()) {
            setAddress_VM(dlg.getReturnValue());
        }
    }
}

void SignVerifyMessageDialog::on_verifyMessageButton_VM_clicked() {
    CTxDestination destination = DecodeDestination(
        ui->addressIn_VM->text().toStdString(), model->getChainParams());
    if (!IsValidDestination(destination)) {
        ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_VM->setText(
            tr("The entered address is invalid.") + QString(" ") +
            tr("Please check the address and try again."));
        return;
    }
    if (!std::get_if<CKeyID>(&destination)) {
        ui->addressIn_VM->setValid(false);
        ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_VM->setText(
            tr("The entered address does not refer to a key.") + QString(" ") +
            tr("Please check the address and try again."));
        return;
    }

    bool fInvalid = false;
    std::vector<uint8_t> vchSig = DecodeBase64(
        ui->signatureIn_VM->text().toStdString().c_str(), &fInvalid);

    if (fInvalid) {
        ui->signatureIn_VM->setValid(false);
        ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_VM->setText(
            tr("The signature could not be decoded.") + QString(" ") +
            tr("Please check the signature and try again."));
        return;
    }

    CHashWriter ss(SER_GETHASH, 0);
    ss << strMessageMagic;
    ss << ui->messageIn_VM->document()->toPlainText().toStdString();

    CPubKey pubkey;
    if (!pubkey.RecoverCompact(ss.GetHash(), vchSig)) {
        ui->signatureIn_VM->setValid(false);
        ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_VM->setText(
            tr("The signature did not match the message digest.") +
            QString(" ") + tr("Please check the signature and try again."));
        return;
    }

    if (!(CTxDestination(pubkey.GetID()) == destination)) {
        ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
        ui->statusLabel_VM->setText(QString("<nobr>") +
                                    tr("Message verification failed.") +
                                    QString("</nobr>"));
        return;
    }

    ui->statusLabel_VM->setStyleSheet("QLabel { color: green; }");
    ui->statusLabel_VM->setText(QString("<nobr>") + tr("Message verified.") +
                                QString("</nobr>"));
}

void SignVerifyMessageDialog::on_clearButton_VM_clicked() {
    ui->addressIn_VM->clear();
    ui->signatureIn_VM->clear();
    ui->messageIn_VM->clear();
    ui->statusLabel_VM->clear();

    ui->addressIn_VM->setFocus();
}

bool SignVerifyMessageDialog::eventFilter(QObject *object, QEvent *event) {
    if (event->type() == QEvent::MouseButtonPress ||
        event->type() == QEvent::FocusIn) {
        if (ui->tabWidget->currentIndex() == 0) {
            /* Clear status message on focus change */
            ui->statusLabel_SM->clear();

            /* Select generated signature */
            if (object == ui->signatureOut_SM) {
                ui->signatureOut_SM->selectAll();
                return true;
            }
        } else if (ui->tabWidget->currentIndex() == 1) {
            /* Clear status message on focus change */
            ui->statusLabel_VM->clear();
        }
    }
    return QDialog::eventFilter(object, event);
}
