#include "TimelineWidget.h"
#include "EventDelegate.h"
#include "ui_TimelineWidgetUi.h"
#include "AbstractTimelineModel.h"
#include "EventGraphic.h"

#include <NGLLogger/NGLLoggerBootstrap.h>

#include <QSize>
#include <QPoint>
#include <QRect>
#include <QDateTime>

#include <QDebug>


namespace LtsTimelineClassic
{

TimelineWidget::TimelineWidget(QWidget *parent) 
  : QWidget(parent)
  , m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("Timeline.Widget"))
  , m_timelineUi(new Ui::Timeline)
  , m_min(0)
  , m_max(1)
  , m_sbPos(0)
  , m_zoomFactor(1) 
  , m_headerView(new TimelineHeaderView)
  , m_model(nullptr)
{
  m_timelineUi->setupUi(this);
  m_timelineUi->view->setHeader(m_headerView);
  m_headerView->setMinimumSectionSize(150);

  m_timelineUi->scrollbar->setMouseTracking(true);
  connect(m_timelineUi->scrollbar, &QScrollBar::sliderReleased, this, &TimelineWidget::scrollBarFilter2);
  connect(m_timelineUi->scrollbar, &QScrollBar::actionTriggered, this, &TimelineWidget::scrollBarFilter1);

  connect(m_headerView, &QHeaderView::sectionResized, m_timelineUi->indicator, &TimelineIndicator::slotSectionResized);
  connect(m_headerView, &QHeaderView::sectionResized, this, &TimelineWidget::slotSectionResized);
  connect(m_timelineUi->view, &TimelineView::signalZoom, m_timelineUi->indicator, &TimelineIndicator::slotZoom);
  connect(m_timelineUi->view, &TimelineView::signalUnzoom, m_timelineUi->indicator, &TimelineIndicator::slotUnzoom);

  connect(m_timelineUi->view, &TimelineView::signalZoom, this, &TimelineWidget::signalZoomChanged);
  connect(m_timelineUi->view, &TimelineView::signalUnzoom, this, &TimelineWidget::signalZoomChanged);

  connect(m_timelineUi->indicator, &TimelineIndicator::signalZoomChanged, this, &TimelineWidget::signalZoomChanged);
  connect(m_timelineUi->indicator, &TimelineIndicator::signalSetZoomFactor, this, &TimelineWidget::slotSetZoomFactor);

  connect(m_timelineUi->view, &TimelineView::signalEventAction,
          this, &TimelineWidget::signalEventAction); 

  connect(m_timelineUi->cbDrawCache, &QCheckBox::toggled,
          this, [this](bool toggled)
  {
    m_timelineUi->view->setDrawCache(toggled);
    update(); 
  });

  connect(m_timelineUi->cbArm, &QCheckBox::toggled,
          this, &TimelineWidget::signalArm);
  connect(m_timelineUi->updateTimeline, &QPushButton::clicked,
          this, &TimelineWidget::slotUpdateTimeline);
}


TimelineWidget::~TimelineWidget()
{
  delete m_timelineUi;
}


void TimelineWidget::setLiveTime(qint64 time)
{
  m_headerView->setLiveTime(time);

  EventDelegate *ed = qobject_cast<EventDelegate *>(m_timelineUi->view->itemDelegate());
  if (ed == nullptr)
  {
    qWarning() << "TimelineWidget::setLiveTime: ed == nullptr";
    return;
  }

  ed->setLiveTime(time);
}


void TimelineWidget::hideDebugWidget()
{
  m_timelineUi->debugWidget->hide();
  m_timelineUi->lbMinMax->hide();
}

void TimelineWidget::knownRangesChanged(const QVector<Range> &newRanges)
{
  EventDelegate *ed = qobject_cast<EventDelegate *>(m_timelineUi->view->itemDelegate());
  if (ed == nullptr)
  {
    WARNING_LOG(m_logger) << "ed == nullptr";
    return;
  }

  m_timelineUi->view->setKnownRanges(newRanges);
  ed->setKnownRanges(newRanges);
  m_timelineUi->view->refreshData(); 
}


void TimelineWidget::setMaxPos()
{
  m_timelineUi->scrollbar->setValue(m_timelineUi->scrollbar->maximum());
}


int TimelineWidget::getMaxPos() const
{
  return m_timelineUi->scrollbar->maximum();
}


int TimelineWidget::getPos() const
{
  return m_timelineUi->scrollbar->value();
}


void TimelineWidget::setPos(qint64 pos)
{
  m_timelineUi->scrollbar->setValue(pos / 1000); 
}


void TimelineWidget::setPositionMarkerTime(const qint64 time)
{
  m_timelineUi->view->slotSetPosMarkTime(time);
}


