#include "Resource.h"

#include <stdexcept>
#include <cstring>
#include <iostream>

std::mutex Resource::mStringResource;
const char* Resource::StringResources = "./Resources/string.res";

std::mutex Resource::mIntResource;
const char* Resource::IntResources = "./Resources/int.res";

std::mutex Resource::mLongResource;
const char* Resource::LongResources = "./Resources/long.res";

std::mutex Resource::mDoubleResource;
const char* Resource::DoubleResources = "./Resources/double.res";

std::mutex Resource::mObjectResource;
const char* Resource::ObjectResources = "./Resources/object.res";

std::string Resource::GetResourceData(const char* name, const char* file_name)
{
    size_t size_name = strlen(name);
    std::ifstream file(file_name);
    if (!file.is_open())
        throw std::runtime_error("Can't open resource file");

    std::string line;
    while (std::getline(file, line))
    {
        if (line.find(name) == 0 && line[size_name] == ':')
        {
            size_t begin = size_name + 2;
            file.close();
            return line.substr(begin, line.length() - begin);
        }
    }
    
    file.close();
    throw std::runtime_error("Can't find resource");
}

void Resource::WriteResource(const char* name, const char* file_name, const std::string& value)
{
    size_t size_name = strlen(name);
    bool isFind = false;
    std::string buffer;
    std::ifstream file(file_name);
    
    std::string line;
    while (std::getline(file, line))
    {
        if (line.find(name) == 0 && line[size_name] == ':')
        {
            isFind = true;
            line.resize(size_name + 2 + value.length());
            line.replace(size_name + 2, value.length(), value);
        }
        buffer += line + '\n';
    }
    file.close();

    if (!isFind)
    {
        buffer += name;
        buffer += ": ";
        buffer += value;
        buffer += '\n';
    }

    std::ofstream drop_file(file_name, std::ios::trunc);
    drop_file << buffer;
    drop_file.close();
}

void Resource::SetString(const char* name, const char* value)
{
    mStringResource.lock();
    WriteResource(name, StringResources, std::string(value));
    mStringResource.unlock();   
}

void Resource::SetInt(const char* name, int value)
{
    mIntResource.lock();
    WriteResource(name, IntResources, std::to_string(value));
    mIntResource.unlock();
}

void Resource::SetLong(const char* name, long long value)
{
    mLongResource.lock();
    WriteResource(name, LongResources, std::to_string(value));
    mLongResource.unlock();
}

void Resource::SetDouble(const char* name, double value)
{
    mDoubleResource.lock();
    WriteResource(name, DoubleResources, std::to_string(value));
    mDoubleResource.unlock();
}

void Resource::SetObject(const char* name, IResource* object)
{
    mObjectResource.lock();
    WriteResource(name, ObjectResources, object->serialize());
    mObjectResource.unlock();
}

std::string Resource::GetString(const char* name)
{
    mStringResource.lock();
    std::string data = GetResourceData(name, StringResources);
    mStringResource.unlock();
    return data;
}

int Resource::GetInt(const char* name)
{
    mIntResource.lock();
    int data = std::stoi(GetResourceData(name, IntResources));
    mIntResource.unlock();
    return data;
}

long long Resource::GetLong(const char* name)
{
    mLongResource.lock();
    long long data = std::stoll(GetResourceData(name, LongResources));
    mLongResource.unlock();
    return data;
}

double Resource::GetDouble(const char* name)
{
    mDoubleResource.lock();
    double data = std::stod(GetResourceData(name, DoubleResources));
    mDoubleResource.unlock();
    return data;
}