#include "fxlib.h"
#include "fight.h"
#include "draw.h"
#include "memory.h"
#include "MonochromeLib.h"
#include "key.h"

#include <stdlib.h>
#include <stdio.h>

void Fight_start() //-- ok
{
    Map map;
    Player *players = NULL;
    int nbrPlayers = -1;
    int i, j;
    
    char debug[50];
    
    // Load
    Fight_worldLoad(&map, &players, &nbrPlayers);
    
    // Draw
    ML_clear_vram();
    Draw_mapFight(map);
    
    // Get down players
    Fight_playerDown(map, players, nbrPlayers);
    
    // Play
    Fight_play(map, players, nbrPlayers);
    
    Fight_quit(&map, &players);
    
    Sleep(250);
}

void Fight_worldLoad(Map *map, Player **players, int *nbrPlayers) //-- ok
{
    int mapId;
    int difficulty, mapMode;
    
    Fight_readOptions(&difficulty, &mapMode);
    
    if(mapMode)
        mapId = mapMode;
    else
        mapId = (rand()%Fight_nbrOfMap())+1;
    
    Fight_mapLoad(mapId, map);
    *nbrPlayers = Fight_playerLoad(mapId, players);
}

int Fight_mapLoad(int id, Map *map) //-- ok for fixed size (16*8)
{
    char fileName[50];
    int handle;
    int i, j;
    
    sprintf(fileName, "\\\\fls0\\SNOWF\\ff%d.map", id);
    
    if(!memory_exists(fileName))
    {
        ML_clear_vram();
        Draw_printText("Error loading map.\nFile missing:", 20);
        Draw_textCenter(fileName, 40);
        ML_display_vram();
        Sleep(5000);
        return -1;
    }
    
    map->lenght = 16;
    map->height = 8;
    
    map->tiles = calloc(map->height,sizeof(char *));
    for(i=0; i<map->height; i++)
    {
        map->tiles[i] = calloc(map->lenght,sizeof(char));
        
        handle = memory_openfile(fileName, _OPENMODE_READ);
        memory_readfile(handle, (void *)map->tiles[i], (map->lenght)*sizeof(char), (map->lenght)*sizeof(char)*i);
        memory_closefile(handle);
    }
    return 1;
}

int Fight_playerLoad(int id, Player **players) //-- ok LePhe<3
{
    char fileName[50];
    int nbrPlayers = -1;
    int handle;
    int i, j;
    
    sprintf(fileName, "\\\\fls0\\SNOWF\\ff%d.pla", id);
    
    if(!memory_exists(fileName))
    {
        ML_clear_vram();
        Draw_printText("Error loading player.\nFile missing:", 20);
        Draw_textCenter(fileName, 40);
        ML_display_vram();
        Sleep(5000);
        return -1;
    }
    
    handle = memory_openfile(fileName, _OPENMODE_READ);
    
    memory_readfile(handle, (void *)&nbrPlayers, sizeof(int), -1);
    *players = calloc(nbrPlayers, sizeof(Player));
    for(i=0; i<nbrPlayers; i++)
    {
        (*players)[i].life = 100;
        (*players)[i].team = i%2;
        memory_readfile(handle, (void *)(*players)[i].pos, 2*sizeof(int), -1);
    }
    
    memory_closefile(handle);
    return nbrPlayers;
}

void Fight_quit(Map *map, Player **players) //-- ok
{
    int i;
    
    for(i=0; i<map->height; i++)
        free(map->tiles[i]);
    free(map->tiles);
    free(players);
    
    ML_clear_vram();
    PrintMini(0, 0, "Free() Done", 0);
    ML_display_vram();
    Sleep(5000);
}

Fight_quit(&map, players);

void Fight_quit(Map *map, Player *players) //-- ok
{
    int i;
    
    for(i=0; i<map->height; i++)
        free(map->tiles[i]);
    free(map->tiles);
    free(players);
    
    ML_clear_vram();
    PrintMini(0, 0, "Free() Done", 0);
    ML_display_vram();
    Sleep(5000);
}