void TimelineWidget::slotUpdateTimeline() 
{
  qint64 min = m_model->lowestPositionedItem();
  qint64 max = m_model->highestPositionedItem();

  if (m_timelineUi->cbMinMax->isChecked())
  {
    QString minmax(QStringLiteral("%1 (%2) - %3 (%4)")
                   .arg(QDateTime::fromMSecsSinceEpoch(min).toString())
                   .arg(min)
                   .arg(QDateTime::fromMSecsSinceEpoch(max).toString())
                   .arg(max));
    m_timelineUi->lbMinMax->setText(minmax);
  }

  setTimelineRange(min, max);
  emit signalRangeChanged();
}


void TimelineWidget::setTimelineModel(AbstractTimelineModel *model)
{
  m_model = model;

  connect(m_model, &AbstractTimelineModel::dataChanged,
          this, &TimelineWidget::slotRefreshData );

  

  m_timelineUi->view->setTimelineModel(m_model);

  
  connect(m_timelineUi->indicator, &TimelineIndicator::signalAddLine,
          m_timelineUi->view, &TimelineView::slotAddLine);
  connect(m_timelineUi->indicator, &TimelineIndicator::signalResetLineList,
          m_timelineUi->view, &TimelineView::slotResetLineList);

  EventDelegate *ed = qobject_cast<EventDelegate *>(m_timelineUi->view->itemDelegate());
  if (ed != nullptr)
  {
    connect(m_timelineUi->indicator, &TimelineIndicator::signalAddLine,
        ed, &EventDelegate::slotAddLine);
    connect(m_timelineUi->indicator, &TimelineIndicator::signalResetLineList,
        ed, &EventDelegate::slotResetLineList);
  }

  m_timelineUi->view->expandToDepth(1);

  m_headerView->resizeSection(0, m_headerView->minimumSectionSize()); 
  m_headerView->resizeSection(1, m_headerView->minimumSectionSize()); 

  slotSetZoomFactor(m_timelineUi->indicator->zoomFactorPoints()); 
}


qint64 TimelineWidget::getRangeMinimum() const
{
  return EventTools::getAdjustedMin();
}


qint64 TimelineWidget::getRangeMaximum() const
{
  return EventTools::getAdjustedMax();
}


void TimelineWidget::setTimelineRange(qint64 min, qint64 max) 
{
  m_min = min;
  m_max = max;

  if (m_min > 0 && m_max > 2) 
  {
    m_sbPos = EventTools::fromSecondsToMsecs(m_timelineUi->scrollbar->sliderPosition());

    if (m_max <= m_min)
    {
      if (m_min > (10 * 60))
        m_min -= (10 * 60); 
    }
    else
    {
      qint64 diff = m_max - m_min;
      if (diff < (10 * 60))
        if (m_min > (10 * 60))
          m_min -= (10 * 60); 
    }

  
  
  


    
    EventTools::setValues(m_min, m_max, m_sbPos, m_zoomFactor);



    
    m_timelineUi->scrollbar->setRange(EventTools::fromMsecsToSeconds(EventTools::getTimelineMin()), EventTools::fromMsecsToSeconds(EventTools::getTimelineMax()));

    if (m_sbPos < m_min) 
    {
      m_sbPos = m_min;
      
      m_timelineUi->scrollbar->setSliderPosition(EventTools::fromMsecsToSeconds(m_sbPos));
    }

    

    int pagestep = EventTools::fromMsecsToSeconds(EventTools::s_diff);
    if (pagestep < 0)
      pagestep = 1;

    
    m_timelineUi->scrollbar->setPageStep(pagestep);

    


    m_timelineUi->bsz->setText(QString::number(EventTools::getBlockSizeTime()));
  }


  refreshData();
}


void TimelineWidget::slotRefreshData()
{
  refreshData();
}


void TimelineWidget::refreshData()
{
  m_headerView->refreshData(); 
  m_timelineUi->indicator->refreshData(); 
  m_timelineUi->view->refreshData(); 
}


void TimelineWidget::slotSetZoomFactor(qint64 zoomFactor)
{
  m_zoomFactor = zoomFactor;
  slotUpdateTimeline(); 
}


void TimelineWidget::scrollBarFilter1(int )
{
  scrollBarFilter2();
}


void TimelineWidget::scrollBarFilter2()
{
  slotUpdateTimeline(); 
}


void TimelineWidget::slotSectionResized(int logicalIndex, int oldSize, int newSize)
{
  (void)oldSize;

  if (logicalIndex == 1) 
  {
    int viewScrollbarWidth = m_timelineUi->view->verticalScrollBar()->width();
    m_timelineUi->scrollbar->setMinimumHeight(viewScrollbarWidth); 
    m_timelineUi->scrollbar->setMaximumHeight(viewScrollbarWidth); 

    m_timelineUi->scrollbar->setMaximumWidth(newSize);
    m_timelineUi->scrollbar->setMinimumWidth(newSize);

    EventTools::setSection(m_headerView->sectionPosition(1),
                           newSize );
  }

  slotUpdateTimeline();
}

}