#pragma once
#include "ltsscripttimeline_export.h"

#include <QObject>
#include <QWidget>

namespace LtsScriptTimeline
{
class TrackEntry;
enum class TrackEntryType;
class TrackWidget;
class ScriptTimeline;
class Tools;
class DragHandler;
class ResizeHandler;
class SelectHandler;

LTSSCRIPTTIMELINE_EXPORT QDataStream& operator<<(QDataStream& ds, const TrackEntry& te);
LTSSCRIPTTIMELINE_EXPORT QDataStream& operator>>(QDataStream& ds, TrackEntry& te);
LTSSCRIPTTIMELINE_EXPORT bool isCollision(int start_s, int end_s, int toCompare_start_s, int toCompare_end_s);
LTSSCRIPTTIMELINE_EXPORT bool isCollision2(int startPreview_s, int endPreview_s, const TrackEntry* pTrackEntry);

class LTSSCRIPTTIMELINE_EXPORT TrackContentWidget : public QWidget
{
    Q_OBJECT

  public:
    explicit TrackContentWidget(QWidget* parent = nullptr, bool isFilter = false, Tools* tools = nullptr,
                                int mainTopicId = -1);
    ~TrackContentWidget() override;

    bool addTrackEntry(TrackEntry* te, bool selectTrackEntry);
    void removeTrackEntryByTopicId(TrackEntry* te);

    void selectAll();
    void unselectAll();

    const QVector<TrackEntry*>& getTrackEntries() const
    {
        return m_entryList;
    }

    const QVector<TrackEntry*>& getSelectedEntries() const
    {
        return m_selected;
    }

    void setIndicatorTime(int time);
    void setTrackName(const QString& trackName);
    void deleteSelectedTopics();
    void selectEntry(int topicId);

    void setTopicFilterId(int id)
    {
        m_topicFilterId = id;
    }

    int topicFilterId() const
    {
        return m_topicFilterId;
    }

    void setReadonly(bool readonly);

    void addAllowedType(const TrackEntryType& tet)
    {
        m_allowedTypes.append(tet);
    }

    void addDisallowedType(const TrackEntryType& tet)
    {
        m_disallowedTypes.append(tet);
    }

    void setTrackWidget(TrackWidget* trackWidget);

    void setScriptTimeline(ScriptTimeline* scriptTimeline)
    {
        m_scriptTimeline = scriptTimeline;
    }

    void setTools(Tools* tools);
    void addCorrespondingTrackWidget(TrackContentWidget* pCorrespondingTrackWidget);
    static QString parallelError();

    bool isMultiLineMultiSelectionMode() const
    {
        return m_isMultiLineMultiSelectionMode;
    }

    void setMultiLineMultiSelectionMode(bool active)
    {
        m_isMultiLineMultiSelectionMode = active;
    }

    bool isDragPossible() const
    {
        return (!m_isMultiLineMultiSelectionMode || m_dragPossible);
    }

    void selectEntriesAtPositions(int fromPos, int toPos);
    void forceLocalUnselect();

    static bool checkForParallelTopics(const TrackContentWidget* pTCW,
                                       const QVector<TrackEntry*>& vecPreviewTrackEntries, int dropTime_s,
                                       bool hack = false);
    static bool checkForParallelTopics(const TrackContentWidget* tcw, const QVector<TrackEntry*>& preview,
                                       int dropTime_s, QVector<TrackEntry*>& vecParallelTopics,
                                       bool ignoreSelectedTopics = false, bool hack = false);
    static bool checkForCollisions(const TrackContentWidget* tcw, const QVector<TrackEntry*>& preview, int dropTime_s,
                                   QVector<TrackEntry*>& vecCollisions, bool ignoreSelected = false,
                                   bool ignoreSelfCheck = false);
    static bool checkForCollisions(const TrackContentWidget* pTCW, const QVector<TrackEntry*>& vecPreviewTrackEntries,
                                   int dropTime_s);
    bool checkForCollisionsSimple(const TrackEntry& previewEntry) const;

    QByteArray selectedItemsToData(int dragPosTime = 0, bool calculateFirstTeTime = true);
    static QByteArray itemsToData(const QVector<TrackEntry*>& items, int dragPosTime = 0,
                                  bool calculateFirstTeTime = true);
    static QVector<TrackEntry*> dataToItems(const QByteArray& data, int& offset);
    bool canPasteTopics(const QVector<TrackEntry*>& topics, int offsetTime, int pasteTime) const;
    void forcePasteTopics(const QVector<TrackEntry*>& topics, int offsetTime, int pasteTime);
    bool canMoveAll(int offset) const;
    void forceMoveAll(int offset);
    bool setDescriptionForSelected();

