#include "config.h"
#include "types.h"

#include "vdp.h"

#include "vdp_tile.h"
#include "vdp_spr.h"
#include "vdp_bg.h"

#include "tools.h"
#include "string.h"
#include "memory.h"
#include "dma.h"
#include "timer.h"
#include "sys.h"
#include "task.h"

#include "sprite_eng.h"
#include "sprite_eng_legacy.h"


#define WINDOW_DEFAULT          0xD000      // multiple of 0x1000 (0x0800 in H32)
#define HSCRL_DEFAULT           0xF000      // multiple of 0x0400
#define SLIST_DEFAULT           0xF400      // multiple of 0x0400 (0x0200 in H32)
#define APLAN_DEFAULT           0xE000      // multiple of 0x2000
#define BPLAN_DEFAULT           0xC000      // multiple of 0x2000


// we don't want to share it
extern u32 task_pc;
// we don't want to share it
extern bool addFrameLoad(u16 frameLoad, u32 vtime);

// forward
static void updateMapsAddress(bool initializing);
static bool computeFrameCPULoad(u16 blank, u16 vcnt, u32 vtime);
u16 getAdjustedVCounterInternal(u16 blank, u16 vcnt);
void updateUserTileMaxIndex();


static u8 regValues[0x13];

u16 window_addr;
u16 bga_addr;
u16 bgb_addr;
u16 hscrl_addr;
u16 slist_addr;
u16 maps_addr;

u16 userTileMaxIndex;

u16 screenWidth;
u16 screenHeight;
u16 planeWidth;
u16 planeHeight;
u16 windowWidth;
u16 planeWidthSft;
u16 planeHeightSft;
u16 windowWidthSft;

u16 lastVCnt;


NO_INLINE void VDP_init()
{
    vu16 *pw;
    u16 i;

    // wait for DMA completion
    VDP_waitDMACompletion();

    // default VRAM organization
    window_addr = WINDOW_DEFAULT;
    bga_addr = APLAN_DEFAULT;
    bgb_addr = BPLAN_DEFAULT;
    slist_addr = SLIST_DEFAULT;
    hscrl_addr = HSCRL_DEFAULT;

    // default resolution
    screenWidth = 320;
    screenHeight = 224;
    planeWidth = 64;
    planeHeight = 32;
    windowWidth = 64;
    planeWidthSft = 6;
    planeHeightSft = 5;
    windowWidthSft = 6;
    lastVCnt = 0;

    regValues[0x00] = 0x04;
    regValues[0x01] = 0x74;                     /* reg. 1 - Enable display, V-Int, DMA + VCell size */
    regValues[0x02] = bga_addr / 0x400;         /* reg. 2 - Plane A = $E000 */
    regValues[0x03] = window_addr / 0x400;      /* reg. 3 - Window  = $D000 */
    regValues[0x04] = bgb_addr / 0x2000;        /* reg. 4 - Plane B = $C000 */
    regValues[0x05] = slist_addr / 0x200;       /* reg. 5 - Sprite table = $F400 */
    regValues[0x06] = 0x00;                     /* reg. 6 - not used */
    regValues[0x07] = 0x00;                     /* reg. 7 - Background Color number*/
    regValues[0x08] = 0x00;                     /* reg. 8 - not used */
    regValues[0x09] = 0x00;                     /* reg. 9 - not used */
    regValues[0x0A] = 0x01;                     /* reg 10 - HInterrupt timing */
    regValues[0x0B] = 0x00;                     /* reg 11 - $0000abcd a=extr.int b=vscr cd=hscr */
    regValues[0x0C] = 0x81;                     /* reg 12 - hcell mode + shadow/highight + interlaced mode (40 cell, no shadow, no interlace) */
    regValues[0x0D] = hscrl_addr / 0x400;       /* reg 13 - HScroll Table = $F000 */
    regValues[0x0E] = 0x00;                     /* reg 14 - not used */
    regValues[0x0F] = 0x02;                     /* reg 15 - auto increment data */
    regValues[0x10] = 0x01;                     /* reg 16 - scrl screen v&h size (32x64) */
    regValues[0x11] = 0x00;                     /* reg 17 - window hpos */
    regValues[0x12] = 0x00;                     /* reg 18 - window vpos */

    // set registers
    pw = (u16 *) VDP_CTRL_PORT;
    for (i = 0x00; i < 0x13; i++) *pw = 0x8000 | (i << 8) | regValues[i];

    maps_addr = 0;
    // update minimum address of all tilemap/table (default is plane B)
    updateMapsAddress(TRUE);

    // clear VRAM, reset palettes / default tiles / font and scroll mode
    VDP_resetScreen();
    // reset sprite struct
    VDP_resetSprites();

    // default plane and base tile attribut for draw text method
    VDP_setTextPlane(BG_A);
    VDP_setTextPalette(PAL0);
    VDP_setTextPriority(TRUE);

    // internal
    curTileInd = TILE_USER_INDEX;
}


