#define DEBUG_MODE  1

#include <azur/azur.h>
#include <azur/gint/render.h>
#include <gint/drivers/r61524.h>
#include <gint/rtc.h>

#include <gint/clock.h>
#include <gint/kmalloc.h>

#include <gint/keyboard.h>

#include <libprof.h>
#include <gint/usb.h>
#include <gint/usb-ff-bulk.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fxlibc/printf.h>
#include <cstdint>

#include <num/num.h>

#include "player.h"
#include "utilities.h"
#include "particles.h"
#include "bullet.h"
#include "ennemy.h"

#include <vector>
#include <algorithm>

#include "MyAzurShaders.h"


bool screenshot = false;
bool record = false;
bool textoutput = false;
bool exitToOS = false;

#define SCALE_PIXEL 1
#define X_RESOL (DWIDTH / SCALE_PIXEL)
#define Y_RESOL (DHEIGHT / SCALE_PIXEL)

#define BIAS 1
#define NOBIAS (1-BIAS)

std::vector<Particle*> MyParticles;
std::vector<Bullet*> MyPlayerBullets;
std::vector<Ennemy*> MyEnnemies;


Starfield *MyStarField;
uint8_t texttodraw=1;

extern bopti_image_t img_mainship1;


Player *MyPlayer;



static void hook_prefrag(int id, void *fragment, int size)
{
    if(!screenshot && !record)
        return;

    /* Screenshot takes precedence */
    char const *type = screenshot ? "image" : "video";

    int pipe = usb_ff_bulk_output();

    if(id == 0) {
        usb_fxlink_header_t h;
        usb_fxlink_image_t sh;
        int size = azrp_width * azrp_height * 2;

        usb_fxlink_fill_header(&h, "fxlink", type, size + sizeof sh);
        sh.width = htole32(azrp_width);
        sh.height = htole32(azrp_height);
        sh.pixel_format = htole32(USB_FXLINK_IMAGE_RGB565);

        usb_write_sync(pipe, &h, sizeof h, 4, false);
        usb_write_sync(pipe, &sh, sizeof sh, 4, false);
    }

    usb_write_sync(pipe, fragment, size, 4, false);

    if(id == azrp_frag_count - 1) {
        usb_commit_sync(pipe);
        //screenshot = false;
    }
}

/*void Create_Starfield( void )
{
    MyStarField = new Starfield();
}*/


void Create_Player_Shoot( uint8_t id )
{

    if (id==0)
    {
        Bullet *b = new Bullet( MyPlayer->x, MyPlayer->y-21, id );
        MyPlayerBullets.push_back( b );
    }
    else if (id==1)
    {
        Bullet *b1 = new Bullet( MyPlayer->x-17, MyPlayer->y, id );
        MyPlayerBullets.push_back( b1 );
        
        Bullet *b2 = new Bullet( MyPlayer->x+17, MyPlayer->y, id );
        MyPlayerBullets.push_back( b2 );
    }
    else if (id==2)
    {
        Bullet *b1 = new Bullet( MyPlayer->x, MyPlayer->y-21, id );
        MyPlayerBullets.push_back( b1 );
        
        Bullet *b2 = new Bullet( MyPlayer->x+17, MyPlayer->y, id );
        MyPlayerBullets.push_back( b2 );
        
        Bullet *b3 = new Bullet( MyPlayer->x-17, MyPlayer->y, id );
        MyPlayerBullets.push_back( b3 );
    }
}

void Create_Ennemies( void )
{
    Ennemy* e1 = new Ennemy( 198, 50, 0);
    e1->Set_Speed_Vector( 1, -6, 1 );
    MyEnnemies.push_back( e1 );

    Ennemy* e2 = new Ennemy( 198, 50, 0);
    e2->Set_Speed_Vector( 1, 6, 1 );
    MyEnnemies.push_back( e2 );

    Ennemy* e3 = new Ennemy( 198, 50, 1);
    e3->Set_Speed_Vector( 1, -3, 3 );
    MyEnnemies.push_back( e3 );

    Ennemy* e4 = new Ennemy( 198, 50, 1);
    e4->Set_Speed_Vector( 1, 3, 3 );
    MyEnnemies.push_back( e4 );
}


