#pragma once

#include <QtCore/QTimer>

#include <QtWidgets/QLabel>

#include <QtWidgets/QLineEdit>

#include <QtWidgets/QPushButton>

#include <QtWidgets/QTextEdit>

#include <QtWidgets/QPlainTextEdit>

#include <QtWidgets/QWidget>

#include <QtWidgets/QDialog>

#include <QtWidgets/QListView>

#include <QtCore/QAbstractListModel>

#include <QtCore/QMimeData>

#include <QTextBrowser>

#include <atomic>

#include <mutex>

#include <memory>

#include <string>

#include <utility>

#include <vector>

#include <functional>

#include "binaryninjaapi.h"

#include "action.h"

#include "globalarea.h"

#include "uitypes.h"

#define SCRIPT_OUTPUT_UPDATE_INTERVAL 100

class ScriptingConsole;

/*!

\defgroup scriptingconsole ScriptingConsole

\ingroup uiapi

*/

/*!

\ingroup scriptingconsole

*/

class BINARYNINJAUIAPI ScriptingCompletionModel : public QAbstractListModel

{

Q_OBJECT

std::vector<std::string> m_completions;

bool m_searching;

public:

ScriptingCompletionModel(QWidget* parent);

virtual QModelIndex index(int row, int col, const QModelIndex& parent = QModelIndex()) const override;

virtual QModelIndex parent(const QModelIndex& i) const override;

virtual bool hasChildren(const QModelIndex& parent) const override;

virtual int rowCount(const QModelIndex& parent = QModelIndex()) const override;

virtual int columnCount(const QModelIndex& parent) const override;

virtual QVariant data(const QModelIndex& i, int role) const override;

void setModelData(const std::vector<std::string>& completions, bool searching);

};

/*!

\ingroup scriptingconsole

*/

class BINARYNINJAUIAPI ScriptingCompletionPopup : public QDialog

{

Q_OBJECT

QListView* m_list;

ScriptingCompletionModel* m_model;

protected:

virtual bool eventFilter(QObject* obj, QEvent* event) override;

public:

ScriptingCompletionPopup(QWidget* parent);

void showWithData(QPoint pt, int cursorSize, const std::vector<std::string>& completions, bool searching = false);

bool handleKeyEvent(QKeyEvent* event);

virtual ~ScriptingCompletionPopup();

private Q_SLOTS:

void clickRow(const QModelIndex& index);

Q_SIGNALS:

void complete(QString text);

};

/*!

Argument display popup.

\ingroup scriptingconsole

*/

class BINARYNINJAUIAPI ScriptingArgumentAssistPopup : public QDialog

{

Q_OBJECT

QTextBrowser* m_textDisplay;

QString m_text;

Q_PROPERTY(QString text READ getText WRITE setText RESET unsetText)

void updateText();

public:

ScriptingArgumentAssistPopup(QWidget* parent);

virtual ~ScriptingArgumentAssistPopup();

void setText(const QString& text) { m_text = text; updateText(); }

QString getText() const { return m_text; }

void unsetText() { m_text.clear(); updateText(); }

protected:

virtual bool eventFilter(QObject* obj, QEvent* event) override;

};

/*!

\ingroup scriptingconsole

*/

class BINARYNINJAUIAPI ScriptingConsoleEdit : public QTextEdit

{

Q_OBJECT

public:

typedef std::function<std::vector<std::string>(const std::string&)> CompletionCallback;

typedef std::function<bool(const std::string&)> CanDoCompleteArgumentsCallback;

typedef std::function<std::pair<std::string, uint64_t>(const std::string&)> CompleteArgumentsCallback;

private:

struct ArgumentAssistRequestState

{

std::atomic<uint64_t> latestRequest {0};

std::mutex callbackMutex;

};

static constexpr int ArgumentAssistDebounceInterval = 100;

ScriptingConsole* m_console;

int m_charHeight;

bool m_continuation;

bool m_searching;

bool m_searchError;

CompletionCallback m_completionCallback;

ScriptingCompletionPopup* m_popup;

CanDoCompleteArgumentsCallback m_canDoArgumentCompletionCallback;

CompleteArgumentsCallback m_completeArgumentsCallback;

ScriptingArgumentAssistPopup* m_argumentAssistPopup;

QTimer* m_argumentAssistUpdateTimer;

std::shared_ptr<ArgumentAssistRequestState> m_argumentAssistState;

bool m_argumentAssistRequestRunning;

bool m_argumentAssistRequestPending;

uint64_t m_argumentAssistPopupPosition;

uint64_t m_completionRegionStart;

uint64_t m_completionRegionInitialStop;

uint64_t m_completionRegionStop;

bool canShowArgumentAssistPopup() const;

void hideArgumentAssistPopup();

void scheduleArgumentAssistPopupUpdate();

void updateArgumentAssistPopup();

void applyArgumentAssistPopup(const QString& text, uint64_t popupPosition);

public:

ScriptingConsoleEdit(ScriptingConsole* parent);

void setCharHeight(int height);

void setContinuation(bool cont);

void setCompletionCallback(CompletionCallback callback) { m_completionCallback = callback; }

void setCanDoCompleteArgumentsCallback(CanDoCompleteArgumentsCallback callback) { m_canDoArgumentCompletionCallback = callback; }

void setCompleteArgumentsCallback(CompleteArgumentsCallback callback) { m_completeArgumentsCallback = callback; }

void insertFromMimeData(const QMimeData* source) override;

private Q_SLOTS:

void complete(QString text);

protected:

virtual void keyPressEvent(QKeyEvent* event) override;

virtual void resizeEvent(QResizeEvent* event) override;

virtual void scrollContentsBy(int dx, int dy) override;

virtual void focusOutEvent(QFocusEvent* event) override;

virtual void hideEvent(QHideEvent* event) override;

virtual void changeEvent(QEvent* event) override;

};

