#include "BlockFilter.h"

#include "Block.h"
#include "FluidBlock.h"
#include "Game.h"

BlockFilter::BlockFilter()
    : ReferenceCounter()
{}

BlockFilterAnd::BlockFilterAnd()
    : BlockFilter()
{}

bool BlockFilterAnd::test(const Block* zBlock)
{
    for (BlockFilter* filter : filters)
    {
        if (!filter->test(zBlock))
        {
            return false;
        }
    }
    return true;
}

void BlockFilterAnd::addFilter(BlockFilter* filter)
{
    filters.add(filter);
}

Framework::RCArray<BlockFilter> BlockFilterAnd::getFilters() const
{
    return filters;
}

BlockFilterAndFactory::BlockFilterAndFactory()
    : SubTypeFactory()
{}

BlockFilterAnd* BlockFilterAndFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterAnd();
}

void BlockFilterAndFactory::fromJson(
    BlockFilterAnd* zResult, Framework::JSON::JSONObject* zJson) const
{
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("filters")->asArray())
    {
        zResult->addFilter(
            Game::INSTANCE->zTypeRegistry()->fromJson<BlockFilter>(value));
    }
}

void BlockFilterAndFactory::toJson(
    BlockFilterAnd* zObject, Framework::JSON::JSONObject* zResult) const
{
    Framework::JSON::JSONArray* filters = new Framework::JSON::JSONArray();
    for (BlockFilter* filter : zObject->getFilters())
    {
        filters->addValue(Game::INSTANCE->zTypeRegistry()->toJson(filter));
    }
    zResult->addValue("filters", filters);
}

JSONObjectValidationBuilder* BlockFilterAndFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredArray("filters")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<BlockFilter>())
        ->finishArray();
}

Framework::Text BlockFilterAndFactory::getTypeToken() const
{
    return "and";
}

BlockFilterOr::BlockFilterOr()
    : BlockFilter()
{}

bool BlockFilterOr::test(const Block* zBlock)
{
    for (BlockFilter* filter : filters)
    {
        if (filter->test(zBlock))
        {
            return true;
        }
    }
    return false;
}

void BlockFilterOr::addFilter(BlockFilter* filter)
{
    filters.add(filter);
}

Framework::RCArray<BlockFilter> BlockFilterOr::getFilters() const
{
    return filters;
}

BlockFilterOrFactory::BlockFilterOrFactory()
    : SubTypeFactory()
{}

BlockFilterOr* BlockFilterOrFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterOr();
}

void BlockFilterOrFactory::fromJson(
    BlockFilterOr* zResult, Framework::JSON::JSONObject* zJson) const
{
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("filters")->asArray())
    {
        zResult->addFilter(
            Game::INSTANCE->zTypeRegistry()->fromJson<BlockFilter>(value));
    }
}

void BlockFilterOrFactory::toJson(
    BlockFilterOr* zObject, Framework::JSON::JSONObject* zResult) const
{
    Framework::JSON::JSONArray* filters = new Framework::JSON::JSONArray();
    for (BlockFilter* filter : zObject->getFilters())
    {
        filters->addValue(Game::INSTANCE->zTypeRegistry()->toJson(filter));
    }
    zResult->addValue("filters", filters);
}

JSONObjectValidationBuilder* BlockFilterOrFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredArray("filters")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<BlockFilter>())
        ->finishArray();
}

Framework::Text BlockFilterOrFactory::getTypeToken() const
{
    return "or";
}

BlockFilterNot::BlockFilterNot()
    : BlockFilter(),
      filter(0)
{}

BlockFilterNot::~BlockFilterNot()
{
    if (filter) filter->release();
}

bool BlockFilterNot::test(const Block* zBlock)
{
    return !filter->test(zBlock);
}

void BlockFilterNot::setFilter(BlockFilter* filter)
{
    if (this->filter) this->filter->release();
    this->filter = filter;
}

BlockFilter* BlockFilterNot::zFilter() const
{
    return filter;
}

BlockFilterNotFactory::BlockFilterNotFactory()
    : SubTypeFactory()
{}

BlockFilterNot* BlockFilterNotFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterNot();
}

void BlockFilterNotFactory::fromJson(
    BlockFilterNot* zResult, Framework::JSON::JSONObject* zJson) const
{
    zResult->setFilter(Game::INSTANCE->zTypeRegistry()->fromJson<BlockFilter>(
        zJson->zValue("filter")));
}

