#include <stdexcept>
#include <Datei.h>
#include <iostream>
#include "RecipieLoader.h"

using namespace Framework::JSON;
using namespace Validator;

RecipieLoader::RecipieLoader()
	: Framework::ReferenceCounter(),
	validator(0)
{}

RecipieLoader::~RecipieLoader()
{
	if (validator)
		validator->release();
}

void RecipieLoader::loadRecipies(const char* path)
{
	shapedLists.leeren();
	lists.leeren();
	std::cout << "loading recipies from '" << path << "'" << std::endl;
	Framework::Datei d;
	d.setDatei(path);
	if (d.istOrdner())
	{
		Framework::RCArray<Framework::Text>* files = d.getDateiListe();
		for (Framework::Text* f : *files)
			loadRecipies(Framework::Text(path) + "/" + *f);
		files->release();
	}
	else
	{
		JSONValue* json = loadJSONFromFile(path);
		JSONValidator* validator = zRecipieValidator();
		JSONValue* valid = validator->getValidParts(json);
		json->release();
		if (valid)
		{
			for (JSONValue* recipie : *valid->asArray())
				loadRecipie(recipie->asObject());
			valid->release();
		}
	}
}

void RecipieLoader::loadRecipie(JSONObject* zRecipie)
{
	Framework::Text group = zRecipie->zValue("group")->asString()->getString();
	if (zRecipie->zValue("type")->asString()->getString().istGleich("shaped"))
	{
		int width = (int)zRecipie->zValue("width")->asNumber()->getNumber();
		int height = (int)zRecipie->zValue("height")->asNumber()->getNumber();
		ShapedRecipie* recipie = new ShapedRecipie(width, height);
		for (JSONValue* input : *zRecipie->zValue("inputs")->asArray())
		{
			int x = (int)input->asObject()->zValue("x")->asNumber()->getNumber();
			int y = (int)input->asObject()->zValue("y")->asNumber()->getNumber();
			ItemFilter* filter = loadFilter(input->asObject()->zValue("filter")->asObject());
			recipie->setIngredient(x, y, filter);
		}
		int outputCount = (int)zRecipie->asObject()->zValue("outputCount")->asNumber()->getNumber();
		Framework::Text outputType = zRecipie->asObject()->zValue("output")->asObject()->zValue("itemType")->asString()->getString();
		Item* item = 0;
		for (int i = 0; i < StaticRegistry<ItemType>::INSTANCE.getCount(); i++)
		{
			if (StaticRegistry<ItemType>::INSTANCE.zElement(i)->getName().istGleich(outputType))
			{
				item = StaticRegistry<ItemType>::INSTANCE.zElement(i)->createItem();
				break;
			}
		}
		recipie->setOutput(item, outputCount);
		if (!zShapedRecipieList(group))
			registerShapedRecipieList(group);
		zShapedRecipieList(group)->addRecipie(recipie);
	}
	else if (zRecipie->zValue("type")->asString()->getString().istGleich("unordered"))
	{
		Recipie* recipie = new Recipie();
		for (JSONValue* input : *zRecipie->zValue("inputs")->asArray())
		{
			int count = (int)input->asObject()->zValue("count")->asNumber()->getNumber();
			ItemFilter* filter = loadFilter(input->asObject()->zValue("filter")->asObject());
			recipie->addIngredient(filter, count);
		}
		for (JSONValue* output : *zRecipie->zValue("outputs")->asArray())
		{
			int count = (int)output->asObject()->zValue("count")->asNumber()->getNumber();
			Framework::Text outputType = output->asObject()->zValue("item")->asObject()->zValue("itemType")->asString()->getString();
			Item* item = 0;
			for (int i = 0; i < StaticRegistry<ItemType>::INSTANCE.getCount(); i++)
			{
				if (StaticRegistry<ItemType>::INSTANCE.zElement(i)->getName().istGleich(outputType))
				{
					item = StaticRegistry<ItemType>::INSTANCE.zElement(i)->createItem();
					break;
				}
			}
			recipie->addOutput(item, count);
		}
		if (!zRecipieList(group))
			registerRecipieList(group);
		zRecipieList(group)->addRecipie(recipie);
	}
}

