/**************************************************************************
 *
 * Copyright 2015 Alexander Trukhin
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 **************************************************************************/

#include "metric_backend_amd_perfmon.hpp"

void Metric_AMD_perfmon::precache() {
    GLenum type;
    int length;
    std::string name;

    glGetPerfMonitorCounterInfoAMD(m_group, m_id, GL_COUNTER_TYPE_AMD, &type);
    if (type == GL_UNSIGNED_INT) m_nType = CNT_NUM_UINT;
    else if (type == GL_FLOAT || type == GL_PERCENTAGE_AMD) m_nType = CNT_NUM_FLOAT;
    else if (type == GL_UNSIGNED_INT64_AMD) m_nType = CNT_NUM_UINT64;
    else m_nType = CNT_NUM_UINT;

    glGetPerfMonitorCounterStringAMD(m_group, m_id, 0, &length, nullptr);
    name.resize(length);
    glGetPerfMonitorCounterStringAMD(m_group, m_id, length, 0, &name[0]);
    m_name = name;
    m_precached = true;
}

unsigned Metric_AMD_perfmon::id() {
    return m_id;
}

unsigned Metric_AMD_perfmon::groupId() {
    return m_group;
}

std::string Metric_AMD_perfmon::name() {
    if (!m_precached) precache();
    return m_name;
}

std::string Metric_AMD_perfmon::description() {
    return ""; // no description available
}

GLenum Metric_AMD_perfmon::size() {
    GLenum type;
    glGetPerfMonitorCounterInfoAMD(m_group, m_id, GL_COUNTER_TYPE_AMD, &type);
    if (type == GL_UNSIGNED_INT) return sizeof(GLuint);
    else if (type == GL_FLOAT || type == GL_PERCENTAGE_AMD) return sizeof(GLfloat);
    else if (type == GL_UNSIGNED_INT64_AMD) return sizeof(uint64_t);
    else return sizeof(GLuint);
}

MetricNumType Metric_AMD_perfmon::numType() {
    if (!m_precached) precache();
    return m_nType;
}

MetricType Metric_AMD_perfmon::type() {
    GLenum type;
    glGetPerfMonitorCounterInfoAMD(m_group, m_id, GL_COUNTER_TYPE_AMD, &type);
    if ((type == GL_UNSIGNED_INT || type == GL_UNSIGNED_INT64_AMD) ||
        (type == GL_FLOAT)) return CNT_TYPE_GENERIC;
    else if (type == GL_PERCENTAGE_AMD) return CNT_TYPE_PERCENT;
    else return CNT_TYPE_OTHER;
}


MetricBackend_AMD_perfmon::DataCollector::~DataCollector() {
    for (auto &t1 : data) {
        for (auto &t2 : t1) {
            alloc.deallocate(t2, 1);
        }
    }
}

unsigned*
MetricBackend_AMD_perfmon::DataCollector::newDataBuffer(unsigned event,
                                                        size_t size)
{
    // in case there is no data for previous events fill with nullptr
    data[curPass].resize(event, nullptr);
    data[curPass].push_back(alloc.allocate(size));
    return data[curPass][event];
}

void MetricBackend_AMD_perfmon::DataCollector::endPass() {
    curPass++;
    data.push_back(mmapdeque<unsigned*>(alloc));
}

unsigned*
MetricBackend_AMD_perfmon::DataCollector::getDataBuffer(unsigned pass,
                                                        unsigned event)
{
    if (event < data[pass].size()) {
        return data[pass][event];
    } else return nullptr;
}


MetricBackend_AMD_perfmon::MetricBackend_AMD_perfmon(glretrace::Context* context,
                                                     MmapAllocator<char> &alloc)
    : numPasses(1), curPass(0), curEvent(0), collector(alloc) {
    if (context->hasExtension("GL_AMD_performance_monitor")) {
        supported = true;
    } else {
        supported = false;
    }
}

bool MetricBackend_AMD_perfmon::isSupported() {
    return supported;
}

