/****************************************************************************
 *   Copyright (c) 2020 Zheng Lei (realthunder) <realthunder.dev@gmail.com> *
 *                                                                          *
 *   This file is part of the FreeCAD CAx development system.               *
 *                                                                          *
 *   This library is free software; you can redistribute it and/or          *
 *   modify it under the terms of the GNU Library General Public            *
 *   License as published by the Free Software Foundation; either           *
 *   version 2 of the License, or (at your option) any later version.       *
 *                                                                          *
 *   This library  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 Library General Public License for more details.                   *
 *                                                                          *
 *   You should have received a copy of the GNU Library General Public      *
 *   License along with this library; see the file COPYING.LIB. If not,     *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,          *
 *   Suite 330, Boston, MA  02111-1307, USA                                 *
 *                                                                          *
 ****************************************************************************/

#ifndef FC_OVERLAYWIDGETS_H
#define FC_OVERLAYWIDGETS_H

#include <QTabWidget>
#include <QTimer>
#include <QTime>
#include <QAction>
#include <QToolButton>
#include <QGraphicsEffect>
#include <QImage>
#include <QDockWidget>
#include <QSplitter>
#include <QMenu>

#include <Base/Parameter.h>

#include "OverlayManager.h"

class QPropertyAnimation;
class QLayoutItem;

namespace Gui {

class OverlayTabWidget;
class OverlayTitleBar;
class OverlaySplitterHandle;
class OverlaySizeGrip;
class OverlayProxyWidget;
class OverlayGraphicsEffect;
class OverlayDragFrame;

/// Tab widget to contain dock widgets in overlay mode
class OverlayTabWidget: public QTabWidget
{
    Q_OBJECT

    /** @name Graphics effect properties for customization through stylesheet */
    //@{
    Q_PROPERTY(QColor effectColor READ effectColor WRITE setEffectColor) // clazy:exclude=qproperty-without-notify
    Q_PROPERTY(int effectWidth READ effectWidth WRITE setEffectWidth) // clazy:exclude=qproperty-without-notify
    Q_PROPERTY(int effectHeight READ effectHeight WRITE setEffectHeight) // clazy:exclude=qproperty-without-notify
    Q_PROPERTY(qreal effectOffsetX READ effectOffsetX WRITE setEffectOffsetX) // clazy:exclude=qproperty-without-notify
    Q_PROPERTY(qreal effectOffsetY READ effectOffsetY WRITE setEffectOffsetY) // clazy:exclude=qproperty-without-notify
    Q_PROPERTY(qreal effectBlurRadius READ effectBlurRadius WRITE setEffectBlurRadius) // clazy:exclude=qproperty-without-notify
    Q_PROPERTY(bool enableEffect READ effectEnabled WRITE setEffectEnabled) // clazy:exclude=qproperty-without-notify
    Q_PROPERTY(qreal animation READ animation WRITE setAnimation) // clazy:exclude=qproperty-without-notify
    //@}

public:
    /** Constructor
     * @param parent: parent widget
     * @param pos: docking position
     */
    OverlayTabWidget(QWidget *parent, Qt::DockWidgetArea pos);

    /// Enable/disable overlay mode for this tab widget
    void setOverlayMode(bool enable);

    /// Update splitter handle according to overlay status
    void updateSplitterHandles();

    /** Add a dock widget
     * @param widget: dock widget to be added
     * @param title: title for the dock widget
     */
    void addWidget(QDockWidget *widget, const QString &title);

    /** Remove a dock widget
     * @param widget: dock widget to be removed
     * @param last: optional non overlaid widget. If given, then the removed
     * dock widget will be tabified together with this one.
     */
    void removeWidget(QDockWidget *widget, QDockWidget *last=nullptr);

    /** Set the current dock widget
     * @param widget: an overlay dock widget
     *
     * All other dock widget in the same tab widget will be collapsed, and the
     * give widget will take the whole space. This is actually handled inside
     * onCurrentChanged().
     */
    void setCurrent(QDockWidget *widget);

