PlayerPrefs.hpp

/*
** EPITECH PROJECT, 2022
** engine
** File description:
** PlayerPrefs
*/
 
#ifndef PLAYERPREFS_HPP_
#define PLAYERPREFS_HPP_
 
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
 
#include "KapEngineDebug.hpp"
 
namespace KapEngine {
 
    class PlayerPrefs {
        public:
            struct PlayerPrefIntel {
                std::string key;
                std::string content;
            };
 
            static void setBool(std::string const& name, bool const& val) {
                if (val) {
                    setString(name, "true");
                } else {
                    setString(name, "false");
                }
            }
 
            static void setInt(std::string const& name, int const& val) {
                setString(name, std::to_string(val));
            }
            
            static void setString(std::string const& name, std::string const& val) {
                std::vector<PlayerPrefIntel> intels = readPlayerPref();
                bool newVal = true;
 
                for (std::size_t i = 0; i < intels.size(); i++) {
                    if (intels.at(i).key == name) {
                        intels.at(i).content = val;
                        newVal = false;
                        break;
                    }
                }
                if (!newVal) {
                    writePlayerPrefs(intels);
                    return;
                }
                PlayerPrefIntel nIntel;
                nIntel.content = val;
                nIntel.key = name;
                intels.push_back(nIntel);
                writePlayerPrefs(intels);
            }
 
            static std::string getString(std::string const& name) {
                std::vector<PlayerPrefIntel> intels = readPlayerPref();
 
                for (std::size_t i = 0; i < intels.size(); i++) {
                    if (name == intels.at(i).key)
                        return intels.at(i).content;
                }
                DEBUG_ERROR("no content with key: " + name);
                return "";
            }
 
            static int getInt(std::string const& name) {
                std::stringstream sstr;
                std::string str = getString(name);
                int res = 0;
 
                sstr << str;
                sstr >> res;
 
                return res;
 
            }
 
            static bool getBool(std::string const& name) {
                std::string strVal = getString(name);
 
                if (strVal == "true" || strVal == "1")
                    return true;
                return false;
            }
 
            static bool hasKey(std::string const& name) {
                std::vector<PlayerPrefIntel> intels = readPlayerPref();
 
                for (std::size_t i = 0; i < intels.size(); i++) {
                    if (name == intels.at(i).key)
                        return true;
                }
                return false;
            }
 
        protected:
        private:
 
            inline static const std::string filePlayerPrefName = "playerPrefs.keDat";
            
            static std::vector<PlayerPrefIntel> readPlayerPref() {
                std::string line;
                std::ifstream myfile (filePlayerPrefName);
                std::vector<std::string> lines;
                std::vector<PlayerPrefIntel> res;
                if (myfile.is_open())
                {
                    while ( getline (myfile,line) ) {
                        lines.push_back(line);
                    }
                    myfile.close();
                } else {
                    DEBUG_ERROR("PlayerPref file does not exists. Please save something with PlayerPref to create this file");
                    return res;
                }
 
                for (std::size_t i = 0; i < lines.size(); i++) {
                    std::size_t posEqu = lines.at(i).find(":");
                    PlayerPrefIntel nIntel;
 
                    nIntel.key = lines.at(i).substr(0, posEqu);
                    nIntel.content = lines.at(i).substr(posEqu + 1, lines.at(i).size());
                    res.push_back(nIntel);
                }
                return res;
            }
 
            static void writePlayerPrefs(std::vector<PlayerPrefIntel> const& list) {
                std::ofstream myfile;
                std::string content = "";
 
                for (std::size_t i = 0; i < list.size(); i++) {
                    std::string lineCont;
 
                    lineCont = list.at(i).key + ":" + list.at(i).content;
                    if (i < list.size() - 1) {
                        lineCont += "\n";
                    }
                    content += lineCont;
                }
 
                myfile.open (filePlayerPrefName);
                if (!myfile.is_open()) {
                    DEBUG_ERROR("PlayerPrefs can't save anything. File does not open");
                    return;
                }
                myfile << content;
                myfile.close();
            }
    };
 
}
 
#endif /* !PLAYERPREFS_HPP_ */