/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/

#include "qmlprofilerstatisticsmodel.h"
#include "qmlprofilermodelmanager.h"
#include "qmlprofilerdatamodel.h"

#include <utils/algorithm.h>
#include <utils/qtcassert.h>

#include <QVector>
#include <QHash>
#include <QString>
#include <QStack>
#include <QSet>
#include <QPointer>

namespace QmlProfiler {

class QmlProfilerStatisticsModel::QmlProfilerStatisticsModelPrivate
{
public:
    QHash<int, QmlProfilerStatisticsModel::QmlEventStats> data;
    QPointer<QmlProfilerStatisticsRelativesModel> childrenModel;
    QPointer<QmlProfilerStatisticsRelativesModel> parentsModel;

    QmlProfilerModelManager *modelManager;

    int modelId;

    QList<RangeType> acceptedTypes;
    QSet<int> eventsInBindingLoop;
    QHash<int, QString> notes;

    QStack<QmlEvent> callStack;
    qint64 qmlTime = 0;
    qint64 lastEndTime = 0;
    QHash <int, QVector<qint64> > durations;
};

QmlProfilerStatisticsModel::QmlProfilerStatisticsModel(QmlProfilerModelManager *modelManager,
                                               QObject *parent) :
    QObject(parent), d(new QmlProfilerStatisticsModelPrivate)
{
    d->modelManager = modelManager;
    d->callStack.push(QmlEvent());
    connect(modelManager, &QmlProfilerModelManager::stateChanged,
            this, &QmlProfilerStatisticsModel::dataChanged);
    connect(modelManager->notesModel(), &Timeline::TimelineNotesModel::changed,
            this, &QmlProfilerStatisticsModel::notesChanged);
    d->modelId = modelManager->registerModelProxy();

    d->acceptedTypes << Compiling << Creating << Binding << HandlingSignal << Javascript;

    modelManager->announceFeatures(Constants::QML_JS_RANGE_FEATURES,
                                   [this](const QmlEvent &event, const QmlEventType &type) {
        loadEvent(event, type);
    }, [this]() {
        finalize();
    });
}

QmlProfilerStatisticsModel::~QmlProfilerStatisticsModel()
{
    delete d;
}

void QmlProfilerStatisticsModel::setEventTypeAccepted(RangeType type, bool accepted)
{
    if (accepted && !d->acceptedTypes.contains(type))
        d->acceptedTypes << type;
    else if (!accepted && d->acceptedTypes.contains(type))
        d->acceptedTypes.removeOne(type);
}

const QHash<int, QmlProfilerStatisticsModel::QmlEventStats> &QmlProfilerStatisticsModel::getData() const
{
    return d->data;
}

const QVector<QmlEventType> &QmlProfilerStatisticsModel::getTypes() const
{
    return d->modelManager->qmlModel()->eventTypes();
}

const QHash<int, QString> &QmlProfilerStatisticsModel::getNotes() const
{
    return d->notes;
}

void QmlProfilerStatisticsModel::clear()
{
    d->data.clear();
    d->eventsInBindingLoop.clear();
    d->notes.clear();
    d->callStack.clear();
    d->callStack.push(QmlEvent());
    d->qmlTime = 0;
    d->lastEndTime = 0;
    d->durations.clear();
    if (!d->childrenModel.isNull())
        d->childrenModel->clear();
    if (!d->parentsModel.isNull())
        d->parentsModel->clear();
}

void QmlProfilerStatisticsModel::limitToRange(qint64 rangeStart, qint64 rangeEnd)
{
    if (!d->modelManager->isEmpty())
        loadData(rangeStart, rangeEnd);
}

void QmlProfilerStatisticsModel::setRelativesModel(QmlProfilerStatisticsRelativesModel *relative,
                                                   QmlProfilerStatisticsRelation relation)
{
    if (relation == QmlProfilerStatisticsParents)
        d->parentsModel = relative;
    else
        d->childrenModel = relative;
}

void QmlProfilerStatisticsModel::dataChanged()
{
    if (d->modelManager->state() == QmlProfilerModelManager::ProcessingData)
        loadData();
    else if (d->modelManager->state() == QmlProfilerModelManager::ClearingData)
        clear();
}

void QmlProfilerStatisticsModel::notesChanged(int typeIndex)
{
    const QmlProfilerNotesModel *notesModel = d->modelManager->notesModel();
    if (typeIndex == -1) {
        d->notes.clear();
        for (int noteId = 0; noteId < notesModel->count(); ++noteId) {
            int noteType = notesModel->typeId(noteId);
            if (noteType != -1) {
                QString &note = d->notes[noteType];
                if (note.isEmpty()) {
                    note = notesModel->text(noteId);
                } else {
                    note.append(QStringLiteral("\n")).append(notesModel->text(noteId));
                }
            }
        }
    } else {
        d->notes.remove(typeIndex);
        const QVariantList changedNotes = notesModel->byTypeId(typeIndex);
        if (!changedNotes.isEmpty()) {
            QStringList newNotes;
            for (QVariantList::ConstIterator it = changedNotes.begin(); it !=  changedNotes.end();
                 ++it) {
                newNotes << notesModel->text(it->toInt());
            }
            d->notes[typeIndex] = newNotes.join(QStringLiteral("\n"));
        }
    }

    emit notesAvailable(typeIndex);
}

void QmlProfilerStatisticsModel::loadData(qint64 rangeStart, qint64 rangeEnd)
{
    clear();

    const bool checkRanges = (rangeStart != -1) && (rangeEnd != -1);

    const QVector<QmlEvent> &eventList = d->modelManager->qmlModel()->events();
    const QVector<QmlEventType> &typesList = d->modelManager->qmlModel()->eventTypes();

    for (int i = 0; i < eventList.size(); ++i) {
        const QmlEvent &event = eventList[i];
        const QmlEventType &type = typesList[event.typeIndex()];

        if (checkRanges) {
            if ((event.timestamp() + event.duration() < rangeStart)
                        || (event.timestamp() > rangeEnd))
                continue;
        }

        loadEvent(event, type);
    }

    finalize();
    if (checkRanges)
        notesChanged(-1); // Reload notes
}

void QmlProfilerStatisticsModel::loadEvent(const QmlEvent &event, const QmlEventType &type)
{
    if (!d->acceptedTypes.contains(type.rangeType))
        return;

    // update stats
    QmlEventStats *stats = &d->data[event.typeIndex()];

    stats->duration += event.duration();
    stats->durationSelf += event.duration();
    if (event.duration() < stats->minTime)
        stats->minTime = event.duration();
    if (event.duration() > stats->maxTime)
        stats->maxTime = event.duration();
    stats->calls++;

    // for median computing
    d->durations[event.typeIndex()].append(event.duration());

    // qml time computation
    if (event.timestamp() > d->lastEndTime) { // assume parent event if starts before last end
        d->qmlTime += event.duration();
        d->lastEndTime = event.timestamp() + event.duration();
    }

    //
    // binding loop detection
    //
    const QmlEvent *potentialParent = &(d->callStack.top());
    while (potentialParent->isValid() &&
           !(potentialParent->timestamp() + potentialParent->duration() > event.timestamp())) {
        d->callStack.pop();
        potentialParent = &(d->callStack.top());
    }

    // check whether event is already in stack
    for (int ii = 1; ii < d->callStack.size(); ++ii) {
        if (d->callStack.at(ii).typeIndex() == event.typeIndex()) {
            d->eventsInBindingLoop.insert(event.typeIndex());
            break;
        }
    }

    if (d->callStack.count() > 1)
        d->data[d->callStack.top().typeIndex()].durationSelf -= event.duration();
    d->callStack.push(event);

    if (!d->childrenModel.isNull())
        d->childrenModel->loadEvent(event);
    if (!d->parentsModel.isNull())
        d->parentsModel->loadEvent(event);
}


void QmlProfilerStatisticsModel::finalize()
{
    // post-process: calc mean time, median time, percentoftime
    for (QHash<int, QmlEventStats>::iterator it = d->data.begin(); it != d->data.end(); ++it) {
        QmlEventStats* stats = &it.value();
        if (stats->calls > 0)
            stats->timePerCall = stats->duration / (double)stats->calls;

        QVector<qint64> eventDurations = d->durations[it.key()];
        if (!eventDurations.isEmpty()) {
            Utils::sort(eventDurations);
            stats->medianTime = eventDurations.at(eventDurations.count()/2);
        }

        stats->percentOfTime = stats->duration * 100.0 / d->qmlTime;
        stats->percentSelf = stats->durationSelf * 100.0 / d->qmlTime;
    }

    // set binding loop flag
    foreach (int typeIndex, d->eventsInBindingLoop)
        d->data[typeIndex].isBindingLoop = true;

    // insert root event
    QmlEventStats rootEvent;
    rootEvent.duration = rootEvent.minTime = rootEvent.maxTime = rootEvent.timePerCall
                       = rootEvent.medianTime = d->qmlTime + 1;
    rootEvent.durationSelf = 1;
    rootEvent.calls = 1;
    rootEvent.percentOfTime = 100.0;
    rootEvent.percentSelf = 1.0 / rootEvent.duration;

    d->data.insert(-1, rootEvent);
    if (!d->childrenModel.isNull())
        d->childrenModel->finalize(d->eventsInBindingLoop);
    if (!d->parentsModel.isNull())
        d->parentsModel->finalize(d->eventsInBindingLoop);

    emit dataAvailable();
}

int QmlProfilerStatisticsModel::count() const
{
    return d->data.count();
}

QmlProfilerStatisticsRelativesModel::QmlProfilerStatisticsRelativesModel(
        QmlProfilerModelManager *modelManager, QmlProfilerStatisticsModel *statisticsModel,
        QmlProfilerStatisticsRelation relation, QObject *parent) :
    QObject(parent), m_relation(relation)
{
    m_endtimesPerLevel[0] = 0;

    QTC_CHECK(modelManager);
    m_modelManager = modelManager;

    QTC_CHECK(statisticsModel);
    statisticsModel->setRelativesModel(this, relation);

    // Load the child models whenever the parent model is done to get the filtering for JS/QML
    // right.
    connect(statisticsModel, &QmlProfilerStatisticsModel::dataAvailable,
            this, &QmlProfilerStatisticsRelativesModel::dataAvailable);
}

const QmlProfilerStatisticsRelativesModel::QmlStatisticsRelativesMap &
QmlProfilerStatisticsRelativesModel::getData(int typeId) const
{
    QHash <int, QmlStatisticsRelativesMap>::ConstIterator it = m_data.find(typeId);
    if (it != m_data.end()) {
        return it.value();
    } else {
        static const QmlStatisticsRelativesMap emptyMap;
        return emptyMap;
    }
}

const QVector<QmlEventType> &QmlProfilerStatisticsRelativesModel::getTypes() const
{
    return m_modelManager->qmlModel()->eventTypes();
}

void QmlProfilerStatisticsRelativesModel::loadEvent(const QmlEvent &event)
{
    // level computation
    if (m_endtimesPerLevel[m_level] > event.timestamp()) {
        m_level++;
    } else {
        while (m_level > Constants::QML_MIN_LEVEL &&
               m_endtimesPerLevel[m_level-1] <= event.timestamp())
            m_level--;
    }
    m_endtimesPerLevel[m_level] = event.timestamp() + event.duration();

    int parentTypeIndex = -1;
    if (m_level > Constants::QML_MIN_LEVEL && m_lastParent.contains(m_level-1))
        parentTypeIndex = m_lastParent[m_level-1];

    int relativeTypeIndex = (m_relation == QmlProfilerStatisticsParents) ? parentTypeIndex :
                                                                           event.typeIndex();
    int selfTypeIndex = (m_relation == QmlProfilerStatisticsParents) ? event.typeIndex() :
                                                                       parentTypeIndex;

    QmlStatisticsRelativesMap &relativesMap = m_data[selfTypeIndex];
    QmlStatisticsRelativesMap::Iterator it = relativesMap.find(relativeTypeIndex);
    if (it != relativesMap.end()) {
        it.value().calls++;
        it.value().duration += event.duration();
    } else {
        QmlStatisticsRelativesData relative = {
            event.duration(),
            1,
            false
        };
        relativesMap.insert(relativeTypeIndex, relative);
    }

    // now lastparent is the new type
    m_lastParent[m_level] = event.typeIndex();
}

void QmlProfilerStatisticsRelativesModel::finalize(const QSet<int> &eventsInBindingLoop)
{
    for (auto map = m_data.begin(), mapEnd = m_data.end(); map != mapEnd; ++map) {
        auto itemEnd = map->end();
        foreach (int typeIndex, eventsInBindingLoop) {
            auto item = map->find(typeIndex);
            if (item != itemEnd)
                item->isBindingLoop = true;
        }
    }
}

int QmlProfilerStatisticsRelativesModel::count() const
{
    return m_data.count();
}

void QmlProfilerStatisticsRelativesModel::clear()
{
    m_data.clear();
    m_endtimesPerLevel.clear();
    m_level = Constants::QML_MIN_LEVEL;
    m_endtimesPerLevel[0] = 0;
    m_lastParent.clear();
}

} // namespace QmlProfiler