    /** Handle ESC key press
     *
     * If the this overlay tab widget is hidden and its hint/tabs are visible,
     * pressing ESC will hide the hint and tabs.
     *
     * If this overlay tab widget is visible and the current mouse cursor is on
     * top of the tab widget title bar or any of its split handler, then
     * pressing ESC will hide the title bar and split handler.
     */
    bool onEscape();

    /// Enable/disable transparent background mode
    void setTransparent(bool enable);

    /// Check if transparent background mode is active
    bool isTransparent() const;

    /// Auto mode to show or hide the tab widget
    enum class AutoMode {
        /// No auto show or hide
        NoAutoMode,
        /// Auto hide tab widget on lost of focus
        AutoHide,
        /// Auto show tab widget on any new editing task
        EditShow,
        /// Auto hide tab widget on any new editing task
        EditHide,
        /// Auto show on any task panel e.g. suggestive task panel in PartDesign
        TaskShow,
    };
    /// Set auto mode to show or hide the tab widget
    void setAutoMode(AutoMode mode);
    /// Get current auto mode
    AutoMode getAutoMode() const { return autoMode; }

    /// Touch the tab widget to trigger saving of settings
    void touch() {touched = true;}
    /// Check if the tab widget settings need to be saved
    bool isTouched() const {return touched;}

    /// Set geometry of this tab widget
    void setRect(QRect rect);

    /// Get the geometry of this tab widget
    const QRect &getRect();

    /// Overlay query option
    enum class QueryOption {
        /// Report the current overlay status
        QueryOverlay,
        /// Report true if transparency status has been changed
        TransparencyChanged,
        /// Report true if transparency status has not been changed
        TransparencyNotChanged,
    };
    /// Query overlay status
    bool isOverlaid(QueryOption option=QueryOption::QueryOverlay) const;
    /** Check if needs to auto hide this tab widget
     *
     * Besides when auto hide mode is activated by user, the tab widget will
     * also auto hide if the current view does not have panning capability
     * (queried through MdiView::hasMsg("CanPan")). The user can explicitly
     * disable this auto hide if no pan by setting user parameter
     * View/DockOverlayAutoView, or preference option Display -> UI -> Auto
     * hide in non 3D view.
     */
    bool checkAutoHide() const;
    /** Obtain geometry of auto hiding tab widget
     * @param rect: output geometry of the tab widget
     * @return Return true if the tab widget should be auto hiding
     */
    bool getAutoHideRect(QRect &rect) const;
    /// Handler of various actions exposed as buttons on title bar
    void onAction(QAction *);
    /// Sync relevant actions status with the current auto mode
    void syncAutoMode();

    /** Set tab widget position offset
     * @param ofs: the offset size. Width is the x offset for top and bottom
     * docking tab widget, and y offset for left and right ones. Height is the y
     * offset for top and bottom, and x offset for left and right ones.
     */
    void setOffset(const QSize &ofs);
    /// Get the tab widget position offset
    const QSize &getOffset() const {return offset;}

    /** Set tab widget size delta
     * @param delta: the size delta. For left and right widget, the delta is
     * added to the height of the tab widget. For top and bottom widget, it is
     * added to the width.
     */
    void setSizeDelta(int delta);
    /// Get the tab widget size delta
    int getSizeDelta() const {return sizeDelta;}

    /// Obtain the proxy widget
    OverlayProxyWidget *getProxyWidget() {return proxyWidget;}

    /// Obtain the current dock widget
    QDockWidget *currentDockWidget() const;
    /// Obtain the dock widget by index
    QDockWidget *dockWidget(int index) const;
    /// Obtain the index of a given dock widget
    int dockWidgetIndex(QDockWidget *) const;

    /// Set the title bar for this tab widget
    void setTitleBar(QWidget *);

    /// Get the splitter
    QSplitter *getSplitter() const {return splitter;}
    /// Get the title bar
    QWidget *getTitleBar() const {return titleBar;}

    /// Get the docking position of this tab widget
    Qt::DockWidgetArea getDockArea() const {return dockArea;}

    /// Get delay time for animated reveal
    const QTime &getRevealTime() const {return revealTime;}
    /// Set delay time for animated reveal
    void setRevealTime(const QTime &time);

