#include "BasicBlocks.h"

#include "AddEntityUpdate.h"
#include "Game.h"
#include "ItemEntity.h"
#include "ModelInfo.h"
#include "TreeSeblingBlock.h"
#include "ItemStack.h"

BasicBlock::BasicBlock(int typeId, Framework::Vec3<int> pos, int dimensionId)
    : BasicBlock(typeId, pos, dimensionId, false)
{}

BasicBlock::BasicBlock(
    int typeId, Framework::Vec3<int> pos, int dimensionId, bool hasInventory)
    : Block(typeId, pos, dimensionId, hasInventory)
{}

bool BasicBlock::onTick(TickQueue* zQueue, int numTicks, bool& blocked)
{
    return 0;
}

void BasicBlock::onPostTick() {}

BasicBlockType::BasicBlockType()
    : BlockType(),
      itemTypeName(),
      transparent(0),
      passable(0),
      speedModifier(1.f),
      interactable(1)
{}

bool BasicBlockType::initialize(Game* zGame)
{
    if (itemTypeName.getLength())
    {
        itemTypeId = zGame->getItemTypeId(itemTypeName);
    }
    else
    {
        itemTypeId = 0;
    }
    return itemTypeId >= 0 && BlockType::initialize(zGame);
}

void BasicBlockType::createSuperBlock(Block* zBlock, Item* zItem) const
{
    BasicBlock* block = dynamic_cast<BasicBlock*>(zBlock);
    block->transparent = transparent;
    block->passable = passable;
    block->hp = (float)getInitialMaxHP();
    block->maxHP = (float)getInitialMaxHP();
    block->hardness = getHardness();
    block->speedModifier = speedModifier;
    block->interactable = interactable;
    BlockType::createSuperBlock(zBlock, zItem);
}

Block* BasicBlockType::createBlock(
    Framework::Vec3<int> position, int dimensionId) const
{
    return new BasicBlock(getId(), position, dimensionId);
}

Item* BasicBlockType::createItem() const
{
    return Game::INSTANCE->zItemType(itemTypeId)->createItem();
}

Framework::Text BasicBlockType::getItemTypeName() const
{
    return itemTypeName;
}

ItemType* BasicBlockType::createItemType() const
{
    return new BasicBlockItemType(getItemTypeName(),
        new ModelInfo(zModel()->getModelPath(),
            zModel()->getTexturePaths(),
            zModel()->isTransparent(),
            zModel()->getSize() / 2.f),
        transparent,
        passable,
        getHardness(),
        speedModifier,
        getItemTypeName(),
        0,
        50,
        getGroupNames());
}

void BasicBlockType::setItemTypeName(Framework::Text itemTypeName)
{
    this->itemTypeName = itemTypeName;
}

int BasicBlockType::getItemTypeId() const
{
    return itemTypeId;
}

void BasicBlockType::setTransparent(bool transparent)
{
    this->transparent = transparent;
}

bool BasicBlockType::isTransparent() const
{
    return transparent;
}

void BasicBlockType::setPassable(bool passable)
{
    this->passable = passable;
}

bool BasicBlockType::isPassable() const
{
    return passable;
}

void BasicBlockType::setSpeedModifier(float speedModifier)
{
    this->speedModifier = speedModifier;
}

float BasicBlockType::getSpeedModifier() const
{
    return speedModifier;
}

void BasicBlockType::setInteractable(bool interactable)
{
    this->interactable = interactable;
}

bool BasicBlockType::isInteractable() const
{
    return interactable;
}

BasicBlockTypeFactory::BasicBlockTypeFactory()
    : BlockTypeFactoryBase()
{}

BasicBlockType* BasicBlockTypeFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BasicBlockType();
}

