/****************************************************************************
* Copyright (C) 2014-2015 Intel Corporation.   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 (including the next
* paragraph) 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.
* 
* @file rdtsc_buckets.h
* 
* @brief declaration for rdtsc buckets.
* 
* Notes:
* 
******************************************************************************/
#pragma once

#include <vector>
#include <cassert>

struct BUCKET
{
    uint32_t id{ 0 };
    uint64_t start{ 0 };
    uint64_t elapsed{ 0 };
    uint32_t count{ 0 };

    BUCKET* pParent{ nullptr };
    std::vector<BUCKET> children;
};

struct BUCKET_DESC
{
    // name of bucket, used in reports
    std::string name;

    // description of bucket, used in threadviz
    std::string description;

    // enable for threadviz dumping
    bool enableThreadViz;

    // threadviz color of bucket, in RGBA8_UNORM format
    uint32_t color;
};


struct BUCKET_THREAD
{
    // name of thread, used in reports
    std::string name;

    // id for this thread, assigned by the thread manager
    uint32_t id{ 0 };

    // root of the bucket hierarchy for this thread
    BUCKET root;

    // currently executing bucket somewhere in the hierarchy
    BUCKET* pCurrent{ nullptr };

    // currently executing hierarchy level
    uint32_t level{ 0 };

    // threadviz file object
    FILE* vizFile{ nullptr };


    BUCKET_THREAD() {}
    BUCKET_THREAD(const BUCKET_THREAD& that)
    {
        name = that.name;
        id = that.id;
        root = that.root;
        pCurrent = &root;
        vizFile = that.vizFile;
    }
};

enum VIZ_TYPE
{
    VIZ_START = 0,
    VIZ_STOP  = 1,
    VIZ_DATA  = 2
};

struct VIZ_START_DATA
{
    uint8_t type;
    uint32_t bucketId;
    uint64_t timestamp;
};

struct VIZ_STOP_DATA
{
    uint8_t type;
    uint64_t timestamp;
};

inline void Serialize(FILE* f, const VIZ_START_DATA& data)
{
    fwrite(&data, sizeof(VIZ_START_DATA), 1, f);
}

inline void Deserialize(FILE* f, VIZ_START_DATA& data)
{
    fread(&data, sizeof(VIZ_START_DATA), 1, f);
    assert(data.type == VIZ_START);
}

inline void Serialize(FILE* f, const VIZ_STOP_DATA& data)
{
    fwrite(&data, sizeof(VIZ_STOP_DATA), 1, f);
}

inline void Deserialize(FILE* f, VIZ_STOP_DATA& data)
{
    fread(&data, sizeof(VIZ_STOP_DATA), 1, f);
    assert(data.type == VIZ_STOP);
}

inline void Serialize(FILE* f, const std::string& string)
{
    assert(string.size() <= 256);

    uint8_t length = (uint8_t)string.size();
    fwrite(&length, sizeof(length), 1, f);
    fwrite(string.c_str(), string.size(), 1, f);
}

inline void Deserialize(FILE* f, std::string& string)
{
    char cstr[256];
    uint8_t length;
    fread(&length, sizeof(length), 1, f);
    fread(cstr, length, 1, f);
    cstr[length] = 0;
    string.assign(cstr);
}

inline void Serialize(FILE* f, const BUCKET_DESC& desc)
{
    Serialize(f, desc.name);
    Serialize(f, desc.description);
    fwrite(&desc.enableThreadViz, sizeof(desc.enableThreadViz), 1, f);
    fwrite(&desc.color, sizeof(desc.color), 1, f);
}

inline void Deserialize(FILE* f, BUCKET_DESC& desc)
{
    Deserialize(f, desc.name);
    Deserialize(f, desc.description);
    fread(&desc.enableThreadViz, sizeof(desc.enableThreadViz), 1, f);
    fread(&desc.color, sizeof(desc.color), 1, f);
}