    /// Restore state
    void restore(ParameterGrp::handle handle);
    /// Save tab orders and positions
    void saveTabs();

    /** @name Graphics effect properties setters and getters */
    //@{
    QColor effectColor() const;
    void setEffectColor(const QColor&);
    int effectWidth() const;
    void setEffectWidth(int);
    int effectHeight() const;
    void setEffectHeight(int);
    qreal effectOffsetX() const;
    void setEffectOffsetX(qreal);
    qreal effectOffsetY() const;
    void setEffectOffsetY(qreal);
    qreal effectBlurRadius() const;
    void setEffectBlurRadius(qreal);
    bool effectEnabled() const;
    void setEffectEnabled(bool);
    qreal animation() const {return _animation;}
    void setAnimation(qreal);
    //@}

    /// Schedule for repaint
    void scheduleRepaint();

    /** Return the pixel alpha value at the give position
     * @param pos: position
     * @param radiusScale: scale of the radius to check for alpha.
     *
     * @return Returns the largest alpha value of a circular area of 'pos' as
     * center and  radius as defined by user parameter
     * View/DockOverlayAlphaRadius. May return -1 if out side of the widget, or
     * zero if transparent.
     */
    int testAlpha(const QPoint &pos, int radiusScale);

    /// Start animated showing
    void startShow();
    /// Start animated hiding
    void startHide();

    /// Internal state of the tab widget
    enum class State {
        /// The tab widget is showing
        Showing,
        /// Normal visible state
        Normal,
        /// Visual hint is visible
        Hint,
        /// Hint is hidden by user after pressing ESC
        HintHidden,
        /// The tab widget is explicitly hidden by user
        Hidden,
    };
    /// Set state of the tab widget
    void setState(State);
    /// Get the state of the widget
    State getState() const {return _state;}

    /// Handle splitter resize
    void onSplitterResize(int index);

    /// Check if the tab widget is saving its state
    bool isSaving() const {return _saving;}

    /// Helper function to create title bar for a dock widget
    static QWidget *createTitleButton(QAction *action, int size);
    /// Helper function to prepare a widget as a title widget
    static QLayoutItem *prepareTitleWidget(QWidget *widget, const QList<QAction*> &actions);

protected:
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
    void enterEvent(QEvent* ev) override;
#else
    void enterEvent(QEnterEvent* ev) override;
#endif
    void leaveEvent(QEvent* ev) override;
    void changeEvent(QEvent* ev) override;
    void resizeEvent(QResizeEvent* ev) override;
    void paintEvent(QPaintEvent* ev) override;
    bool event(QEvent* ev) override;
    bool eventFilter(QObject* obj, QEvent* ev) override;

    void retranslate();
    void refreshIcons();

    /// Overlay mode options
    enum class OverlayOption {
        /// Enable overlay
        Enable,
        /// Disable overlay
        Disable,
        /// Enable overlay and show tab bar
        ShowTab,
    };
    /// Toggle overlay mode for a given widget
    void setOverlayMode(QWidget *widget, OverlayOption option);
    /// Helper function to set overlay mode for a give widget
    static void _setOverlayMode(QWidget *widget, OverlayOption option);

protected:
    void onCurrentChanged(int index);
    void onTabMoved(int from, int to);
    void onRepaint();
    void onAnimationStateChanged();
    void setupLayout();
    void onSizeGripMove(const QPoint &);

private:
    friend class OverlayProxyWidget;
    friend class OverlayTitleBar;
    friend class OverlayManager;
    friend class OverlayManager::Private;
    friend class OverlaySplitterHandle;
    friend class OverlaySizeGrip;

    QSize offset;
    int sizeDelta = 0;
    QRect rectOverlay;
    OverlayProxyWidget *proxyWidget;
    QSplitter *splitter = nullptr;
    QWidget *titleBar = nullptr;
    QAction actNoAutoMode;
    QAction actAutoHide;
    QAction actEditHide;
    QAction actEditShow;
    QAction actTaskShow;
    QAction actAutoMode;
    QMenu autoModeMenu;
    QAction actTransparent;
    QAction actIncrease;
    QAction actDecrease;
    QAction actOverlay;
    QTimer timer;
    QTimer repaintTimer;
    AutoMode autoMode = AutoMode::NoAutoMode;
    bool repainting = false;
    bool overlaid = false;
    bool currentTransparent = false;
    bool touched = false;
    bool busy = false;
    Qt::DockWidgetArea dockArea;
    int tabSize = 0;
    QTime revealTime;
    ParameterGrp::handle hGrp;