void MetricBackend_AMD_perfmon::enumGroups(enumGroupsCallback callback,
                                           void* userData)
{
    std::vector<unsigned> groups;
    int num_groups;
    glGetPerfMonitorGroupsAMD(&num_groups, 0, nullptr);
    groups.resize(num_groups);
    glGetPerfMonitorGroupsAMD(nullptr, num_groups, &groups[0]);
    for(unsigned &g : groups) {
        callback(g, 0, userData);
    }
}

void MetricBackend_AMD_perfmon::enumMetrics(unsigned group,
                                            enumMetricsCallback callback,
                                            void* userData)
{
    std::vector<unsigned> metrics;
    int num_metrics;
    Metric_AMD_perfmon metric(0,0);
    glGetPerfMonitorCountersAMD(group, &num_metrics, nullptr,  0, nullptr);
    metrics.resize(num_metrics);
    glGetPerfMonitorCountersAMD(group, nullptr, nullptr, num_metrics, &metrics[0]);
    for(unsigned &c : metrics) {
        metric = Metric_AMD_perfmon(group, c);
        callback(&metric, 0, userData);
    }
}

std::unique_ptr<Metric>
MetricBackend_AMD_perfmon::getMetricById(unsigned groupId, unsigned metricId)
{
    std::unique_ptr<Metric> p(new Metric_AMD_perfmon(groupId, metricId));
    return p;
}

void MetricBackend_AMD_perfmon::populateLookupGroups(unsigned group,
                                                     int error,
                                                     void* userData)
{
    reinterpret_cast<MetricBackend_AMD_perfmon*>(userData)->enumMetrics(group,
                                                        populateLookupMetrics);
}

void MetricBackend_AMD_perfmon::populateLookupMetrics(Metric* metric,
                                                      int error,
                                                      void* userData)
{
    nameLookup[metric->name()] = std::make_pair(metric->groupId(),
                                                metric->id());
}

std::unique_ptr<Metric>
MetricBackend_AMD_perfmon::getMetricByName(std::string metricName)
{
    if (nameLookup.empty()) {
        enumGroups(populateLookupGroups, this);
    }
    if (nameLookup.count(metricName) > 0) {
        std::unique_ptr<Metric> p(new Metric_AMD_perfmon(nameLookup[metricName].first,
                                                         nameLookup[metricName].second));
        return p;
    }
    else return nullptr;
}

std::string MetricBackend_AMD_perfmon::getGroupName(unsigned group) {
    int length;
    std::string name;
    glGetPerfMonitorGroupStringAMD(group, 0, &length, nullptr);
    name.resize(length);
    glGetPerfMonitorGroupStringAMD(group, length, 0, &name[0]);
    return name;
}

int MetricBackend_AMD_perfmon::enableMetric(Metric* metric_, QueryBoundary pollingRule) {
    unsigned id = metric_->id();
    unsigned gid = metric_->groupId();
    unsigned monitor;

    // profiling only draw calls
    if (pollingRule == QUERY_BOUNDARY_CALL) return 1;

    // check that Metric is valid metric
    glGenPerfMonitorsAMD(1, &monitor);
    glGetError();
    glSelectPerfMonitorCountersAMD(monitor, 1, gid, 1, &id);
    GLenum err = glGetError();
    glDeletePerfMonitorsAMD(1, &monitor);
    if (err == GL_INVALID_VALUE) {
        return 1;
    }

    Metric_AMD_perfmon metric(gid, id);
    metric.numType(); // triggers metric vars precache (in case context changes)
    metrics[pollingRule].push_back(metric);
    return 0;
}

