#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include "structures.h"
#include "constantes.h"
#include "prototypes.h"
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include "players.h"

#include "rpg.h"

static void init_team_players(struct team_t *team, bool left,
        const enum character_class_t *classes, SURFACES *surfaces)
{
    for (int i = 0; i < team->chr_cnt; i++) {
        struct character_t *chr = &team->chrs[i];

        chr->name = "Player";
        chr->team = team;
        chr->idx = i;
        chr->cpu = team->cpu;
        chr->class_ = classes[i];
        chr->alive = true;

        chr->defensive = false;
        chr->poisoned = false;

        switch (chr->class_) {
            case CLASS_PALADIN:
                chr->def_surf = surfaces->Ppaladin;
                chr->red_surf = surfaces->red_paladin;
                break;
            case CLASS_PRIEST:
                chr->def_surf = surfaces->Ppretre;
                chr->red_surf = surfaces->red_priest;
                break;
            case CLASS_THIEF:
                chr->def_surf = surfaces->Pvoleur;
                chr->red_surf = surfaces->red_thief;
                break;
            case CLASS_WARRIOR_GOBELIN:
                chr->def_surf = surfaces->Pgobelin;
                chr->red_surf = surfaces->red_warrior_gobelin;
                break;
            default:
                abort();
        }

        chr->surf = chr->def_surf;

        chr->hp = base_stats_g[chr->class_].hp;
        chr->max_hp = base_stats_g[chr->class_].hp;
        chr->mp = base_stats_g[chr->class_].mp;
        chr->max_mp = base_stats_g[chr->class_].mp;
        chr->magic = base_stats_g[chr->class_].magic;
        chr->strength = base_stats_g[chr->class_].strength;
        chr->defense = base_stats_g[chr->class_].defense;
        chr->spirit = base_stats_g[chr->class_].spirit;

        for (int j = 0; j < countof(chr->affinities); ++j) {
            chr->affinities[j] = rand() % AFFINITY_COUNT;
        }

        chr->pos.y = (rpg_g.screen->h / ((team->chr_cnt + 1) * 2)) * (2 * (i + 1)) - chr->surf->h / 2;

        if (left) {
            chr->curs = surfaces->Pcurseurallies;
            chr->pos.x = 20;
            chr->pos_curs.x = chr->pos.x + chr->surf->w + 20;
        } else {
            chr->curs = surfaces->Pcurseurennemis;
            chr->pos.x = surfaces->screen->w - chr->surf->w - 20;
            chr->pos_curs.x = chr->pos.x - chr->curs->w - 20;
        }

        chr->pos_curs.y = chr->pos.y + chr->surf->h / 2 - chr->curs->h / 2;
    }
}

static void init_team(struct team_t *team, int chr_cnt)
{
    team->objects.potions = 10;
    team->objects.ethers = 10;
    team->objects.potionsplus = 5;
    team->objects.ethersplus = 5;

    team->chr_cnt = chr_cnt;
    team->chr_cur = rand() % team->chr_cnt;
    team->chrs = malloc(sizeof(struct character_t) * team->chr_cnt);
}

static
struct team_t *new_ally_team(SURFACES *surfaces,
        const enum character_class_t *classes, int cnt)
{
    struct team_t *team = malloc(sizeof(struct team_t));

    team->name = "Team Player";
    team->cpu = false;

    init_team(team, cnt);

    init_team_players(team, true, classes, surfaces);

    /* TODO remove when the level is set */
    for (int i = 0; i < team->chr_cnt; ++i) {
        team->chrs[i].ally.nv = 0;
    }

    return team;
}

static void generate_enemy_types(const struct team_t *ally_team,
        enum character_class_t *classes, int count)
{
    int avg = 0;

    for (int i = 0; i < ally_team->chr_cnt; i++) {
        avg += ally_team->chrs[i].ally.nv;
    }

    avg /= ally_team->chr_cnt;

    if (avg < 5)
    {
        /* easy */
        for (int i = 0; i < count; i++) {
            classes[i] = CLASS_WARRIOR_GOBELIN;
        }
    } else {
        /* XXX should not happen for now since we do not change the levels */
        abort();
    }
}

static
struct team_t *new_enemy_team(SURFACES *surfaces, const struct team_t *ally_team)
{
    struct team_t *team = malloc(sizeof(struct team_t));
    enum character_class_t *classes;

    team->name = "Team CPU";
    team->cpu = true;

    init_team(team, rand() % 5 + 1);

    classes = malloc(sizeof(enum character_class_t) * team->chr_cnt);