void BasicBlockTypeFactory::fromJson(
    BasicBlockType* zResult, Framework::JSON::JSONObject* zJson) const
{
    zResult->setItemTypeName(
        zJson->zValue("itemType")->asString()->getString());
    zResult->setTransparent(zJson->zValue("transparent")->asBool()->getBool());
    zResult->setPassable(zJson->zValue("passable")->asBool()->getBool());
    zResult->setSpeedModifier(
        (float)zJson->zValue("speedModifier")->asNumber()->getNumber());
    zResult->setInteractable(
        (float)zJson->zValue("interactable")->asBool()->getBool());
    BlockTypeFactoryBase::fromJson(zResult, zJson);
}

void BasicBlockTypeFactory::toJson(
    BasicBlockType* zObject, Framework::JSON::JSONObject* zResult) const
{
    zResult->addValue("itemType",
        new Framework::JSON::JSONString(zObject->getItemTypeName()));
    zResult->addValue(
        "transparent", new Framework::JSON::JSONBool(zObject->isTransparent()));
    zResult->addValue(
        "passable", new Framework::JSON::JSONBool(zObject->isPassable()));
    zResult->addValue("speedModifier",
        new Framework::JSON::JSONNumber(zObject->getSpeedModifier()));
    zResult->addValue("interactable",
        new Framework::JSON::JSONBool(zObject->isInteractable()));
    BlockTypeFactoryBase::toJson(zObject, zResult);
}

JSONObjectValidationBuilder* BasicBlockTypeFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return BlockTypeFactoryBase::addToValidator(
        builder->withRequiredString("itemType")
            ->withDefault("")
            ->finishString()
            ->withRequiredBool("transparent")
            ->withDefault(false)
            ->finishBool()
            ->withRequiredBool("passable")
            ->withDefault(false)
            ->finishBool()
            ->withRequiredNumber("speedModifier")
            ->withDefault(1.0)
            ->finishNumber()
            ->withRequiredBool("interactable")
            ->withDefault(true)
            ->finishBool());
}

Framework::Text BasicBlockTypeFactory::getTypeToken() const
{
    return "basicBlock";
}

AdditionalItemSpawningBlock::AdditionalItemSpawningBlock(
    int typeId, Framework::Vec3<int> pos, int dimensionId)
    : BasicBlock(typeId, pos, dimensionId)
{}

void AdditionalItemSpawningBlock::addSpawn(SpawnConfig config)
{
    spawns.add(config);
}

void AdditionalItemSpawningBlock::onDestroy()
{
    for (const SpawnConfig& config : spawns)
    {
        if ((double)rand() / RAND_MAX < config.chance)
        {
            int amount = config.min
                       + (int)((config.max - config.min)
                               * ((double)rand() / RAND_MAX));
            if (amount > 0)
            {
                ItemStack* spawnedItems
                    = Game::INSTANCE->zItemType(config.typeId)
                          ->createItemStack(amount);
                if (spawnedItems)
                {
                    ItemEntity* itemEntity
                        = (ItemEntity*)Game::INSTANCE
                              ->zEntityType(EntityTypeEnum::ITEM)
                              ->createEntity(location
                                                 + Framework::Vec3<float>(
                                                     0.5f, 0.5f, 0.5f),
                                  getDimensionId(),
                                  Game::INSTANCE->getNextEntityId());
                    itemEntity->unsaveAddItem(spawnedItems, NO_DIRECTION, 0);
                    spawnedItems->release();
                    Game::INSTANCE->requestWorldUpdate(
                        new AddEntityUpdate(itemEntity, getDimensionId()));
                }
            }
        }
    }
    BasicBlock::onDestroy();
}

AdditionalItemSpawningBlockType::AdditionalItemSpawningBlockType()
    : BasicBlockType(),
      spawns()
{}

void AdditionalItemSpawningBlockType::createSuperBlock(
    Block* zBlock, Item* zItem) const
{
    AdditionalItemSpawningBlock* block
        = dynamic_cast<AdditionalItemSpawningBlock*>(zBlock);
    if (block)
    {
        for (const SpawnConfig& config : spawns)
        {
            block->addSpawn(config);
        }
    }
    BasicBlockType::createSuperBlock(zBlock, zItem);
}