ItemFilter* RecipieLoader::loadFilter(JSONObject* zFilter)
{
	Framework::Text type = zFilter->zValue("itemType")->asString()->getString();
	for (int i = 0; i < StaticRegistry<ItemType>::INSTANCE.getCount(); i++)
	{
		if (StaticRegistry<ItemType>::INSTANCE.zElement(i)->getName().istGleich(type))
			return new TypeItemFilter(StaticRegistry<ItemType>::INSTANCE.zElement(i));
	}
	return 0;
}

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

ShapedRecipieList* RecipieLoader::zShapedRecipieList(const char* name)
{
	for (ShapedRecipieList* l : shapedLists)
	{
		if (l->getName().istGleich(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));
}

void RecipieLoader::registerShapedRecipieList(const char* name)
{
	if (zShapedRecipieList(name))
		throw new std::invalid_argument("the recipie list already exists");
	shapedLists.add(new ShapedRecipieList(name));
}

JSONValidator* RecipieLoader::zRecipieValidator()
{
	if (validator)
		return validator;
	Framework::RCArray<Framework::Text> itemTypes;
	for (int i = 0; i < StaticRegistry<ItemType>::INSTANCE.getCount(); i++)
		itemTypes.add(new Framework::Text(StaticRegistry<ItemType>::INSTANCE.zElement(i)->getName().getText()));
	JSONValidator* filterValidator = JSONValidator::buildForObject()
		->withRequiredString("itemType")->whichIsOneOf(itemTypes)->finishString()
		->finishObject();
	JSONValidator* outputValidator = JSONValidator::buildForObject()
		->withRequiredString("itemType")->whichIsOneOf(itemTypes)->finishString()
		->finishObject();
	validator = JSONValidator::buildForArray()
		->typeSpecifiedByAttribute("type")
		->removeInvalidEntries()
		->addAcceptedTypeInArray(
			JSONValidator::buildForObject()
			->withRequiredString("type")->withExactMatch("shaped")->finishString()
			->withRequiredString("group")->finishString()
			->withRequiredNumber("width")->whichIsGreaterThen(0)->finishNumber()
			->withRequiredNumber("height")->whichIsGreaterThen(0)->finishNumber()
			->withRequiredAttribute("inputs",
				JSONValidator::buildForArray()
				->withDefault(new JSONArray())
				->addAcceptedTypeInArray(JSONValidator::buildForObject()
					->withRequiredNumber("x")->whichIsGreaterOrEqual(0)->finishNumber()
					->withRequiredNumber("y")->whichIsGreaterOrEqual(0)->finishNumber()
					->withRequiredAttribute("filter", dynamic_cast<JSONValidator*>(filterValidator->getThis()))
					->finishObject())
				->finishArray())
			->withRequiredAttribute("output", dynamic_cast<JSONValidator*>(outputValidator->getThis()))
			->withRequiredNumber("outputCount")->withDefault(1)->whichIsGreaterThen(0)->finishNumber()
			->finishObject())
		->addAcceptedTypeInArray(
			JSONValidator::buildForObject()
			->withRequiredString("type")->withExactMatch("unordered")->finishString()
			->withRequiredString("group")->finishString()
			->withRequiredAttribute("inputs",
				JSONValidator::buildForArray()
				->withDefault(new JSONArray())
				->addAcceptedTypeInArray(
					JSONValidator::buildForObject()
					->withRequiredNumber("count")->withDefault(1)->whichIsGreaterThen(0)->finishNumber()
					->withRequiredAttribute("filter", dynamic_cast<JSONValidator*>(filterValidator->getThis()))
					->finishObject())
				->finishArray())
			->withRequiredAttribute("output",
				JSONValidator::buildForArray()
				->addAcceptedTypeInArray(JSONValidator::buildForObject()
					->withRequiredAttribute("item", dynamic_cast<JSONValidator*>(outputValidator->getThis()))
					->withRequiredNumber("count")->withDefault(1)->whichIsGreaterThen(0)->finishNumber()
					->finishObject())
				->finishArray())
			->finishObject())
		->finishArray();
	filterValidator->release();
	outputValidator->release();
	return validator;
}