#include "SynEngine.hpp"

class GameConfiguration
{
    private:
        sf::Vector2i referenceWindowDimensions;
        sf::Vector2f canvasSizeMultiplierRatio;
        sf::Texture spriteSheet;
        std::string spriteSheetPath;
        sf::Vector2i spriteSheetCellSize;
        sf::IntRect spriteSheetRect;
        float spriteSizeMultiplier;
        
        float audioVolume;

        void LoadDefaultValues();
        void LoadValuesFromFile(std::string);
        void WriteValuesToFile(std::string);
        std::istringstream GetNextNonCommentLine(std::istream &);
        bool LoadSpriteSheet(std::string);
        bool IsFileExists(std::string);
    public:
        GameConfiguration();
        GameConfiguration(sf::Vector2i, std::string = std::string());
        float GetSpriteSizeMultiplier();
        float GetAudioVolume();
        sf::Sprite GetSprite(unsigned int, sf::Vector2f = sf::Vector2f(0, 0), float = 0.0);
        ~GameConfiguration();
};

GameConfiguration::GameConfiguration()
{
    LoadDefaultValues();
}

GameConfiguration::GameConfiguration(sf::Vector2i windowDimensions, std::string configurationPath)
{
    if(!configurationPath.empty())
        if(IsFileExists(configurationPath))
            LoadValuesFromFile(configurationPath);
        else
        {
            LoadDefaultValues();
            WriteValuesToFile(configurationPath);
        }
    else
        LoadDefaultValues();

    spriteSheetRect = sf::IntRect(sf::Vector2i(0, 0), spriteSheetCellSize);
    spriteSizeMultiplier = 
        (float)windowDimensions.x / (float)referenceWindowDimensions.x * canvasSizeMultiplierRatio.x +
        (float)windowDimensions.y / (float)referenceWindowDimensions.y * canvasSizeMultiplierRatio.y;
}

bool GameConfiguration::IsFileExists(std::string path)
{   
    std::fstream file(path);
    return file.good();
}

void GameConfiguration::LoadValuesFromFile(std::string path)
{
    std::ifstream confFile(path);
    std::istream &stream = confFile;
    char coma; // this is stupid there has to be a better way

    GetNextNonCommentLine(stream) >> referenceWindowDimensions.x >> coma >> referenceWindowDimensions.y;
    GetNextNonCommentLine(stream) >> canvasSizeMultiplierRatio.x >> coma >> canvasSizeMultiplierRatio.y;
    LoadSpriteSheet(GetNextNonCommentLine(stream).str());
    GetNextNonCommentLine(stream) >> spriteSheetCellSize.x >> coma >> spriteSheetCellSize.y;
    GetNextNonCommentLine(stream) >> audioVolume;
    
    confFile.close();
}

std::istringstream GameConfiguration::GetNextNonCommentLine(std::istream &stream)
{
    std::string line;
    while (std::getline(stream, line) && !stream.eof())
        switch (line[0])
        {
            case '#': case '\n': case ' ': case NULL: break;
            default:
                return std::istringstream(line);
        }

    return std::istringstream();
}

void GameConfiguration::WriteValuesToFile(std::string path)
{
    std::ofstream confFile(path);

    confFile << "# Reference Window Dimensions (x, y)\n";
    confFile << referenceWindowDimensions.x << ", " << referenceWindowDimensions.y << "\n\n";
    confFile << "# Canvas Size Multiplier Ratio (x, y)\n";
    confFile << canvasSizeMultiplierRatio.x << ", " << canvasSizeMultiplierRatio.y << "\n\n";
    confFile << "# Sprite Sheet Path\n";
    confFile << spriteSheetPath << "\n\n";
    confFile << "# Sprite Sheet Cell Size (x, y)\n";
    confFile << spriteSheetCellSize.x << ", " << spriteSheetCellSize.y << "\n\n";
    confFile << "# Audio Volume\n";
    confFile << audioVolume << "\n";
    
    confFile.close();
}

void GameConfiguration::LoadDefaultValues()
{
    // !! Placeholder values! Change after real sprites are added! !!
    referenceWindowDimensions = sf::Vector2i(600, 500);
    canvasSizeMultiplierRatio = sf::Vector2f(0.0, 1.0f);
    spriteSizeMultiplier = 1.0;
    
    LoadSpriteSheet("Data\\SpriteSheet.png");
    // !! Placeholder values! Change after real sprites are added! !!
    spriteSheetCellSize = sf::Vector2i(50, 50);

    audioVolume = 1.0;
}

bool GameConfiguration::LoadSpriteSheet(std::string path)
{
    spriteSheetPath = path;
    return spriteSheet.loadFromFile(path);
}

sf::Sprite GameConfiguration::GetSprite(unsigned int index, sf::Vector2f position, float rotation)
{
    int offset = spriteSheetRect.width * index;
    int xSize = spriteSheet.getSize().x;
    sf::Sprite sprite;

    spriteSheetRect.left = offset % xSize;
    spriteSheetRect.top  = offset / xSize * spriteSheetCellSize.y;
    
    sprite.setTexture(spriteSheet);
    sprite.setTextureRect(spriteSheetRect);
    sprite.setPosition(position * spriteSizeMultiplier);
    sprite.setRotation(rotation);
    sprite.setScale(spriteSizeMultiplier, spriteSizeMultiplier);
    return sprite;
}

float GameConfiguration::GetSpriteSizeMultiplier()
{
    return spriteSizeMultiplier;
}

float GameConfiguration::GetAudioVolume()
{
    return audioVolume;
}

GameConfiguration::~GameConfiguration()
{
}