/*
    gdi.cpp
    Copyright (C) 2007 Acekard, www.acekard.com
    Copyright (C) 2007-2009 somebody
    Copyright (C) 2009 yellow wood goblin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#include <cstring>
#include <cstdio>
#include "dbgtool.h"
#include "gdi.h"
#include "sprite.h"
#include "../../share/memtool.h"
#include "userinput.h"
#include "globalsettings.h"
#include "fontfactory.h"

static inline void dmaCopyWordsGdi(uint8 channel,const void* src,void* dest,uint32 size)
{
  DC_FlushRange(src,size);
  dmaCopyWords(channel,src,dest,size);
  DC_InvalidateRange(dest,size);
}

#ifdef DEBUG
PrintConsole custom_console;

static void MyInitConsole(u16* aBufferSub1,u16* aBufferSub2)
{
  custom_console=*consoleGetDefault();

  custom_console.loadGraphics=false;

  consoleInit(&custom_console, custom_console.bgLayer, BgType_Text4bpp, BgSize_T_256x256, custom_console.mapBase, custom_console.gfxBase, false, false);

  custom_console.fontBgMap=aBufferSub1;
  custom_console.fontBgGfx=aBufferSub2;

  dmaCopy(custom_console.font.gfx, custom_console.fontBgGfx, custom_console.font.numChars * 64 / 2);
  custom_console.fontCurPal = 15 << 12;

  u16* palette = BG_PALETTE_SUB;
  palette[1 * 16 - 15] = RGB15(0,0,0); //30 normal black
  palette[2 * 16 - 15] = RGB15(15,0,0); //31 normal red
  palette[3 * 16 - 15] = RGB15(0,15,0); //32 normal green
  palette[4 * 16 - 15] = RGB15(15,15,0); //33 normal yellow

  palette[5 * 16 - 15] = RGB15(0,0,15); //34 normal blue
  palette[6 * 16 - 15] = RGB15(15,0,15); //35 normal magenta
  palette[7 * 16 - 15] = RGB15(0,15,15); //36 normal cyan
  palette[8 * 16 - 15] = RGB15(24,24,24); //37 normal white

  palette[9 * 16 - 15] = RGB15(15,15,15); //40 bright black
  palette[10 * 16 - 15] = RGB15(31,0,0); //41 bright red
  palette[11 * 16 - 15] = RGB15(0,31,0); //42 bright green
  palette[12 * 16 - 15] = RGB15(31,31,0);  //43 bright yellow

  palette[13 * 16 - 15] = RGB15(0,0,31); //44 bright blue
  palette[14 * 16 - 15] = RGB15(31,0,31);  //45 bright magenta
  palette[15 * 16 - 15] = RGB15(0,31,31);  //46 bright cyan
  palette[16 * 16 - 15] = RGB15(31,31,31); //47 & 39 bright white
}
#endif

cGdi::cGdi()
{
  _transColor=0;
  _mainEngineLayer=MEL_UP;
  _subEngineMode=SEM_TEXT;
  _bufferMain2=NULL;
  _bufferSub2=NULL;
#ifdef DEBUG
  _bufferSub3=NULL;
#endif
  _sprites=NULL;
}

cGdi::~cGdi()
{
    if( NULL != _bufferMain2 )
        delete[] _bufferMain2;
    if( NULL != _bufferSub2 )
        delete[] _bufferSub2;
#ifdef DEBUG
    if( NULL != _bufferSub3 )
        delete[] _bufferSub3;
#endif
    if( NULL != _sprites )
        delete[] _sprites;
}

void cGdi::init()
{
    swapLCD();
    activeFbMain();
    activeFbSub();
    cSprite::sysinit();
}

void cGdi::initBg(const std::string& aFileName)
{
  _sprites=new cSprite[12];
  _background=createBMP15FromFile(aFileName);
  if(_background.width()<SCREEN_WIDTH&&_background.height()<SCREEN_WIDTH)
  {
    _background=createBMP15(SCREEN_WIDTH,SCREEN_HEIGHT);
    zeroMemory(_background.buffer(),_background.height()*_background.pitch());
  }
  u32 pitch=_background.pitch()>>1;
  for(size_t ii=0;ii<3;++ii)
  {
    for(size_t jj=0;jj<4;++jj)
    {
      size_t index=ii*4+jj;
      _sprites[index].init(2+index);
      _sprites[index].setSize(SS_SIZE_64);
      _sprites[index].setPriority(3);
      _sprites[index].setBufferOffset(32+index*64);
      _sprites[index].setPosition(jj*64,ii*64);
      for(size_t kk=0;kk<64;++kk)
      {
        for(size_t ll=0;ll<64;++ll)
        {
          ((u16*)_sprites[index].buffer())[kk*64+ll]=((u16*)_background.buffer())[(kk+ii*64)*pitch+(ll+jj*64)];
        }
      }
      _sprites[index].show();
    }
  }
  oamUpdate(&oamMain);
}

void cGdi::swapLCD(void)
{
    lcdSwap();
}

void cGdi::activeFbMain(void)
{
    vramSetBankB( VRAM_B_MAIN_BG_0x06000000 );
    vramSetBankD( VRAM_D_MAIN_BG_0x06020000 );

    vramSetBankA( VRAM_A_MAIN_SPRITE_0x06400000 );

    REG_BG2CNT = BG_BMP16_256x256 | BG_BMP_BASE(0) | BG_PRIORITY_1;
    REG_BG2PA = 1 << 8; // 2 =放大倍数
    REG_BG2PD = 1 << 8;  // 2 =放大倍数
    REG_BG2PB = 0;
    REG_BG2PC = 0;
    REG_BG2Y = 0;
    REG_BG2X = 0;

    REG_BG3CNT = BG_BMP16_256x256 | BG_BMP_BASE(8) | BG_PRIORITY_2;
    REG_BG3PA = 1 << 8; // 2 =放大倍数
    REG_BG3PD = 1 << 8;  // 2 =放大倍数
    REG_BG3PB = 0;
    REG_BG3PC = 0;
    REG_BG3Y = 0;
    REG_BG3X = 0;

    _bufferMain1 = (u16 *)0x06000000;
    _bufferMain2 = (u16 *)new u32[256*192];
    _bufferMain3 = (u16 *)0x06020000;

    setMainEngineLayer( MEL_UP );

    zeroMemory( _bufferMain1, 0x20000 );
    fillMemory( _bufferMain3, 0x20000, 0xffffffff );

    REG_BLDCNT = BLEND_ALPHA | BLEND_DST_BG2 | BLEND_DST_BG3;
    REG_BLDALPHA = (4 << 8) | 7;

    swiWaitForVBlank(); //remove tearing at bottop screen
    videoSetMode( MODE_5_2D
        | DISPLAY_BG2_ACTIVE
        | DISPLAY_BG3_ACTIVE
        | DISPLAY_SPR_ACTIVE
        | DISPLAY_SPR_1D_BMP_SIZE_128
        | DISPLAY_SPR_1D_BMP );

}

void cGdi::activeFbSub(void)
{
#ifdef DEBUG
    _bufferSub3 = (u16 *)new u32[0x1200];
    MyInitConsole(_bufferSub3+0x2000,_bufferSub3);
#endif

    // 分配显存存， 128k
    vramSetBankC( VRAM_C_SUB_BG_0x06200000 );    // 128k

    // 初始化为文字模式
    _subEngineMode = SEM_GRAPHICS;

    // BMP bg 的参数设置，从 VRAM地址 0x06200000 开始，优先级3
    REG_BG2CNT_SUB = BG_BMP16_256x256 | BG_BMP_BASE(0) | BG_PRIORITY_1;
    REG_BG2PA_SUB = 1<<8;
    REG_BG2PD_SUB = 1<<8;
    REG_BG2PB_SUB = 0;
    REG_BG2PC_SUB = 0;
    REG_BG2Y_SUB = 0;
    REG_BG2X_SUB = 0;

    _bufferSub1 = (u16 *)0x06200000;
    _bufferSub2 = (u16 *)new u32[256*192/2];

    fillMemory( _bufferSub2, 0x18000, 0xffffffff );
    fillMemory( _bufferSub1, 0x18000, 0xffffffff );

    // text BG
    // text bg 的字模占用 32(字节/字模) * 256(个ascii字) = 8192 字节显存，
    // 文字显示占用 32 x 32 * 2 = 2048 字节显存
    // 字模从 block 8 开始 = 0x06200000 + 8 * 0x4000      = 0x06220000
    // 文字信息从 block 72 开始 = 0x06200000 + 72 * 0x800 = 0x06224000
    // 优先级 2
#ifdef DEBUG
    BG_PALETTE_SUB[255] = RGB15(31,31,31);    //by default font will be rendered with color 255
    REG_BG0CNT_SUB = BG_TILE_BASE(0) | BG_MAP_BASE(8) | BG_PRIORITY_2;
#endif

    swiWaitForVBlank(); //remove tearing at top screen
    // 模式5，开两层BG，一层BMP，一层文字(用于调试)，bmp层现在默认关闭
    videoSetModeSub( MODE_5_2D | DISPLAY_BG2_ACTIVE );
}

void cGdi::drawLine( s16 x1, s16 y1, s16 x2, s16 y2, GRAPHICS_ENGINE engine )
{
    if((x1==x2)&&(y1==y2)) return;

    if(x1==x2) {
        int ys,ye;
        if(y1<y2) {
            ys=y1;
            ye=y2-1;
        } else {
            ys=y2+1;
            ye=y1;
        }
        for(int py=ys;py<=ye;py++) {
            drawPixel(x1,py,engine);
        }
        return;
    }

    if(y1==y2) {
        int xs,xe;
        if(x1<x2) {
            xs=x1;
            xe=x2-1;
        } else {
            xs=x2+1;
            xe=x1;
        }
        if( GE_MAIN == engine )
            fillRect( _penColor, _penColor, xs, y1, xe - xs + 1, 1, engine );
        else
            fillRect( _penColorSub, _penColorSub, xs, y1, xe - xs + 1, 1, engine );
        return;
    }

    if(abs(x2-x1)>abs(y2-y1)) {
        int px=0;
        float py=0;
        int xe=x2-x1;
        float ye=y2-y1;
        int xv;
        float yv;

        if(0<xe) {
            xv=1;
        } else {
            xv=-1;
        }
        yv=ye/abs(xe);

        while(px!=xe) {
            drawPixel(x1+px,y1+(int)py,engine);
            px+=xv;
            py+=yv;
        }
        return;
    }
    else {
        float px=0;
        int py=0;
        float xe=x2-x1;
        int ye=y2-y1;
        float xv;
        int yv;

        xv=xe/abs(ye);
        if(0<ye) {
            yv=1;
        } else {
            yv=-1;
        }

        while(py!=ye) {
            drawPixel(x1+(int)px,y1+py,engine);
            px+=xv;
            py+=yv;
        }
        return;
    }
}

void cGdi::frameRect( s16 x, s16 y, u16 w, u16 h, GRAPHICS_ENGINE engine )
{
    drawLine( x, y, x + w - 1, y, engine );
    drawLine( x + w - 1, y, x + w - 1, y + h - 1, engine );
    drawLine( x + w - 1, y + h - 1, x, y + h - 1, engine );
    drawLine( x, y + h - 1, x, y, engine );
}

void cGdi::frameRect( s16 x, s16 y, u16 w, u16 h, u16 thickness, GRAPHICS_ENGINE engine )
{
  for(size_t ii=0;ii<thickness;++ii)
  {
    frameRect(x,y,w,h,engine);
    if(h<=2||w<=2) break;
    ++x; ++y; w-=2; h-=2;
  }
}

void cGdi::fillRect( u16 color1, u16 color2, s16 x, s16 y, u16 w, u16 h, GRAPHICS_ENGINE engine )
{
    ALIGN(4) u16 color[2] = { BIT(15) | color1 , BIT(15) | color2 };
    u16 * pSrc = (u16 *)color;
    u16 * pDest = NULL;


    if( GE_MAIN == engine )
        pDest = _bufferMain2 + (y << 8) + x + _layerPitch;
    else
        pDest = _bufferSub2 + (y << 8) + x;

    bool destAligned = !(x & 1);

    u16 destInc = 256 - w;
    u16 halfWidth = w >> 1;
    u16 remain = w & 1;

    if( destAligned )
        for( u32 i = 0; i < h; ++i ) {
            swiFastCopy( pSrc, pDest, COPY_MODE_WORD | COPY_MODE_FILL | halfWidth );
            pDest += halfWidth << 1;
            if( remain )
                *pDest++ = *pSrc;
            pDest += destInc;
        }
    else
        for( u32 i = 0; i < h; ++i ) {
            for( u32 j = 0; j < w; ++j ) {
                *pDest++ = pSrc[j&1];
            }
            pDest += destInc;
        }

}

void cGdi::fillRectBlend( u16 color1, u16 color2, s16 x, s16 y, u16 w, u16 h, GRAPHICS_ENGINE engine, u16 opacity)
{
  if(opacity==0) return;
  if(opacity==100)
  {
    fillRect(color1,color2,x,y,w,h,engine);
    return;
  }
  u16* pSrc=((GE_MAIN==engine)?(u16*)_background.buffer():_bufferSub2)+(y<<8)+x;
  u16* pDest=((GE_MAIN==engine)?(_bufferMain2+_layerPitch):_bufferSub2)+(y<<8)+x;
  u32 alpha=(opacity*32)/100;
  u32 destInc=256-w;
  for(u32 ii=0;ii<h;++ii)
  {
    for(u32 jj=0;jj<w;++jj)
    {
      u32 original=*pSrc++&0x7fff;
      u32 color=(jj&1)?color2:color1;
      u32 rb=((color&0x7c1f)*alpha+(original&0x7c1f)*(32-alpha))&0xf83e0;
      u32 g=((color&0x3e0)*alpha+(original&0x3e0)*(32-alpha))&0x7c00;
      *pDest++=((rb|g)>>5)|BIT(15);
    }
    pDest+=destInc;
    pSrc+=destInc;
  }
}

void cGdi::bitBlt( const void * src, s16 srcW, s16 srcH, s16 destX, s16 destY, u16 destW, u16 destH, GRAPHICS_ENGINE engine )
{
    if( destW <= 0 )
        return;

    u16 * pSrc = (u16 *)src;
    u16 * pDest = NULL;

    if( GE_MAIN == engine )
        pDest = _bufferMain2 + (destY) * 256 + destX + _layerPitch;
    else
        pDest = _bufferSub2 + (destY) * 256 + destX;

    bool destAligned = !(destX & 1);

    if( destW > srcW )
        destW = srcW;
    if( destH > srcH )
        destH = srcH;

    u16 srcInc = srcW - destW;
    u16 destInc = 256 - destW;
    u16 destHalfWidth = destW >> 1;
    u16 lineSize = destW << 1;
    u16 remain = destW & 1;

    if( destAligned ) {
        for( u32 i = 0; i < destH; ++i ) {
            dmaCopyWordsGdi( 3, pSrc, pDest, lineSize );
            pDest += destHalfWidth << 1;
            pSrc += destHalfWidth << 1;
            if( remain )
                *pDest++ = *pSrc++;
            pDest += destInc;
            pSrc += srcInc;
        }
    }
}


void cGdi::bitBlt( const void * src, s16 destX, s16 destY, u16 destW, u16 destH, GRAPHICS_ENGINE engine )
{
    u16 * pSrc = (u16 *)src;
    u16 * pDest = NULL;

    if( GE_MAIN == engine )
        pDest = _bufferMain2 + (destY) * 256 + destX + _layerPitch;
    else
        pDest = _bufferSub2 + (destY) * 256 + destX;

    u16 pitchPixel = (destW + (destW & 1));
    u16 destInc = 256 - pitchPixel;
    u16 halfPitch = pitchPixel >> 1;
    u16 remain = pitchPixel & 1;

    for( u16 i = 0; i < destH; ++i ) {
        swiFastCopy( pSrc, pDest, COPY_MODE_WORD | COPY_MODE_COPY | halfPitch );
        pDest += halfPitch << 1;
        pSrc += halfPitch << 1;
        if( remain )
            *pDest++ = *pSrc++;
        pDest += destInc;
    }
}

// maskBlt 要destW是偶数，速度可以快一倍
// 不是偶数也可以，但要求在内存中 src 的 pitch 凑成偶数
void cGdi::maskBlt( const void * src, s16 destX, s16 destY, u16 destW, u16 destH, GRAPHICS_ENGINE engine )
{
    u16 * pSrc = (u16 *)src;
    u16 * pDest = NULL;
    bool destAligned = !(destX & 1);

    if( GE_MAIN == engine )
        pDest = _bufferMain2 + (destY)  * 256 + destX + _layerPitch;
    else
        pDest = _bufferSub2 + (destY) * 256 + destX;

    u16 pitch = (destW + (destW & 1));
    u16 destInc = 256 - pitch;
    u16 halfPitch = pitch >> 1;

    if( destAligned )
    for( u32 i = 0; i < destH; ++i ) {
        for( u32 j = 0; j < halfPitch; ++j ) {
            if( ((*(u32 *)pSrc) & 0x80008000) == 0x80008000 ) {
                *(u32 *)pDest = *(u32 *)pSrc;
                pSrc += 2; pDest += 2;
            }
            else {
                if( *pSrc & 0x8000 )
                    *pDest = *pSrc;
                pSrc++; pDest++;
                if( *pSrc & 0x8000 )
                    *pDest = *pSrc;
                pSrc++; pDest++;
            }
        }
        pDest += destInc;
    }
    else
    for( u16 i = 0; i < destH; ++i ) {
        for( u16 j = 0; j < pitch; ++j ) {
            if( *pSrc & 0x8000 )
                *pDest = *pSrc;
            pDest++; pSrc++;
        }
        pDest += destInc;
    }
}

void cGdi::maskBlt( const void * src, s16 srcW, s16 srcH, s16 destX, s16 destY, u16 destW, u16 destH, GRAPHICS_ENGINE engine )
{
    if( destW <= 0 )
        return;

    u16 * pSrc = (u16 *)src;
    u16 * pDest = NULL;

    if( GE_MAIN == engine )
        pDest = _bufferMain2 + (destY) * 256 + destX + _layerPitch;
    else
        pDest = _bufferSub2 + (destY) * 256 + destX;

    bool destAligned = !(destX & 1);

    if( destW > srcW )
        destW = srcW;
    if( destH > srcH )
        destH = srcH;

    u16 srcInc = srcW - destW;
    u16 destInc = 256 - destW;
    u16 destHalfWidth = destW >> 1;
    u16 pitch = (destW + (destW & 1));
    u16 remain = destW & 1;

    if( destAligned ) {
        for( u32 i = 0; i < destH; ++i ) {
            for( u32 j = 0; j < destHalfWidth; ++j ) {
                if( ((*(u32 *)pSrc) & 0x80008000) == 0x80008000 ) {
                    *(u32 *)pDest = *(u32 *)pSrc;
                    pSrc += 2; pDest += 2;
                }
                else {
                    if( *pSrc & 0x8000 )
                        *pDest = *pSrc;
                    pSrc++; pDest++;
                    if( *pSrc & 0x8000 )
                        *pDest = *pSrc;
                    pSrc++; pDest++;
                }
            }
            if( remain )
                *pDest++ = *pSrc++;
            pDest += destInc;
            pSrc += srcInc;
        }
    }
    else
    for( u16 i = 0; i < destH; ++i ) {
        for( u16 j = 0; j < pitch; ++j ) {
            if( *pSrc & 0x8000 )
                *pDest = *pSrc;
            pDest++; pSrc++;
        }
        pDest += destInc;
        pSrc += srcInc;
    }
}

void cGdi::textOutRect( s16 x, s16 y, u16 w, u16 h, const char * text, GRAPHICS_ENGINE engine )
{
  const s16 originX=x,limitY=y+h-gs().fontHeight;
  while(*text)
  {
    if('\r'==*text||'\n'==*text)
    {
      y+=gs().fontHeight; //FIXME
      x=originX;
      ++text;
      if(y>limitY) break;
    }
    else
    {
      u32 ww,add;
      font().Info(text,&ww,&add);
      if(x+(s16)ww<originX+w)
      {
        font().Draw((GE_MAIN==engine)?(_bufferMain2+_layerPitch):_bufferSub2,x,y,(const u8*)text,(GE_MAIN==engine)?_penColor:_penColorSub);
      }
      text+=add;
      x+=ww;
    }
  }
}

void cGdi::present( GRAPHICS_ENGINE engine )
{
    if( GE_MAIN == engine ) { // 翻转主引擎

        dmaCopyWordsGdi( 3, _bufferMain2 + _layerPitch,
            _bufferMain1 + (_mainEngineLayer << 16), 256 * 192 * 2 );

        fillMemory( (void *)(_bufferMain2 + _layerPitch), 256 * 192 * 2, 0 );

        oamUpdate(&oamMain);

    } else if ( GE_SUB == engine ) { // 翻转副引擎
        if( SEM_GRAPHICS == _subEngineMode )
            dmaCopyWordsGdi( 3, (void *)_bufferSub2, (void *)_bufferSub1, 256 * 192 * 2 );
        fillMemory( (void *)_bufferSub2, 0x18000, 0xffffffff );
    }
}

//special version for window switching
void cGdi::present(void)
{
  swiWaitForVBlank();
  dmaCopyWordsGdi(3,_bufferMain2,_bufferMain1,256*192*2);
  dmaCopyWordsGdi(3,_bufferMain2+(256*192),_bufferMain1+(1<<16),256*192*2);
  fillMemory((void *)_bufferMain2,256*192*4,0);
}

#ifdef DEBUG
void cGdi::switchSubEngineMode()
{
    // 需要保存和恢复文本模式的现场
    switch( _subEngineMode )
    {
    case SEM_GRAPHICS:   // 当前是图形模式的话，就恢复刚才的text现场
        videoSetModeSub( MODE_5_2D | DISPLAY_BG0_ACTIVE );
        custom_console.fontBgMap=(u16*)0x6204000;
        custom_console.fontBgGfx=(u16*)0x6200000;
        dmaCopyWordsGdi( 3, (void *)_bufferSub3, (void *)_bufferSub1, 0x4800 );
        break;
    case SEM_TEXT:      // 当前是文字模式的话，保存现场，切到图形模式
        videoSetModeSub( MODE_5_2D | DISPLAY_BG2_ACTIVE );
        custom_console.fontBgMap=_bufferSub3+0x2000;
        custom_console.fontBgGfx=_bufferSub3;
        dmaCopyWordsGdi( 3, (void *)_bufferSub1, (void *)_bufferSub3, 0x4800 );
        break;
    };
    _subEngineMode = (SUB_ENGINE_MODE)(_subEngineMode^1);
}
#endif