void BlockFilterNotFactory::toJson(
    BlockFilterNot* zObject, Framework::JSON::JSONObject* zResult) const
{
    zResult->addValue(
        "filter", Game::INSTANCE->zTypeRegistry()->toJson(zObject->zFilter()));
}

JSONObjectValidationBuilder* BlockFilterNotFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredAttribute(
        "filter", Game::INSTANCE->zTypeRegistry()->getValidator<BlockFilter>());
}

Framework::Text BlockFilterNotFactory::getTypeToken() const
{
    return "not";
}

BlockFilterBlockType::BlockFilterBlockType()
    : BlockFilter()
{}

bool BlockFilterBlockType::test(const Block* zBlock)
{
    for (int blockTypeId : blockTypeIds)
    {
        if (zBlock->zBlockType()->getId() == blockTypeId)
        {
            return true;
        }
    }
    return false;
}

void BlockFilterBlockType::addBlockTypeId(int blockTypeId)
{
    blockTypeIds.add(blockTypeId);
}

const Framework::Array<int>& BlockFilterBlockType::getBlockTypeIds() const
{
    return blockTypeIds;
}

BlockFilterBlockTypeFactory::BlockFilterBlockTypeFactory()
    : SubTypeFactory()
{}

BlockFilterBlockType* BlockFilterBlockTypeFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterBlockType();
}

void BlockFilterBlockTypeFactory::fromJson(
    BlockFilterBlockType* zResult, Framework::JSON::JSONObject* zJson) const
{
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("typeNames")->asArray())
    {
        zResult->addBlockTypeId(
            Game::INSTANCE->getBlockTypeId(value->asString()->getString()));
    }
}

void BlockFilterBlockTypeFactory::toJson(
    BlockFilterBlockType* zObject, Framework::JSON::JSONObject* zResult) const
{
    Framework::JSON::JSONArray* typeNames = new Framework::JSON::JSONArray();
    for (int typeId : zObject->getBlockTypeIds())
    {
        typeNames->addValue(new Framework::JSON::JSONString(
            Game::INSTANCE->zBlockType(typeId)->getName()));
    }
    zResult->addValue("typeNames", typeNames);
}

JSONObjectValidationBuilder* BlockFilterBlockTypeFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredArray("typeNames")
        ->addAcceptedStringInArray()
        ->finishString()
        ->finishArray();
}

Framework::Text BlockFilterBlockTypeFactory::getTypeToken() const
{
    return "types";
}

BlockFilterTypeGroup::BlockFilterTypeGroup()
    : BlockFilter()
{}

bool BlockFilterTypeGroup::test(const Block* zBlock)
{
    for (Framework::Text* groupName : groupNames)
    {
        for (Framework::Text* otherGroupName :
            zBlock->zBlockType()->getGroupNames())
        {
            if (groupName->istGleich(*otherGroupName))
            {
                return true;
            }
        }
    }
    return false;
}

void BlockFilterTypeGroup::addGroupName(const Framework::Text groupName)
{
    groupNames.add(new Framework::Text(groupName));
}

const Framework::RCArray<Framework::Text>&
BlockFilterTypeGroup::getGroupNames() const
{
    return groupNames;
}

BlockFilterTypeGroupFactory::BlockFilterTypeGroupFactory()
    : SubTypeFactory()
{}

BlockFilterTypeGroup* BlockFilterTypeGroupFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterTypeGroup();
}

void BlockFilterTypeGroupFactory::fromJson(
    BlockFilterTypeGroup* zResult, Framework::JSON::JSONObject* zJson) const
{
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("groupNames")->asArray())
    {
        zResult->addGroupName(value->asString()->getString());
    }
}

void BlockFilterTypeGroupFactory::toJson(
    BlockFilterTypeGroup* zObject, Framework::JSON::JSONObject* zResult) const
{
    Framework::JSON::JSONArray* groupNames = new Framework::JSON::JSONArray();
    for (Framework::Text* groupName : zObject->getGroupNames())
    {
        groupNames->addValue(new Framework::JSON::JSONString(*groupName));
    }
    zResult->addValue("groupNames", groupNames);
}

JSONObjectValidationBuilder* BlockFilterTypeGroupFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredArray("groupNames")
        ->addAcceptedStringInArray()
        ->finishString()
        ->finishArray();
}

Framework::Text BlockFilterTypeGroupFactory::getTypeToken() const
{
    return "groups";
}

BlockFilterMaxHardness::BlockFilterMaxHardness()
    : BlockFilter()
{}