bool
MetricBackend_AMD_perfmon::testMetrics(std::vector<Metric_AMD_perfmon>* metrics) {
    unsigned monitor;
    unsigned id;
    glGenPerfMonitorsAMD(1, &monitor);
    for (Metric_AMD_perfmon &c : *metrics) {
        id = c.id();
        glSelectPerfMonitorCountersAMD(monitor, 1, c.groupId(), 1, &id);
    }
    glGetError();
    glBeginPerfMonitorAMD(monitor);
    GLenum err = glGetError();
    glEndPerfMonitorAMD(monitor);
    glDeletePerfMonitorsAMD(1, &monitor);
    if (err == GL_INVALID_OPERATION) {
        return 0;
    }
    return 1;
}

void MetricBackend_AMD_perfmon::generatePassesBoundary(QueryBoundary boundary) {
    std::vector<Metric_AMD_perfmon> copyMetrics(metrics[boundary]);
    std::vector<Metric_AMD_perfmon> newPass;
    while (!copyMetrics.empty()) {
        std::vector<Metric_AMD_perfmon>::iterator it = copyMetrics.begin();
        while (it != copyMetrics.end()) {
            newPass.push_back(*it);
            if (!testMetrics(&newPass)) {
                newPass.pop_back();
                break;
            }
            it = copyMetrics.erase(it);
        }
        passes.push_back(newPass);
        newPass.clear();
    }
}

unsigned MetricBackend_AMD_perfmon::generatePasses() {
    generatePassesBoundary(QUERY_BOUNDARY_FRAME);
    numFramePasses = passes.size();
    generatePassesBoundary(QUERY_BOUNDARY_DRAWCALL);
    nameLookup.clear(); // no need in it after all metrics are set up
    numPasses = passes.size();
    return passes.size();
}

void MetricBackend_AMD_perfmon::beginPass() {
    if (!numPasses) return;
    /* First process per-frame passes, then per-call passes */
    if (curPass < numFramePasses) {
        perFrame = true;
    } else {
        perFrame = false;
    }
    /* Generate monitor */
    glGenPerfMonitorsAMD(NUM_MONITORS, monitors);
    for (Metric_AMD_perfmon &c : passes[curPass]) {
        unsigned id = c.id();
        for (auto & monitor : monitors) {
            glSelectPerfMonitorCountersAMD(monitor, 1, c.groupId(), 1, &id);
        }
    }
    curMonitor = 0;
    firstRound = true;
    curEvent = 0;
    supported = true; // can change if context is switched, so revert back
}

void MetricBackend_AMD_perfmon::endPass() {
    if (supported && numPasses) {
        for (unsigned k = 0; k < curMonitor; k++) {
            freeMonitor(k);
        }
        glDeletePerfMonitorsAMD(NUM_MONITORS, monitors);
    }
    curPass++;
    collector.endPass();
}

void MetricBackend_AMD_perfmon::pausePass() {
    if (!supported || !numPasses) return;
    // clear all queries and monitors
    // ignore data from the query in progress
    if (queryInProgress) {
        glEndPerfMonitorAMD(monitors[curMonitor]);
        curEvent++;
        queryInProgress = false;
    }
    for (unsigned k = 0; k < curMonitor; k++) {
        freeMonitor(k);
    }
    glDeletePerfMonitorsAMD(NUM_MONITORS, monitors);
}

void MetricBackend_AMD_perfmon::continuePass() {
    // here new context might be used
    // better to check if it supports AMD_perfmon extension
    glretrace::Context* context = glretrace::getCurrentContext();
    if (context && context->hasExtension("GL_AMD_performance_monitor")) {
        supported = true;
    } else {
        supported = false;
    }

    if (supported && numPasses) {
    // call begin pass and save/restore event id
        unsigned tempId = curEvent;
        beginPass();
        curEvent = tempId;
    }
}

void MetricBackend_AMD_perfmon::beginQuery(QueryBoundary boundary) {
    if (!supported || !numPasses) return;
    if (boundary == QUERY_BOUNDARY_CALL) return;
    if ((boundary == QUERY_BOUNDARY_FRAME) && !perFrame) return;
    if ((boundary == QUERY_BOUNDARY_DRAWCALL) && perFrame) return;

    curMonitor %= NUM_MONITORS;
    if (!firstRound) freeMonitor(curMonitor); // get existing data
    monitorEvent[curMonitor] = curEvent; // save monitored event
    glBeginPerfMonitorAMD(monitors[curMonitor]);
    queryInProgress = true;
}

