Classroom refactoring exercise (day 1)

/*
2018-11-27 classroom refactoring exercise
- replaced char* with const char* in all arguments
- removed dependency on "TextBox", replacing it with std::string outputBuffer.
- inverted needlessly long branches to reduce the amount of nested scopes
- turned the global functions into static class methods
- made "internal" functions private
- changed all const char* arguments to const std::string&
- fixed smell: multiple output parameters (GetProfileFromHistory(const string&, float*, float*, float*))
------by creating a SamplePoint type and making use of structured bindings
- Changed char* members in ProfileSampleHistory and ProfileSample for std::string
--- allowing us to remove all strcmp and strln-calls.
*/
#ifndef _PROFILE_H
#define _PROFILE_H
#include <string>
class Profile {
    struct SamplePoint{
        float ave{ 0 }, min{ 0 }, max{ 0 };
    };
    static void StoreProfileInHistory(const std::string& name, float percent);
    static SamplePoint GetProfileFromHistory(const std::string& name);
public:
    static void Init(void);
    static void Begin(const std::string& name);
    static void End(const std::string& name);
    static void DumpOutputToBuffer(void);
    static void Draw(void);
};
#endif //_PROFILE_H

/* Copyright (C) Steve Rabin, 2000.
 * All rights reserved worldwide.
 *
 * This software is provided "as is" without express or implied
 * warranties. You may freely copy and compile this source into
 * applications you distribute provided that the copyright text
 * below is included in the resulting source code, for example:
 * "Portions Copyright (C) Steve Rabin, 2000"
 */
#include "profile.h"
#include "custom_time.h"
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
typedef struct {
    bool bValid;                 //Whether this data is valid
    unsigned int iProfileInstances;      //# of times ProfileBegin called
    int iOpenProfiles;           //# of times ProfileBegin w/o ProfileEnd
    std::string szName;            //Name of sample
    float fStartTime;            //The current open profile start time
    float fAccumulator;          //All samples this frame added together
    float fChildrenSampleTime;   //Time taken by all children
    unsigned int iNumParents;            //Number of profile parents
} ProfileSample;

typedef struct {
    bool bValid;        //Whether the data is valid
    std::string szName;   //Name of the sample
    float fAve;         //Average time per frame (percentage)
    float fMin;         //Minimum time per frame (percentage)
    float fMax;         //Maximum time per frame (percentage)
} ProfileSampleHistory;

#define NUM_PROFILE_SAMPLES 50
ProfileSample g_samples[NUM_PROFILE_SAMPLES];
ProfileSampleHistory g_history[NUM_PROFILE_SAMPLES];
float g_startProfile = 0.0f;
float g_endProfile = 0.0f;
std::string outputBuffer = "";

void Profile::Init(void) {
    for (unsigned int i = 0; i < NUM_PROFILE_SAMPLES; i++) {
        g_samples[i].bValid = false;
        g_history[i].bValid = false;
    }
    g_startProfile = GetExactTime();
}

void Profile::Begin(const std::string& name) {
    unsigned int i = 0;
    while (i < NUM_PROFILE_SAMPLES && g_samples[i].bValid == true) {
        if (g_samples[i].szName == name) {
            //Found the sample
            g_samples[i].iOpenProfiles++;
            g_samples[i].iProfileInstances++;
            g_samples[i].fStartTime = GetExactTime();
            assert(g_samples[i].iOpenProfiles == 1); //max 1 open at once
            return;
        }
        i++;
    }

    if (i >= NUM_PROFILE_SAMPLES) {
        assert(!"Exceeded Max Available Profile Samples");
        return;
    }

    g_samples[i].szName = name;
    g_samples[i].bValid = true;
    g_samples[i].iOpenProfiles = 1;
    g_samples[i].iProfileInstances = 1;
    g_samples[i].fAccumulator = 0.0f;
    g_samples[i].fStartTime = GetExactTime();
    g_samples[i].fChildrenSampleTime = 0.0f;
}


void Profile::End(const std::string& name) {
    unsigned int i = 0;
    unsigned int numParents = 0;
    while (i < NUM_PROFILE_SAMPLES && g_samples[i].bValid == true) {
        if (g_samples[i].szName != name) {
            i++;
            continue; // not the sample we want, go to the next
        }
        unsigned int inner = 0;
        int parent = -1;
        float fEndTime = GetExactTime();
        g_samples[i].iOpenProfiles--;

        //Count all parents and find the immediate parent
        while (g_samples[inner].bValid == true) {
            if (g_samples[inner].iOpenProfiles > 0) {  //Found a parent (any open profiles are parents)
                numParents++;
                if (parent < 0) {  //Replace invalid parent (index)
                    parent = inner;
                }
                else if (g_samples[inner].fStartTime >= g_samples[parent].fStartTime) {
                    //Replace with more immediate parent
                    parent = inner;
                }
            }
            inner++;
        }
        g_samples[i].iNumParents = numParents; //Remember the current number of parents of the sample

        if (parent >= 0) {  //Record this time in fChildrenSampleTime (add it in)
            g_samples[parent].fChildrenSampleTime += fEndTime - g_samples[i].fStartTime;
        }
        //Save sample time in accumulator
        g_samples[i].fAccumulator += fEndTime - g_samples[i].fStartTime;
        return;
    }
}