NO_INLINE void VDP_resetScreen()
{
    u16 i;
    bool enable = VDP_isEnable();

    // for faster operation
    VDP_setEnable(FALSE);

    // reset video memory (len = 0 is a special value to define 0x10000)
    DMA_doVRamFill(0, 0, 0, 1);
    // wait for DMA completion
    VDP_waitDMACompletion();

     // system tiles (16 plain tile)
    i = 16;
    while(i--) VDP_fillTileData(i | (i << 4), TILE_SYSTEM_INDEX + i, 1, TRUE);

    PAL_setPalette(PAL0, palette_grey, CPU);
    PAL_setPalette(PAL1, palette_red, CPU);
    PAL_setPalette(PAL2, palette_green, CPU);
    PAL_setPalette(PAL3, palette_blue, CPU);

    VDP_setScrollingMode(HSCROLL_PLANE, VSCROLL_PLANE);
    VDP_setHorizontalScroll(BG_A, 0);
    VDP_setHorizontalScroll(BG_B, 0);

    {
        s16 values[20];

        // clear
        memset(values, 0, sizeof(values));

        // clear VSRAM
        VDP_setVerticalScrollTile(BG_A, 0, values, 20, CPU);
        VDP_setVerticalScrollTile(BG_B, 0, values, 20, CPU);
    }

    // load default font
    if (!VDP_loadDefaultFont(DMA))
    {
        VDP_setEnable(TRUE);

        KLog("A fatal error occured (not enough memory to reset VDP) !");

        // fatal error --> die here (the font did not get loaded so maybe not really useful to show this message...)
        VDP_drawText("Not enough memory to reset VDP !", 0, 2);

        VDP_drawText("A fatal error occured !", 2, 4);
        VDP_drawText("cannot continue...", 4, 5);

        // stop here
        while(TRUE);
    }

    // re-enable
    if (enable)
        VDP_setEnable(TRUE);
}


u8 VDP_getReg(u16 reg)
{
    if (reg < 0x13) return regValues[reg];
    else return 0;
}

void VDP_setReg(u16 reg, u8 value)
{
    vu16 *pw;
    u16 v;

    // update cached values
    switch (reg & 0x1F)
    {
        default:
            v = value;
            break;

        case 0x01:
            if (IS_PAL_SYSTEM)
            {
                v = value;
                if (v & 0x08) screenHeight = 240;
                else screenHeight = 224;
            }
            else
                v = value & 0xF7;
            break;

        case 0x02:
            v = value & 0x38;
            // update plane address
            bga_addr = v * 0x400;
            updateMapsAddress(FALSE);
            break;

        case 0x03:
            // 40H mode
            if (regValues[0x0C] & 0x81) v = value & 0x3C;
            // 32H mode
            else v = value & 0x3E;
            window_addr = v * 0x0400;
            updateMapsAddress(FALSE);
            break;

        case 0x04:
            v = value & 0x7;
            // update text plane address
            bgb_addr = v * 0x2000;
            updateMapsAddress(FALSE);
            break;

        case 0x05:
            // 40H mode
            if (regValues[0x0C] & 0x81) v = value & 0x7E;
            // 32H mode
            else v = value & 0x7F;
            slist_addr = v * 0x0200;
            updateMapsAddress(FALSE);
            break;

        case 0x0C:
            v = value;
            if (v & 0x81)
            {
                screenWidth = 320;
                windowWidth = 64;
                windowWidthSft = 6;
            }
            else
            {
                screenWidth = 256;
                windowWidth = 32;
                windowWidthSft = 5;
            }
            break;

        case 0x0D:
            v = value & 0x3F;
            hscrl_addr = v * 0x0400;
            updateMapsAddress(FALSE);
            break;

        case 0x10:
            v = value;
            if (v & 0x02)
            {
                planeWidth = 128;
                planeWidthSft = 7;
            }
            else if (v & 0x01)
            {
                planeWidth = 64;
                planeWidthSft = 6;
            }
            else
            {
                planeWidth = 32;
                planeWidthSft = 5;
            }
            if (v & 0x20)
            {
                planeHeight = 128;
                planeHeightSft = 7;
            }
            else if (v & 0x10)
            {
                planeHeight = 64;
                planeHeightSft = 6;
            }
            else
            {
                planeHeight = 32;
                planeHeightSft = 5;
            }
            break;
    }

    if (reg < 0x13) regValues[reg] = v;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8000 | (reg << 8) | v;
}