    static QString mime;

    void dragEnd();
    void setDragPossible(bool possible);
    void dragLeave();
    bool dragEnter(const QByteArray& itemData);
    bool dragMove(int pos);
    bool dragDrop(int pos);
    void clearDrag();
    int getDropPos() const;

    TrackWidget* trackWidget()
    {
        return m_trackWidget;
    }

    TrackEntry* trackEntryAtPos(int x) const;

    void keyPressEvent(QKeyEvent* event) override;

  protected:
    void paintEvent(QPaintEvent* event) override;
    void dragEnterEvent(QDragEnterEvent* event) override;
    void dragLeaveEvent(QDragLeaveEvent* event) override;
    void dropEvent(QDropEvent* event) override;
    void dragMoveEvent(QDragMoveEvent* event) override;
    void resizeEvent(QResizeEvent* event) override;
    void mousePressEvent(QMouseEvent* event) override;
    void mouseMoveEvent(QMouseEvent* event) override;
    void mouseReleaseEvent(QMouseEvent* event) override;
    void mouseDoubleClickEvent(QMouseEvent* event) override;

  private:
    TrackEntry* getTrackEntryOnPos(QPoint globalPos);
    bool allowedByType(const TrackEntry* te) const;
    TrackEntry* getParentTopicOfFilter(TrackEntry* filterTe) const;

    int m_topicFilterId = -1;

    friend class SelectHandler;
    SelectHandler* m_selectHandler;

    friend class ResizeHandler;
    ResizeHandler* m_resizeHandler;

    friend class DragHandler;
    DragHandler* m_dragHandler;

    void selectEntry(TrackEntry* te);
    void addFilterType(const TrackEntryType& tet);
    void unselect();
    void moveAll(int offset);
    bool handleResize(int cursorTime, bool leftButton);
    bool handleDrag(int cursorTime, bool leftButton);
    void cancelResize();
    TrackEntry* getTrackEntryAt(int clickedTime);
    void clearPreview();

    int dragPos() const
    {
        return m_dragPos;
    }

    int m_dragOffsetTime;
    int m_dragPos;
    QVector<TrackEntry*> m_entryList;
    QVector<TrackEntry*> m_selected;

    TrackEntry* m_mainSelected;
    QVector<TrackEntry*> m_preview;
    int m_width;
    bool m_cursorSet;
    int m_oldEntryLength;
    bool m_unselectAllImmune;
    int m_indicatorTime;
    QString m_trackName;
    QVector<TrackEntryType> m_allowedTypes;
    QVector<TrackEntryType> m_disallowedTypes;
    bool m_isFilter;
    bool m_readonly;
    TrackWidget* m_trackWidget;
    ScriptTimeline* m_scriptTimeline;
    Tools* m_tools;
    QVector<TrackContentWidget*> m_tcwCorresponding;
    bool m_isMultiLineMultiSelectionMode;
    bool m_multiLineMultiSelectionOkay;
    bool m_dragPossible;
    bool m_moveValid;
    int m_mainTopicId;

  signals:
    void signalUnselectAll();
    void signalTrackEntrySelectionChanged(TrackEntry*);
    void signalChangesMade();
    void signalTrackEntryAdded(TrackEntry* te);
    void signalTrackEntryDeleted(const int topicId);
    void signalEditEntry(const int topicId);
    void signalMultiLineMultiSelectionFailed();
    void signalMultiLineMultiSelectionOkay();
    void signalMultiLineMultiSelectionDone(int dropPos);
    void signalMultiLineMultiSelectionStart(int dragPosTime);
    void signalMultiLineMultiSelectionMove(int x);
    void signalStartRubberband(QPoint pos);
    void signalStopRubberband();
    void signalEscapeRubberband();
    void signalModifyRubberband();
    void signalSelectAllGlobal();
    void signalCopyTopics();
    void signalPasteTopics();
    void signalCutTopics();
    void signalDeleteSelectedTopics();
    void signalSave();
    void signalMoveAll(int offset);
    void signalScroll(int incr);
};

} // namespace LtsScriptTimeline