#pragma once

#include "common/FlagsEnum.hpp"
#include "messages/layouts/MessageLayoutContext.hpp"
#include "messages/LimitedQueue.hpp"
#include "messages/LimitedQueueSnapshot.hpp"
#include "messages/Selection.hpp"
#include "util/ThreadGuard.hpp"
#include "widgets/BaseWidget.hpp"
#include "widgets/TooltipWidget.hpp"

#include <pajlada/signals/signal.hpp>
#include <QMenu>
#include <QPaintEvent>
#include <QScroller>
#include <QTimer>
#include <QVariantAnimation>
#include <QWheelEvent>
#include <QWidget>

#include <unordered_map>
#include <unordered_set>

namespace chatterino {
enum class HighlightState;

class Channel;
using ChannelPtr = std::shared_ptr<Channel>;

struct Message;
using MessagePtr = std::shared_ptr<const Message>;

enum class MessageFlag : int64_t;
using MessageFlags = FlagsEnum<MessageFlag>;

class MessageLayout;
using MessageLayoutPtr = std::shared_ptr<MessageLayout>;

enum class MessageElementFlag : int64_t;
using MessageElementFlags = FlagsEnum<MessageElementFlag>;

class Scrollbar;
class EffectLabel;
struct Link;
class MessageLayoutElement;
class Split;
class FilterSet;
using FilterSetPtr = std::shared_ptr<FilterSet>;

enum class PauseReason {
    Mouse,
    Selection,
    DoubleClick,
    KeyboardModifier,
};

enum class FromTwitchLinkOpenChannelIn {
    Split,
    Tab,
    BrowserPlayer,
    Streamlink,
};

using SteadyClock = std::chrono::steady_clock;

class ChannelView final : public BaseWidget
{
    Q_OBJECT

public:
    enum class Context {
        None,
        UserCard,
        ReplyThread,
        Search,
    };

    /// Creates a channel view without a split.
    /// In such a view, usercards and reply-threads can't be opened.
    ///
    /// @param parent The parent of this widget. Can be `nullptr`.
    /// @param context The context in which this view is shown (e.g. as a usercard).
    /// @param messagesLimit The maximum amount of messages this view will display.
    explicit ChannelView(QWidget *parent, Context context = Context::None,
                         size_t messagesLimit = 1000);

    /// Creates a channel view in a split.
    ///
    /// @param parent The parent of this widget.
    /// @param split The split containing this widget.
    ///              @a split must be in the widget tree of @a parent.
    /// @param context The context in which this view is shown (e.g. as a usercard).
    /// @param messagesLimit The maximum amount of messages this view will display.
    explicit ChannelView(QWidget *parent, Split *split,
                         Context context = Context::None,
                         size_t messagesLimit = 1000);

    void queueUpdate();
    void queueUpdate(const QRect &area);
    Scrollbar &getScrollBar();

    QString getSelectedText();
    bool hasSelection();
    void clearSelection();
    /**
     * Copies the currently selected text to the users clipboard.
     *
     * @see ::getSelectedText()
     */
    void copySelectedText();

    void setEnableScrollingToBottom(bool);
    bool getEnableScrollingToBottom() const;
    void setOverrideFlags(std::optional<MessageElementFlags> value);
    const std::optional<MessageElementFlags> &getOverrideFlags() const;
    void updateLastReadMessage();

    /**
     * Attempts to scroll to a message in this channel.
     * @return <code>true</code> if the message was found and highlighted.
     */
    bool scrollToMessage(const MessagePtr &message);
    /**
     * Attempts to scroll to a message id in this channel.
     * @return <code>true</code> if the message was found and highlighted.
     */
    bool scrollToMessageId(const QString &id);

    /// Pausing
    bool pausable() const;
    void setPausable(bool value);
    bool paused() const;
    void pause(PauseReason reason,
               std::optional<uint32_t> msecs = std::nullopt);
    void unpause(PauseReason reason);

    MessageElementFlags getFlags() const;

    ChannelPtr channel();
    void setChannel(const ChannelPtr &underlyingChannel);

