#include "GameplayScreen.h"
#include "Config.h"

GameplayScreen::GameplayScreen(SDL_Renderer *renderer)
{
    this->file.LoadFromFile("Video");

    this->text.setFont("font", renderer);

    this->posX = file.getX();
    this->posY = file.getY();

    this->moveMap = true;

    this->showDebugVariables = 0;

    this->multiplierX = 0;
    this->multiplierY = 8;

    this->pPosX = 0;
    this->pPosY = 0;

    this->blockState = None;
    this->blockState = None;
    this->currentElement = Earth;

    LoadElement(renderer);
    LoadGameDate(renderer);

    ePlayer = new Player(renderer);
}

GameplayScreen::~GameplayScreen(void)
{
    for (std::vector<Block*>::iterator i = vBlock.begin(); i < vBlock.end(); ++i)
    {
        delete (*i);
    }
    vBlock.clear();

    for (auto &m : map)
    {
        for (auto &mp : m)
        {
            mp.clear();
        }
        m.clear();
    }
    map.clear();

    delete ePlayer;
    ent.ClearEntity();
}

void GameplayScreen::Update()
{
    ePlayer->Update();
    if (ePlayer->getPosY() >= 700)
    {
        ePlayer->setMove(false);
        resetMapWhenPlayerFalled();
        if (posX == 0)
        {
            ePlayer->setVelY(0);
            ePlayer->setPosX(100);
            ePlayer->setPosY(450);
        }
    }

    ent.Update();
}

void GameplayScreen::Draw(SDL_Renderer *renderer)
{
    DrawMap(renderer);
    ePlayer->Draw(renderer, showDebugVariables);
    ent.Draw(renderer, posX, posY, showDebugVariables);
}

void GameplayScreen::DrawMap(SDL_Renderer *renderer)
{
    for (int y = map.size() - 1; y >= 0; --y)
    {
        for (int x = getStartBlockX(), iEnd = getEndBlockX(); x <= iEnd && x < map[y].size(); ++x)
        {
            if (map[y][x] != "0,0")
            {
                SDL_Rect destRect;
                SDL_Rect srcRect;

                srcRect.w = 32;
                srcRect.h = 32;
                srcRect.x = bNum(map[y][x]).first * srcRect.w;
                srcRect.y = bNum(map[y][x]).second * srcRect.h;

                destRect.x = (x * 32 + posX) - 32 * multiplierX;         //destRect.x = x * 8 + posX;
                destRect.y = (y * 32 + posY) - 32 * multiplierY;         //destRect.y = y * 8 + posY;
                destRect.w = 33;                                         //destRect.w = 8;
                destRect.h = 33;                                         //destRect.h = 8;

                switch (currentElement)
                {
                    case Earth: vBlock[Earth]->Draw(renderer, srcRect, destRect); break;
                    case Fire: vBlock[Fire]->Draw(renderer, srcRect, destRect); break;
                    case Water: vBlock[Water]->Draw(renderer, srcRect, destRect); break;
                    case Wind: vBlock[Wind]->Draw(renderer, srcRect, destRect); break;
                }
            }
        }
    }
}

void GameplayScreen::LoadElement(SDL_Renderer *renderer)
{
    switch (currentElement)
    {
        case Earth: EarthElement(renderer); break;
        case Fire: FireElement(renderer); break;
        case Water: WaterElement(renderer); break;
        case Wind: WindElement(renderer); break;
    }
}

void GameplayScreen::EarthElement(SDL_Renderer *renderer)
{
    file.LoadFromFile("EarthEnviroment", map);

    ent.ClearEntity();
    ent.CreateEntity(map);

    this->pPosX = 100;
    this->pPosY = 300;

    ent.AddComponent("Human", EntityManager::EntityType::human, renderer);
    ent.AddComponent("Cleaver", EntityManager::EntityType::cleaver, renderer);
}
void GameplayScreen::FireElement(SDL_Renderer *renderer)
{
    file.LoadFromFile("FireEnviroment", map);

    ent.ClearEntity();
    ent.CreateEntity(map);
}
void GameplayScreen::WaterElement(SDL_Renderer *renderer)
{
    file.LoadFromFile("WaterEnviroment", map);

    ent.ClearEntity();
    ent.CreateEntity(map);
}
void GameplayScreen::WindElement(SDL_Renderer *renderer)
{
    file.LoadFromFile("WindEnviroment", map);

    ent.ClearEntity();
    ent.CreateEntity(map);
}

void GameplayScreen::LoadGameDate(SDL_Renderer *renderer)
{
    std::vector<std::string> blockID;
    blockID.push_back("1,0"); // dirt
    blockID.push_back("2,0"); // grass
    blockID.push_back("3,0"); // cobble
    blockID.push_back("4,0"); // cobble 2
    blockID.push_back("5,0"); // cobble

    if (blockID.size() != -1 && blockID.size() >= 5)
    {
        blockState = Collision;
        blockState2 = Visible;
    }

    switch(currentElement)
    {
        case Earth: vBlock.push_back(new Block(Earth, new Texture("EarthTile", renderer))); break;
        case Fire: vBlock.push_back(new Block(Fire, new Texture("FireTile", renderer))); break;
        case Wind: vBlock.push_back(new Block(Wind, new Texture("WindTile", renderer))); break;
        case Water: vBlock.push_back(new Block(Water, new Texture("WaterTile", renderer))); break;
    }
}

//też taka prymitywna wersja
void GameplayScreen::MoveMap(int moveSpeedX, int moveY)
{
    posX += moveSpeedX;
    posY -= moveY;
}

std::pair<int, int> GameplayScreen::bNum(std::string map)
{
    return std::pair<int, int>
    (
        //szuka w pliku tekstowym ma break;b case Water: e oznaczają przesunięcie obrazków na osi X
        //(wtedy mapa wie od jakie break;ela X ma ciąć obraz)
        atoi(map.substr(0, map.find(',')).c_str()),
        //szuka w pliku tekstowym mapy liczb po ',', które oznaczają przesunięcie obrazków na osi Y
        //(wtedy mapa wie od jakiego piksela Y ma ciąć obraz)
        atoi(map.substr(map.find(',') + 1).c_str())
    );
}

void GameplayScreen::resetGameData()
{
    posX = 0;
    posY = 0;

    switch (currentElement)
    {
        case Earth: getPlayer()->setStartPosition(pPosX, pPosY); break;
        case Fire: getPlayer()->setStartPosition(pPosX, pPosY); break;
        case Water: getPlayer()->setStartPosition(pPosX, pPosY); break;
        case Wind: getPlayer()->setStartPosition(pPosX, pPosY); break;
    }
}

//wiem, wygląda to brzydko, ale miało początkowo miało działać, nie wyglądać.
void GameplayScreen::resetMapWhenPlayerFalled()
{
    if (posX < 0)
    {
        int x = 0;
        for (int i = 0; i < 10; i++)
        {
            x += i;
        }
        posX += x;
        x = 0;
    }
    else posX = 0;
}

int GameplayScreen::getStartBlockX()
{
    return (int)(-posX + (int)posX % 32) / 32;
}
int GameplayScreen::getEndBlockX()
{
    return (int)(-posX + (int)posX % 32 + 1280) / 32;
}