void Fight_play(Map map, Player *players, int nbrPlayers) //-- test it ! -- problem jump -- problem ball + ground
{
    int turn = -1;
    int distMade, i, jump;
    Snowball ball;
    char buffer[50];
    
    int handle;
    char names[2][21] = {0};
    
    // Load names
    // Player 1
    handle = memory_openfile("\\\\fls0\\SNOWF\\name.txt", _OPENMODE_READ);
    memory_readfile(handle, (void *)names[0], 20*sizeof(char), 0);
    memory_closefile(handle);
    // Player 2
    ML_clear_vram();
    sprintf(buffer, "\nHey guys,\nbefore starting the battle, what's your name dear guest of %s ?", names[0]);
    Draw_printText(buffer, 25);
    PrintMini(10, 50, "GUEST: ", 0);
    InputString(names[1], 19, 40, 50);
    ML_clear_vram();
    sprintf(buffer, "Nice to meet you %s !\nBe careful, %s is a pro player at SBF...", names[1], names[0]);
    Draw_printText(buffer, 25);
    Draw_textCenter("Press [ExE]", 50);
    ML_display_vram();
    while(!key_down(K_EXE))
        Sleep(100);
    while(key_down(K_EXE));
    
    // Draw map
    ML_clear_vram();
    Draw_mapFight(map);
    SaveDisp(2);
    
    // Engine
    while(1)
    {
        turn = (turn+1)%nbrPlayers;
        
        if(players[turn].life > 0)
        {
            
            RestoreDisp(2);
            Draw_playersFight(players, nbrPlayers);
            ML_rectangle(30, 28, 98, 37, 1, ML_CHECKER, ML_WHITE);
            ML_rectangle(29, 27, 99, 38, 1, ML_BLACK, ML_TRANSPARENT);
            sprintf(buffer, "%s turn", names[players[turn].team]);
            Draw_textCenter(buffer, 30);
            ML_display_vram();
            while(!key_down(K_EXE))
                Sleep(100);
            while(key_down(K_EXE));
    
            // MOVE
            distMade = 0;
            jump = 0;
            do
            {
                // Draw
                RestoreDisp(2);
                Draw_selectedPlayer(players[turn], MAX_DEP-distMade);
                if(!jump)
                    Fight_playerDown(map, players, nbrPlayers);
                else
                    Draw_playersFight(players, nbrPlayers);
                ML_display_vram();
                
                // Keys
                // Goto shoot
                if(key_down(K_EXE) && !jump || players[turn].life<=0)
                {
                    while(key_down(K_EXE));
                    break;
                }
                // Quit
                if(key_down(K_EXIT))
                {
                    while(key_down(K_EXIT));
                    return;
                }
                // Left
                if(key_down(K_LEFT)  &&  players[turn].pos[0] > 0  &&  map.tiles[(int)((players[turn].pos[1])/8)][(int)((players[turn].pos[0])/8)] == 0)
                {
                    distMade++;
                    players[turn].pos[0]--;
                }
                // Right
                if(key_down(K_RIGHT)  &&  (int)((players[turn].pos[0]+8)/8) < map.length   &&  map.tiles[(int)((players[turn].pos[1])/8)][(int)((players[turn].pos[0]+6)/8)] == 0)
                {
                    distMade++;
                    players[turn].pos[0]++;
                }
                // Up
                if(jump)
                {
                    jump--;
                    if(players[turn].pos[1] > 1)
                    {
                        if(map.tiles[(int)((players[turn].pos[1]-8)/8)][(int)((players[turn].pos[0])/8)] == 0)
                            players[turn].pos[1]--;
                    }
                }
                else if(key_down(K_UP)  &&  map.tiles[(int)((players[turn].pos[1]-8)/8)][(int)((players[turn].pos[0])/8)] == 0)
                {
                    jump = 10;
                }
                
                Sleep(100);
            }while(distMade < MAX_DEP);
            
            if(players[turn].life > 0)
            {
                RestoreDisp(2);
                Draw_selectedPlayer(players[turn], MAX_DEP-distMade);
                Fight_playerDown(map, players, nbrPlayers);
                
                // SHOOT
                SaveDisp(1);
                ball.pos[0] = (float)players[turn].pos[0] + (players[turn].pos[0]>64 ? -1. : 7.);
                ball.pos[1] = (float)players[turn].pos[1] + 4.;
                ball.speed[0] = (players[turn].pos[0]>64 ? -1. : 1.);
                ball.speed[1] = -1.5;
                do
                {
                    // Draw
                    RestoreDisp(1);
                    Draw_traject(ball);
                    ML_display_vram();
                    
                    // Keys
                    if(key_down(K_EXIT))
                    {
                        while(key_down(K_EXIT));
                        return;
                    }
                    if(key_down(K_LEFT) && ball.speed[0] > -MAX_SPEED)
                    {
                        ball.speed[0] -= .05;
                        if(ball.speed[0] < 0.)
                            ball.pos[0] = (float)players[turn].pos[0] - 1.;
                    }
                    if(key_down(K_RIGHT) && ball.speed[0] < MAX_SPEED)
                    {
                        ball.speed[0] += .05;
                        if(ball.speed[0] > 0.)
                            ball.pos[0] = (float)players[turn].pos[0] + 7.;
                    }
                    if(key_down(K_UP) && ball.speed[1] > -MAX_SPEED)
                    {
                        ball.speed[1] -= .05;
                    }
                    if(key_down(K_DOWN) && ball.speed[1] < MAX_SPEED)
                    {
                        ball.speed[1] += .05;
                    }
                    if(key_down(K_EXE))
                    {
                        while(key_down(K_EXE));
                        break;
                    }
                    
                    Sleep(50);
                }while(1);
                    
                ball.flying = 1;
                do
                {
                    // Draw
                    RestoreDisp(1);
                    ML_point((int)(ball.pos[0]+.5), (int)(ball.pos[1]+.5), 3, ML_BLACK);
                    ML_display_vram();
                    
                    // Ball position
                    ball.pos[0] += ball.speed[0]/2.;
                    ball.pos[1] += ball.speed[1]/2.;
                    ball.speed[1] += .05;
                    
                    // Quit
                    if(key_down(K_EXIT))
                    {
                        while(key_down(K_EXIT));
                        return;
                    }
                    
                    // Player collision
                    for(i=0; i<nbrPlayers; i++)
                    {
                        if( ball.pos[0]+1.>=(float)players[i].pos[0] && ball.pos[0]-1.<=(float)players[i].pos[0]+5.  &&  ball.pos[1]+1.>=(float)players[i].pos[1] && ball.pos[1]-1.<=(float)players[i].pos[1]+8.)
                        {
                            if(ball.pos[1]+1.>=(float)players[i].pos[1]+3.)
                                players[i].life -= 35; // Bodyshoot
                            else
                                players[i].life -= 70; // Headshoot
                            
                            if(players[i].life < 0)
                                players[i].life = 0;
                            ball.flying = 0;
                        }
                    }
                    
                    // Ground collision
                    if((int)((ball.pos[0] + 1.)/8.) > map.length   ||  ((ball.pos[0] - 1.)/8.) < 0.  ||  map.tiles[(int)((ball.pos[1] + (ball.speed[0]>0. ? 1. : -1.))/8.)][(int)((ball.pos[0] + (ball.speed[0]>0. ? 1. : -1.))/8.)] != 0)
                        ball.flying = 0;
                    
                    Sleep(BALL_SPEED);
                }while(ball.flying);
            }
        }
        
        if(Fight_checkPlayers(players, nbrPlayers))
            break;
    }
    
    // End of game
    ML_clear_vram();
    Draw_mapFight(map);
    Draw_playersFight(players, nbrPlayers);
    
    ML_rectangle(30, 28, 98, 37, 1, ML_CHECKER, ML_WHITE);
    ML_rectangle(29, 27, 99, 38, 1, ML_BLACK, ML_TRANSPARENT);
    sprintf(buffer, "%s wins !", names[Fight_checkPlayers(players, nbrPlayers)-1]);
    Draw_textCenter(buffer, 30);
    ML_display_vram();
    while(!key_down(K_EXE))
        Sleep(100);
    while(key_down(K_EXE));
}

