FactoryCraft-Server/FactoryCraft/RecipieLoader.cpp

#include "RecipieLoader.h"

#include <File.h>
#include <iostream>
#include <Logging.h>
#include <stdexcept>

#include "Game.h"
#include "JsonUtils.h"
#include "UIMLBuilder.h"

using namespace Framework::JSON;
using namespace Framework::Validator;

RecipieLoader::RecipieLoader()
    : Framework::ReferenceCounter()
{}

RecipieLoader::~RecipieLoader() {}

void RecipieLoader::loadRecipies(const char* path)
{
    DataValidator* validator
        = Framework::Validator::DataValidator::buildForArray()
              ->addAcceptedTypeInArray(Game::INSTANCE->zTypeRegistry()
                      ->getValidator<RecipieGroupConfig>())
              ->removeInvalidEntries()
              ->finishArray();
    loadAllJsonsFromDirectory(Framework::Text(path) + "/recipieGroups",
        [this, &validator](JSONValue* zJson, Framework::Text path) {
            Framework::Logging::info()
                << "loading recipie groups from '" << path << "'";
            Framework::RCArray<ValidationResult> invalidParts;
            JSONValue* valid = validator->getValidParts(zJson, &invalidParts);
            for (ValidationResult* invalidPart : invalidParts)
            {
                Framework::Logging::error() << invalidPart->getInvalidInfo();
            }
            int count = 0;
            if (valid)
            {
                for (JSONValue* value : *valid->asArray())
                {
                    RecipieGroupConfig* recipieGroup
                        = Game::INSTANCE->zTypeRegistry()
                              ->fromJson<RecipieGroupConfig>(value);
                    if (recipieGroup)
                    {
                        groupConfigs.add(recipieGroup);
                        count++;
                    }
                }
                valid->release();
            }
            Framework::Logging::info()
                << count << " recipie groups were loaded.";
        });
    Framework::JSON::JSONObject* schema = validator->getJsonSchema();
    Framework::File syntaxFile;
    syntaxFile.setFile("data/syntax/schema/recipieGroups.json");
    syntaxFile.create();
    syntaxFile.open(Framework::File::Style::write);
    syntaxFile.write(schema->toString(), schema->toString().getLength());
    syntaxFile.close();
    schema->release();
    validator->release();
    validator
        = Framework::Validator::DataValidator::buildForArray()
              ->addAcceptedTypeInArray(
                  Game::INSTANCE->zTypeRegistry()->getValidator<Recipie>())
              ->removeInvalidEntries()
              ->finishArray();
    loadAllJsonsFromDirectory(Framework::Text(path) + "/recipies",
        [this, &validator](JSONValue* zJson, Framework::Text path) {
            Framework::Logging::info()
                << "loading recipies from '" << path << "'";
            Framework::RCArray<ValidationResult> invalidParts;
            JSONValue* valid = validator->getValidParts(zJson, &invalidParts);
            for (ValidationResult* invalidPart : invalidParts)
            {
                Framework::Logging::error() << invalidPart->getInvalidInfo();
            }
            int count = 0;
            if (valid)
            {
                for (JSONValue* value : *valid->asArray())
                {
                    Recipie* recipie
                        = Game::INSTANCE->zTypeRegistry()->fromJson<Recipie>(
                            value);
                    if (recipie)
                    {
                        Framework::Text group = recipie->getGroupName();
                        RecipieList* list = zRecipieList(group);
                        if (!list)
                        {
                            registerRecipieList(group);
                            list = zRecipieList(group);
                        }
                        list->addRecipie(recipie);
                        count++;
                    }
                }
                valid->release();
            }
            Framework::Logging::info() << count << " recipies were loaded.";
        });
    schema = validator->getJsonSchema();
    syntaxFile.setFile("data/syntax/schema/recipies.json");
    syntaxFile.create();
    syntaxFile.open(Framework::File::Style::write);
    syntaxFile.write(schema->toString(), schema->toString().getLength());
    syntaxFile.close();
    schema->release();
    validator->release();
    for (RecipieList* list : lists)
    {
        bool found = 0;
        for (RecipieGroupConfig* groupConfig : groupConfigs)
        {
            if (list->getName().isEqual(groupConfig->getGroupName()))
            {
                found = 1;
                break;
            }
        }
        if (!found)
        {
            Framework::Logging::warning()
                << "Recipie list '" << list->getName()
                << "' has no group config. The recipies can not be viewed by "
                   "the client.";
        }
    }
}

RecipieList* RecipieLoader::zRecipieList(const char* name) const
{
    for (RecipieList* l : lists)
    {
        if (l->getName().isEqual(name)) return l;
    }
    return 0;
}

void RecipieLoader::registerRecipieList(const char* name)
{
    if (zRecipieList(name))
        throw new std::invalid_argument("the recipie list already exists");
    lists.add(new RecipieList(name));
}

Framework::XML::Element* RecipieLoader::getCrafingUIML(int itemTypeId) const
{
    UIMLCraftingRecipiesBuilder* recipiesBuilder
        = UIMLBuilder::createCraftingRecipies();
    for (RecipieList* list : lists)
    {
        Framework::RCArray<Recipie> recipies;
        list->findRecipies(itemTypeId, recipies);
        if (recipies.getEntryCount() > 0)
        {
            for (RecipieGroupConfig* groupConfig : groupConfigs)
            {
                if (list->getName().isEqual(groupConfig->getGroupName()))
                {
                    recipiesBuilder->addRecipieGroup(list->getName(),
                        groupConfig->getIconItemType(),
                        recipies);
                    break;
                }
            }
        }
    }
    return UIMLBuilder::createDialog(Framework::Text("crafting_") += itemTypeId)
        ->addElement(recipiesBuilder->build())
        ->build();
}