#include "Event.h"

#include <LtsSession/lts_session.h>
#include <QPainter>
#include <QPainterPath>
#include <QRect>
#include <time.h>

namespace LtsTimelineClassic
{
Event::Event(int uniqueId, int typeId, qint64 startTime, qint64 endTime, int playerId, int partyId, int equipmentId,
             const QStringList& path, const EventPaintFunc& paintFunc, const QColor& paintColor,
             const QJsonObject& detailData, int subEventId, const LtsUtils::QPoint3D& pos,
             LtsSession::LtsSession* session)
    : m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger()), m_path(path), m_detailData(detailData), m_position(pos),
      m_paintFunc(paintFunc), m_session(session), m_eventColor(paintColor), m_startTime(startTime), m_endTime(endTime),
      m_uniqueId(uniqueId), m_typeId(typeId), m_subEventId(subEventId), m_playerId(playerId), m_partyId(partyId),
      m_equipmentId(equipmentId), m_deleted(false), m_visible(true)
{
    checkDuration();
}

void Event::setVisible(bool visibility)
{
    if (visibility)
        show();
    else
        hide();
}

void Event::hide()
{
    this->m_visible = false;
}

void Event::show()
{
    this->m_visible = true;
}

QString Event::getShortActuator() const
{
    return m_path.isEmpty() ? QString() : m_path.last();
}

void Event::setEndT(qint64 newEnd)
{
    m_endTime = newEnd;

    checkDuration();
}

bool Event::checkDuration()
{

    return true;
}

qint64 Event::duration(bool ignoreLiveEvents) const
{
    if (m_endTime > m_startTime)
    {
        if (m_duration == -1)
            m_duration = m_endTime - m_startTime;

        return m_duration;
    }

    if (m_endTime < 0 && !ignoreLiveEvents)
    {
        qint64 currentTime = (m_session != nullptr) ? m_session->partitionTime() : time(nullptr);
        qint64 duration = currentTime - m_startTime;

        return duration;
    }

    return 0;
}

void Event::drawMultipleEventGraphic(QPainter* painter, const QRect& rect)
{
    painter->save();
    painter->setBrush(Qt::white);

    int x = rect.x();
    int y = rect.y();
    int h = rect.height();
    int w = rect.width();

    painter->drawRect(rect);

    int s1 = y + h - (h * 0.4);
    int s2 = y + h - (h * 0.2);

    painter->drawLine(QPoint(x, s1), QPoint(x + w, s1));
    painter->drawLine(QPoint(x, s2), QPoint(x + w, s2));

    painter->restore();
}

void Event::drawCustomEventGraphicTriangle(QPainter* painter, const QRect& rect)
{
    int x = rect.x();
    int y = rect.y();
    int h = rect.height();
    int w = rect.width();

    QPolygon pol;
    pol.append(QPoint(x + 0, y + h));
    pol.append(QPoint(x + (w / 2), y + 0));
    pol.append(QPoint(x + w, y + h));
    pol.append(QPoint(x + 0, y + h));

    QPainterPath path;
    path.moveTo(x, y);
    path.addPolygon(pol);

    painter->drawPath(path);
}

void Event::drawCustomEventGraphicInvertTriangle(QPainter* painter, const QRect& rect)
{
    int x = rect.x();
    int y = rect.y();
    int h = rect.height();
    int w = rect.width();

    QPolygon pol;
    pol.append(QPoint(x + 0, y + 0));
    pol.append(QPoint(x + w, y + 0));
    pol.append(QPoint(x + (w / 2), y + h));
    pol.append(QPoint(x + 0, y + 0));

    QPainterPath path;
    path.moveTo(x, y);
    path.addPolygon(pol);

    painter->drawPath(path);
}

void Event::drawCustomEventGraphicEllipse(QPainter* painter, const QRect& rect)
{
    QPoint ellipsePos = rect.center();
    ellipsePos.rx()++;
    ellipsePos.ry()++;

    painter->drawEllipse(ellipsePos, rect.width() / 2, rect.height() / 2);
}

void Event::drawCustomEventGraphicRect(QPainter* painter, const QRect& rect)
{
    painter->drawRect(rect);
}

void Event::drawCustomEventGraphicRoundedRect(QPainter* painter, const QRect& rect)
{
    painter->drawRoundedRect(rect, 50, 50, Qt::RelativeSize);
}

} // namespace LtsTimelineClassic