    generate_enemy_types(ally_team, classes, team->chr_cnt);

    init_team_players(team, false, classes, surfaces);

    free(classes);

    return team;
}

static void Fchangersurlignage2(int Vchoix, SURFACES *surfaces,
        SDL_Surface *text, POSITIONS *positions)
{
    SDL_Surface *surf;

    if (Vchoix == CLASS_PALADIN) {
        surf = surfaces->Pchoixpaladin;
    } else if (Vchoix == CLASS_PRIEST) {
        surf = surfaces->Pchoixpretre;
    } else if (Vchoix == CLASS_THIEF) {
        surf = surfaces->Pchoixvoleur;
    } else {
        abort();
    }

    /* this surface fills the whole screen */
    SDL_BlitSurface(surf, NULL, surfaces->screen, NULL);

    SDL_BlitSurface(surfaces->Ppretre, NULL, surfaces->screen, &positions->menupretre);
    SDL_BlitSurface(surfaces->Ppaladin, NULL, surfaces->screen, &positions->menupaladin);
    SDL_BlitSurface(surfaces->Pvoleur, NULL, surfaces->screen, &positions->menuvoleur);

    SDL_BlitSurface(text, NULL, surfaces->screen, &positions->textemenu);

    SDL_Flip (surfaces->Pecran);
}

void Fmenuchoixpersos (SURFACES *surfaces, POSITIONS *positions)
{
    int Vchoix = CLASS_PALADIN;
    SDL_Color vert;
    bool continuer = true;
    struct team_t *ally_team;
    struct team_t *enemy_team;
    enum character_class_t chr_classes[3];
    SDL_Event event;
    int Vnbperso = 0;

    vert.r = 39;
    vert.g = 189;
    vert.b = 31;

    /* loop until we have actually chosen our three characters */
    while (Vnbperso < 3) {
        static const char *strings[] = {
            "Please choose the class of your first character",
            "Please choose the class of your second character",
            "Please choose the class of your third character",
        };

        SDL_Surface *surf;

        /* display the background with the selected text */
        if (Vchoix == CLASS_PALADIN) {
            surf = surfaces->Pchoixpaladin;
        } else if (Vchoix == CLASS_PRIEST) {
            surf = surfaces->Pchoixpretre;
        } else if (Vchoix == CLASS_THIEF) {
            surf = surfaces->Pchoixvoleur;
        } else {
            abort();
        }

        SDL_BlitSurface(surf, NULL, surfaces->screen, NULL);

        /* display the string associated with the current character number (aka Please choose ...) */
        surf = TTF_RenderText_Blended(rpg_g.font, strings[Vnbperso], vert);

        positions->textemenu.x = surfaces->screen->w / 2 - surf->w / 2;
        SDL_BlitSurface(surf, NULL, surfaces->screen, &positions->textemenu);


        SDL_BlitSurface(surfaces->Ppretre, NULL, surfaces->screen, &positions->menupretre);
        SDL_BlitSurface(surfaces->Ppaladin, NULL, surfaces->screen, &positions->menupaladin);
        SDL_BlitSurface(surfaces->Pvoleur, NULL, surfaces->screen, &positions->menuvoleur);
        SDL_Flip (surfaces->Pecran);

        continuer = true;
        while (continuer)
        {
            SDL_WaitEvent (&event);
            switch (event.type)
            {
                case SDL_KEYDOWN:
                switch (event.key.keysym.sym)
                {
                    case SDLK_LEFT:
                    case SDLK_h:
                        if (Vchoix > CLASS_PALADIN) {
                            Vchoix--;
                        } else {
                            Vchoix = CLASS_THIEF;
                        }
                        Fchangersurlignage2(Vchoix, surfaces, surf, positions);

                        break;
                    case SDLK_RIGHT:
                    case SDLK_l:
                        if (Vchoix < CLASS_THIEF) {
                            Vchoix++;
                        } else {
                            Vchoix = CLASS_PALADIN;
                        }
                        Fchangersurlignage2(Vchoix, surfaces, surf, positions);
                    break;
                    case SDLK_RETURN:
                    case SDLK_f:
                    chr_classes[Vnbperso++] = Vchoix;
                    continuer = false;
                    break;
                    default:
                    break;
                }
                break;
            }
        }

        SDL_FreeSurface(surf);
    }

    SDL_Flip(surfaces->Pecran);
    ally_team = new_ally_team(surfaces, chr_classes, 3);
    enemy_team = new_enemy_team(surfaces, ally_team);
    Fmap(surfaces,positions, ally_team, enemy_team);
}