//  BlockyFroggy
//  Copyright © 2017 John Ryland.
//  All rights reserved.
#include "SystemInformation.h"
#include <mach/mach.h>
#include <cassert>


SystemInformation::SystemInformation()
{
    m_lastFrameTimePoint = GameTime::now();
}


SystemInformation::~SystemInformation()
{
}


//
// http://stackoverflow.com/questions/8223348/ios-get-cpu-usage-from-application
//
float SystemInformation::getCpuUsage()
{
    kern_return_t kr;
    task_info_data_t tinfo;
    mach_msg_type_number_t task_info_count;
    
    task_info_count = TASK_INFO_MAX;
    kr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)tinfo, &task_info_count);
    if (kr != KERN_SUCCESS) {
        return -1;
    }
    
    //task_basic_info_t      basic_info;
    thread_array_t         thread_list;
    mach_msg_type_number_t thread_count;
    
    thread_info_data_t     thinfo;
    mach_msg_type_number_t thread_info_count;
    
    thread_basic_info_t basic_info_th;
    //uint32_t stat_thread = 0; // Mach threads
    
    //basic_info = (task_basic_info_t)tinfo;
    
    // get threads in the task
    kr = task_threads(mach_task_self(), &thread_list, &thread_count);
    if (kr != KERN_SUCCESS) {
        return -1;
    }
  
    //if (thread_count > 0)
    //    stat_thread += thread_count;
    
    long tot_sec = 0;
    long tot_usec = 0;
    float tot_cpu = 0;
    int j;
    
    for (j = 0; j < thread_count; j++)
    {
        thread_info_count = THREAD_INFO_MAX;
        kr = thread_info(thread_list[j], THREAD_BASIC_INFO,
                         (thread_info_t)thinfo, &thread_info_count);
        if (kr != KERN_SUCCESS) {
            return -1;
        }
        
        basic_info_th = (thread_basic_info_t)thinfo;
        
        if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
            tot_sec = tot_sec + basic_info_th->user_time.seconds + basic_info_th->system_time.seconds;
            tot_usec = tot_usec + basic_info_th->user_time.microseconds + basic_info_th->system_time.microseconds;
            tot_cpu = tot_cpu + basic_info_th->cpu_usage / (float)TH_USAGE_SCALE * 100.0;
        }
        
    } // for each thread
    
    kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
    assert(kr == KERN_SUCCESS);
    return tot_cpu;
}


//
// http://stackoverflow.com/questions/7989864/watching-memory-usage-in-ios
//
size_t SystemInformation::getMemoryUsage()
{
    struct task_basic_info info;
    mach_msg_type_number_t size = sizeof(info);
    //kern_return_t kr =
    task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &size);
    //assert(kr == KERN_SUCCESS);
    return info.resident_size; // size in bytes
}


float SystemInformation::getFrameTime()
{
    return m_lastFrameDuration.count() * 0.000000001f; // nanosecs to seconds as a float
}


float SystemInformation::getFps()
{
    return m_fps;
}


float SystemInformation::getAverageFps()
{
    return m_averageFps;
}


float SystemInformation::getDrawTime()
{
    return m_postDrawFrameDuration.count() * 0.000000001f; // nanosecs to seconds as a float
}


void SystemInformation::preDraw()
{
    m_preDrawTimePoint = GameTime::now();
}


//
// fps calculations
// http://stackoverflow.com/questions/1738315/calculate-fps-frames-per-second-for-iphone-app
//
void SystemInformation::frameDrawn()
{
    GameTime::TimePoint thisFrameTimePoint = GameTime::now();
    m_lastFrameDuration = thisFrameTimePoint - m_lastFrameTimePoint;
    m_lastFrameTimePoint = thisFrameTimePoint;
    m_postDrawFrameDuration = thisFrameTimePoint - m_preDrawTimePoint;

    uint64_t nanoSecs = m_lastFrameDuration.count();
    m_fps = (nanoSecs == 0) ? 0 : 1000000000 / float(nanoSecs);
    m_averageFpsCounter++;
    m_averageFpsSum += m_fps;
    if (m_averageFpsCounter >= 5) // calculate average FPS over 5 frames
    {
        m_averageFps = m_averageFpsSum / m_averageFpsCounter;
        m_averageFpsCounter = 0;
        m_averageFpsSum = 0;
    }
}