/**
 * m_Do_main.cpp
 * Main Initialization
 */

#include "m_Do/m_Do_main.h"
#include "DynamicLink.h"
#include "JSystem/JAudio2/JASAudioThread.h"
#include "JSystem/JAudio2/JAUSoundTable.h"
#include "JSystem/JFramework/JFWSystem.h"
#include "JSystem/JKernel/JKRAram.h"
#include "JSystem/JKernel/JKRSolidHeap.h"
#include "JSystem/JUtility/JUTConsole.h"
#include "JSystem/JUtility/JUTReport.h"
#include "JSystem/JUtility/JUTException.h"
#include "JSystem/JUtility/JUTProcBar.h"
#include "JSystem/JHostIO/JORServer.h"
#include "Z2AudioLib/Z2WolfHowlMgr.h"
#include "c/c_dylink.h"
#include "d/d_com_inf_game.h"
#include "d/d_s_logo.h"
#include "d/d_s_menu.h"
#include "d/d_s_play.h"
#include "d/d_debug_pad.h"
#include "f_ap/f_ap_game.h"
#include "f_op/f_op_msg.h"
#include "m_Do/m_Do_MemCard.h"
#include "m_Do/m_Do_Reset.h"
#include "m_Do/m_Do_controller_pad.h"
#include "m_Do/m_Do_dvd_thread.h"
#include "m_Do/m_Do_graphic.h"
#include "m_Do/m_Do_machine.h"
#include "m_Do/m_Do_printf.h"
#include "m_Do/m_Do_ext2.h"
#include "SSystem/SComponent/c_counter.h"
#include <string>

#if PLATFORM_WII || PLATFORM_SHIELD
#include <revolution/sc.h>
#endif

class mDoMain_HIO_c : public mDoHIO_entry_c {
public:
    void listenPropertyEvent(const JORPropertyEvent*);
    void genMessage(JORMContext*);
};

void version_check() {
#if !PLATFORM_SHIELD
    if (!strcmp("20Apr2004", "20Apr2004") && !strcmp("Patch2", "Patch2")) {
        return;
    }

    // "SDK version doesn't match. Stopping\n"
    OSReport_Error("SDKのバージョンが一致しません。停止します\n");
    do {
    } while (true);
#endif
}

char mDoMain::COPYDATE_STRING[18] = "??/??/?? ??:??:??";

// static HeapCheck RootHeapCheck;
static HeapCheck RootHeapCheck = HeapCheck(0,"Root","ルート");

// static HeapCheck SystemHeapCheck;
static HeapCheck SystemHeapCheck = HeapCheck(0,"System","システム");

// static HeapCheck ZeldaHeapCheck;
static HeapCheck ZeldaHeapCheck = HeapCheck(0,"Zelda","ゼルダ");

// static HeapCheck GameHeapCheck;
static HeapCheck GameHeapCheck = HeapCheck(0,"Game","ゲーム");

// static HeapCheck ArchiveHeapCheck;
static HeapCheck ArchiveHeapCheck = HeapCheck(0,"Archive","アーカイブ");

// static HeapCheck J2dHeapCheck;
static HeapCheck J2dHeapCheck = HeapCheck(0,"J2d","J2D");

// static HeapCheck HostioHeapCheck;
static HeapCheck HostioHeapCheck = HeapCheck(0,"Hostio","ホストIO");

// static HeapCheck CommandHeapCheck;
static HeapCheck CommandHeapCheck = HeapCheck(0,"Command","コマンド");

static HeapCheck* HeapCheckTable[8] = {
    &RootHeapCheck,    &SystemHeapCheck, &ZeldaHeapCheck,  &GameHeapCheck,
    &ArchiveHeapCheck, &J2dHeapCheck,    &HostioHeapCheck, &CommandHeapCheck,
};

void printFrameLine() {
    OSCalendarTime calendar;
    OSTime time = OSGetTime();
    u32 retrace = VIGetRetraceCount();
    OSTicksToCalendarTime(time, &calendar);

    OS_REPORT("\x1b[44m-- %5d - %5d - %3d %d %04d/%02d/%02d %02d:%02d:%02d\'%03d\'\'%03d\n\x1b[m",
              g_Counter.mCounter0, retrace,
              calendar.yday, calendar.wday, calendar.year, calendar.mon, calendar.mday,
              calendar.hour, calendar.min, calendar.sec, calendar.msec, calendar.usec);
}

void HeapCheck::CheckHeap1() {
    s32 totalUsedSize = mHeap->getTotalUsedSize();
    s32 freeSize = mHeap->getFreeSize();

    if (mMaxTotalUsedSize < totalUsedSize)
        mMaxTotalUsedSize = totalUsedSize;

    if (mMaxTotalFreeSize > freeSize)
        mMaxTotalFreeSize = freeSize;
}

void CheckHeap(u32 i_padNo) {
    mDoMch_HeapCheckAll();
    OSCheckActiveThreads();

    int saveRel = (mDoCPd_c::getHold(i_padNo) & ~PAD_TRIGGER_Z) == (PAD_TRIGGER_L + PAD_TRIGGER_R) && mDoCPd_c::getTrig(i_padNo) & PAD_TRIGGER_Z;

    for (int i = 0; i < 8; i++) {
        HeapCheckTable[i]->CheckHeap1();
        if (saveRel) {
            HeapCheckTable[i]->saveRelBase();
        }
    }
}