void Create_Explosion( uint16_t xexplosion, uint16_t yexplosion )
{
    srand(rtc_ticks());

    for(int i=0; i<=50; i++)
    {
        Particle *p = new Particle( xexplosion, yexplosion, i );
        MyParticles.push_back( p );
    }
}


void Clean_Everything( void )
{
    for(unsigned int i=0; i<MyEnnemies.size(); i++)
    {
        delete( MyEnnemies[i] );
        MyEnnemies.erase( MyEnnemies.begin() + i );
    }
    MyEnnemies.clear();

    for(unsigned int i=0; i<MyParticles.size(); i++)
    {
        delete( MyParticles[i] );
        MyParticles.erase( MyParticles.begin() + i );
    }
    MyParticles.clear();

    for(unsigned int i=0; i<MyPlayerBullets.size(); i++)
    {
        delete( MyPlayerBullets[i] );
        MyPlayerBullets.erase( MyPlayerBullets.begin() + i );
    }
    MyPlayerBullets.clear();
}


static void update( float dt )
{
	// all update stuff depending on time will be done here

    MyPlayer->Update( dt );


    for(auto& e : MyEnnemies)
        e->Update( dt );

    for(unsigned int i=0; i<MyEnnemies.size(); i++)
    {
        // Check if the property toberemoved has been set to "true" for particle deletion
        if (MyEnnemies[i]->toberemoved == true)
        {
            Create_Explosion( (int) MyEnnemies[i]->x, (int) MyEnnemies[i]->y );
            delete( MyEnnemies[i] );
            MyEnnemies.erase( MyEnnemies.begin() + i );

        }
    }

    for(unsigned int i=0; i<MyParticles.size(); i++)
    {
        MyParticles[i]->Update( dt );

        // Check if the property toberemoved has been set to "true" for particle deletion
        if (MyParticles[i]->toberemoved == true)
        {
            delete( MyParticles[i] );
            MyParticles.erase( MyParticles.begin() + i );
        }
    }


    for(unsigned int i=0; i<MyPlayerBullets.size(); i++)
    {
        MyPlayerBullets[i]->Update( dt );

        // Check if the property toberemoved has been set to "true" for particle deletion
        if (MyPlayerBullets[i]->toberemoved == true)
        {
            delete( MyPlayerBullets[i] );
            MyPlayerBullets.erase( MyPlayerBullets.begin() + i );
        }
    }

    for(unsigned int i=0; i<MyPlayerBullets.size(); i++)
    {
        for( unsigned j=0; j<MyEnnemies.size(); j++ )
        {
            if(MyEnnemies[j]->Test_Impact(MyPlayerBullets[i])==true)
            {
                //TODO : we can create a list of impacts here, to be rendered later on
            }
        }
    }   
}


