/********************************************
* Fichier : map.cpp - Version : 0.1 Rev4
* Auteur : Johann Mallet <76617>
* ? : Fichier source de la class Map
* ? : Cette class gére l'affichage de la map
*********************************************/

/** Include **/
#include <SFML/Graphics.hpp>
#include <string>
#include <stdio.h>
#include <iostream>
#include "constantes.hpp"
#include "map.hpp"

using namespace std;

/** Class source **/
Map::Map() {

    // Initialisation d'une nouvelle map, avec les setters tant qu'a faire...
    // Image, et sprite associe
    setIMur(R_MUR);
    setIMurCassable(R_MURCASSABLE);
    setIFond(R_FOND);

    setMur(getIMur());
    setMurCassable(getIMurCassable());
    setFond(getIFond());

    // Chargement du niveau à partir du .lvl
    chargerNiveau(carte);
}

sf::Image& Map::getIFond () {
    return iFond;
}
void Map::setIFond(string filename) {
    /*if(!iFond.LoadFromFile(filename)) {
        printf("prout");
        exit(EXIT_FAILURE);
    }*/
    iFond.LoadFromFile(filename);
}
sf::Sprite Map::getFond () {
    return fond;
}
void Map::setFond(sf::Image& img) {
    fond.SetImage(img);
    //this->fond.Resize(LARGEUR_FENETRE, HAUTEUR_FENETRE);
}


int Map::chargerNiveau(Case niveau[][NB_BLOCS_LARGEUR]) {
    FILE* fichier = NULL;
    char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
    int i = 0, j = 0;

    fichier = fopen(NIVEAU, "r");
    if (fichier == NULL) { return 0; }

    fgets(ligneFichier, NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1, fichier);

    for (i = 0 ; i < NB_BLOCS_HAUTEUR ; i++)
    {
        for (j = 0 ; j < NB_BLOCS_LARGEUR ; j++)
        {
            switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
            {
                case '0':
                    niveau[i][j].setType(VIDE);
                    break;
                case '1':
                    niveau[i][j].setType(MUR);
                    break;
                case '2':
                    niveau[i][j].setType(MURCASSABLE);
                    break;
                case '3':
                    niveau[i][j].setType(JOUEUR); // Même si redéfini par sécurité plus tard...
                    cout << "Ligne " << i << " - Colone " << j << "Joueur trouvé" << endl;
                    break;
            }
        }
    }

    fclose(fichier);
    return 1;
}

void Map::AfficheMap() {

  /*  // Effacement de la fenetre
    //fenetre->Clear(sf::Color(255, 255, 255));
    fenetre->Clear(sf::Color(0, 0, 255));

    // Le fond
    //getFond().SetPosition(sf::Vector2f(0,0));
    fenetre->Draw(fond);
    fenetre->Display();*/

     // Effacement de la fenetre
    fenetre->Clear(sf::Color(255, 255, 255));

    // Le fond
    fond.SetPosition(sf::Vector2f(0,0));
    fond.SetColor(sf::Color(255, 255, 255, 128));
    fenetre->Draw(fond);

    // Parcour du tableau
    sf::Vector2i position;

    for (int i = 0 ; i < NB_BLOCS_HAUTEUR ; i++)
    {
        for (int j = 0 ; j < NB_BLOCS_LARGEUR ; j++)
        {
            position.x = j * TAILLE_BLOC;
            position.y = i * TAILLE_BLOC;

            switch(carte[i][j].getType())
            {
                case MUR:
                    mur.SetPosition(sf::Vector2f(position.x, position.y));
                    fenetre->Draw(mur);
                    break;
                case MURCASSABLE:
                    murCassable.SetPosition(sf::Vector2f(position.x, position.y));
                    fenetre->Draw(murCassable);
                    break;
                //default:
                    //cout << "type : " << carte[i][j].getType() << endl;
            }
        }
    }

    // Affichage
    fenetre->Display();


}

/** Getters et Setters **/
//Case** Map::getCarte () { return this->carte; }
//void Map::setCarte(Case** carte) { this->carte = carte; }

/** Sf::Image **/
sf::Image Map::getIMur () { return this->iMur;}
void Map::setIMur(string iMur) { this->iMur.LoadFromFile(iMur); }

sf::Image Map::getIMurCassable () { return this->iMurCassble; }
void Map::setIMurCassable(string iMurCassble) { this->iMurCassble.LoadFromFile(iMurCassble); }


//sf::Image* Map::getIBombe () { return this->iBombe; }
/*void Map::setIBombe(string* iBombe) {
    for ((int i=0;i<NB_BOMBE; i++) {
        this->iBombe[i].LoadFromFile(iBombe[i]);
    }
}*/

/** sf:Sprite **/
sf::Sprite Map::getMur () { return this->mur; }
void Map::setMur(sf::Image mur) { this->mur.SetImage(mur); }

sf::Sprite Map::getMurCassable () { return this->murCassable; }
void Map::setMurCassable(sf::Image murCassable) { this->murCassable.SetImage(murCassable); }


//sf::Sprite* Map::getBombe () { return this->bombe; }
/*void Map::setIBombe(sf::Image* bombe) {
    for ((int i=0;i<NB_BOMBE; i++) {
        this->bombe[i].SetImage(bombe[i]);
    }
}*/

// Programmation défensive pour le getter
sf::RenderWindow* Map::getFenetre() { // A change dans le futur par l'appel a la classe qui gere les fenetres
   /* if (this->fenetre != NULL) {
        sf::RenderWindow fenetre(sf::VideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE), TITRE_FENETRE);
        fenetre.SetFramerateLimit(FRAMERATE); // Limite à X images par seconde (CPU less, artefact less...)
        this->fenetre = &fenetre;
    }*/
    return this->fenetre;
}

void Map::setFenetre(sf::RenderWindow* fenetre) { this->fenetre = fenetre; }