/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     demo_DebugUtility.cpp
  
  Copyright (C)2009-2011 Nintendo/HAL Laboratory, Inc.  All rights reserved.
  
  These coded instructions, statements, and computer programs contain proprietary
  information of Nintendo and/or its licensed developers and are protected by
  national and international copyright laws. They may not be disclosed to third
  parties or copied or duplicated in any form, in whole or in part, without the
  prior written consent of Nintendo.
  
  The content herein is highly confidential and should be handled accordingly.
  
  $Revision: $
 *---------------------------------------------------------------------------*/

#include <nw/types.h>
#include <nw/os.h>
#include <nw/ut/ut_Inlines.h>
#include <nw/demo/demo_DebugUtility.h>

#include <nn/fs.h>


namespace nw {
namespace demo {

size_t DebugUtility::s_DeviceMemoryFreeSize = 0;
size_t DebugUtility::s_ParticleMemoryFreeSize = 0;
nw::demo::DemoAllocator* DebugUtility::s_DeviceAllocator = NULL;
nw::demo::DemoAllocator* DebugUtility::s_ParticleAllocator = NULL;
bool DebugUtility::s_IsForceCpuProfilingMode = false;
bool DebugUtility::s_SilentMode = false;
s32 DebugUtility::s_ProfileCallCount = 0;
s32 DebugUtility::s_DebugFrameCount = 0;

static bool s_LastCpuCountingMode = false;

//----------------------------------------
void
DebugUtility::CalcLoadMeter(
    nw::demo::RenderSystem* renderSystem
)
{
    NW_POINTER_ASSERT(renderSystem);

    ++s_DebugFrameCount;

    if (nw::demo::DebugUtility::IsCpuProfilingMode() != s_LastCpuCountingMode)
    {
        if (!s_SilentMode)
        {
            if (nw::demo::DebugUtility::IsCpuProfilingMode())
            {
                NW_DEV_LOG("-------------------------------------------------------------------------------\n");
                NW_DEV_LOG("|                         Entering CPU profiling mode.                        |\n");
                NW_DEV_LOG("-------------------------------------------------------------------------------\n");
                NW_DEV_LOG("Command list won't run.\n");
                NW_DEV_LOG("Load meter will be output to log.\n");
                NW_DEV_LOG("To leave profiling mode, turn DBG switch OFF.\n");
                NW_DEV_LOG("\n");
            }
            else
            {
                NW_DEV_LOG("-------------------------------------------------------------------------------\n");
                NW_DEV_LOG("|                         Leaving CPU profiling mode.                         |\n");
                NW_DEV_LOG("-------------------------------------------------------------------------------\n");
            }
        }
        s_LastCpuCountingMode = nw::demo::DebugUtility::IsCpuProfilingMode();
    }

    if (s_DebugFrameCount % NW_LOAD_METER_INTERVAL == 0)
    {
        if (nw::demo::DebugUtility::IsCpuProfilingMode())
        {
            if (s_DebugFrameCount % (NW_LOAD_METER_INTERVAL * 3) == 0)
            {
                renderSystem->CalcLoadMeter();
                if (!s_SilentMode)
                {
                    DumpLoadMeter(renderSystem);
                    NW_DEV_LOG("\n");
                }
            }
        }
        else
        {
            renderSystem->CalcLoadMeter();
        }
    }
}

//----------------------------------------
void
DebugUtility::DrawLoadMeterText(
    nw::demo::RenderSystem* renderSystem,
    nw::demo::GraphicsDrawing* graphicsDrawing
)
{
    NW_POINTER_ASSERT(renderSystem);
    NW_POINTER_ASSERT(graphicsDrawing);

    static const s32 POS_LOAD_METER_TEXT_X = POS_LOAD_METER_X + 15;
    static const s32 POS_BAR_CHART_TEXT_X = POS_BAR_CHART_X + 14;


    graphicsDrawing->DrawString(POS_COMMAND_SIZE_X, POS_COMMAND_SIZE_Y, "Cmd size : %d bytes\n",
        renderSystem->GetLoadMeter().drawCommandBufferSize);

    float loadRate =
        renderSystem->GetLoadMeter().loadTime * nw::demo::RenderSystem::LoadMeterDescription::MILLI_TO_RATE;
    graphicsDrawing->DrawString(POS_LOAD_METER_TEXT_X, POS_LOAD_METER_Y, "CPU :%5.2f ms/f\n", 
        renderSystem->GetLoadMeter().loadTime);
    
    float loadGpuRate =
        renderSystem->GetLoadMeter().loadGpuTime * nw::demo::RenderSystem::LoadMeterDescription::MILLI_TO_RATE;
    graphicsDrawing->DrawString(POS_LOAD_METER_TEXT_X, POS_LOAD_METER_Y + HEIGHT_LOAD_METER,"GPU :%5.2f ms/f\n",
        renderSystem->GetLoadMeter().loadGpuTime);


    graphicsDrawing->DrawString(
        POS_BAR_CHART_TEXT_X + WIDTH_LOAD_METER_BAR_CHART / 4 * loadRate,
        POS_BAR_CHART_Y,
        "%.2f %%", 
        loadRate * 100.0f
    );

    graphicsDrawing->DrawString(
        POS_BAR_CHART_TEXT_X + WIDTH_LOAD_METER_BAR_CHART / 4 * loadGpuRate,
        POS_BAR_CHART_Y + HEIGHT_LOAD_METER_BAR_CHART,
        "%.2f %%", 
        loadGpuRate * 100.0f
    );
}

//----------------------------------------
void
DebugUtility::DrawLoadMeter(
    nw::demo::RenderSystem* renderSystem,
    nw::demo::GraphicsDrawing* graphicsDrawing
)
{
    NW_POINTER_ASSERT(renderSystem);
    NW_POINTER_ASSERT(graphicsDrawing);

    static const s32 POS_BAR_CHART_BACKGROUND_X = POS_BAR_CHART_X + 8;
    static const s32 WIDTH_BAR_CHART_BACKGROUND = WIDTH_LOAD_METER_BAR_CHART + 2;
    static const s32 HEIGHT_BAR_CHART_BACKGROUND = 15;
    static const s32 WIDTH_BAR_CHART_LEFTBOX = 8;
    static const s32 HEIGHT_BAR_CHART_LEFTBOX = 16;
    static const s32 POS_BAR_CHART_LINE_Y = POS_BAR_CHART_Y + HEIGHT_BAR_CHART_LEFTBOX;
    static const s32 POS_BAR_CHART_BAR_LEFT = POS_BAR_CHART_X + WIDTH_BAR_CHART_LEFTBOX + 2;
    static const s32 HEIGHT_BAR_CHART_BAR = 14;
    static const s32 WIDTH_COLORBOX = 10;
    static const s32 HEIGHT_COLORBOX = 15;

    static const u32 COLOR_CPU = 0x2DC400FF;
    static const u32 COLOR_BAR_CHART_CPU = 0x6CFF52FF;
    static const u32 COLOR_GPU = 0xFF0000FF;
    static const u32 COLOR_BAR_CHART_GPU = 0xF464EFFF;
    static const u32 COLOR_BAR_CHART_BACKGROUND = 0x4B4B4BFF;
    static const u32 COLOR_BAR_CHART_HUNDRED_PERCENT = 0x808080FF;

    float loadRate =
        renderSystem->GetLoadMeter().loadTime * nw::demo::RenderSystem::LoadMeterDescription::MILLI_TO_RATE;
    float loadGpuRate =
        renderSystem->GetLoadMeter().loadGpuTime * nw::demo::RenderSystem::LoadMeterDescription::MILLI_TO_RATE;

    // CPU メーターを描画します。
    graphicsDrawing->FillRectangle(
        nw::math::VEC2(POS_BAR_CHART_BACKGROUND_X, POS_BAR_CHART_Y),
        nw::math::VEC2(WIDTH_BAR_CHART_BACKGROUND, HEIGHT_BAR_CHART_BACKGROUND),
        COLOR_BAR_CHART_BACKGROUND
    );

    graphicsDrawing->FillRectangle(
        nw::math::VEC2(POS_BAR_CHART_X, POS_BAR_CHART_Y),
        nw::math::VEC2(WIDTH_BAR_CHART_LEFTBOX, HEIGHT_BAR_CHART_LEFTBOX),
        COLOR_CPU
    );

    graphicsDrawing->DrawLine(
        nw::math::VEC2(POS_BAR_CHART_X, POS_BAR_CHART_LINE_Y),
        nw::math::VEC2(POS_BAR_CHART_BAR_LEFT + WIDTH_LOAD_METER_BAR_CHART, POS_BAR_CHART_LINE_Y),
        COLOR_CPU
    );

    graphicsDrawing->FillRectangle(
        nw::math::VEC2(POS_BAR_CHART_BAR_LEFT, POS_BAR_CHART_Y),
        nw::math::VEC2(WIDTH_LOAD_METER_BAR_CHART / 4 * loadRate, HEIGHT_BAR_CHART_BAR),
        COLOR_BAR_CHART_CPU
    );

    graphicsDrawing->DrawLine(
        nw::math::VEC2(POS_BAR_CHART_BAR_LEFT + WIDTH_LOAD_METER_BAR_CHART / 4, POS_BAR_CHART_Y),
        nw::math::VEC2(POS_BAR_CHART_BAR_LEFT + WIDTH_LOAD_METER_BAR_CHART / 4, POS_BAR_CHART_Y + HEIGHT_BAR_CHART_BACKGROUND),
        COLOR_BAR_CHART_HUNDRED_PERCENT
    );

    graphicsDrawing->FillRectangle(
        nw::math::VEC2(POS_LOAD_METER_X, POS_LOAD_METER_Y),
        nw::math::VEC2(WIDTH_COLORBOX, HEIGHT_COLORBOX),
        COLOR_CPU
    );

    // GPU メーターを描画します。
    graphicsDrawing->FillRectangle(
        nw::math::VEC2(POS_BAR_CHART_BACKGROUND_X, POS_BAR_CHART_Y + HEIGHT_LOAD_METER_BAR_CHART),
        nw::math::VEC2(WIDTH_BAR_CHART_BACKGROUND, HEIGHT_BAR_CHART_BACKGROUND),
        COLOR_BAR_CHART_BACKGROUND
    );

    graphicsDrawing->FillRectangle(
        nw::math::VEC2(POS_BAR_CHART_X, POS_BAR_CHART_Y + HEIGHT_LOAD_METER_BAR_CHART),
        nw::math::VEC2(WIDTH_BAR_CHART_LEFTBOX, HEIGHT_BAR_CHART_LEFTBOX),
        COLOR_GPU
    );

    graphicsDrawing->DrawLine(
        nw::math::VEC2(POS_BAR_CHART_X, POS_BAR_CHART_LINE_Y + HEIGHT_LOAD_METER_BAR_CHART),
        nw::math::VEC2(POS_BAR_CHART_BAR_LEFT + WIDTH_LOAD_METER_BAR_CHART, POS_BAR_CHART_LINE_Y + HEIGHT_LOAD_METER_BAR_CHART),
        COLOR_GPU
    );

    graphicsDrawing->FillRectangle(
        nw::math::VEC2(POS_BAR_CHART_BAR_LEFT, POS_BAR_CHART_Y + HEIGHT_LOAD_METER_BAR_CHART),
        nw::math::VEC2(WIDTH_LOAD_METER_BAR_CHART / 4 * loadGpuRate, HEIGHT_BAR_CHART_BAR),
        COLOR_BAR_CHART_GPU
    );

    graphicsDrawing->DrawLine(
        nw::math::VEC2(POS_BAR_CHART_BAR_LEFT + WIDTH_LOAD_METER_BAR_CHART / 4, POS_BAR_CHART_Y + HEIGHT_LOAD_METER_BAR_CHART),
        nw::math::VEC2(POS_BAR_CHART_BAR_LEFT + WIDTH_LOAD_METER_BAR_CHART / 4, POS_BAR_CHART_Y + HEIGHT_BAR_CHART_BACKGROUND + HEIGHT_LOAD_METER_BAR_CHART),
        COLOR_BAR_CHART_HUNDRED_PERCENT
    );

    graphicsDrawing->FillRectangle(
        nw::math::VEC2(POS_LOAD_METER_X, POS_LOAD_METER_Y + HEIGHT_LOAD_METER),
        nw::math::VEC2(WIDTH_COLORBOX, HEIGHT_COLORBOX),
        COLOR_GPU
    );
}

//----------------------------------------
void
DebugUtility::DumpLoadMeter(
    nw::demo::RenderSystem* renderSystem
)
{
    float loadRate =
        renderSystem->GetLoadMeter().loadTime * nw::demo::RenderSystem::LoadMeterDescription::MILLI_TO_RATE;
    NW_DEV_LOG("      CPU :%5.2f ms/f (%6.2f %%)\n", 
        renderSystem->GetLoadMeter().loadTime, loadRate * 100.0f);
    
    float loadGpuRate =
        renderSystem->GetLoadMeter().loadGpuTime * nw::demo::RenderSystem::LoadMeterDescription::MILLI_TO_RATE;
    NW_DEV_LOG("      GPU :%5.2f ms/f (%6.2f %%)\n",
        renderSystem->GetLoadMeter().loadGpuTime, loadGpuRate * 100.0f);
    
    NW_DEV_LOG(" Cmd size :% 8d bytes\n",
        renderSystem->GetLoadMeter().drawCommandBufferSize);
}

} // namespace demo
} // namespace nw