    OverlayGraphicsEffect *_graphicsEffect = nullptr;
    OverlayGraphicsEffect *_graphicsEffectTab = nullptr;
    bool _effectEnabled = false;

    QImage _image;
    qreal _imageScale;

    qreal _animation = 0;
    QPropertyAnimation *_animator = nullptr;

    State _state = State::Normal;

    std::map<QDockWidget *, int> _sizemap;
    bool _saving = false;

    // NOLINTBEGIN
    static OverlayDragFrame *_DragFrame;
    static QDockWidget *_DragFloating;
    static QWidget *_Dragging;
    static OverlayTabWidget *_LeftOverlay;
    static OverlayTabWidget *_RightOverlay;
    static OverlayTabWidget *_TopOverlay;
    static OverlayTabWidget *_BottomOverlay;
    // NOLINTEND
};

/// A translucent frame as a visual indicator when dragging a dock widget
class OverlayDragFrame: public QWidget
{
    Q_OBJECT
public:
    explicit OverlayDragFrame(QWidget * parent);
    QSize sizeHint() const override;
    QSize minimumSizeHint() const override;

protected:
    void paintEvent(QPaintEvent* ev) override;
};

/// Title bar for OverlayTabWidget
class OverlayTitleBar: public QWidget
{
    Q_OBJECT
public:
    explicit OverlayTitleBar(QWidget * parent);
    void setTitleItem(QLayoutItem *);
    void endDrag();

protected:
    void mouseMoveEvent(QMouseEvent* ev) override;
    void mousePressEvent(QMouseEvent* ev) override;
    void mouseReleaseEvent(QMouseEvent* ev) override;
    void paintEvent(QPaintEvent* ev) override;
    void keyPressEvent(QKeyEvent* ke) override;
    void timerEvent(QTimerEvent* te) override;

private:
    QPoint dragOffset;
    QSize dragSize;
    QLayoutItem *titleItem = nullptr;
    QColor textcolor;
    int timerId = 0;
    bool blink = false;
    bool mouseMovePending = false;
    bool ignoreMouse = false;
};

/// Size grip for title bar and split handler of OverlayTabWidget
class OverlaySizeGrip: public QWidget
{
    Q_OBJECT
public:
    OverlaySizeGrip(QWidget *parent, bool vertical);

Q_SIGNALS:
    void dragMove(const QPoint &globalPos);

protected:
    void paintEvent(QPaintEvent* ev) override;
    void mouseMoveEvent(QMouseEvent* ev) override;
    void mousePressEvent(QMouseEvent* ev) override;
    void mouseReleaseEvent(QMouseEvent* ev) override;
    const QPixmap &pixmap() const;

private:
    bool vertical;
};

/// Splitter for OverlayTabWidget
class OverlaySplitter : public QSplitter
{
    Q_OBJECT
public:
    explicit OverlaySplitter(QWidget *parent);
    void retranslate();

protected:
    QSplitterHandle *createHandle() override;
};


/// Splitter handle for dragging the splitter
class OverlaySplitterHandle : public QSplitterHandle
{
    Q_OBJECT
public:
    friend class OverlaySplitter;

    OverlaySplitterHandle(Qt::Orientation, QSplitter *parent);
    void setTitleItem(QLayoutItem *);
    void retranslate();
    void refreshIcons();
    QDockWidget * dockWidget();

