#pragma once

#include <Vec3.h>

#include "BlockFilter.h"
#include "Item.h"
#include "ItemSkill.h"

class FluidContainerItemType;

class FluidContainerItem : public Item
{
private:
    int fluidTypeId;
    int fluidAmount;

public:
    FluidContainerItem(int itemTypeId, Framework::Text name);
    virtual const BlockType* zPlacedBlockType() const override;
    virtual bool canBeStackedWith(const Item* zItem) const override;
    virtual bool canBePlacedAt(
        int dimensionId, Framework::Vec3<int> worldPos) const override;
    virtual void onPlaced();
    virtual Framework::Text getTooltipUIML() const override;
    virtual bool applyFoodEffects(Entity* zTarget) override;
    virtual bool canApplyFoodEffectsFully(Entity* zTarget) const override;

    int getAmount() const;
    void setAmount(int amount);
    int getFluidTypeId() const;
    void setFluidTypeId(int fluidTypeId);

    friend FluidContainerItemType;
};

class FluidContainerItemSkillConfig : public Framework::ReferenceCounter
{
private:
    BlockFilter* targetFilter;
    float staminaCost;
    float staminaCostDevider;
    float staminaCostDeviderPerLevel;
    int cooldownTicks;
    float xpGain;

public:
    FluidContainerItemSkillConfig(BlockFilter* targetFilter,
        float staminaCost,
        float staminaCostDevider,
        float staminaCostDeviderPerLevel,
        int cooldownTicks,
        float xpGain);
    ~FluidContainerItemSkillConfig();
    BlockFilter* zTargetFilter() const;
    float getStaminaCost() const;
    float getStaminaCostDevider() const;
    float getStaminaCostDeviderPerLevel() const;
    int getCooldownTicks() const;
    float getXpGain() const;
};

class FluidContainerItemSkillConfigFactory
    : public TypeFactory<FluidContainerItemSkillConfig>
{
public:
    FluidContainerItemSkillConfigFactory();
    FluidContainerItemSkillConfig* fromJson(
        Framework::JSON::JSONValue* zJson) const override;
    Framework::JSON::JSONValue* toJson(
        FluidContainerItemSkillConfig* zObject) const override;
    Framework::JSON::Validator::JSONValidator* getValidator() const override;
};

class FluidContainerItemSkill : public ItemSkill
{
private:
    int cooldownTicks;
    FluidContainerItemSkillConfig* invalidUseConfig;
    Framework::RCArray<FluidContainerItemSkillConfig> configs;

public:
    FluidContainerItemSkill(float xp,
        float maxXp,
        float level,
        int cooldownTicks,
        FluidContainerItemSkillConfig* invalidUseConfig,
        Framework::RCArray<FluidContainerItemSkillConfig> configs);
    virtual bool use(Entity* zActor, Item* zUsedItem, Block* zTarget) override;
    virtual bool use(Entity* zActor, Item* zUsedItem, Entity* zTarget) override;
    FluidContainerItemSkillConfig* zInvalidUseConfig() const;
    const Framework::RCArray<FluidContainerItemSkillConfig>& zConfigs() const;
};

class FluidContainerItemSkillFactory
    : public SubTypeFactory<ItemSkill, FluidContainerItemSkill>
{
public:
    FluidContainerItemSkillFactory();
    FluidContainerItemSkill* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJson(
        FluidContainerItemSkill* zObject) const override;
    Framework::JSON::Validator::JSONValidator* getValidator(
        Framework::JSON::Validator::ObjectValidationBuilder<
            Framework::JSON::Validator::JSONValidator>* builder) const override;
    Framework::Text getTypeToken() const override;
};

class FluidContainerItemType : public ItemType
{
private:
    int maxFluidAmount;
    Framework::JSON::JSONObject* itemSkillConfig;
    ItemSkillLevelUpRule* levelUpRule;

public:
    FluidContainerItemType(Framework::Text name,
        ModelInfo* model,
        Framework::JSON::JSONObject* itemSkillConfig,
        ItemSkillLevelUpRule* levelUpRule,
        int maxFluidAmount,
        int maxStackSize,
        Framework::RCArray<Framework::Text> groups);
    ~FluidContainerItemType();

protected:
    virtual void loadSuperItem(
        Item* zItem, Framework::StreamReader* zReader) const override;
    virtual void saveSuperItem(
        const Item* zItem, Framework::StreamWriter* zWriter) const override;

public:
    virtual Item* createItem() const override;
    virtual ItemSkill* createDefaultItemSkill() const override;
    virtual void levelUpItemSkill(ItemSkill* zSkill) const override;
    virtual void setItemAttribute(Item* zItem,
        Framework::Text name,
        Framework::JSON::JSONValue* zValue) const override;
    virtual void addItemAttributes(
        Item* zItem, Framework::JSON::JSONObject* zItemObjet) const override;
    Framework::JSON::JSONObject* zItemSkillConfig() const;
    ItemSkillLevelUpRule* zLevelUpRule() const;
    int getMaxFluidAmount() const;

    FluidContainerItemType* setMaxFluidAmount(int maxFluidAmount);
};

class FluidContainerItemTypeFactory
    : public SubTypeFactory<ItemType, FluidContainerItemType>
{
public:
    FluidContainerItemTypeFactory();
    FluidContainerItemType* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJson(
        FluidContainerItemType* zObject) const override;
    Framework::JSON::Validator::JSONValidator* getValidator(
        Framework::JSON::Validator::ObjectValidationBuilder<
            Framework::JSON::Validator::JSONValidator>* builder) const override;
    Framework::Text getTypeToken() const override;
};