bool VDP_getEnable()
{
    return regValues[0x01] & 0x40;
}

bool VDP_isEnable()
{
    return VDP_getEnable();
}

void VDP_setEnable(bool value)
{
    vu16 *pw;

    if (value) regValues[0x01] |= 0x40;
    else regValues[0x01] &= ~0x40;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8100 | regValues[0x01];
}


u16 VDP_getScanlineNumber()
{
    if IS_PAL_SYSTEM return 312;
    else return 262;
}

u16 VDP_getScreenHeight()
{
    return screenHeight;
}

void VDP_setScreenHeight224()
{
    vu16 *pw;

    regValues[0x01] &= ~0x08;
    screenHeight = 224;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8100 | regValues[0x01];
}

void VDP_setScreenHeight240()
{
    vu16 *pw;

    if (IS_PAL_SYSTEM)
    {
        regValues[0x01] |= 0x08;
        screenHeight = 240;

        pw = (u16 *) VDP_CTRL_PORT;
        *pw = 0x8100 | regValues[0x01];
    }
}

u16 VDP_getScreenWidth()
{
    return screenWidth;
}

void VDP_setScreenWidth256()
{
    vu16 *pw;

    regValues[0x0C] &= ~0x81;
    screenWidth = 256;
    windowWidth = 32;
    windowWidthSft = 5;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8C00 | regValues[0x0C];
}

void VDP_setScreenWidth320()
{
    vu16 *pw;

    regValues[0x0C] |= 0x81;
    screenWidth = 320;
    windowWidth = 64;
    windowWidthSft = 6;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8C00 | regValues[0x0C];
}


u16 VDP_getPlaneWidth()
{
    return planeWidth;
}

u16 VDP_getPlaneHeight()
{
    return planeHeight;
}

NO_INLINE void VDP_setPlaneSize(u16 w, u16 h, bool setupVram)
{
    vu16 *pw;
    u16 v = 0;

    if (w & 0x80)
    {
        planeWidth = 128;
        planeWidthSft = 7;
        v |= 0x03;

        // plane height fixed to 32
        planeHeight = 32;
        planeHeightSft = 5;
    }
    else if (w & 0x40)
    {
        planeWidth = 64;
        planeWidthSft = 6;
        v |= 0x01;

        // only 64 or 32 accepted for plane height
        if (h & 0x40)
        {
            planeHeight = 64;
            planeHeightSft = 6;
            v |= 0x10;
        }
        else
        {
            planeHeight = 32;
            planeHeightSft = 5;
        }
    }
    else
    {
        planeWidth = 32;
        planeWidthSft = 5;

        // plane height can be 128, 64 or 32
        if (h & 0x80)
        {
            planeHeight = 128;
            planeHeightSft = 7;
            v |= 0x30;
        }
        else if (h & 0x40)
        {
            planeHeight = 64;
            planeHeightSft = 6;
            v |= 0x10;
        }
        else
        {
            planeHeight = 32;
            planeHeightSft = 5;
        }
    }

    regValues[0x10] = v;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x9000 | regValues[0x10];

    if (setupVram)
    {
        switch(planeWidthSft + planeHeightSft)
        {
            case 10:
                // 2KB tilemap VRAM setup: 0xC000 --> 0xEFFF
                // 0xD000-0xDFFF free
                VDP_setBGBAddress(0xC000);
                VDP_setWindowAddress(0xC800);
                VDP_setBGAAddress(0xE000);
                VDP_setSpriteListAddress(0xE800);
                VDP_setHScrollTableAddress(0xEC00);
                break;

            case 11:
                // 4KB tilemap VRAM setup: 0xC000 --> 0xFFFF
                // 0xF700-0xFFFF free
                VDP_setBGBAddress(0xC000);
                VDP_setWindowAddress(0xD000);
                VDP_setBGAAddress(0xE000);
                VDP_setHScrollTableAddress(0xF000);
                VDP_setSpriteListAddress(0xF400);
                break;

            default:
                // 8KB tilemap VRAM setup: 0xA800 --> 0xFFFF
                // 0xAF00-0xAFFF free
                VDP_setSpriteListAddress(0xAC00);
                VDP_setHScrollTableAddress(0xA800);
                VDP_setWindowAddress(0xB000);
                VDP_setBGBAddress(0xC000);
                VDP_setBGAAddress(0xE000);
                break;
        }

        updateMapsAddress(FALSE);
    }
}