void MetricBackend_AMD_perfmon::endQuery(QueryBoundary boundary) {
    if (!queryInProgress) return;
    if (!supported || !numPasses) return;
    if (boundary == QUERY_BOUNDARY_CALL) return;
    if ((boundary == QUERY_BOUNDARY_FRAME) && !perFrame) return;
    if ((boundary == QUERY_BOUNDARY_DRAWCALL) && perFrame) return;

    curEvent++;
    glEndPerfMonitorAMD(monitors[curMonitor]);
    curMonitor++;
    if (curMonitor == NUM_MONITORS) firstRound = 0;
    queryInProgress = false;
}

void MetricBackend_AMD_perfmon::freeMonitor(unsigned monitorId) {
    unsigned monitor = monitors[monitorId];
    GLuint dataAvail = 0;
    GLuint size;

    glFlush();
    while (!dataAvail) {
        glGetPerfMonitorCounterDataAMD(monitor, GL_PERFMON_RESULT_AVAILABLE_AMD,
                                       sizeof(GLuint), &dataAvail, nullptr);
    }
    glGetPerfMonitorCounterDataAMD(monitor, GL_PERFMON_RESULT_SIZE_AMD,
                                   sizeof(GLuint), &size, nullptr);
    // collect data
    unsigned* buf = collector.newDataBuffer(monitorEvent[monitorId],
                                            size/sizeof(unsigned));
    glGetPerfMonitorCounterDataAMD(monitor, GL_PERFMON_RESULT_AMD, size, buf, nullptr);

    /* populate metricOffsets */
    if (metricOffsets.size() < curPass + 1) {
        std::map<std::pair<unsigned, unsigned>, unsigned> pairOffsets;
        unsigned offset = 0;
        unsigned id, gid;
        for (int k = 0; k < passes[curPass].size(); k++) {
            gid = buf[offset++];
            id = buf[offset++];
            pairOffsets[std::make_pair(gid, id)] = offset;
            Metric_AMD_perfmon metric(gid, id);
            offset += metric.size() / sizeof(unsigned);
        }
        // translate to existing metrics in passes variable
        std::map<Metric_AMD_perfmon*, unsigned> temp;
        for (auto &m : passes[curPass]) {
            id = m.id();
            gid = m.groupId();
            temp[&m] = pairOffsets[std::make_pair(gid, id)];
        }
        metricOffsets.push_back(std::move(temp));
    }
}

void
MetricBackend_AMD_perfmon::enumDataQueryId(unsigned id,
                                           enumDataCallback callback,
                                           QueryBoundary boundary,
                                           void* userData)
{
    /* Determine passes to return depending on the boundary */
    if (boundary == QUERY_BOUNDARY_CALL) return;
    unsigned j = 0;
    unsigned nPasses = numFramePasses;
    if (boundary == QUERY_BOUNDARY_DRAWCALL) {
        j = numFramePasses;
        nPasses = numPasses;
    }
    /* enum passes */
    for (; j < nPasses; j++) {
        unsigned* buf = collector.getDataBuffer(j, id);
        for (auto &m : passes[j]) {
            void* data = (buf) ? &buf[metricOffsets[j][&m]] : nullptr;
            callback(&m, id, data, 0, userData);
        }
    }
}

unsigned MetricBackend_AMD_perfmon::getNumPasses() {
    return numPasses;
}

MetricBackend_AMD_perfmon&
MetricBackend_AMD_perfmon::getInstance(glretrace::Context* context,
                                       MmapAllocator<char> &alloc) {
    static MetricBackend_AMD_perfmon backend(context, alloc);
    return backend;
}


std::map<std::string, std::pair<unsigned, unsigned>> MetricBackend_AMD_perfmon::nameLookup;