/*
    SPDX-FileCopyrightText: 2002-2003 Tim Jansen <tim@tjansen.de>
    SPDX-FileCopyrightText: 2007-2008 Urs Wolfer <uwolfer@kde.org>
    SPDX-FileCopyrightText: 2021 Rafał Lalik <rafallalik@gmail.com>

    SPDX-License-Identifier: GPL-2.0-or-later
*/

#ifndef REMOTEVIEW_H
#define REMOTEVIEW_H

#ifndef QTONLY
#include "krdccore_export.h"
#include <KWallet>
#else
#define KRDCCORE_EXPORT
#endif

#include <QUrl>
#include <QWidget>

class HostPreferences;

/**
 * Generic widget that displays a remote framebuffer.
 * Implement this if you want to add another backend.
 *
 * Things to take care of:
 * @li The RemoteView is responsible for its size. In
 *     non-scaling mode, set the fixed size of the widget
 *     to the remote resolution. In scaling mode, set the
 *     maximum size to the remote size and minimum size to the
 *     smallest resolution that your scaler can handle.
 * @li if you override mouseMoveEvent()
 *     you must ignore the QEvent, because the KRDC widget will
 *     need it for stuff like toolbar auto-hide and bump
 *     scrolling. If you use x11Event(), make sure that
 *     MotionNotify events will be forwarded.
 *
 */
class KRDCCORE_EXPORT RemoteView : public QWidget
{
    Q_OBJECT

public:
    enum Quality {
        Unknown,
        High,
        Medium,
        Low,
    };
    Q_ENUM(Quality)

    /**
     * Describes the state of a local cursor, if there is such a concept in the backend.
     * With local cursors, there are two cursors: the cursor on the local machine (client),
     * and the cursor on the remote machine (server). Because there is usually some lag,
     * some backends show both cursors simultaneously. In the VNC backend the local cursor
     * is a dot and the remote cursor is the 'real' cursor, usually an arrow.
     */

    enum LocalCursorState {
        CursorOn, ///< Always show local cursor based on remote one (or fallback to default).
        CursorOff, ///< Never show local cursor, only the remote one.
        /// Try to measure the lag and enable the local cursor if the latency is too high.
        CursorAuto,
    };
    Q_ENUM(LocalCursorState)

    /**
     * State of the connection. The state of the connection is returned
     * by @ref RemoteView::status().
     *
     * Not every state transition is allowed. You are only allowed to transition
     * a state to the following state, with three exceptions:
     * @li You can move from every state directly to Disconnected
     * @li You can move from every state except Disconnected to
     *     Disconnecting
     * @li You can move from Disconnected to Connecting
     *
     * @ref RemoteView::setStatus() will follow this rules for you.
     * (If you add/remove a state here, you must adapt it)
     */

    enum RemoteStatus {
        Connecting = 0,
        Authenticating = 1,
        Preparing = 2,
        Connected = 3,
        Disconnecting = -1,
        Disconnected = -2,
    };
    Q_ENUM(RemoteStatus)

    enum ErrorCode {
        None = 0,
        Internal,
        Connection,
        Protocol,
        IO,
        Name,
        NoServer,
        ServerBlocked,
        Authentication,
    };
    Q_ENUM(ErrorCode)

    ~RemoteView() override;

    /**
     * Checks whether the backend supports scaling. The
     * default implementation returns false.
     * @return true if scaling is supported
     * @see scaling()
     */
    virtual bool supportsScaling() const;

    /**
     * Checks whether the widget is in scale mode. The
     * default implementation always returns false.
     * @return true if scaling is activated. Must always be
     *         false if @ref supportsScaling() returns false
     * @see supportsScaling()
     */
    virtual bool scaling() const;

    /**
     * Checks whether the backend supports the concept of local cursors. The
     * default implementation returns false.
     * @return true if local cursors are supported/known
     * @see LocalCursorState
     * @see showLocalCursor()
     * @see localCursorState()
     */
    virtual bool supportsLocalCursor() const;

    /**
     * Sets the state of the dot cursor, if supported by the backend.
     * The default implementation does nothing.
     * @param state the new state (CursorOn, CursorOff or
     *        CursorAuto)
     * @see localCursorState()
     * @see supportsLocalCursor()
     */
    virtual void showLocalCursor(LocalCursorState state);

    /**
     * Returns the state of the local cursor. The default implementation returns
     * always CursorOff.
     * @return true if local cursors are supported/known
     * @see showLocalCursor()
     * @see supportsLocalCursor()
     */
    virtual LocalCursorState localCursorState() const;

    /**
     * Checks whether the backend supports the view only mode. The
     * default implementation returns false.
     * @return true if view-only mode is supported
     * @see LocalCursorState
     * @see showLocalCursor()
     * @see localCursorState()
     */
    virtual bool supportsViewOnly() const;

    /**
     * Checks whether the view is in view-only mode. This means
     * that all input is ignored.
     */
    virtual bool viewOnly();

    /**
     * Checks whether grabbing all possible keys is enabled.
     */
    virtual bool grabAllKeys();

    /**
     * Returns the resolution of the remote framebuffer.
     * It should return a null @ref QSize when the size
     * is not known.
     * The backend must also emit a @ref framebufferSizeChanged()
     * when the size of the framebuffer becomes available
     * for the first time or the size changed.
     * @return the remote framebuffer size, a null QSize
     *         if unknown
     */
    virtual QSize framebufferSize();

    /**
     * Initiate the disconnection. This doesn't need to happen
     * immediately. The call must not block.
     * @see isQuitting()
     */
    virtual void startQuitting();

