#pragma once

#include "timeline_view_drag_handler.h"
#include "timeline_view_resize_handler.h"
#include "timeline_view_selection_handler.h"
#include "timeline_view_track_handler.h"
#include "timeline_header_view.h"
#include "timeline_model.h"

#include <LtsTimeline/ltstimeline_export.h>

#include <functional>

#include <QLabel>
#include <QTreeView>


class QAbstractProxyModel;


namespace LtsTimeline
{

class TimelineViewDragHandler;
class TimelineViewResizeHandler;
class TimelineViewSelectHandler;
class TimelineViewTrackHandler;
class TimelineWidget;


class LTSTIMELINE_EXPORT TimelineView : public QTreeView
{
  Q_OBJECT

  friend class ItemDelegate;
  friend class TimelineHeaderView;
  friend class TimelineViewDragHandler;
  friend class TimelineViewResizeHandler;
  friend class TimelineViewSelectHandler;
  friend class TimelineViewTrackHandler;
  friend class TimelineWidget;

public:
  static const int s_textHeight;

  

  explicit TimelineView(QWidget *parent = nullptr);

  TimelineHeaderView *header() { return m_header; }
  void setHeader(QHeaderView *header);

  QAbstractItemModel *model() { return m_model; }
  TimelineModel *timelineModel() { return m_timelineModel; }
  void setModel(QAbstractItemModel *model) override;

  QAbstractProxyModel *proxyModel() { return m_proxyModel; }
  void setProxyModel(QAbstractProxyModel *proxy) noexcept(false);

  void setItemDelegate(QAbstractItemDelegate *delegate);
  ItemDelegate *itemDelegate() const { return m_delegate; }

  ZoomFactor zoomFactor() const { return m_zoomFactor; }
  

  void setZoomFactor(ZoomFactor zoomFactor);

  ZoomFactor minimumZoomFactor() const { return m_minZoomFactor; }
  void setMinimumZoomFactor(ZoomFactor zoomFactor);

  ZoomFactor maximumZoomFactor() const { return m_maxZoomFactor; }
  void setMaximumZoomFactor(ZoomFactor zoomFactor);

  ZoomFactor upperZoomFactor() const { return m_upperZoomFactor; }

  qint64 startTime() const { return m_startTime; }
  void setStartTime(qint64 time);

  qint64 currentTime() const { return m_currentTime; }
  void setCurrentTime(qint64 time);

  qint64 endTime() const { return m_startTime + m_duration; }
  void setEndTime(qint64 time);

  int duration() const { return m_duration; }
  void setDuration(int duration);

  void setRange(qint64 start, qint64 end);

  bool isCursorTextVisible() const { return m_isCursorTextVisible; }
  void setCursorTextVisible(bool visible);
  void setCursorText(const QString &text);

  int toPixel(qint64 time) const;
  qint64 toTime(int pixel) const;
  qint64 toDuration(int pixel) const;
  int fromDuration(qint64 time) const;

  const QVector<int> &selectedItemIds() const { return m_selectedItemIds; }
  bool hasSelectedItems() const { return !m_selectedItemIds.isEmpty(); }
  void clearSelectedItems();
  void selectAllItems();
  void selectItem(int itemId, bool reset = true);
  void selectItems(const QVector<int> &itemIds, bool reset = true);
  void unselectItem(int itemId);

  TimelineViewDragHandler *dragHandler() { return m_dragHandler; }
  void setDragHandler(TimelineViewDragHandler *dragHandler) { m_dragHandler = dragHandler; }
  TimelineViewResizeHandler *resizeHandler() { return m_resizeHandler; }
  void setResizeHandler(TimelineViewResizeHandler *resizeHandler) { m_resizeHandler = resizeHandler; }
  TimelineViewSelectHandler *selectHandler() { return m_selectHandler; }
  void setSelectHandler(TimelineViewSelectHandler *selectHandler) { m_selectHandler = selectHandler; }
  TimelineViewTrackHandler *trackHandler() { return m_trackHandler; }
  void setTrackHandler(TimelineViewTrackHandler *trackHandler) { m_trackHandler = trackHandler; }

  bool isCursorWithinRange(const QPoint &pos) const { return isCursorWithinRangeX(pos.x()) && isCursorWithinRangeY(pos.y()); }
  bool isCursorWithinRangeX(int x) const;
  bool isCursorWithinRangeY(int y) const;

protected:
  void dragEnterEvent(QDragEnterEvent *event) override;
  void dragMoveEvent(QDragMoveEvent *event) override;
  void dragLeaveEvent(QDragLeaveEvent *event) override;
  void dropEvent(QDropEvent *event) override;
  void mouseDoubleClickEvent(QMouseEvent *event) override;
  void mouseMoveEvent(QMouseEvent *event) override;
  void mousePressEvent(QMouseEvent *event) override;
  void mouseReleaseEvent(QMouseEvent *event) override;
  void keyPressEvent(QKeyEvent *event) override;
  void wheelEvent(QWheelEvent *event) override;
  virtual void paintEvent(QPaintEvent *event) override;

signals:
  void rangeChanged(qint64, qint64);
  void currentTimeChanged(qint64);
  void zoomChanged(ZoomFactor);
  void trackActivated(int);
  void selectedItemsChanged(const QVector<int> &);
  void itemActivated(int);
  void currentItemTimeChanged();

private:
  TimelineHeaderView *m_header{nullptr};
  TimelineModel *m_timelineModel{nullptr};
  QAbstractItemModel *m_model{nullptr};
  QAbstractProxyModel *m_proxyModel{nullptr};
  ItemDelegate *m_delegate{nullptr};
  TimelineViewDragHandler *m_dragHandler{nullptr};
  TimelineViewResizeHandler *m_resizeHandler{nullptr};
  TimelineViewSelectHandler *m_selectHandler{nullptr};
  TimelineViewTrackHandler *m_trackHandler{nullptr};

  ZoomFactor m_zoomFactor{ZoomFactor::ThirtyMinutes}; 
  ZoomFactor m_upperZoomFactor{ZoomFactor::OneDay}; 
  ZoomFactor m_minZoomFactor{ZoomFactor::FifteenSeconds};
  ZoomFactor m_maxZoomFactor{ZoomFactor::OneDay};

  qint64 m_startTime{-1};
  qint64 m_currentTime{-1};
  int m_duration{-1};

  bool m_isCursorTextVisible{false};
  QString m_cursorText;
  QPoint m_cursorPosition;

  QVector<int> m_selectedItemIds;

  NGL::INGLLogger &m_logger;

};

}