void Profile::DumpOutputToBuffer(void) {
    unsigned int i = 0;
    g_endProfile = GetExactTime();
    outputBuffer.clear();
    outputBuffer += "  Ave :   Min :   Max :   # : Profile Name\n";
    outputBuffer += "--------------------------------------------\n";
    while (i < NUM_PROFILE_SAMPLES && g_samples[i].bValid == true) {
        unsigned int indent = 0;
        float sampleTime, percentTime;
        char line[256], name[256];
        std::string indentedName;
        char ave[16], min[16], max[16], num[16];

        if (g_samples[i].iOpenProfiles < 0) { assert(!"ProfileEnd() called without a ProfileBegin()"); }
        else if (g_samples[i].iOpenProfiles > 0) { assert(!"ProfileBegin() called without a ProfileEnd()"); }

        sampleTime = g_samples[i].fAccumulator - g_samples[i].fChildrenSampleTime;
        percentTime = (sampleTime / (g_endProfile - g_startProfile)) * 100.0f;


        //Add new measurement into the history and get the ave, min, and max
        StoreProfileInHistory(g_samples[i].szName, percentTime);
        auto [aveTime, minTime, maxTime] = GetProfileFromHistory(g_samples[i].szName);

        //TODO Format the data
        /*std::stringstream output;
        output << std::setprecision(4) <<;*/
        sprintf_s(ave, "%3.1f", aveTime);
        sprintf_s(min, "%3.1f", minTime);
        sprintf_s(max, "%3.1f", maxTime);
        sprintf_s(num, "%3d", g_samples[i].iProfileInstances);

        indentedName = g_samples[i].szName;
        for (indent = 0; indent < g_samples[i].iNumParents; indent++) {
            sprintf_s(name, "   %s", indentedName.c_str());
            indentedName = name;
        }
        sprintf_s(line, "%3s : %3s : %3s : %3s : %s\n", ave, min, max, num, indentedName.c_str());
        outputBuffer += line;   //Send the line to text buffer
        i++;
    }
    {  //Reset samples for next frame
        unsigned int j;
        for (j = 0; j < NUM_PROFILE_SAMPLES; j++) {
            g_samples[j].bValid = false;
        }
        g_startProfile = GetExactTime();
    }
}

void Profile::StoreProfileInHistory(const std::string& name, float percent) {
    unsigned int i = 0;
    float oldRatio;
    float newRatio = 0.8f * GetElapsedTime();
    if (newRatio > 1.0f) {
        newRatio = 1.0f;
    }
    oldRatio = 1.0f - newRatio;
    // TODO: replace with std::find
    for (auto& sample : g_history) {
        if (!sample.bValid) {
            break;
        }
        if (sample.szName != name) {
            i++;
            continue;
        }

        //Found the sample
        sample.fAve = (sample.fAve*oldRatio) + (percent*newRatio);
        if (percent > sample.fMax) {
            sample.fMax = percent;
        }
        if (percent < sample.fMin) {
            sample.fMin = percent;
        }
        else {
            sample.fMin = (sample.fMin*oldRatio) + (percent*newRatio);
        }
        if (sample.fMin < 0.0f) {
            sample.fMin = 0.0f;
        }
        else {
            sample.fMax = (sample.fMax*oldRatio) + (percent*newRatio);
        }
        return;
    }

    if (i < NUM_PROFILE_SAMPLES) {  //Add to history
        g_history[i].szName = name;
        g_history[i].bValid = true;
        g_history[i].fAve = g_history[i].fMin = g_history[i].fMax = percent;
    }
    else {
        assert(!"Exceeded Max Available Profile Samples!");
    }
}

Profile::SamplePoint Profile::GetProfileFromHistory(const std::string& name) {
    SamplePoint result{};
    for (auto& sample : g_history){
        if (sample.bValid == true && sample.szName == name) {
            result.ave = sample.fAve;
            result.max = sample.fMax;
            result.min = sample.fMin;

            return result;
        }
    }
    return result;
}

void Profile::Draw(void) {
    std::cout << outputBuffer << '\n';
}