/*!

\ingroup scriptingconsole

*/

class BINARYNINJAUIAPI ScriptingConsoleOutput : public QPlainTextEdit

{

Q_OBJECT

ScriptingConsole* m_console;

UIActionHandler* m_handler;

UIActionHandler m_actionHandler;

ContextMenuManager* m_contextMenuManager;

BinaryViewRef m_data;

Menu* m_menu;

public:

ScriptingConsoleOutput(ScriptingConsole* parent, Menu* menu);

bool IsNavigable(const QString& str, const std::pair<int, int>& offsetLen, uint64_t& value, bool highlight) const;

protected:

void contextMenuEvent(QContextMenuEvent* event) override;

public Q_SLOTS:

virtual void mouseReleaseEvent(QMouseEvent* event) override;

void viewChanged(QWidget* frame);

};

class ScriptingConsoleWidget;

/*!

\ingroup scriptingconsole

*/

class BINARYNINJAUIAPI ScriptingConsole : public SidebarWidget, BinaryNinja::ScriptingOutputListener

{

Q_OBJECT

struct ScriptOutput

{

std::string text;

bool isError;

bool isWarning;

};

QString m_providerName;

QString m_instanceName;

ScriptingInstanceRef m_instance;

ScriptingConsoleOutput* m_output;

ScriptingConsoleEdit* m_input;

Splitter* m_splitter;

QLabel* m_prompt;

QPushButton* m_button;

QTimer* m_runTimer;

bool m_scriptActive;

BinaryNinja::Ref<BinaryNinja::Logger> m_logger;

std::mutex m_mutex;

std::vector<ScriptOutput> m_pendingOutput;

QTimer* m_updateTimer;

BNScriptingProviderInputReadyState m_currentState;

QStringList m_history;

QString m_inputOutsideHistory;

int m_currentHistoryEntry;

static int m_stateUpdatedEventType;

private Q_SLOTS:

void updateTimerEvent();

void consoleTextChanged();

void cancel();

void showCancelButton();

Q_SIGNALS:

void viewChanged(QWidget* frame);

void onScriptExecution();

void onScriptCompletion();

protected:

void customEvent(QEvent* event) override;

public:

ScriptingConsole(

QWidget* parent, const QString& providerName, const QString& instanceName, ScriptingInstanceRef instance);

virtual ~ScriptingConsole();

QString getProviderName() const { return m_providerName; }

QString getInstanceName() const { return m_instanceName; }

ScriptingInstanceRef getInstance() { return m_instance; }

bool getScriptIsActive() const { return m_scriptActive; }

void clearConsole();

void addInput(const std::string& text);

virtual void NotifyOutput(const std::string& text) override;

virtual void NotifyWarning(const std::string& text) override;

virtual void NotifyError(const std::string& text) override;

virtual void NotifyInputReadyStateChanged(BNScriptingProviderInputReadyState state) override;

virtual void notifyViewChanged(ViewFrame* frame) override;

virtual void notifyFontChanged() override;

virtual void focus() override;

void moveUpInHistory();

void moveDownInHistory();

void stopMovingInHistory();

std::vector<std::string> reverseSearch(const QString& text);

void closing() override;

void runScriptFromFile(const std::string& filename);

};

/*!

\ingroup scriptingconsole

*/

class BINARYNINJAUIAPI ScriptingConsoleSidebarWidgetType : public SidebarWidgetType

{

public:

ScriptingConsoleSidebarWidgetType();

SidebarWidgetLocation defaultLocation() const override { return SidebarWidgetLocation::LeftBottom; }

SidebarContextSensitivity contextSensitivity() const override { return GlobalSidebarContext; }

bool alwaysShowTabs() const override { return true; }

#ifdef DEMO_EDITION

virtual QString noWidgetMessage() const override;

#endif

};