    void setFilters(const QList<QUuid> &ids);
    QList<QUuid> getFilterIds() const;
    FilterSetPtr getFilterSet() const;

    ChannelPtr sourceChannel() const;
    void setSourceChannel(ChannelPtr sourceChannel);
    bool hasSourceChannel() const;

    LimitedQueueSnapshot<MessageLayoutPtr> &getMessagesSnapshot();

    void queueLayout();
    void invalidateBuffers();

    void clearMessages();

    Context getContext() const;

    /**
     * @brief Creates and shows a UserInfoPopup dialog
     *
     * @param userName The login name of the user
     * @param alternativePopoutChannel Optional parameter containing the channel name to use for context
     **/
    void showUserInfoPopup(const QString &userName,
                           QString alternativePopoutChannel = QString());

    /**
     * @brief This method is meant to be used when filtering out channels.
     *        It <b>must</b> return true if a message belongs in this channel.
     *        It <b>might</b> return true if a message doesn't belong in this channel.
     */
    bool mayContainMessage(const MessagePtr &message);

    pajlada::Signals::Signal<QMouseEvent *> mouseDown;
    pajlada::Signals::NoArgSignal selectionChanged;
    pajlada::Signals::Signal<HighlightState> tabHighlightRequested;
    pajlada::Signals::NoArgSignal liveStatusChanged;
    pajlada::Signals::Signal<const Link &> linkClicked;
    pajlada::Signals::Signal<QString, FromTwitchLinkOpenChannelIn>
        openChannelIn;

protected:
    void themeChangedEvent() override;
    void scaleChangedEvent(float scale) override;

    void resizeEvent(QResizeEvent * /*event*/) override;

    void paintEvent(QPaintEvent * /*event*/) override;
    void wheelEvent(QWheelEvent *event) override;

#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    void enterEvent(QEnterEvent * /*event*/) override;
#else
    void enterEvent(QEvent * /*event*/) override;
#endif
    void leaveEvent(QEvent * /*event*/) override;

    void mouseMoveEvent(QMouseEvent *event) override;
    void mousePressEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
    void mouseDoubleClickEvent(QMouseEvent *event) override;

    void hideEvent(QHideEvent * /*event*/) override;
    void showEvent(QShowEvent *event) override;

    void handleLinkClick(QMouseEvent *event, const Link &link,
                         MessageLayout *layout);

    bool tryGetMessageAt(QPoint p, std::shared_ptr<MessageLayout> &message,
                         QPoint &relativePos, int &index);

private:
    struct InternalCtor {
    };

    ChannelView(InternalCtor tag, QWidget *parent, Split *split,
                Context context, size_t messagesLimit);

    void initializeLayout();
    void initializeScrollbar();
    void initializeSignals();

    void messageAppended(MessagePtr &message,
                         std::optional<MessageFlags> overridingFlags);
    void messageAddedAtStart(std::vector<MessagePtr> &messages);
    void messageRemoveFromStart(MessagePtr &message);
    void messageReplaced(size_t index, MessagePtr &replacement);
    void messagesUpdated();

    void performLayout(bool causedByScrollbar = false,
                       bool causedByShow = false);
    void layoutVisibleMessages(
        const LimitedQueueSnapshot<MessageLayoutPtr> &messages);
    void updateScrollbar(const LimitedQueueSnapshot<MessageLayoutPtr> &messages,
                         bool causedByScrollbar, bool causedByShow);

    void drawMessages(QPainter &painter, const QRect &area);
    void setSelection(const SelectionItem &start, const SelectionItem &end);
    void setSelection(const Selection &newSelection);
    void selectWholeMessage(MessageLayout *layout, int &messageIndex);

    void handleMouseClick(QMouseEvent *event,
                          const MessageLayoutElement *hoveredElement,
                          MessageLayoutPtr layout);
    void addContextMenuItems(const MessageLayoutElement *hoveredElement,
                             MessageLayoutPtr layout, QMouseEvent *event);
    void addMessageContextMenuItems(QMenu *menu,
                                    const MessageLayoutPtr &layout);
    void addTwitchLinkContextMenuItems(
        QMenu *menu, const MessageLayoutElement *hoveredElement);
    void addCommandExecutionContextMenuItems(QMenu *menu,
                                             const MessageLayoutPtr &layout);