u8 VDP_getVerticalScrollingMode()
{
    return (regValues[0x0B] >> 2) & 1;
}

u8 VDP_getHorizontalScrollingMode()
{
    return regValues[0x0B] & 3;
}

void VDP_setScrollingMode(u16 hscroll, u16 vscroll)
{
    vu16 *pw;

    regValues[0x0B] &= ~0x07;
    regValues[0x0B] |= ((vscroll & 1) << 2) | (hscroll & 3);

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8B00 | regValues[0x0B];
}


u8 VDP_getBackgroundColor()
{
    return regValues[0x07];
}

void VDP_setBackgroundColor(u8 value)
{
    vu16 *pw;

    regValues[0x07] = value & 0x3F;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8700 | regValues[0x07];
}


u8 VDP_getAutoInc()
{
    return regValues[0x0F];
}

void VDP_setAutoInc(u8 value)
{
    vu16 *pw;

    regValues[0x0F] = value;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8F00 | value;
}


u8 VDP_getDMAEnabled()
{
    return regValues[0x01] & 0x10;
}

void VDP_setDMAEnabled(bool value)
{
    vu16 *pw;

    if (value) regValues[0x01] |= 0x10;
    else regValues[0x01] &= ~0x10;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8100 | regValues[0x01];
}

u8 VDP_getHVLatching()
{
    return regValues[0x00] & 0x02;
}

void VDP_setHVLatching(bool value)
{
    vu16 *pw;

    if (value) regValues[0x00] |= 0x02;
    else regValues[0x00] &= ~0x02;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8000 | regValues[0x00];
}

void VDP_setVInterrupt(bool value)
{
    vu16 *pw;

    if (value) regValues[0x01] |= 0x20;
    else regValues[0x01] &= ~0x20;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8100 | regValues[0x01];
}

void VDP_setHInterrupt(bool value)
{
    vu16 *pw;

    if (value) regValues[0x00] |= 0x10;
    else regValues[0x00] &= ~0x10;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8000 | regValues[0x00];
}

void VDP_setExtInterrupt(bool value)
{
    vu16 *pw;

    if (value) regValues[0x0B] |= 0x08;
    else regValues[0x0B] &= ~0x08;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8B00 | regValues[0x0B];
}

void VDP_setHilightShadow(bool value)
{
    vu16 *pw;

    if (value) regValues[0x0C] |= 0x08;
    else regValues[0x0C] &= ~0x08;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8C00 | regValues[0x0C];
}


u8 VDP_getHIntCounter()
{
    return regValues[0x0A];
}

void VDP_setHIntCounter(u8 value)
{
    vu16 *pw;

    regValues[0x0A] = value;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8A00 | regValues[0x0A];
}


u16 VDP_getBGAAddress()
{
    return bga_addr;
}

u16 VDP_getBGBAddress()
{
    return bgb_addr;
}

u16 VDP_getWindowAddress()
{
    return window_addr;
}

u16 VDP_getSpriteListAddress()
{
    return slist_addr;
}

u16 VDP_getHScrollTableAddress()
{
    return hscrl_addr;
}


void VDP_setBGAAddress(u16 value)
{
    vu16 *pw;

    bga_addr = value & 0xE000;
    updateMapsAddress(FALSE);

    regValues[0x02] = bga_addr / 0x400;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8200 | regValues[0x02];
}

void VDP_setBGBAddress(u16 value)
{
    vu16 *pw;

    bgb_addr = value & 0xE000;
    updateMapsAddress(FALSE);

    regValues[0x04] = bgb_addr / 0x2000;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8400 | regValues[0x04];
}

void VDP_setWindowAddress(u16 value)
{
    vu16 *pw;

    // 40H mode
    if (regValues[0x0C] & 0x81) window_addr = value & 0xF000;
    // 32H mode
    else window_addr = value & 0xF800;
    updateMapsAddress(FALSE);

    regValues[0x03] = window_addr / 0x400;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8300 | regValues[0x03];
}