static int countUsed(JKRExpHeap* heap) {
    OSDisableScheduler();

    int counter = 0;
    JKRExpHeap::CMemBlock* used_blocks_head = heap->getUsedFirst();
    while (used_blocks_head) {
        counter++;
        used_blocks_head = used_blocks_head->getNextBlock();
    }

    OSEnableScheduler();
    return counter;
}

s32 HeapCheck::getUsedCount() const {
    return countUsed(mHeap);
}

void HeapCheck::heapDisplay() const {
    s32 heap_size = mHeap->getHeapSize();
    s32 used_count = heap_size - getTargetHeapSize();

    s32 total_used_size = mHeap->getTotalUsedSize();
    s32 total_free_size = mHeap->getTotalFreeSize();
    s32 heap_free_size = mHeap->getFreeSize();

    JUTReport(100, 212, "[%sName]", mName);
    JUTReport(100, 227, "HeapSize         %8ld", heap_size);
    JUTReport(100, 240, "TargetHeapSize   %8ld", getTargetHeapSize());
    JUTReport(100, 253, "TotalFree        %8ld", total_free_size - used_count);
    JUTReport(100, 266, "FreeSize         %8ld", heap_free_size - used_count);
    JUTReport(100, 279, "TotalUsedSize    %8ld", total_used_size);
    JUTReport(100, 292, "TotalUsedRate        %3ld%%", (int)(total_used_size * 100) / (int)getTargetHeapSize());
    JUTReport(100, 305, "MaxTotalUsedSize %8ld", mMaxTotalUsedSize);
    JUTReport(100, 318, "MaxTotalUsedRate     %3ld%%", (mMaxTotalUsedSize * 100) / (int)getTargetHeapSize());
    JUTReport(100, 331, "MinFreeSize      %8ld", mMaxTotalFreeSize - used_count);
    JUTReport(100, 344, "MinFreeRate          %3ld%%", ((mMaxTotalFreeSize - used_count) * 100) / (int)getTargetHeapSize());
    JUTReport(100, 357, "UsedCount             %3ld%", countUsed(mHeap));
}

#if DEBUG
int mDoMain::argument = -1;
#endif

s8 mDoMain::developmentMode = -1;

#if DEBUG
u32 mDoMain::gameHeapSize = 0xFFFFFFFF;
u32 mDoMain::archiveHeapSize = 0xFFFFFFFF;
#endif

u32 mDoMain::memMargin = 0xFFFFFFFF;

#if DEBUG
int mDoMain::e3menu_no = -1;
#endif

u8 mHeapBriefType = 4;

#if DEBUG
static u8 memorycheck_check_frame;
#endif

static u8 fillcheck_check_frame;

OSTime mDoMain::sPowerOnTime;

OSTime mDoMain::sHungUpTime;

static u8 mDisplayHeapSize;

#if DEBUG
static u8 mReportDisable;
#endif

static u8 mSelectHeapBar;

#if DEBUG
static u8 mVisibleHeapBar;
static u8 mPrintFrameLine;
#endif

static u8 mCheckHeap;

#if DEBUG
mDoMain_HIO_c mDoMain_HIO;
#endif

void debugDisplay() {
    static const char* desc1[5] = {
        "", "TotalFree", "MaxUsed  ", "Used     ", "RelUsed  ",
    };

    static const char* desc2[5] = {
        "", "/ MaxFree", "/HeapSize", "Blk/Bytes", "Blk/Bytes",
    };

    if (mSelectHeapBar >= 1 && mSelectHeapBar <= 6) {
        HeapCheckTable[mSelectHeapBar - 1]->heapDisplay();
    }

    if (mHeapBriefType == 5) {
        JKRAramHeap* heap = JKRAram::getAramHeap();
        if (heap != NULL) {
            JUTReport(475, 100, "ARAM Free");
            JUTReport(475, 114, "%d", heap->getFreeSize());
            JUTReport(475, 128, "TotalFree");
            JUTReport(475, 142, "%d", heap->getTotalFreeSize());
        }
        return;
    }
    
    if (mHeapBriefType != 0) {
        JUT_ASSERT(596, mHeapBriefType < HeapCheckTableNum);
        JUTReport(475, 100, "%s", desc1[mHeapBriefType]);
        JUTReport(475, 114, "%s", desc2[mHeapBriefType]);

        for (int i = 0; i < 8; i++) {
            HeapCheck* heap_check = HeapCheckTable[i];
            JKRExpHeap* expHeap = heap_check->getHeap();

            s32 check1;
            s32 check2;
            switch (mHeapBriefType) {
            case 1:
                check1 = expHeap->getTotalFreeSize();
                check2 = expHeap->getFreeSize();
                break;
            case 2:
                check1 = heap_check->getMaxTotalUsedSize();
                check2 = expHeap->getHeapSize();
                break;
            case 3:
                check1 = heap_check->getUsedCount();
                check2 = expHeap->getTotalUsedSize();
                break;
            case 4:
                check1 = heap_check->getRelUsedCount();
                check2 = heap_check->getRelTotalUsedSize();
                break;
            }

            JUTReport(475, (i * 44) + 150, " [%s]", heap_check->getName());
            JUTReport(475, (i * 44) + 164, "%10d", check1);
            JUTReport(475, (i * 44) + 178, "%10d", check2);
        }
    }
}

