/* Keep these headers */
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <tice.h>

/* Standard headers - it's recommended to leave them included */
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "screen8bpp.h"
#include "tools.h"

static const uint8_t* screen_buf = (uint8_t*)0xD40000;
static const uint8_t* offscreen_ptr = (uint8_t*)0xD52C00;    // vram "back buffer" (free to use when LCD is in 8bpp)  76.8k
uint8_t* brightness = (uint8_t*)0xF60024;
uint8_t minBrightness = 255;
uint8_t maxBrightness = 49; // Do NOT set lower, may damage the hardware.
uint16_t* palette = (uint16_t*)0xE30200;
uint8_t bpp=16;

/* Your code here */

uint8_t* getOffscreen()
{
    return offscreen_ptr;
}

uint8_t getBrightness()
{
    return *brightness;
}

void setBrightness(uint8_t bright)
{
    *brightness=bright;
}

void increaseBrightness(uint8_t targetBrightness)
{
    uint8_t i=0;
        // increase brightness
    for (i=*brightness; i>=targetBrightness; i--) // yes this is the good direction
    {
        *brightness = i;
        nopwait(2000);
    }
}

void fillScreen(uint8_t color)
{
    memset_fast(screen_buf, color, SCR_HEIGHT*SCR_WIDTH*bpp/8);
}

void fillLines(uint8_t color, uint8_t y1, uint8_t y2)
{
    uint8_t yi=min(y1,y2);
    uint8_t ys=max(y1,y2);
    memset_fast(screen_buf+yi*SCR_WIDTH*bpp/8,color,(ys-yi+1)*SCR_WIDTH*bpp/8);
}

void initPalette()
{
    palette[0] = rgb2color(0, 0, 0);        // noir
    palette[1] = rgb2color(0xFF, 0, 0);    // rouge
    palette[2] = rgb2color(0, 0x60, 0x8E);
    palette[3] = rgb2color(0x8E, 0x60, 0xFF);
    palette[4] = rgb2color(0xFF, 0x60, 0xAA);
    palette[5] = rgb2color(0, 0xAA, 0xFF);
    palette[6] = rgb2color(0xAA, 0xAA, 0xAA); // gris
    palette[7] = rgb2color(0xFF, 0xAA, 0);
    palette[8] = rgb2color(0xFF, 0x9E, 0x9E);
    palette[9] = rgb2color(0xFF, 0xAA, 0xFF);
    palette[10] = rgb2color(0x60, 0xF9, 0);
    palette[11] = rgb2color(0xFF, 0xDB, 0xAA);
    palette[12] = rgb2color(0xF9, 0xF9, 0);
    palette[13] = rgb2color(0xFF, 0xFF, 0xFF); // blanc
    palette[14] = rgb2color(0, 0xFE, 0xFF);
}

void startScreen8bpp()
{
    // 320x240 8bpp
    fillScreen(0);
    *brightness=minBrightness;
    initPalette();
    (*(uint8_t*)0xE30018) = 0x27;
    bpp=8;
    fillScreen(0);
}

void endScreen8bpp()
{
    (*(uint8_t*)0xE30018) = 0x2D;
    bpp=16;
}

void gc_drawTile(uint8_t* data, uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t searchval, uint8_t replval)
{
    uint8_t* ptr_out = screen_buf;
    uint8_t* ptr_in  = data;
    uint8_t subst=(searchval!=replval)?1:0;
    uint8_t i;
    ptr_out += y*SCR_WIDTH + x;
    while (h>0)
    {
        memcpy(ptr_out, ptr_in, w);
        if(subst)
        {
            for(i=0;i<w;i++)
            {
                if(*ptr_out==searchval) *ptr_out=replval;
                ptr_out++;
            }
            ptr_out+=SCR_WIDTH-w;
        }
        else
            ptr_out += SCR_WIDTH;
        ptr_in  += w;
        h--;
    }
}

void gc_drawTranspTile(uint8_t* data, uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t transp)
{
    uint8_t* ptr_out = screen_buf;
    uint8_t* ptr_in  = data;
    uint8_t i;
    ptr_out += y*SCR_WIDTH + x;
    while (h>0)
    {   for(i=0;i<w;i++)
        {
            if(*ptr_in!=transp)
                *ptr_out=*ptr_in;
            ptr_out++;
            ptr_in++;
        }
        ptr_out+=SCR_WIDTH-w;
        h--;
    }
}

void gc_drawTranspZoomTile(uint8_t* data, uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t transp, uint8_t zoom)
{
    uint8_t* ptr_out = screen_buf;
    uint8_t* ptr_in  = data;
    uint8_t i,val;
    uint16_t cw=w,cx=x,n;
    if(zoom==1)
        gc_drawTranspTile(data, x, y, w, h, transp);
    else
    {
        ptr_out += y*SCR_WIDTH + x;
        while (h>0)
        {
            if(*ptr_in!=transp && cx<SCR_WIDTH)
            {
                n=min(zoom,SCR_WIDTH-cx);
                for(i=0;i<zoom;i++)
                    memset_fast(ptr_out+i*SCR_WIDTH, *ptr_in, n);
            }
            ptr_out += zoom;
            cx+=zoom;
            ptr_in++;
            w--;
            if(!w) {
                w=cw;
                cx=x;
                h--;
                ptr_out+=zoom*SCR_WIDTH-w*zoom;
            }
        }
    }
}


void gc_drawZoomTile(uint8_t* data, uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t zoom)
{
    uint8_t* ptr_out = screen_buf;
    uint8_t* ptr_in  = data;
    uint8_t i,val;
    uint16_t cw=w,cx=x,n;
    if(zoom==1)
        gc_drawTile(data, x, y, w, h, 0, 0);
    else
    {
        ptr_out += y*SCR_WIDTH + x;
        while (h>0)
        {
            if(cx<SCR_WIDTH)
            {
                n=min(zoom,SCR_WIDTH-cx);
                for(i=0;i<zoom;i++)
                    memset_fast(ptr_out+i*SCR_WIDTH, *ptr_in, n);
            }
            ptr_out += zoom;
            cx+=zoom;
            ptr_in++;
            w--;
            if(!w) {
                w=cw;
                cx=x;
                h--;
                ptr_out+=zoom*SCR_WIDTH-w*zoom;
            }
        }
    }
}

void drawVert(uint16_t x, uint16_t y1, uint16_t y2, uint8_t color)
{
    uint16_t y;
    if(x<SCR_WIDTH)
    {
        uint8_t* ptr_out = screen_buf+x+y1*SCR_WIDTH;
        for(y=y1;y<=y2;y++)
        {
            *ptr_out=color;
            ptr_out+=SCR_WIDTH;
        }
    }
}