void VDP_setSpriteListAddress(u16 value)
{
    vu16 *pw;

    // 40H mode
    if (regValues[0x0C] & 0x81) slist_addr = value & 0xFC00;
    // 32H mode
    else slist_addr = value & 0xFE00;
    updateMapsAddress(FALSE);

    regValues[0x05] = slist_addr / 0x200;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8500 | regValues[0x05];
}

void VDP_setHScrollTableAddress(u16 value)
{
    vu16 *pw;

    hscrl_addr = value & 0xFC00;
    updateMapsAddress(FALSE);

    regValues[0x0D] = hscrl_addr / 0x400;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8D00 | regValues[0x0D];
}

void VDP_setScanMode(u16 value)
{
    vu16 *pw;

    if (value == 0)
        // non-interlaced
        regValues[0x0C] &= ~0x06;
    else if (value == 1)
        // interlace mode 1
        regValues[0x0C] = (regValues[0x0C] & ~0x04) | 0x02;
    else
        // interlace mode 2
        regValues[0x0C] |= 0x06;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x8C00 | regValues[0x0C];
}

void VDP_setWindowHPos(u16 right, u16 pos)
{
    vu16 *pw;
    u16 v;

    v = pos & 0x7F;
    if (right) v |= 0x80;

    regValues[0x11] = v;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x9100 | v;
}

void VDP_setWindowVPos(u16 down, u16 pos)
{
    vu16 *pw;
    u16 v;

    v = pos & 0x7F;
    if (down) v |= 0x80;

    regValues[0x12] = v;

    pw = (u16 *) VDP_CTRL_PORT;
    *pw = 0x9200 | v;
}

void VDP_setWindowOff() 
{
    VDP_setWindowVPos(false, 0);
    VDP_setWindowHPos(false, 0);
}

void VDP_setWindowOnTop(u16 rows) 
{
    VDP_setWindowVPos(false, rows);
}

void VDP_setWindowOnBottom(u16 rows) 
{
    VDP_setWindowVPos(true, (screenHeight / 8) - rows);
}

void VDP_setWindowOnLeft(u16 cols) 
{
    VDP_setWindowHPos(false, cols);
}

void VDP_setWindowOnRight(u16 cols) 
{
    VDP_setWindowHPos(true, (screenWidth / 16) - cols);
}

void VDP_setWindowFullScreen()
{
    VDP_setWindowVPos(false, screenHeight / 8);
}

void VDP_waitDMACompletion()
{
    while(GET_VDP_STATUS(VDP_DMABUSY_FLAG));
}

void VDP_waitFIFOEmpty()
{
    while(!GET_VDP_STATUS(VDP_FIFOEMPTY_FLAG));
}


NO_INLINE bool VDP_waitVInt()
{
    // in VInt --> return
    if (SYS_isInVInt()) return FALSE;

    // initial frame counter
    const u32 t = vtimer;
    // store V-Counter and initial blank state
    const u16 vcnt = GET_VCOUNTER;
    const u16 blank = GET_VDP_STATUS(VDP_VBLANK_FLAG);
    // save it (used to diplay frame load)
    lastVCnt = vcnt;

    // compute frame load now (return TRUE if frame miss / late detected)
    bool late = computeFrameCPULoad(blank, vcnt, t);

#if (LIB_LOG_LEVEL >= LOG_LEVEL_WARNING)
    if (late)
    {
        // we cannot detect frame miss if HV latching is enabled..
        if (!VDP_getHVLatching())
            KLog_U2("Warning: frame missed detection on frame #", t, " - V-Counter = ", vcnt);
    }
#endif

    // background user task ? --> switch to it (automatically switch back to front task on v-int)
    if (task_pc != NULL) TSK_userYield();
    // otherwise we just wait for next VInt
    else while (vtimer == t);

    return late;
}