    void showTitle(bool enable);
    bool isShowing() const { return _showTitle; }
    void endDrag();

protected:
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
    void enterEvent(QEvent* ev) override;
#else
    void enterEvent(QEnterEvent* ev) override;
#endif
    void showEvent(QShowEvent* ev) override;
    void leaveEvent(QEvent* ev) override;
    void paintEvent(QPaintEvent* ev) override;
    void changeEvent(QEvent* ev) override;
    void mouseMoveEvent(QMouseEvent* ev) override;
    void mousePressEvent(QMouseEvent* ev) override;
    void mouseReleaseEvent(QMouseEvent* ev) override;
    void keyPressEvent(QKeyEvent* ev) override;
    QSize sizeHint() const override;

protected:
    void onAction();
    void onTimer();

private:
    QLayoutItem * titleItem = nullptr;
    int idx = -1;
    QAction actFloat;
    bool _showTitle = true;
    int dragging = 0;
    QPoint dragOffset;
    QSize dragSize;
    QTimer timer;
};


/// Tool button for the title bar of the OverlayTabWidget
class OverlayToolButton: public QToolButton
{
    Q_OBJECT
public:
    explicit OverlayToolButton(QWidget *parent);
};

/** Class for handling visual hint for bringing back hidden overlay dock widget
 *
 * The proxy widget is transparent except a customizable rectangle area with a
 * selectable color shown as the visual hint. The hint is normally hidden, and
 * is shown only if the mouse hovers within the widget. When the hint area is
 * clicked, it will bring back hidden overlay dock panel. Note that the proxy
 * widget itself is mouse transparent as well, meaning that it will not receive
 * any mouse event. It is handled in the OverlayManager event filter.
 */
class OverlayProxyWidget: public QWidget
{
    Q_OBJECT

    Q_PROPERTY(QBrush hintColor READ hintColor WRITE setHintColor) // clazy:exclude=qproperty-without-notify

public:
    explicit OverlayProxyWidget(OverlayTabWidget *);

    OverlayTabWidget *getOwner() const {return owner;}

    /// For representing hit region
    enum class HitTest {
        /// Not hitting
        HitNone = 0,
        /// Hitting the proxy widget size but not within the visible hint area.
        HitOuter = 1,
        /// Hitting the visible hint area.
        HitInner = 2,
    };
    /** Mouse cursor hit test
     * @param pos: cursor position
     * @param delay: Whether to delay showing hint on mouse hit
     */
    HitTest hitTest(const QPoint &pos, bool delay=true);

    /// Check if the visual hint is showing
    bool isActivated() const;

    QBrush hintColor() const;
    void setHintColor(const QBrush &);

    QRect getRect() const;

    void onMousePress();

protected:
#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
    void enterEvent(QEvent* ev) override;
#else
    void enterEvent(QEnterEvent* ev) override;
#endif
    void hideEvent(QHideEvent* ev) override;
    void paintEvent(QPaintEvent* ev) override;

protected:
    void onTimer();

private:
    OverlayTabWidget* owner;
    bool drawLine = false;
    int dockArea;
    QTimer timer;
    QBrush _hintColor;
};

/** Graphic effects for drawing shadow and outline of text on transparent background
 *
 * Modified from https://stackoverflow.com/a/23752747
 */
class OverlayGraphicsEffect: public QGraphicsEffect
{
    Q_OBJECT
public:
    explicit OverlayGraphicsEffect(QObject *parent);

    void draw(QPainter* painter) override;
    QRectF boundingRectFor(const QRectF& rect) const override;

    inline void setSize(const QSize &size)
        { if(_size!=size){_size = size; updateBoundingRect(); } }

    inline QSize size() const { return _size; }

    inline void setOffset(const QPointF &offset)
        { if(_offset!=offset) {_offset = offset; updateBoundingRect(); } }

    inline QPointF offset() const { return _offset; }

    inline void setBlurRadius(qreal blurRadius)
        { if(_blurRadius!=blurRadius) {_blurRadius = blurRadius; updateBoundingRect();} }

    inline qreal blurRadius() const { return _blurRadius; }

    inline void setColor(const QColor& color) { _color = color; }
    inline QColor color() const { return _color; }

    inline bool enabled() const {return _enabled;}
    inline void setEnabled(bool enabled)
        { if(_enabled!=enabled) {_enabled = enabled; updateBoundingRect();} }

private:
    bool _enabled;
    QSize  _size;
    qreal  _blurRadius;
    QColor _color;
    QPointF _offset;
};

} // namespace Gui

#endif // FC_OVERLAYWIDGETS_H