bool BlockFilterMaxHardness::test(const Block* zBlock)
{
    return zBlock->zBlockType()->getHardness() <= maxHardness;
}

void BlockFilterMaxHardness::setMaxHardness(float maxHardness)
{
    this->maxHardness = maxHardness;
}

float BlockFilterMaxHardness::getMaxHardness() const
{
    return maxHardness;
}

BlockFilterMaxHardnessFactory::BlockFilterMaxHardnessFactory()
    : SubTypeFactory()
{}

BlockFilterMaxHardness* BlockFilterMaxHardnessFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterMaxHardness();
}

void BlockFilterMaxHardnessFactory::fromJson(
    BlockFilterMaxHardness* zResult, Framework::JSON::JSONObject* zJson) const
{
    zResult->setMaxHardness(
        (float)zJson->zValue("maxHardness")->asNumber()->getNumber());
}

void BlockFilterMaxHardnessFactory::toJson(
    BlockFilterMaxHardness* zObject, Framework::JSON::JSONObject* zResult) const
{
    zResult->addValue("maxHardness",
        new Framework::JSON::JSONNumber(zObject->getMaxHardness()));
}

JSONObjectValidationBuilder* BlockFilterMaxHardnessFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredNumber("maxHardness")
        ->whichIsGreaterOrEqual(0.0)
        ->finishNumber();
}

Framework::Text BlockFilterMaxHardnessFactory::getTypeToken() const
{
    return "maxHardness";
}

BlockFilterMinHardness::BlockFilterMinHardness()
    : BlockFilter(),
      minHardness(0.f)
{}

bool BlockFilterMinHardness::test(const Block* zBlock)
{
    return zBlock->zBlockType()->getHardness() >= minHardness;
}

void BlockFilterMinHardness::setMinHardness(float minHardness)
{
    this->minHardness = minHardness;
}

float BlockFilterMinHardness::getMinHardness() const
{
    return minHardness;
}

BlockFilterMinHardnessFactory::BlockFilterMinHardnessFactory()
    : SubTypeFactory()
{}

BlockFilterMinHardness* BlockFilterMinHardnessFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterMinHardness();
}

void BlockFilterMinHardnessFactory::fromJson(
    BlockFilterMinHardness* zResult, Framework::JSON::JSONObject* zJson) const
{
    zResult->setMinHardness(
        (float)zJson->zValue("minHardness")->asNumber()->getNumber());
}

void BlockFilterMinHardnessFactory::toJson(
    BlockFilterMinHardness* zObject, Framework::JSON::JSONObject* zResult) const
{
    zResult->addValue("minHardness",
        new Framework::JSON::JSONNumber(zObject->getMinHardness()));
}

JSONObjectValidationBuilder* BlockFilterMinHardnessFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredNumber("minHardness")
        ->whichIsGreaterOrEqual(0.0)
        ->finishNumber();
}

Framework::Text BlockFilterMinHardnessFactory::getTypeToken() const
{
    return "minHardness";
}

BlockFilterMaxHeat::BlockFilterMaxHeat()
    : BlockFilter(),
      maxHeat(0.f)
{}

bool BlockFilterMaxHeat::test(const Block* zBlock)
{
    const FluidBlockType* type
        = dynamic_cast<const FluidBlockType*>(zBlock->zBlockType());
    return type && type->getHeat() <= maxHeat;
}

void BlockFilterMaxHeat::setMaxHeat(float maxHeat)
{
    this->maxHeat = maxHeat;
}

float BlockFilterMaxHeat::getMaxHeat() const
{
    return maxHeat;
}

BlockFilterMaxHeatFactory::BlockFilterMaxHeatFactory()
    : SubTypeFactory()
{}

BlockFilterMaxHeat* BlockFilterMaxHeatFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BlockFilterMaxHeat();
}

void BlockFilterMaxHeatFactory::fromJson(
    BlockFilterMaxHeat* zResult, Framework::JSON::JSONObject* zJson) const
{
    zResult->setMaxHeat((float)zJson->zValue("heat")->asNumber()->getNumber());
}

void BlockFilterMaxHeatFactory::toJson(
    BlockFilterMaxHeat* zObject, Framework::JSON::JSONObject* zResult) const
{
    zResult->addValue(
        "heat", new Framework::JSON::JSONNumber(zObject->getMaxHeat()));
}

JSONObjectValidationBuilder* BlockFilterMaxHeatFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredNumber("heat")->finishNumber();
}

Framework::Text BlockFilterMaxHeatFactory::getTypeToken() const
{
    return "maxHeat";
}