#include "ItemFilter.h"
#include "ItemType.h"
#include "Item.h"
#include "ItemSlot.h"


ItemFilter::ItemFilter()
	: ReferenceCounter()
{}

bool ItemFilter::matchItem(const Item* zItem) const
{
	return 1;
}

bool ItemFilter::matchSourceSlot(ItemSlot* zSlot) const
{
	return zSlot->zStack() ? matchItem(zSlot->zStack()->zItem()) : 0;
}

bool ItemFilter::matchTargetSlot(ItemSlot* zSlot) const
{
	return 1;
}


CombinedItemFilter::CombinedItemFilter(ItemFilter* filterA, ItemFilter* filterB, std::function<bool(bool, bool)> op)
	: ItemFilter(),
	filterA(filterA),
	filterB(filterB),
	op(op)
{}

CombinedItemFilter::~CombinedItemFilter()
{
	filterA->release();
	filterB->release();
}

bool CombinedItemFilter::matchItem(const Item* zItem) const
{
	return op(filterA->matchItem(zItem), filterB->matchItem(zItem));
}


AnyItemFilter::AnyItemFilter()
	: ItemFilter()
{}

bool AnyItemFilter::matchItem(const Item* zItem) const
{
	return true;
}


TypeItemFilter::TypeItemFilter(const ItemType* zType)
	: ItemFilter(),
	zType(zType)
{}

bool TypeItemFilter::matchItem(const Item* zItem) const
{
	return zItem->zItemType() == zType;
}


SpecificSlotFilter::SpecificSlotFilter(int sourceSlotId, int targetSlotId)
	: ItemFilter(),
	sourceSlotId(sourceSlotId),
	targetSlotId(targetSlotId)
{}

bool SpecificSlotFilter::matchSourceSlot(ItemSlot* zSlot) const
{
	return sourceSlotId == zSlot->getId();
}

bool SpecificSlotFilter::matchTargetSlot(ItemSlot* zSlot) const
{
	return targetSlotId == zSlot->getId();
}


SourceSlotBlacklistFilter::SourceSlotBlacklistFilter()
	: ItemFilter()
{}

void SourceSlotBlacklistFilter::addBlackListSlotId(int id)
{
	blackList.add(id);
}

bool SourceSlotBlacklistFilter::matchSourceSlot(ItemSlot* zSlot) const
{
	for (int black : blackList)
	{
		if (black == zSlot->getId())
			return 0;
	}
	return 1;
}

bool SourceSlotBlacklistFilter::matchTargetSlot(ItemSlot* zSlot) const
{
	return 1;
}