bool AdditionalItemSpawningBlockType::initialize(Game* zGame)
{
    for (auto iterator = spawns.begin(); iterator; iterator++)
    {
        int itemTypeId
            = Game::INSTANCE->getItemTypeId(iterator.val().itemTypeName);
        if (itemTypeId < 0)
        {
            return false;
        }
        iterator.set({iterator.val().min,
            iterator.val().max,
            iterator.val().chance,
            iterator.val().itemTypeName,
            itemTypeId});
    }
    return BasicBlockType::initialize(zGame);
}

Block* AdditionalItemSpawningBlockType::createBlock(
    Framework::Vec3<int> position, int dimensionId) const
{
    AdditionalItemSpawningBlock* block
        = new AdditionalItemSpawningBlock(getId(), position, dimensionId);
    return block;
}

void AdditionalItemSpawningBlockType::addSpawn(SpawnConfig config)
{
    spawns.add(config);
}

const Framework::Array<SpawnConfig>&
AdditionalItemSpawningBlockType::getSpawns() const
{
    return spawns;
}

AdditionalItemSpawningBlockTypeFactory::AdditionalItemSpawningBlockTypeFactory()
    : BlockTypeFactoryBase()
{}

AdditionalItemSpawningBlockType*
AdditionalItemSpawningBlockTypeFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new AdditionalItemSpawningBlockType();
}

void AdditionalItemSpawningBlockTypeFactory::fromJson(
    AdditionalItemSpawningBlockType* zResult,
    Framework::JSON::JSONObject* zJson) const
{
    Framework::JSON::JSONArray* spawnsJson = zJson->zValue("spawns")->asArray();
    for (int i = 0; i < spawnsJson->getLength(); i++)
    {
        Framework::JSON::JSONObject* spawnJson
            = spawnsJson->zValue(i)->asObject();
        zResult->addSpawn(SpawnConfig{
            (int)spawnJson->zValue("min")->asNumber()->getNumber(),
            (int)spawnJson->zValue("max")->asNumber()->getNumber(),
            (float)spawnJson->zValue("chance")->asNumber()->getNumber(),
            spawnJson->zValue("itemType")->asString()->getString(),
            0,
        });
    }
    super.fromJson(zResult, zJson);
}

void AdditionalItemSpawningBlockTypeFactory::toJson(
    AdditionalItemSpawningBlockType* zObject,
    Framework::JSON::JSONObject* zResult) const
{
    Framework::JSON::JSONArray* spawns = new Framework::JSON::JSONArray();
    for (const SpawnConfig& config : zObject->getSpawns())
    {
        Framework::JSON::JSONObject* spawn = new Framework::JSON::JSONObject();
        spawn->addValue(
            "itemType", new Framework::JSON::JSONString(config.itemTypeName));
        spawn->addValue(
            "chance", new Framework::JSON::JSONNumber(config.chance));
        spawn->addValue("min", new Framework::JSON::JSONNumber(config.min));
        spawn->addValue("max", new Framework::JSON::JSONNumber(config.max));
        spawns->addValue(spawn);
    }
    zResult->addValue("spawns", spawns);
    return super.toJson(zObject, zResult);
}

JSONObjectValidationBuilder*
AdditionalItemSpawningBlockTypeFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return super.addToValidator(
        builder->withRequiredAttribute("spawns",
            Framework::JSON::Validator::JSONValidator::buildForArray()
                ->addAcceptedObjectInArray()
                ->withRequiredString("itemType")
                ->finishString()
                ->withRequiredNumber("chance")
                ->finishNumber()
                ->withRequiredNumber("min")
                ->finishNumber()
                ->withRequiredNumber("max")
                ->finishNumber()
                ->finishObject()
                ->finishArray()));
}

Framework::Text AdditionalItemSpawningBlockTypeFactory::getTypeToken() const
{
    return "additionalItemsBlockType";
}