NO_INLINE bool VDP_waitVBlank(bool forceNext)
{
    vu16 *pw = (u16 *) VDP_CTRL_PORT;

    // initial frame counter
    const u32 t = vtimer;
    // store V-Counter and initial blank state
    const u16 vcnt = GET_VCOUNTER;
    const u16 blank = *pw & VDP_VBLANK_FLAG;
    // have an user task (multitasking) ?
    const bool yield_to_user = (task_pc != NULL);
    // VDP enable
    const bool enabled = VDP_isEnable();
    // save it (used to diplay frame load)
    lastVCnt = vcnt;

    // we want to wait for next start of VBlank ? (only if no multitasking)
    if (forceNext && blank && enabled && !yield_to_user)
    {
        // wait end of vblank if already in vblank
        while (*pw & VDP_VBLANK_FLAG);
    }

    // compute frame load now (return TRUE if frame miss / late detected)
    bool late = computeFrameCPULoad(blank, vcnt, t);

#if (LIB_LOG_LEVEL >= LOG_LEVEL_WARNING)
    if (late)
    {
        // we cannot detect late frame if VDP is disabled or HV latching is enabled
        if (enabled && !VDP_getHVLatching())
        {
            if (forceNext)
                KLog_U2("Warning: frame missed detection on frame #", vtimer, " - V-Counter = ", vcnt);
            else
                KLog_U2("Warning: frame late detection on frame #", vtimer, " - V-Counter = ", vcnt);
        }
    }
#endif

    // background user task ? --> switch to it (automatically switch back to front task on v-int)
    if (yield_to_user) TSK_userYield();
    // otherwise we just wait end of active period
    else while (!(*pw & VDP_VBLANK_FLAG));

    return late;
}

void VDP_waitVActive(bool forceNext)
{
    vu16 *pw = (u16 *) VDP_CTRL_PORT;

    // we want to wait for next start of VActive ?
    if (forceNext)
    {
        // wait end of vactive if already in vactive
        while (!(*pw & VDP_VBLANK_FLAG));
    }
    // we stay blank forever if VDP is disabled..
    if (VDP_isEnable())
    {
        // wait end of vblank
        while (*pw & VDP_VBLANK_FLAG);
    }
}

bool VDP_waitVSync()
{
    return VDP_waitVBlank(TRUE);
}


static bool computeFrameCPULoad(u16 blank, u16 vcnt, u32 vtime)
{
    // update CPU frame load
    return addFrameLoad(getAdjustedVCounterInternal(blank, vcnt), vtime);
}

u16 getAdjustedVCounterInternal(u16 blank, u16 vcnt)
{
    u16 result = vcnt;

    // adjust V-Counter to take care of blanking rollback
    if (IS_PAL_SYSTEM)
    {
        // blank adjustement
        if (blank && ((result >= 0xCA) || (result <= 0x0A))) result = 8;
        // sometime blank flag is not yet/anymore set on edge area so we double check
        else if (result >= VDP_getScreenHeight()) result = 8;
        else result += 16;
    }
    else
    {
        // blank adjustement
        if (blank && (result >= 0xDF)) result = 16;
        // sometime blank flag is not yet/anymore set on edge area
        else if (result >= 224) result = 16;
        else result += 32;
    }

    return result;
}

u16 VDP_getAdjustedVCounter()
{
    return getAdjustedVCounterInternal(GET_VDP_STATUS(VDP_VBLANK_FLAG), GET_VCOUNTER);
}


void VDP_showFPS(u16 asFloat, u16 x, u16 y)
{
    char str[16];

    if (asFloat)
    {
        fix32ToStr(SYS_getFPSAsFloat(), str, 1);
        // display FPS
        VDP_drawTextFill(str, x, y, 4);
    }
    else
    {
        uintToStr(SYS_getFPS(), str, 1);
        // display FPS
        VDP_drawTextFill(str, x, y, 2);
    }
}

void VDP_showCPULoad(u16 x, u16 y)
{
    char str[16];

    uintToStr(SYS_getCPULoad(), str, 1);
    strcat(str, "%");

    // display CPU load
    VDP_drawTextFill(str, x, y, 4);
}


void updateUserTileMaxIndex()
{
    // user tile max index is where sprite engine tileset space starts
    userTileMaxIndex = TILE_SPRITE_INDEX;
}

static void updateMapsAddress(bool initializing)
{
    u16 min_addr = window_addr;

    if (bgb_addr < min_addr) min_addr = bgb_addr;
    if (bga_addr < min_addr) min_addr = bga_addr;
    if (hscrl_addr < min_addr) min_addr = hscrl_addr;
    if (slist_addr < min_addr) min_addr = slist_addr;

    // need to reload font
    if (min_addr != maps_addr)
    {
        maps_addr = min_addr;
        // update user max tile index
        updateUserTileMaxIndex();

        // initialization will load font afterward
        if (!initializing)
        {
            // reload default font as its VRAM address has changed
            VDP_loadDefaultFont(CPU);
            // re-pack memory as VDP_lontFont allocate memory to unpack font
            MEM_pack();
        }

        // sprite engine in use ? --> defrag VRAM (this will basically re-allocate all dynamically managed VRAM)
        if (SPR_isInitialized())
            SPR_defragVRAM();
    }
}