static void get_inputs( void  )
{
    uint8_t speed = 4;
    uint32_t tempshoot = rtc_ticks();

    key_event_t ev;
    while((ev = pollevent()).type != KEYEV_NONE)
    {

    }

    //if(keydown(KEY_F3)) {Create_Explosion();}
    if(keydown(KEY_F1))
    {
        if (MyPlayer->Shoot_OK(tempshoot, 0)) Create_Player_Shoot(0);
    }
    if(keydown(KEY_F2))
    {
        if (MyPlayer->Shoot_OK(tempshoot, 1)) Create_Player_Shoot(1);
    }
    if(keydown(KEY_F3))
    {
        if (MyPlayer->Shoot_OK(tempshoot, 2)) Create_Player_Shoot(2);
    }


    if(keydown(KEY_EXIT)) {exitToOS = true; };


#if(DEBUG_MODE)
    if(keydown(KEY_7) && usb_is_open() )    {screenshot = true;};
    if(keydown(KEY_8) && usb_is_open())    {record = true; };
    if(keydown(KEY_9) && usb_is_open())    {record = false; };
    if(keydown(KEY_DEL) && usb_is_open())    {textoutput = true;};
    
    if(keydown(KEY_SHIFT) && keydown(KEY_F1))   {texttodraw=0;}
    if(keydown(KEY_SHIFT) && keydown(KEY_F2))   {texttodraw=1;}
    if(keydown(KEY_SHIFT) && keydown(KEY_F3))   {texttodraw=2;}
    if(keydown(KEY_SHIFT) && keydown(KEY_F4))   {texttodraw=3;}
#endif


    if(keydown(KEY_LEFT))
    {
        MyPlayer->Go_Left();
    }
    if(keydown(KEY_RIGHT))
    {
        MyPlayer->Go_Right();
    }
    if(keydown(KEY_UP))
    {
        MyPlayer->Go_Up();
    }
    if(keydown(KEY_DOWN))
    {
        MyPlayer->Go_Down();
    }



    if(keydown(KEY_F6))
    {
        azrp_starfield_close( );
        azrp_starfield_init( 100 );
    }

}



static kmalloc_arena_t extended_ram = { 0 };



bool AddMoreRAM( void )
{
    /* allow more RAM */
    char const *osv = (char*) 0x80020020;

    if((!strncmp(osv, "03.", 3) && osv[3] <= '6') && gint[HWCALC] == HWCALC_FXCG50) // CG-50
    {
        extended_ram.name = "extram";
        extended_ram.is_default = true;
        extended_ram.start =   (void *)0x8c200000;
        extended_ram.end = (void *)0x8c500000 ;

        kmalloc_init_arena(&extended_ram, true);
        kmalloc_add_arena(&extended_ram );
        return true;
    }
    else if (gint[HWCALC] == HWCALC_PRIZM)  // CG-10/20
    {

        extended_ram.name = "extram";
        extended_ram.is_default = true;

        uint16_t *vram1, *vram2;
        dgetvram(&vram1, &vram2);
        dsetvram(vram1, vram1);

        extended_ram.start = vram2;
        extended_ram.end = (char *)vram2 + 396*224*2;

        kmalloc_init_arena(&extended_ram, true);
        kmalloc_add_arena(&extended_ram );
        return false;

    }
    else if (gint[HWCALC] == HWCALC_FXCG_MANAGER) // CG-50 EMULATOR
    {

        extended_ram.name = "extram";
        extended_ram.is_default = true;
        extended_ram.start =   (void *)0x88200000;
        extended_ram.end = (void *)0x88500000 ;

        kmalloc_init_arena(&extended_ram, true);
        kmalloc_add_arena(&extended_ram );
        return true;
    }
}


void FreeMoreRAM( void )
{
    memset(extended_ram.start, 0, (char *)extended_ram.end - (char *)extended_ram.start);
}



