#include "stdafx.h"
#include "DataReader.hpp"
#include <fstream>
#include <sstream>

#pragma region Helper Functions


std::string ReadWholeFile(std::string aPath)
{
    if (aPath.empty())
    {
        ////std::cout << "trying to open empty path" << std::endl;
        return "{}";
    }
    std::stringstream out;
    std::string buff;
    std::ifstream stream;
    stream.open(aPath);
    if (stream.fail())
    {
        ////std::cout << "file does not exist: " << aPath.c_str() << std::endl;
        return "{}";
    }

    while (std::getline(stream, buff))
    {
        out << buff;
    }
    stream.close();
    return out.str();
}
std::string translateJsonErrors(rapidjson::ParseErrorCode aCode)
{
    std::stringstream out;
    do
    {
        if (aCode & rapidjson::ParseErrorCode::kParseErrorDocumentEmpty != 0)
        {
            out << "document empty \n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorArrayMissCommaOrSquareBracket != 0)
        {
            out << "missing , or [ or ]\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorDocumentRootNotSingular != 0)
        {
            out << "ducument has more than one root\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorNone != 0)
        {
            out << "No error\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorNumberMissExponent != 0)
        {
            out << "number missing exponent\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorNumberMissFraction != 0)
        {
            out << "number missing fraction\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorNumberTooBig != 0)
        {
            out << "number too big\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorObjectMissColon != 0)
        {
            out << "object missing ,\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorObjectMissCommaOrCurlyBracket != 0)
        {
            out << "object missing , or { or }\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorObjectMissName != 0)
        {
            out << "object missing name\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorStringEscapeInvalid != 0)
        {
            out << "invalid excape character\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorStringInvalidEncoding != 0)
        {
            out << "invalid encoding (What in the hell did you do!?)\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorStringMissQuotationMark != 0)
        {
            out << "missing \"\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorStringUnicodeEscapeInvalidHex != 0)
        {
            out << "invalid hexcode escape\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorStringUnicodeSurrogateInvalid != 0)
        {
            out << "invalid unicode surrogate (i'm.. i.. don't know)\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorTermination != 0)
        {
            out << "Terminated\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorUnspecificSyntaxError != 0)
        {
            out << "unspecific syntac error\n";
        }
        if (aCode & rapidjson::ParseErrorCode::kParseErrorValueInvalid != 0)
        {
            out << "invalid value\n";
        }
    } while (false); // quick return

    return out.str();
}
void ParseFile(const char * aFile, rapidjson::Document& aDocument)
{
    aDocument.Parse(ReadWholeFile(aFile).c_str());
    if (aDocument.HasParseError())
    {
        std::cout << "Parse error(s)! in " << aFile << std::endl;
        rapidjson::ParseErrorCode errCode = aDocument.GetParseError();
    }
}
#pragma endregion




std::ostream& operator<<(std::ostream& aStream, std::string& aString)
{
    return aStream << aString.c_str();
}



std::vector<TypedInterface*> DataReader::myLinks;

void DataReader::CleanUp()
{
    for (auto link : myLinks)
    {
        delete link;
    }
}

TypedInterface* DataReader::FindMatchingLink(std::string aKey)
{
    for (auto link : myLinks)
    {
        if (link->myPath == aKey)
        {
            return link;
        }
    }
    return nullptr;
}

void DataReader::ResetTagged()
{
    for (auto link : myLinks)
    {
        link->myHasBeenAssigned = false;
    }
}

void DataReader::LogMissedValues()
{
    for (auto link : myLinks)
    {
        if (!link->myHasBeenAssigned)
        {
            std::cout << link->myPath << " was not assigned from json" << std::endl;
        }
    }
}

void DataReader::AssignToValues(rapidjson::Value& aValue,std::string aName)
{
    auto it = aValue.MemberBegin();
    while (it != aValue.MemberEnd())
    {
        std::string compoundName = aName + (aName.empty() ? "" : "/") + it->name.GetString();

        if (it->value.IsObject())
        {
            AssignToValues(it->value, compoundName);
            it++;
            continue;
        }
        TypedInterface* link = FindMatchingLink(compoundName);

        if (link)
        {
            link->Load(it->value);
        }
        else
        {
            std::cout << "the value " << compoundName << " is not loaded in code" << std::endl;
        }
        it++;
    }
}

void DataReader::Load(const char * aPath)
{
    rapidjson::Document doc;
    ParseFile(aPath, doc);
    ResetTagged();
    AssignToValues(doc);
    LogMissedValues();
}

DataReader::DataReader()
{
}


DataReader::~DataReader()
{
}


Data::Data(const char * aPath) : myPath(aPath)
{
}

Data::Data(std::string aString) : Data(aString.c_str())
{
}

const char * DataReader::JsonTypeToString(rapidjson::Type aType)
{
    switch (aType)
    {
    case rapidjson::kNullType:
        return "Null";
    case rapidjson::kFalseType:
        return "False";
    case rapidjson::kTrueType:
        return "True";
    case rapidjson::kObjectType:
        return "Object";
    case rapidjson::kArrayType:
        return "Array";
    case rapidjson::kStringType:
        return "String";
    case rapidjson::kNumberType:
        return "Number";
    default:
        break;
    }
    return nullptr;
}