FactoryCraft-Server/FactoryCraft/Inventory.h

#pragma once

#include <Critical.h>
#include <HashMap.h>
#include <ImmutablePair.h>
#include <ReferenceCounter.h>
#include <Vec3.h>
#include <Writer.h>

#include "Area.h"
#include "ItemSlot.h"
#include "Recipie.h"
#include "UIObservable.h"

class ItemFilter;
class Inventory;
class NetworkMessage;
class Entity;
class Item;
class ItemStack;

class InventoryInteraction
{
private:
    Inventory* current;
    Inventory* other;
    Direction dir;
    void lock();
    void unlock();
    void transaction(Inventory* zSource,
        Inventory* zTarget,
        ItemFilter* zFilter,
        Direction sourceView,
        Direction targetView,
        int count);

public:
    InventoryInteraction(Inventory* zCurrent, Inventory* zOther, Direction dir);
    InventoryInteraction(const InventoryInteraction& interaction);
    ~InventoryInteraction();
    InventoryInteraction& operator=(const InventoryInteraction& data);
    void endInteraction();
    void pullItems(int count, ItemFilter* zFilter);
    void pushItems(int count, ItemFilter* zFilter);
};

class MultipleInventoryLock
{
private:
    Inventory** inventories;
    int count;
    bool locked;

public:
    MultipleInventoryLock(Inventory** inventories, int count);
    ~MultipleInventoryLock();

    void unlock();
    void lock();
};

struct InventoryObserver
{
    int entityId;
    Framework::Text uimlId;
    int processorId;
};

class Inventory : public virtual Framework::ReferenceCounter
{
private:
    UIObservable observable;
    Framework::RCArray<ItemSlot>* pullSlotsOrder;
    Framework::RCArray<ItemSlot>* pushSlotsOrder;
    Framework::HashMap<int, Framework::Array<ItemSlot*>*>* itemCache;
    Framework::Critical cs;
    Framework::Array<std::function<void(
        ItemSlot* zSlot, Direction dir, const Item* zItem, int count)>>
        afterPullStackCalls;
    Framework::Array<std::function<void(
        ItemSlot* zSlot, Direction dir, const Item* zItem, int count)>>
        afterPushStackCalls;
    int nextSlotId;

public:
    Inventory(const Framework::Vec3<float> location,
        int dimensionId,
        bool hasInventory);
    virtual ~Inventory();

private:
    void updateCache(ItemSlot* zSlot, int beforeKey);

protected:
    int dimensionId;
    Framework::Vec3<float> location;

    virtual bool allowPullStack(ItemSlot* zSlot, Direction dir) const;
    virtual bool allowPushStack(
        ItemSlot* zSlot, Direction dir, const Item* zItem, int& count) const;
    virtual void afterPullStack(
        ItemSlot* zSlot, Direction dir, const Item* zItem, int count);
    virtual void afterPushStack(
        ItemSlot* zSlot, Direction dir, const Item* zItem, int count);
    virtual void updateSlot(ItemSlot* zSlot);
    virtual void loadInventory(Framework::StreamReader* zReader);
    virtual void saveInventory(Framework::StreamWriter* zWriter);
    virtual void addItems(
        ItemStack* zItems, Direction dir, ItemFilter* zFilter);

public:
    void lock();
    void unlock();
    void notifyObservers(NetworkMessage* msg);
    const ItemSlot* zSlot(int id) const;
    void addSlot(ItemSlot* slot);
    void localTransaction(Framework::Array<ItemSlot*>* zSourceSlots,
        Framework::Array<ItemSlot*>* zTargetSlots,
        ItemFilter* zFilter,
        int count,
        Direction outDir,
        Direction inDir);
    ItemStack* takeItemsOut(ItemSlot* zSlot, int count, Direction dir);
    virtual void addItems(ItemSlot* zSlot, ItemStack* zItems, Direction dir);
    InventoryInteraction interactWith(Inventory* zInventory, Direction dir);
    void unsaveAddItem(ItemStack* zStack, Direction dir, ItemFilter* zFilter);
    int numberOfAddableItems(const Item* zItem, Direction dir) const;
    int numberOfAddableItems(const Item* zItem,
        Direction dir,
        const Framework::Text& slotName) const;
    bool isAllAvailable(Framework::RCArray<RecipieInput>& inputs,
        const Framework::Text& slotName) const;
    void consume(Framework::RCArray<RecipieInput>& inputs,
        const Framework::Text& slotName);
    Framework::ArrayIterator<ItemSlot*> begin();
    Framework::ArrayIterator<ItemSlot*> end();
    void inventoryApi(Framework::StreamReader* zRequest,
        NetworkMessage* zResponse,
        Entity* zSource);
    void registerAfterPullStackCall(std::function<void(
            ItemSlot* zSlot, Direction dir, const Item* zItem, int count)>
            call);
    void registerAfterPushStackCall(std::function<void(
            ItemSlot* zSlot, Direction dir, const Item* zItem, int count)>
            call);
    void registerObserverAddedCall(
        std::function<void(Entity* zSource, Framework::Text id, int processor)>
            call);
    int getDimensionId() const;
    Framework::Vec3<float> getLocation() const;

    friend InventoryInteraction;
    friend MultipleInventoryLock;

private:
    static bool unsafeMove(Inventory* zSource,
        Inventory* zTarget,
        Framework::ArrayIterator<ItemSlot*>& sourceSlot,
        Framework::ArrayIterator<ItemSlot*>& targetSlot,
        Direction outDir,
        Direction inDir,
        int& count);
};