void AGBS_MenuJeu()
{
    // SPRITES
    const unsigned char fond[]={
        
        0x0,0x0,0x0,0x0,0x0,0x78,0x0,0x0,
    };
    const unsigned char oeuf[]={
        0x6,0x0,
        0x1f,0x80,
    };
    
    unsigned int key;
    int x, y;
    
    x = 64;
    y = 32;
    
    do
    {
        // AFFICHAGE
        ML_clear_vram();
        ML_bmp_or(fond, 0, 0, 128, 64);
        ML_bmp_or(oeuf, x-6, y-7, 12, 14);
        ML_display_vram();
        
        // Gauche
        if(key_down(K_LEFT) && x>6)
            x--;
        // Droite
        if(key_down(K_RIGHT) && x<122)
            x++;
        // Haut
        if(key_down(K_UP) && y>7)
            y--;
        // Bas
        if(key_down(K_DOWN) && y<57)
            y++;
        // Retour
        if(key_down(K_EXIT))
        {
            while(key_down(K_EXIT))
                Sleep(100);
            return;
        }
        // Exe
        if(key_down(K_EXE))
        {
            while(key_down(K_EXE))
                Sleep(100);
            
            if(x>5 && y>4  &&  x<36 && y<35)
                return;
            if(x>28 && y>33  &&  x<59 && y<64)
                AGBS_Monde1();
            if(x>54 && y>1  &&  x<85 && y<32)
                AGBS_Monde2();
            if(x>88 && y>15  &&  x<119 && y<46)
                AGBS_Monde3();
        }
        Sleep(15);
    }while(1);
}

void AGBS_Monde1()
{
    // SPRITES
    const unsigned char fond[]={
        0x0,0x0,0x0,0x0,
    };
    const unsigned char pointeur[]={
        0x0,0x0,0x0,0x0,
    };
    const unsigned char cadena[]={
        0xff,
    };

    unsigned int key = 0;
    int xPointeur, nbr;
    
    xPointeur = 0;
    
    do
    {
        // AFFICHAGE
        ML_clear_vram();
        ML_bmp_or_cl(fond, -7*xPointeur, 0, 191, 64);
        ML_bmp_or_cl(pointeur, xPointeur*12+1, -3, 16, 18);
        for(nbr = data[1]; nbr<8; nbr++)
            ML_bmp_xor_cl(cadena, 43+19*nbr-7*xPointeur, 23, 8, 7);
        
        
        // GESTION DES TOUCHES
        GetKey(&key);
        
        switch(key)
        {
            case KEY_CTRL_EXIT:
                if(xPointeur != 0)
                    xPointeur = 0;
                else
                    return;
                break;
            case KEY_CTRL_LEFT:
                if(xPointeur>0)
                    xPointeur--;
                break;
            case KEY_CTRL_RIGHT:
                if(xPointeur<data[1]+1)
                    xPointeur++;
                break;
            case KEY_CTRL_EXE:
                while(key_down(K_EXE))
                    Sleep(100);
                if(xPointeur)
                    level(1, xPointeur-1);
                else
                    return;
        }
    }while(1);
}

char debug[200] = {0};