    int getLayoutWidth() const;
    void updatePauses();
    void unpaused();

    void enableScrolling(const QPointF &scrollStart);
    void disableScrolling();

    /**
     * Scrolls to a message layout that must be from this view.
     *
     * @param layout Must be from this channel.
     * @param messageIdx Must be an index into this channel.
     */
    void scrollToMessageLayout(MessageLayout *layout, size_t messageIdx);

    void setInputReply(const MessagePtr &message);
    void showReplyThreadPopup(const MessagePtr &message);
    bool canReplyToMessages() const;

    bool layoutQueued_ = false;
    bool bufferInvalidationQueued_ = false;

    bool lastMessageHasAlternateBackground_ = false;
    bool lastMessageHasAlternateBackgroundReverse_ = true;

    /// Tracks the area of animated elements in the last full repaint.
    /// If this is empty (QRect::isEmpty()), no animated element is shown.
    QRect animationArea_;

    bool pausable_ = false;
    QTimer pauseTimer_;
    std::unordered_map<PauseReason, std::optional<SteadyClock::time_point>>
        pauses_;
    std::optional<SteadyClock::time_point> pauseEnd_;
    int pauseScrollMinimumOffset_ = 0;
    int pauseScrollMaximumOffset_ = 0;
    // Keeps track how many message indices we need to offset the selection when we resume scrolling
    uint32_t pauseSelectionOffset_ = 0;

    std::optional<MessageElementFlags> overrideFlags_;
    MessageLayoutPtr lastReadMessage_;

    ThreadGuard snapshotGuard_;
    LimitedQueueSnapshot<MessageLayoutPtr> snapshot_;

    ChannelPtr channel_ = nullptr;
    ChannelPtr underlyingChannel_ = nullptr;
    ChannelPtr sourceChannel_ = nullptr;
    Split *split_;

    Scrollbar *scrollBar_;
    EffectLabel *goToBottom_{};
    bool showScrollBar_ = false;

    FilterSetPtr channelFilters_;

    // Returns true if message should be included
    bool shouldIncludeMessage(const MessagePtr &m) const;

    // Returns whether the scrollbar should have highlights
    bool showScrollbarHighlights() const;

    // This variable can be used to decide whether or not we should render the
    // "Show latest messages" button
    bool showingLatestMessages_ = true;
    bool enableScrollingToBottom_ = true;

    bool onlyUpdateEmotes_ = false;

    // Mouse event variables
    bool isLeftMouseDown_ = false;
    bool isRightMouseDown_ = false;
    bool isDoubleClick_ = false;
    QPointF lastLeftPressPosition_;
    QPointF lastRightPressPosition_;
    QPointF lastDoubleClickPosition_;
    QTimer clickTimer_;

    bool isScrolling_ = false;
    QPointF lastMiddlePressPosition_;
    QPointF currentMousePosition_;
    QTimer scrollTimer_;

    // We're only interested in the pointer, not the contents
    MessageLayout *highlightedMessage_ = nullptr;
    QVariantAnimation highlightAnimation_;
    void setupHighlightAnimationColors();

    struct {
        QCursor neutral;
        QCursor up;
        QCursor down;
    } cursors_;

    Selection selection_;
    Selection doubleClickSelection_;

    const Context context_;

    LimitedQueue<MessageLayoutPtr> messages_;

    pajlada::Signals::SignalHolder signalHolder_;

    // channelConnections_ will be cleared when the underlying channel of the channelview changes
    pajlada::Signals::SignalHolder channelConnections_;

    std::unordered_set<std::shared_ptr<MessageLayout>> messagesOnScreen_;

    MessageColors messageColors_;
    MessagePreferences messagePreferences_;

    void scrollUpdateRequested();

    TooltipWidget *const tooltipWidget_{};
};

}  // namespace chatterino