#include "EventTools.h"
#include "EventGraphic.h"
#include "Event.h"

#include <NGLLogger/NGLLoggerBootstrap.h>
#include <math.h>
#include <QPainter>
#include <QDebug>


namespace LtsTimelineClassic
{

#define logger NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("Timeline.EventTools") 
#ifdef LTS_DEBUG

#endif
#ifdef VERBOSE
  #define dbg_print(x) qWarning() << #x << x
#else
  #define dbg_print(x) (void)x;
#endif

qint64 EventTools::s_minAdjusted = 0;
qint64 EventTools::s_maxAdjusted = 1;
qint64 EventTools::s_minTimeline = 0;
qint64 EventTools::s_maxTimeline = 1;
qint64 EventTools::s_sbPos = 0;
qint64 EventTools::s_zoomFactor = 1;
int    EventTools::s_paintMin = 0;
int    EventTools::s_paintDiff = 0;
bool   EventTools::s_isValid = false;
qint64 EventTools::s_diff = 0;
int    EventTools::s_sectionHeight = 0;
int    EventTools::s_test = 0;
qint64 EventTools::s_blockSizeTime = 0;
bool   EventTools::s_inUse = false;




void EventTools::setValues(const qint64 min, const qint64 max, const qint64 sbPos, const qint64 zoomFactor)
{
  if (s_minTimeline == min && s_maxTimeline == max && s_sbPos == sbPos && s_zoomFactor == zoomFactor) 
    return;

  s_sbPos = sbPos;
  s_zoomFactor = zoomFactor;

  
  

  s_isValid = false;

  s_minAdjusted = s_sbPos;

  double d_max = s_minAdjusted;
  d_max += s_zoomFactor;

  s_maxAdjusted = d_max;
  s_diff = s_maxAdjusted - s_minAdjusted;

  s_minTimeline = min;
  s_maxTimeline = max - EventTools::s_diff + (EventTools::getBlockSizeTime() * 2); 

  recalcBlockSizeTime();

  if (min > 0 && max > 1)
  {
    s_isValid = true;

    
  }
  else
  {
    
  }

#ifdef VERBOSE
  qWarning() << "\r\n\r\nEventTools::setValues: "  << "\r\n"
             << "s_sbPos" << s_sbPos  << "\r\n"
             << "s_zoomFactor" << s_zoomFactor  << "\r\n"
             << "s_minTimeline" << s_minTimeline  << "\r\n"
             << "s_maxTimeline" << s_maxTimeline  << "\r\n"
             << "s_isValid" << s_isValid << "\r\n"
             << "s_minAdjusted" << s_minAdjusted << "\r\n"
             << "s_maxAdjusted" << (long)s_maxAdjusted << "\r\n"
             << "s_diff" << s_diff << "\r\n"
             ;
#endif
}


void EventTools::setSection(const int x, const int length)
{
  s_paintMin = x;
  s_paintDiff = length;
  
}


bool EventTools::isValid()
{
#ifdef VERBOSE
  if (!s_isValid)
    qWarning() << "<<<< INVALID EVENT TOOLS!!";

  qWarning() << "\r\nEventTools::isValid: " << "\r\n"
             << "s_isValid" << s_isValid << "\r\n"
             ;
#endif

  return s_isValid;
}

qint64 EventTools::getAdjustedMin()
{
  if (!isValid())
    return 0;

  return s_minAdjusted;
}

qint64 EventTools::getAdjustedMax()
{
  if (!isValid())
    return 1;

  return s_maxAdjusted;
}

qint64 EventTools::getTimelineMin()
{
  if (!isValid())
    return 0;

  return s_minTimeline;
}

qint64 EventTools::getScrollbarPosition()
{
  return s_sbPos;
}

qint64 EventTools::getTimelineMax()
{
  if (!isValid())
    return 1;

  return s_maxTimeline;
}

int EventTools::getEventPosition(qint64 eventTime) 
{
  qint64 min = s_minAdjusted;
  
  qint64 diff = s_diff; 

  
  

  if (diff == 0)
  {
#ifdef VERBOSE
    qWarning() << "\n\ngetEventPosition: diff == 0\n";
#endif
    return 0;
  }

  double pDiff = s_paintDiff; 
  double pMin = s_paintMin;   

  double x1 = eventTime; 
  x1 -= min;             
  x1 /= diff;            

  double x2  = x1; 
  x2 *= pDiff;     
  x2 += pMin;      

#ifdef VERBOSE
  qWarning() << "\r\n\r\nEventTools::getEventPosition: "  << "\r\n"
             << "min" << min << "\r\n"
             << "diff" << diff << "\r\n"
             << "pDiff" << pDiff << "\r\n"
             << "pMin" << pMin << "\r\n"
             << (long)x1 << "[x1]" << "= (" << eventTime << "[eventTime]" << "-" << min << "[min]" << ") /" << diff << "[diff]" << "\r\n"
             << (long)x2 << "[x2]" << "= (" << (long)x1 << "[x1]" << "*" << pDiff << "[pDiff]" << ") +" << pMin << "[pMin]" << "\r\n"
             ;

  dbg_print(min);
#endif

  return qRound(x2);
}

qint64 EventTools::getEventTime(double eventPosition) 
{
  if (!isValid())
  {
    
    return 0;
  }

  if (eventPosition > 999999)
  {
    
    WARNING_LOG(logger) << "getEventTime: pos > 999999  =>  returning 0" ;
    return 0;
  }

  double min = s_minAdjusted;
  double diff = s_diff;
  double pDiff = s_paintDiff;

  if (pDiff < 1)
  {
    
    WARNING_LOG(logger) << "getEventTime: pDiff < 1" ;
    return 0;
  }

  double pMin = s_paintMin;

  double x1 = eventPosition;
  x1 -= pMin;
  x1 /= pDiff;

  double x2 = x1;
  x2 *= diff;
  x2 += min;

  return qRound64(x2);
}


void EventTools::drawMarkLines(QPainter *painter, const EventList &eventList, int viewHeight)
{
  if (!isValid())
    return;

  

  for (int k = 0; k < eventList.count(); k++)
  {
    Event *e = eventList.at(k);
    int pos = getEventPosition(e->startTime());

    if (pos < (s_paintMin) || pos > (s_paintMin + s_paintDiff)) 
      continue;

    painter->drawLine(pos, 0, pos, viewHeight);
  }
}


void EventTools::recalcBlockSizeTime()
{
  s_blockSizeTime = _getBlockSizeTime();
}


qint64 EventTools::_getBlockSizeTime()
{
  
  int startPos = getEventPosition(s_minAdjusted); 
  int endPos = getEventPosition(s_maxAdjusted); 

  int posDiff = endPos - startPos;

  if (posDiff < 1)
  {
    
    return 0; 
  }

  qint64 diff = s_maxAdjusted - s_minAdjusted; 

  double pixelWidthInSeconds = diff;
  pixelWidthInSeconds /= posDiff; 

  int eventGraphicsWidth = eventWidth(); 
  qint64 result = eventGraphicsWidth; result *= pixelWidthInSeconds; 

  #ifdef VERBOSE
  qWarning() << "\r\n\r\nEventTools::recalcBlockSizeTime: " << "\r\n"
             << "minAdj" << s_minAdjusted << "\r\n"
             << "maxAdj" << s_maxAdjusted << "\r\n"
             << "endPos" << endPos << "\r\n"
             << "diff" << diff << "\r\n"
             << "pixelWidthInSeconds" << pixelWidthInSeconds << "\r\n"
             << "eventGraphicsWidth" << eventGraphicsWidth << "\r\n"
             << "result" << result << "\r\n"
             << "(duration > result) ?" << (duration > result)
             ;
  #endif

  return result;
}


qint64 EventTools::getBlockSizeTime(qint64 duration)
{
  if (duration < s_blockSizeTime)
    return s_blockSizeTime;
  else
    return duration;
}


void EventTools::drawEvents(QPainter *painter, const EventGraphicList &eventGraphicList, const int verticalPosition )
{
  painter->save();

  
  painter->setClipping(true); 
  painter->setClipRect(QRect(s_paintMin, verticalPosition, s_paintDiff, s_sectionHeight)); 

  
  for (int i = 0; i < eventGraphicList.count(); i++)
  {
    EventGraphic *eg = eventGraphicList.at(i);

    if (!eg)
    {
      
      
      continue;
    }

    qint64 eventStart = eg->lowestTime();

    if (eventStart == 0)
      continue;



#ifdef VERBOSE
    qWarning() << "\r\n\r\nEventTools::drawEvents" << "\r\n"
               << "eventStart" << eventStart << "\r\n";
#endif

    qint64 eventDuration = eg->getDuration(); 

    int newEventPosition = getEventPosition(eventStart);

    int newEventEndPosition = 0;
    int finalEventEndPos = 0;

    int eventGraphicsWidth = eventWidth(); 

    if (eventDuration > 1) 
    {
      qint64 eventPosition = eventStart;
      eventPosition += eventDuration;
      newEventEndPosition = getEventPosition(eventPosition);
      finalEventEndPos = GetEndPos(newEventEndPosition, eventGraphicsWidth); 
    }
    else
    {
      newEventEndPosition = newEventPosition; 
    }


    if (newEventPosition + (newEventEndPosition - newEventPosition) < ((-eventGraphicsWidth) + s_paintMin) || 
        newEventPosition > (s_paintMin + s_paintDiff)) 
    {
#ifdef VERBOSE
      qWarning() << "\n\ndrawEvents: boundary check result was negative\n" <<
                    " newEventPosition=" << newEventPosition << "\n" <<
                    " newEventEndPosition=" << newEventPosition << "\n" <<
                    " eventGraphicsWidth=" << eventGraphicsWidth << "\n" <<
                    " s_paintMin=" << s_paintMin << "\n" <<
                    " s_paintDiff=" << s_paintDiff << "\n";
#endif
      continue;
    }


    
    int finalEventPos = newEventPosition;

    QRect eventGraphicRect(finalEventPos, verticalPosition + 2, eventGraphicsWidth, s_sectionHeight - 6); 

    

    eg->drawEventGraphic(painter, eventGraphicRect); 

#ifdef VERBOSE
    qWarning() << "drawEvents > actually draw an event at  "
                  "x=" << eventGraphicRect.x() << "  "
                  "y=" << eventGraphicRect.y() << "  "
                  "eventStart=" << eventStart ;
#endif

    if (eventDuration > 1 && 
        (finalEventEndPos - 1) > finalEventPos) 
    {
      QRect eventGraphicEndRect(finalEventEndPos, verticalPosition + 2, eventGraphicsWidth, s_sectionHeight - 6);
      eg->drawEventGraphic(painter, eventGraphicEndRect); 

      
      
      QRect eventWholeRect(newEventPosition + (eventGraphicsWidth / 2) 

                           , verticalPosition + 2
                           , (newEventEndPosition - newEventPosition) - (eventGraphicsWidth) 
                           , s_sectionHeight - 6); 

      eg->drawDurationBackground(painter, eventWholeRect);
    }
  }

  painter->restore();
}

}