#pragma once

#include <memory>

namespace ConditionType
{
	enum type
	{
		NONE,
		isTuesday,
		isThursday,
		isAfterEight
	};
}

namespace OperatorType
{
	enum type
	{
		NONE,
		OR,
		AND
	};
}

class Condition
{
public:
	Condition(ConditionType::type condition)
		: mCondition(condition)
		, mOperatorType(OperatorType::NONE)
		, mLCondition()
		, mRCondition()
	{}

	Condition(const Condition &left, OperatorType::type opType, const Condition &right)
		: mCondition(ConditionType::NONE)
		, mOperatorType(opType)
		, mLCondition(new Condition(left))
		, mRCondition(new Condition(right))
	{}

	Condition(const Condition &other)
		: mCondition(other.mCondition)
		, mOperatorType(other.mOperatorType)
		, mLCondition(other.mLCondition ? new Condition(*other.mLCondition) : nullptr)
		, mRCondition(other.mRCondition ? new Condition(*other.mRCondition) : nullptr)
	{
	}

	Condition &Condition::operator=(const Condition &other)
	{
		mCondition = other.mCondition;
		mOperatorType = other.mOperatorType;
		mLCondition.reset(other.mLCondition ? new Condition(*other.mLCondition) : nullptr);
		mRCondition.reset(other.mRCondition ? new Condition(*other.mRCondition) : nullptr);

		return *this;
	}
	
	operator bool() const
	{
		return evauluate();
	}

	bool evauluate() const
	{
		if(mOperatorType == OperatorType::NONE)
			return passesValue();
		else if(mOperatorType == OperatorType::AND)
			return mLCondition->evauluate() && mRCondition->evauluate();
		else if(mOperatorType == OperatorType::OR)
			return mLCondition->evauluate() || mRCondition->evauluate();

		return false;
	}

	Condition operator&&(const Condition &other) const
	{
		return Condition(*this, OperatorType::AND, other);
	}

	Condition operator||(const Condition &other) const
	{
		return Condition(*this, OperatorType::OR, other);
	}

private:
	ConditionType::type mCondition;

	OperatorType::type mOperatorType;
	std::unique_ptr<Condition> mLCondition;
	std::unique_ptr<Condition> mRCondition;

	bool passesValue() const
	{
		switch (mCondition)
		{
		case ConditionType::isTuesday:
			return false;
		case ConditionType::isThursday:
			return true;
		case ConditionType::isAfterEight:
			return false;
		}

		return false;
	}
};