int main(void)
{
	exitToOS = false;
	float elapsedTime = 0.0f;

    kmalloc_arena_t *_uram = kmalloc_get_arena("_uram");
    kmalloc_gint_stats_t *_uram_stats;
    kmalloc_gint_stats_t *extram_stats;

    bool canWeAllocate3Mb = AddMoreRAM();

    __printf_enable_fp();
    __printf_enable_fixed();

    azrp_config_scale(SCALE_PIXEL);
    azrp_shader_clear_configure();
    azrp_shader_image_rgb16_configure();
    azrp_shader_image_p8_configure();
    azrp_shader_image_p4_configure();
    azrp_hook_set_prefrag(hook_prefrag);

    azrp_starfield_init( 100 );

    Create_Ennemies( );


    MyPlayer = new Player( azrp_width/2, azrp_height/2, 0);


    usb_interface_t const *interfaces[] = { &usb_ff_bulk, NULL };
    usb_open(interfaces, GINT_CALL_NULL);

	prof_init();
    prof_t perf_update, perf_render;
	uint32_t time_update=0, time_render=0;

	do
	{
            perf_update = prof_make();
            prof_enter(perf_update);

			{
				// all the stuff to be update should be put here

				// read inputs from the player
				get_inputs( );

				// update as per the time spend to do the loop
				update( elapsedTime );

                // update the RAM consumption status
                _uram_stats = kmalloc_get_gint_stats(_uram);
                extram_stats = kmalloc_get_gint_stats(&extended_ram);
			}

            prof_leave(perf_update);
            time_update = prof_time(perf_update);

            perf_render = prof_make();
            prof_enter(perf_render);

			{
				// all the stuff to be rendered should be put here
				azrp_clear( C_BLACK );

                #if(BIAS)
                    if (texttodraw>=1) Azur_draw_text(1,01, "FPS  = %.0f", (float) (1000000.0f / elapsedTime) );
                    if (texttodraw>=1) Azur_draw_text(1,11, "Part.= %d - Bull.= %d", MyParticles.size(), MyPlayerBullets.size() );
                    if (texttodraw>=1 && !MyEnnemies.empty()) Azur_draw_text(1,21, "Ennmy Life= %d", MyEnnemies[0]->life );
                    if (texttodraw>=2) Azur_draw_text(1,31, "Update = %.0f mc secs", (float) time_update );
                    if (texttodraw>=2) Azur_draw_text(1,41, "Render = %.0f mc secs", (float) time_render );
                    if (texttodraw>=2) Azur_draw_text(1,51, ">Total = %.3f ml secs", (float) elapsedTime / 1000.0f );
                    if (texttodraw>=2) Azur_draw_text(1,61, ">Total = %.0f seconds", (float) elapsedTime );
                
                    if (texttodraw>=3) Azur_draw_text(1,81,  "Mem Used      : %d", _uram_stats->used_memory + extram_stats->used_memory);
                    if (texttodraw>=3) Azur_draw_text(1,91,  "Mem Free      : %d", _uram_stats->free_memory + extram_stats->free_memory);
                    if (texttodraw>=3) Azur_draw_text(1,101, "Mem Peak Used : %d", _uram_stats->peak_used_memory + extram_stats->peak_used_memory );
                
                    if (texttodraw>=3) Azur_draw_text(1,121, "Size of Particles : %d bytes", sizeof(Particle) );
                    if (texttodraw>=3) Azur_draw_text(1,131, "Size of Bullets   : %d bytes", sizeof(Bullet) );

                #endif

               
                azrp_starfield();
               
                for(auto& b : MyPlayerBullets)
                    b->Render();

                for(auto& e : MyEnnemies)
                    e->Render();

                for(auto& p : MyParticles)
                    p->Render();

                MyPlayer->Render();

				azrp_update();
			}

            prof_leave(perf_render);
            time_render = prof_time(perf_render);

            #if(NOBIAS)
                dclear(C_BLACK);
                dprint(1,01, C_WHITE, "Update = %.0f mc secs", (float) time_update );
                dprint(1,11, C_WHITE, "Render = %.0f mc secs", (float) time_render );
                dprint(1,21, C_WHITE, ">Total = %.3f ml secs", (float) elapsedTime / 1000.0f );
                dprint(1,31, C_WHITE, ">Total = %.0f", (float) elapsedTime );
                dprint(1,41, C_WHITE, "  FPS  = %.0f", (float) (1000000.0f / elapsedTime) );
                dprint(1,51, C_WHITE, "Parts  = %d", MyParticles.size() );
                dupdate();
            #endif

			elapsedTime = ((float) (time_update+time_render));

#if(DEBUG_MODE)
    		if (textoutput && usb_is_open())
            {
                azrp_starfield_USBDEBUG( SHOW_PIXELS );
                azrp_starfield_USBDEBUG( SHOW_STARS );
                textoutput = false;
            }
#endif

    }
    while (exitToOS==false);


    Clean_Everything();

    azrp_starfield_close( );


    prof_quit();
    usb_close();


    FreeMoreRAM( );

	return 1;
}