void my_genCheckBox(JORMContext* mctx, const char* label, u8* pSrc, u8 mask) {
    mctx->genCheckBox(label, pSrc, mask, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
}

#if DEBUG
void mDoMain_HIO_c::genMessage(JORMContext* mctx) {
    mctx->genSlider("コード破壊チェックフレーム", &memorycheck_check_frame, 0, 0xFF, 0, NULL, 0xFFFF,
                    0xFFFF, 0x200, 0x18);
    mctx->genButton("コード破壊チェックcheck", 0, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("コード破壊チェックsave", 1, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("コード破壊チェックdiff", 2, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genCheckBox("デバッグフィル", &mDoMch::mDebugFill, 1, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genSlider("ヒープ破壊チェックフレーム", &fillcheck_check_frame, 0, 0xFF, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ヒープ破壊チェック", 3, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ヒープFree領域フィル", 4, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("浮動小数点例外を(再び)有効にする", 5, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genCheckBox("◎無効演算", &mDoMch::FpscrEnableBits, 0x80, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genCheckBox("○オーバー", &mDoMch::FpscrEnableBits, 0x40, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genCheckBox("△アンダー", &mDoMch::FpscrEnableBits, 0x20, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genCheckBox("○ゼロ除算", &mDoMch::FpscrEnableBits, 0x10, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genCheckBox("▲不正確  ", &mDoMch::FpscrEnableBits, 0x8, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);

    mctx->genLabel("ソースファイル：m_Do_main.cpp", 0, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genCheckBox("OSReport 表示しない", &mReportDisable, 1, 0, NULL, 0xFFFF, 0xFFFF, 0x200,
                      0x18);
    mctx->genCheckBox("OSReport 優先度最高", &print_highPriority, 1, 0, NULL, 0xFFFF, 0xFFFF, 0x200,
                      0x18);
    mctx->genCheckBox("OSReport スレッド表示", &print_threadID, 1, 0, NULL, 0xFFFF, 0xFFFF,
                      0x200, 0x18);
    mctx->genCheckBox("OSReport CallerPC表示", &print_callerPC, 1, 0, NULL, 0xFFFF, 0xFFFF,
                      0x200, 0x18);
    mctx->genSlider("レベル", &print_callerPCLevel, 3, 10, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);

    mctx->startComboBox("簡易ヒープ表示", &mHeapBriefType, 0, NULL, 0xFFFF, 0xFFFF, 0x100, 0x1a);
    mctx->genComboBoxItem("なし", 0);
    mctx->genComboBoxItem("合計空き・最大空き", 1);
    mctx->genComboBoxItem("最大使用量・ヒープサイズ元使用量", 2);
    mctx->genComboBoxItem("使用ブロック数・元使用量", 3);
    mctx->genComboBoxItem("相対 使用ブロック数・元使用量", 4);
    mctx->endComboBox();

    my_genCheckBox(mctx, "ヒープサイズ表示を行う", &mDisplayHeapSize, 1);
    mctx->genCheckBox("ヒープバーを表示する", &mVisibleHeapBar, 1, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);

    mctx->startComboBox("ヒープバーの種類", &mSelectHeapBar, 0, NULL, 0xFFFF, 0xFFFF, 0x100, 0x1a);
    mctx->genComboBoxItem("カレント", 0);
    for (int i = 0; i < 8; i++) {
        mctx->genComboBoxItem(HeapCheckTable[i]->getJName(), i + 1);
    }
    mctx->endComboBox();

    mctx->genCheckBox("ヒープチェック", &mCheckHeap, 1, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genCheckBox("フレームバー表示", &mPrintFrameLine, 1, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);

    mctx->startComboBox("GX警告レベル", &mDoMch::GXWarningLevel, 0, NULL, 0xFFFF, 0xFFFF, 0x100, 0x1a);
    mctx->genComboBoxItem("エラー＆警告なし", 0);
    mctx->genComboBoxItem("致命的なエラー", 1);
    mctx->genComboBoxItem("中警告と全エラー", 2);
    mctx->genComboBoxItem("すべての警告", 3);
    mctx->endComboBox();

    mctx->genButton("GX警告を１フレームだけ実行", 9, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ダイナミックリンク状況をダンプ", 7, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ダイナミックリンクカウンタをリセット", 8, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ARAMヒープをダンプ", 10, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ゲームリソースをダンプ", 11, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("RES_CONTROLをダンプ", 12, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ルートヒープをダンプ", 13, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("システムヒープをダンプ", 14, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ゼルダヒープをダンプ", 15, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ゲームヒープをダンプ", 16, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("アーカイブヒープをダンプ", 17, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("J2Dヒープをダンプ", 18, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("ホストIOヒープをダンプ", 19, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);
    mctx->genButton("コマンドヒープをダンプ", 20, 0, NULL, 0xFFFF, 0xFFFF, 0x200, 0x18);

    mctx->genCheckBox("ダイナミックリンク冗長表示", &DynamicModuleControlBase::verbose, 1, 0, NULL, 0xFFFF, 0xFFFF,
                      0x200, 0x18);
    mctx->genCheckBox("ヒープコールバック冗長表示", &mDoMch::myHeapVerbose, 1, 0, NULL, 0xFFFF, 0xFFFF,
                      0x200, 0x18);
    mctx->genCheckBox("ヒープコールバックチェック", &mDoMch::myHeapCallbackCheck, 1, 0, NULL, 0xFFFF, 0xFFFF,
                      0x200, 0x18);
    mctx->genCheckBox("mDoDvdThd::verbose冗長表示", &mDoDvdThd::verbose, 1, 0, NULL, 0xFFFF, 0xFFFF,
                      0x200, 0x18);
    mctx->genCheckBox("mDoDvdThd::DVDRead冗長表示", &mDoDvdThd::Report_DVDRead, 1, 0, NULL, 0xFFFF, 0xFFFF,
                      0x200, 0x18);
    mctx->genCheckBox("mDoDvdThd::DVDログモード", &mDoDvdThd::DVDLogoMode, 1, 0, NULL, 0xFFFF, 0xFFFF,
                      0x200, 0x18);
    mctx->genCheckBox("fopMsg::MemCheck ヒープチェック", &fopMsg::MemCheck, 1, 0, NULL, 0xFFFF,
                      0xFFFF, 0x200, 0x18);
}

void mDoMain_HIO_c::listenPropertyEvent(const JORPropertyEvent* property) {
    JORMContext* mctx = attachJORMContext(8);
    JORReflexible::listenPropertyEvent(property);

    if ((u32)property->id >= 13 && (u32)property->id <= 20) {
        int sp14 = (u32)property->id - 13;
        HeapCheck* heapCheck = HeapCheckTable[sp14];
        JUTReportConsole_f("\n[%sHeap]\n", heapCheck->getName());
        heapCheck->getHeap()->dump_sort();
    } else {
        switch ((u32)property->id) {
        case 0:
            FixedMemoryCheck::checkAll();
            break;
        case 1:
            FixedMemoryCheck::saveAll();
            break;
        case 2:
            FixedMemoryCheck::diffAll();
            break;
        case 3:
            mDoMch_HeapCheckAll();
            break;
        case 4:
            mDoMch_HeapFreeFillAll();
            break;
        case 5: {
            u32 fpscr = PPCMffpscr();
            JUTException::setFPException(0);
            JUTException::setFPException(mDoMch::FpscrEnableBits);
            PPCMtfpscr(fpscr);
            break;
        }
        case 9:
            GXSetVerifyLevel(GX_WARN_ALL);
            mDoMch::GXWarningExecuteFrame = TRUE;
            break;
        case 7: {
            int RoomId = dComIfGp_roomControl_getStayNo();
            JUTReportConsole_f("\nRoomId = %d\n", RoomId);

            JUTReportConsole_f("\nDynamicModule\n");
            DynamicModuleControlBase::dump();
            break;
        }
        case 8:
            DynamicModuleControlBase::resetDoLinkCount();
            break;
        case 10: {
            JUTReportConsole_f("\nAramHeap\n");
            JKRAramHeap* aramHeap = JKRAram::getAramHeap();
            if (aramHeap != NULL) {
                aramHeap->dump();
            }
            break;
        }
        case 11:
            JUTReportConsole_f("\nGameResource\n");
            g_dComIfG_gameInfo.mResControl.dump();
            break;
        case 12:
            JUTReportConsole_f("\nResControl\n");
            dComIfG_dumpResControl();
            break;
        case 6:
        default:
            if ((u8*)property->id == &mDisplayHeapSize) {
                mctx->startUpdateNode(this);
                mctx->endUpdateNode();
            }

            if ((u8*)property->id == &mReportDisable) {
                if (mReportDisable == 0) {
                    OSReportEnable();
                } else {
                    OSReportDisable();
                }
            }

            if ((u8*)property->id == &mSelectHeapBar) {
                JKRHeap* heap = NULL;
                u32 select_heap = mSelectHeapBar - 1;
                if (select_heap < 8) {
                    heap = HeapCheckTable[select_heap]->getHeap();
                }

                JUTProcBar::getManager()->setWatchHeap(heap);
            }

            if ((u8*)property->id == &mVisibleHeapBar) {
                JUTProcBar::getManager()->setVisibleHeapBar(mVisibleHeapBar);
            }

            if ((u8*)property->id == &mDoMch::GXWarningLevel) {
                GXSetVerifyLevel((GXWarningLevel)mDoMch::GXWarningLevel);
            }

            if ((u8*)property->id == &mDoMch::mDebugFill) {
                JKRHeap::setDefaultDebugFill(mDoMch::mDebugFill);

                for (JSUTree<JKRHeap>* i = JKRGetRootHeap()->getHeapTree().getFirstChild(); i != NULL; i = i->getNextChild()) {
                    JKRHeap* heap = i->getObject();
                    heap->setDebugFill(mDoMch::mDebugFill);
                }
            }

            JKRSetDebugFillNotuse(mDoMch::mDebugFillNotUse);
            JKRSetDebugFillNew(mDoMch::mDebugFillNew);
            JKRSetDebugFillDelete(mDoMch::mDebugFillDelete);
        }
    }

    releaseJORMContext(mctx);
}
#endif

bool Debug_console(u32 i_padNo) {
    JUTConsole* console = JFWSystem::getSystemConsole();
    if (console != NULL) {
        static f32 console_position_x = 20.0f;
        static f32 console_position_y = 30.0f;
        static f32 console_scroll = 0.0f;

        if (mDoCPd_c::getTrig(i_padNo) & PAD_TRIGGER_Z && !(mDoCPd_c::getHold(i_padNo) & ~PAD_TRIGGER_Z)) {
            console->setVisible(console->isVisible() == false);
            JUTAssertion::setMessageCount(0);
        }

        if (console->isVisible()) {
            if ((mDoCPd_c::getHold(i_padNo) & PAD_TRIGGER_L && mDoCPd_c::getHold(i_padNo) & PAD_TRIGGER_R) ||
                ((mDoCPd_c::getAnalogL(i_padNo) > 0.0f && mDoCPd_c::getAnalogR(i_padNo) > 0.0f)))
            {
                f32 stick_x = mDoCPd_c::getStickX(i_padNo);
                f32 stick_y = mDoCPd_c::getStickY(i_padNo);

                if (mDoCPd_c::getHold(i_padNo) & (PAD_BUTTON_Y | PAD_BUTTON_X) &&
                    mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_START)
                {
                    console->clear();
                }

                if (!(mDoCPd_c::getHold(i_padNo) & (PAD_BUTTON_Y | PAD_BUTTON_X))) {
                    console_scroll -= stick_y;

                    int scrollAmount;
                    if (console_scroll > 1.0f) {
                        scrollAmount = console_scroll;
                    } else if (console_scroll < -1.0f) {
                        scrollAmount = -(int)-console_scroll;
                    } else {
                        scrollAmount = 0;
                    }

                    if (scrollAmount != 0) {
                        console_scroll -= scrollAmount;
                        console->scroll(scrollAmount);
                    }
                } else {
                    if (mDoCPd_c::getHold(i_padNo) & PAD_BUTTON_X) {
                        console_position_x += stick_x;
                    }

                    if (mDoCPd_c::getHold(i_padNo) & PAD_BUTTON_Y) {
                        console_position_y -= stick_y;
                    }
                }

                if (mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_A) {
                    console->dumpToTerminal(0xFFFFFFFF);
                    console->setOutput(JUTConsole::OUTPUT_OSREPORT | JUTConsole::OUTPUT_CONSOLE);
                }

                JUTReport(30, 390, 1, "Press X+Y+START to CLEAR console.");
                JUTReport(30, 400, 1, "3DStick UP/Down to scroll");
                JUTReport(30, 410, 1, "Press A to output terminal from console.");
                JUTReport(30, 420, 1, "SCROLL：%3d %3d %3d Output=%1x", console->getLineOffset(),
                          console->getPositionX(), console->getPositionY(), console->getOutput());
            } else {
                if (mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_DOWN) {
                    g_HIO.mDisplayMeter ^= (u8)1;
                }

                if (mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_LEFT) {
                    JKRAramHeap* aram = JKRAram::getAramHeap();
                    if (aram != NULL) {
                        aram->dump();
                    }

                    DynamicModuleControlBase::dump();
                    g_dComIfG_gameInfo.mResControl.dump();
                }

                if (mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_RIGHT) {
                    JKRGetSystemHeap()->dump_sort();
                }

                if (mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_UP) {
                    zeldaHeap->dump_sort();
                    gameHeap->dump_sort();
                    archiveHeap->dump_sort();
                }

                JUTReport(30, 440, 1, "Press L+R trigger to control console.");
                JUTReport(30, 450, 1, "Press [Z] trigger to close this window.");
            }

            console->setPosition(console_position_x, console_position_y);
            return 1;
        }
    }

    return 0;
}

#if PLATFORM_GCN
#define COPYDATE_PATH "/str/Final/Release/COPYDATE"
#else
#define COPYDATE_PATH "/str/RVL/Debug/COPYDATE"
#endif

s32 LOAD_COPYDATE(void*) {
    DVDFileInfo ATTRIBUTE_ALIGN(32) fileInfo;
    u8 buffer[32];

    BOOL status = DVDOpen(COPYDATE_PATH, &fileInfo);
    if (status) {
        s32 rt = DVDReadPrio(&fileInfo, &buffer, sizeof(buffer), 0, 2);
        memcpy(mDoMain::COPYDATE_STRING, buffer, sizeof(mDoMain::COPYDATE_STRING) - 1);
        status = DVDClose(&fileInfo);
    }

    OS_REPORT("\x1b[36mCOPYDATE=[%s]\n\x1b[m", mDoMain::COPYDATE_STRING);
    return status;
}

static void debug() {
    #if DEBUG
    if (mPrintFrameLine) {
        printFrameLine();
    }
    #endif

    if (mDoMain::developmentMode) {
        if (mCheckHeap) {
            CheckHeap(PAD_3);
        }

        if ((mDoCPd_c::getGamePad(PAD_3)->getButton() & ~PAD_TRIGGER_Z) == PAD_TRIGGER_R &&
            mDoCPd_c::getGamePad(PAD_3)->testTrigger(PAD_TRIGGER_Z))
        {
            mDisplayHeapSize ^= (u8)1;
        }

        if (mDisplayHeapSize) {
            if ((mDoCPd_c::getGamePad(PAD_3)->getButton() & ~PAD_TRIGGER_Z) == PAD_TRIGGER_L &&
                mDoCPd_c::getGamePad(PAD_3)->testTrigger(PAD_TRIGGER_Z))
            {
                if (mHeapBriefType < 5) {
                    mHeapBriefType++;
                } else {
                    mHeapBriefType = 1;
                }
            }

            debugDisplay();
        }

        #if DEBUG
        if (!dDebugPad.Active()) {
            Debug_console(PAD_3);
        }
        #else
        Debug_console(PAD_3);
        #endif
        
        #if DEBUG
        fapGm_HIO_c::startCpuTimer();

        if (fapGmHIO_getHostIO()) {
            JKRHeap* var_r30 = mDoExt_getHostIOHeap();
            JKRHeap* var_r29 = mDoExt_setCurrentHeap(var_r30);
            JOR_MESSAGELOOP();
            mDoExt_setCurrentHeap(var_r29);
        }

        fapGm_HIO_c::printCpuTimer("");
        fapGm_HIO_c::stopCpuTimer("ホストＩＯ");
        fapGm_HIO_c::printCpuTimer("\n↑↑↑↑↑↑↑↑↑↑　ＣＰＵ時間計測終了　↑↑↑↑↑↑↑↑↑↑\n");
        fapGm_HIO_c::offCpuTimer();
        #endif
    }
}

// linker generated symbols
extern u8 _f_text[];
extern u8 _e_text[];
extern u8 _f_ctors[];
extern u8 _e_ctors[];
extern u8 _f_dtors[];
extern u8 _e_dtors[];
extern u8 _f_rodata[];
extern u8 _e_rodata[];

#if VERSION == VERSION_SHIELD_DEBUG
const int audioHeapSize = 0x169000;
#else
const int audioHeapSize = 0x14D800;
#endif

void main01(void) {
    OS_REPORT("\x1b[m");

    // Setup heaps, setup exception manager, set RNG seed, setup DVDError Thread, setup Memory card Thread
    mDoMch_Create();

    #if DEBUG
    FixedMemoryCheck* local_20 = FixedMemoryCheck::easyCreate(_f_text, intptr_t(_e_text - _f_text));
    FixedMemoryCheck* local_24 = FixedMemoryCheck::easyCreate(_f_ctors, intptr_t(_e_ctors - _f_ctors));
    FixedMemoryCheck* local_28 = FixedMemoryCheck::easyCreate(_f_dtors, intptr_t(_e_dtors - _f_dtors));
    FixedMemoryCheck* local_2c = FixedMemoryCheck::easyCreate(_f_rodata, intptr_t(_e_rodata - _f_rodata));
    #endif

    // setup FrameBuffer and ZBuffer, init display lists
    mDoGph_Create();

    // Setup control pad
    mDoCPd_c::create();

    RootHeapCheck.setHeap((JKRExpHeap*)JKRGetRootHeap());
    SystemHeapCheck.setHeap((JKRExpHeap*)JKRGetSystemHeap());
    ZeldaHeapCheck.setHeap(mDoExt_getZeldaHeap());
    GameHeapCheck.setHeap(mDoExt_getGameHeap());
    ArchiveHeapCheck.setHeap(mDoExt_getArchiveHeap());
    J2dHeapCheck.setHeap(mDoExt_getJ2dHeap());
    HostioHeapCheck.setHeap(mDoExt_getHostIOHeap());
    CommandHeapCheck.setHeap(mDoExt_getCommandHeap());

    #if DEBUG
    JKRHeap* var_r28 = mDoExt_getHostIOHeap();
    JKRHeap* sp10 = mDoExt_setCurrentHeap(var_r28);
    JOR_INIT();
    JOR_SETROOTNODE("root", &mDoHIO_root, 4, 3);
    mDoExt_setCurrentHeap(sp10);

    var_r28->dump_sort();
    s32 local_34 = var_r28->getTotalFreeSize();
    OSReport("\x1b[36mHOSTIOヒープ残り %u Bytes\n\x1b[m", local_34);
    #endif

    JUTConsole* console = JFWSystem::getSystemConsole();
    console->setOutput(mDoMain::developmentMode ? JUTConsole::OUTPUT_OSR_AND_CONSOLE :
                                                  JUTConsole::OUTPUT_NONE);
    console->setPosition(32, 42);

    mDoDvdThd_callback_c::create((mDoDvdThd_callback_func)LOAD_COPYDATE, NULL);
    fapGm_Create(); // init framework

    #if DEBUG
    mDoMain_HIO.entryHIO("メイン");
    g_regHIO.id = mDoHIO_createChild("レジスタ", &g_regHIO);
    g_presetHIO.field_0x4 = mDoHIO_createChild("状況ファイル", &g_presetHIO);
    #endif

    fopAcM_initManager();
    mDisplayHeapSize = 0;
    cDyl_InitAsync(); // init RELs

    g_mDoAud_audioHeap = JKRCreateSolidHeap(audioHeapSize, JKRGetCurrentHeap(), false);

    do {
        static u32 frame;
        frame++;

        #if DEBUG
        if (memorycheck_check_frame != 0 && frame % memorycheck_check_frame == 0) {
            FixedMemoryCheck::checkAll();
        }
        #endif

        if (fillcheck_check_frame != 0 && frame % fillcheck_check_frame == 0) {
            mDoMch_HeapCheckAll();
        }

        if (mDoDvdThd::SyncWidthSound) {
            mDoMemCd_UpDate();
        }

        mDoCPd_c::read();   // read controller input

        #if DEBUG
        if (mDoMch::GXWarningExecuteFrame) {
            GXSetVerifyLevel(GX_WARN_ALL);
        }
        #endif

        fapGm_Execute();    // handle game execution

        #if DEBUG
        if (mDoMch::GXWarningExecuteFrame) {
            mDoMch::GXWarningExecuteFrame = 0;
            GXSetVerifyLevel((GXWarningLevel)mDoMch::GXWarningLevel);
        }
        #endif

        #if DEBUG
        fapGm_HIO_c::startCpuTimer();
        #endif

        mDoAud_Execute();   // handle audio execution

        #if DEBUG
        fapGm_HIO_c::printCpuTimer("");
        fapGm_HIO_c::stopCpuTimer("オーディオ");
        #endif

        debug();            // run debugger
    } while (true);
}

#if DEBUG
JHIComPortManager<JHICmnMem>* JHIComPortManager<JHICmnMem>:: instance;

// DEBUG NONMATCHING
void parse_args(int argc, const char* argv[]) {
    int i;

    OS_REPORT("argc = %d\n", argc);
    for (i = 0; i < argc; i++) {
        OS_REPORT("argv[%d] = %s\n", i, argv[i]);
    }

    for (i = 1; i < argc; i++) {
        if (strcmp(argv[i], "--noopening") == 0) {
            dScnLogo_c::onOpeningCut();
        } else if (strcmp(argv[i], "--nobank") == 0) {
            dStage_roomControl_c::onNoArcBank();
            OS_REPORT("\x1b[33mアーカイブバンクを無効にしました\n\x1b[m");
        } else if (strcmp(argv[i], "--particle254") == 0) {
            fapGm_HIO_c::mParticle254Fix = 1;
            OSReport_Warning("パーティクル２５４固定にしました\n");
        } else if (strncmp(argv[i], "--menu=", sizeof("--menu=") - 1) == 0) {
            char* var_r27 = strchr(argv[i] + 7, ',');
            if (var_r27 != NULL) {
                *var_r27 = 0;
                var_r27++;

                char* var_r26 = std::strchr(var_r27, ',');
                if (var_r26 != NULL) {
                    *var_r26 = 0;
                    var_r26++;

                    char* spC = std::strchr(var_r26, ',');
                    if (spC != NULL) {
                        *spC = 0;
                        spC++;
                        sscanf(spC, "%d", &dScnMenu_c::cursolPoint);
                        dScnMenu_c::m_error_flags |= (u8)8;
                    }

                    sscanf(var_r26, "%d", &dScnMenu_c::cursolLayer);
                    dScnMenu_c::m_error_flags |= (u8)4;
                }

                sscanf(var_r27, "%d", &dScnMenu_c::cursolRoomNo);
                dScnMenu_c::m_error_flags |= (u8)2;
            }

            strcpy(dScnMenu_c::cursolStageName, argv[i] + 7);
            dScnMenu_c::m_error_flags |= (u8)1;

            OS_REPORT("\n\n\ndScnMenu_c::cursolLayer=[%x]", dScnMenu_c::cursolLayer);
            OS_REPORT("\ndScnMenu_c::cursolRoomNo=[%x]", dScnMenu_c::cursolRoomNo);
            OS_REPORT("\ndScnMenu_c::cursolStageName=[%s]\n\n", dScnMenu_c::cursolStageName);
        } else if (strncmp(argv[i], "--situation=", sizeof("--situation=") - 1) == 0) {
            for (int j = 0; j < 100; j++) {
                if (argv[i][12 + j] <= ' ') {
                    break;
                }

                g_presetHIO.filename_buf[j] = argv[i][12 + j];
            }

            OS_REPORT("\n11 g_presetHIO.filename_buf[0]=[%-100.100s]", g_presetHIO.filename_buf);
        } else if (strcmp(argv[i], "--noprint") == 0) {
            OSReportDisable();
        } else if (strcmp(argv[i], "--develop") == 0) {
            mDoMain::developmentMode = 1;
        } else if (strcmp(argv[i], "--nodevelop") == 0) {
            mDoMain::developmentMode = 0;
        } else if (strncmp(argv[i], "--e3argument=", sizeof("--e3argument=") - 1) == 0) {
            sscanf(argv[i] + sizeof("--e3argument=") - 1, "%d", &mDoMain::argument);
        } else if (strncmp(argv[i], "--gameheapsize=0x", sizeof("--gameheapsize=0x") - 1) == 0) {
            sscanf(argv[i] + sizeof("--gameheapsize=0x") - 1, "%x", &mDoMain::gameHeapSize);
        } else if (strncmp(argv[i], "--archiveheapsize=0x", sizeof("--archiveheapsize=0x") - 1) == 0) {
            sscanf(argv[i] + sizeof("--archiveheapsize=0x") - 1, "%x", &mDoMain::archiveHeapSize);
        } else if (strncmp(argv[i], "--memmargin=0x", sizeof("--memmargin=0x") - 1) == 0) {
            sscanf(argv[i] + sizeof("--memmargin=0x") - 1, "%x", &mDoMain::memMargin);
        } else if (strncmp(argv[i], "--e3menu=0x", sizeof("--e3menu=0x") - 1) == 0) {
            sscanf(argv[i] + sizeof("--e3menu=0x") - 1, "%x", &mDoMain::e3menu_no);
        } else {
            OSReport_Error("unknown argument %d, %s\n", i, argv[i]);
        }
    }
}
#endif

static u8 mainThreadStack[32768];

OSThread mainThread;

void main(int argc, const char* argv[]) {
    OSThread* current_thread = OSGetCurrentThread();
    u8* stack = mainThreadStack;
    mDoMain::sPowerOnTime = OSGetTime();
    OSReportInit();
    version_check();

    #if PLATFORM_WII || PLATFORM_SHIELD
    mDoRst::setResetData((mDoRstData*)OSAllocFromMEM1ArenaLo(0x18, 4));
    #else
    mDoRst::setResetData((mDoRstData*)OSAllocFromArenaLo(0x18, 4));
    #endif

    if (!mDoRst::getResetData()) {
        do {
        } while (true);
    }

    if (!((OSGetResetCode() & 0x80000000) ? 1 : 0)) {
        mDoRst::offReset();
        mDoRst::offResetPrepare();
        mDoRst::off3ButtonReset();
        mDoRst::set3ButtonResetPort(-1);
        mDoRst::setLogoScnFlag(0);
        mDoRst::setProgSeqFlag(0);
        mDoRst::setProgChgFlag(0);
        mDoRst::setWarningDispFlag(0);
        mDoRst::offShutdown();
        mDoRst::offReturnToMenu();
    }

    #if PLATFORM_WII || PLATFORM_SHIELD
    SCInit();
    #endif

    dComIfG_ct();

    #if PLATFORM_WII || PLATFORM_SHIELD
    u32 status;
    do {
        status = SCCheckStatus();
    } while (status != 0);
    JUT_ASSERT(1785, status != 2);
    #endif

    #if DEBUG
    parse_args(argc, argv);
    #endif

    if (mDoMain::developmentMode < 0) {
        DVDDiskID* disk_id = DVDGetCurrentDiskID();

        if (disk_id->gameVersion > 0x90) {
            mDoMain::developmentMode = 1;
        } else if (disk_id->gameVersion > 0x80) {
            mDoMain::developmentMode = (OSGetConsoleType() & OS_CONSOLE_DEVELOPMENT) != 0;
        } else {
            mDoMain::developmentMode = 0;
        }
    }

    OS_REPORT("メインスレッドを作成します\n");
    OSCreateThread(&mainThread, (void*(*)(void*))main01, 0, stack + sizeof(mainThreadStack), sizeof(mainThreadStack), OSGetThreadPriority(current_thread), 0);
    OSResumeThread(&mainThread);
    OS_REPORT("メインスレッドを起動しました <%x>\n", &mainThread);
    OSSetThreadPriority(current_thread, 0x1F);
    OSSuspendThread(current_thread);
}

bool JKRHeap::dump_sort() {
    return true;
}

template<>
Z2WolfHowlMgr* JASGlobalInstance<Z2WolfHowlMgr>::sInstance;

template<>
Z2EnvSeMgr* JASGlobalInstance<Z2EnvSeMgr>::sInstance;

template<>
Z2FxLineMgr* JASGlobalInstance<Z2FxLineMgr>::sInstance;

template<>
Z2Audience* JASGlobalInstance<Z2Audience>::sInstance;

template<>
Z2SoundObjMgr* JASGlobalInstance<Z2SoundObjMgr>::sInstance;

template<>
Z2SoundInfo* JASGlobalInstance<Z2SoundInfo>::sInstance;

template<>
JAUSoundInfo* JASGlobalInstance<JAUSoundInfo>::sInstance;

template<>
JAUSoundNameTable* JASGlobalInstance<JAUSoundNameTable>::sInstance;

template<>
JAUSoundTable* JASGlobalInstance<JAUSoundTable>::sInstance;

template<>
JAISoundInfo* JASGlobalInstance<JAISoundInfo>::sInstance;

template<>
Z2SoundMgr* JASGlobalInstance<Z2SoundMgr>::sInstance;

template<>
JAIStreamMgr* JASGlobalInstance<JAIStreamMgr>::sInstance;

template<>
JAISeqMgr* JASGlobalInstance<JAISeqMgr>::sInstance;

template<>
JAISeMgr* JASGlobalInstance<JAISeMgr>::sInstance;

template<>
Z2SpeechMgr2* JASGlobalInstance<Z2SpeechMgr2>::sInstance;

template<>
Z2SoundStarter* JASGlobalInstance<Z2SoundStarter>::sInstance;

template<>
JAISoundStarter* JASGlobalInstance<JAISoundStarter>::sInstance;

template<>
Z2StatusMgr* JASGlobalInstance<Z2StatusMgr>::sInstance;

template<>
Z2SceneMgr* JASGlobalInstance<Z2SceneMgr>::sInstance;

template<>
Z2SeqMgr* JASGlobalInstance<Z2SeqMgr>::sInstance;

template<>
Z2SeMgr* JASGlobalInstance<Z2SeMgr>::sInstance;

template<>
JASAudioThread* JASGlobalInstance<JASAudioThread>::sInstance;

template<>
JASDefaultBankTable* JASGlobalInstance<JASDefaultBankTable>::sInstance;