    /**
     * Checks whether the view is currently quitting.
     * @return true if it is quitting
     * @see startQuitting()
     * @see setStatus()
     */
    virtual bool isQuitting();

    /**
     * @return the host the view is connected to
     */
    virtual QString host();

    /**
     * @return the port the view is connected to
     */
    virtual int port();

    /**
     * Initialize the view (for example by showing configuration
     * dialogs to the user) and start connecting. Should not block
     * without running the event loop (so displaying a dialog is ok).
     * When the view starts connecting the application must call
     * @ref setStatus() with the status Connecting.
     * @return true if successful (so far), false
     *         otherwise
     * @see connected()
     * @see disconnected()
     * @see disconnectedError()
     * @see statusChanged()
     */
    virtual bool start() = 0;

    /**
     * Called when the configuration is changed.
     * The default implementation does nothing.
     */
    virtual void updateConfiguration();

    /**
     * @return screenshot of the view
     */
    virtual QPixmap takeScreenshot();

#ifndef QTONLY
    /**
     * Returns the current host preferences of this view.
     */
    virtual HostPreferences *hostPreferences() = 0;
#endif

    /**
     * Returns the current status of the connection.
     * @return the status of the connection
     * @see setStatus()
     */
    RemoteStatus status();

    /**
     * @return the current url
     */
    QUrl url();

public Q_SLOTS:
    /**
     * Called to enable or disable scaling.
     * Ignored if @ref supportsScaling() is false.
     * The default implementation does nothing.
     * @param scale true to enable, false to disable.
     * @see supportsScaling()
     * @see scaling()
     */
    virtual void enableScaling(bool scale);

    /**
     * Sets scaling factor for the view. If remote view has width R and
     * the window has width W, then scaling factor (float, range 0-1) set the
     * remote view width A to be: A = (R-W)*factor + W. For factor = 0, A=W,
     * so no scalling, for factor=1, A=R.
     *
     * @param factor scaling factor in the range 0-1
     */
    virtual void setScaleFactor(float factor);

    /**
     * Enables/disables the view-only mode.
     * Ignored if @ref supportsScaling() is false.
     * The default implementation does nothing.
     * @param viewOnly true to enable, false to disable.
     * @see supportsScaling()
     * @see viewOnly()
     */
    virtual void setViewOnly(bool viewOnly);

    /**
     * Enables/disables grabbing all possible keys.
     * @param grabAllKeys true to enable, false to disable.
     * Default is false.
     * @see grabAllKeys()
     */
    virtual void setGrabAllKeys(bool grabAllKeys);

    /**
     * Called to let the backend know it when
     * we switch from/to fullscreen.
     * @param on true when switching to fullscreen,
     *           false when switching from fullscreen.
     */
    virtual void switchFullscreen(bool on);

    /**
     * Sends a QKeyEvent to the remote server.
     * @param event the key to send
     */
    virtual void keyEvent(QKeyEvent *event);

    /**
     * Called when the visible place changed so remote
     * view can resize itself.
     *
     * @param w width of the remote view
     * @param h height of the remote view
     */
    virtual void scaleResize(int w, int h);

Q_SIGNALS:
    /**
     * Emitted when the size of the remote screen changes. Also
     * called when the size is known for the first time.
     * @param w the width of the screen
     * @param h the height of the screen
     */
    void framebufferSizeChanged(int w, int h);

    /**
     * Emitted when the view connected successfully.
     */
    void connected();

    /**
     * Emitted when the view disconnected without error.
     */
    void disconnected();

    /**
     * Emitted when the view disconnected with error.
     */
    void disconnectedError();

    /**
     * Emitted when the view has a specific error.
     */
    void errorMessage(const QString &title, const QString &message);

    /**
     * Emitted when the status of the view changed.
     * @param s the new status
     */
    void statusChanged(RemoteView::RemoteStatus s);

    /**
     * Emitted when the password dialog is shown or hidden.
     * @param b true when the dialog is shown, false when it has been hidden
     */
    void showingPasswordDialog(bool b);

    /**
     * Emitted when the mouse on the remote side has been moved.
     * @param x the new x coordinate
     * @param y the new y coordinate
     * @param buttonMask the mask of mouse buttons (bit 0 for first mouse
     *                   button, 1 for second button etc)a
     */
    void mouseStateChanged(int x, int y, int buttonMask);

protected:
    RemoteView(QWidget *parent = nullptr);

    void focusInEvent(QFocusEvent *event) override;
    void focusOutEvent(QFocusEvent *event) override;

    /**
     * The status of the remote view.
     */
    RemoteStatus m_status;

    /**
     * Set the status of the connection.
     * Emits a statusChanged() signal.
     * Note that the states need to be set in a certain order,
     * see @ref RemoteStatus. setStatus() will try to do this
     * transition automatically, so if you are in Connecting
     * and call setStatus(Preparing), setStatus() will
     * emit a Authenticating and then Preparing.
     * If you transition backwards, it will emit a
     * Disconnected before doing the transition.
     * @param s the new status
     */
    virtual void setStatus(RemoteStatus s);

    QCursor localDefaultCursor() const;

    QString m_host;
    int m_port;
    bool m_viewOnly;
    bool m_grabAllKeys;
    bool m_scale;
    bool m_keyboardIsGrabbed;
    QUrl m_url;
    qreal m_factor;

#ifndef QTONLY
    QString readWalletPassword(bool fromUserNameOnly = false);
    void saveWalletPassword(const QString &password, bool fromUserNameOnly = false);
    QString readWalletPasswordForKey(const QString &key);
    void saveWalletPasswordForKey(const QString &key, const QString &password);
    KWallet::Wallet *m_wallet;
#endif

    LocalCursorState m_localCursorState;
};

#endif
