# A basic match query
#
# `MongoMatch` is used with most of the Mongo services like `find`, `find_all`,
# `remove` etc.
#
# Building a query can be done with the fluent interface:
#
# ~~~
# var query = (new MongoMatch).
#	eq("login", "Morriar").
#	gt("age", 18).
#	exists("email", true).
#	is_in("status", [1, 2, 3, 4])
# ~~~
#
# Fore more help on how to use the query operators of MongoDB please
# refer to the official MongoDB documentation:
# https://docs.mongodb.com/manual/reference/operator/query/
class MongoMatch
	super JsonObject

	# Define a custom operaton for `field`
	#
	# If no `field` is specified, append the operator the the root object:
	# ~~~json
	# {$<name>: <value>}
	# ~~~
	#
	# Else, append the operator to the field:
	# ~~~json
	# {field: {$<name>: <value>} }
	# ~~~
	fun op(name: String, field: nullable String, value: nullable Serializable): MongoMatch do
		if field != null then
			var q = new JsonObject
			q["${name}"] = value
			self[field] = q
		else
			self["${name}"] = value
		end
		return self
	end

	# Match documents where `field` equals `value`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/eq/#op._S_eq
	#
	# ~~~json
	# {field: {$eq: value} }
	# ~~~
	fun eq(field: String, value: nullable Serializable): MongoMatch do
		self[field] = value
		return self
	end

	# Match documents where `field` not equals `value`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/ne/#op._S_ne
	#
	# ~~~json
	# {field: {$ne: value} }
	# ~~~
	fun ne(field: String, value: nullable Serializable): MongoMatch do
		op("ne", field, value)
		return self
	end

	# Match documents where `field` is greater than `value`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/gt/#op._S_gt
	#
	# ~~~json
	# {field: {$gt: value} }
	# ~~~
	fun gt(field: String, value: nullable Serializable): MongoMatch do
		op("gt", field, value)
		return self
	end

	# Match documents where `field` is greater or equal to `value`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/gte/#op._S_gte
	#
	# ~~~json
	# {field: {$gte: value} }
	# ~~~
	fun gte(field: String, value: nullable Serializable): MongoMatch do
		op("gte", field, value)
		return self
	end

	# Match documents where `field` is less than `value`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/lt/#op._S_lt
	#
	# ~~~json
	# {field: {$lt: value} }
	# ~~~
	fun lt(field: String, value: nullable Serializable): MongoMatch do
		op("lt", field, value)
		return self
	end

	# Match documents where `field` is less or equal to `value`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/lte/
	#
	# ~~~json
	# {field: {$lte: value} }
	# ~~~
	fun lte(field: String, value: nullable Serializable): MongoMatch do
		op("lte", field, value)
		return self
	end

	# Match documents where `field` exists or not
	#
	# https://docs.mongodb.com/manual/reference/operator/query/exists/#op._S_exists
	#
	# ~~~json
	# {field: {$exists: boolean} }
	# ~~~
	#
	# When `exists` is true, `$exists` matches the documents that contain the
	# field, including documents where the field value is null.
	# If <boolean> is false, the query returns only the documents that do not
	# contain the field.
	fun exists(field: String, exists: Bool): MongoMatch do
		op("exists", field, exists)
		return self
	end

	# Match documents where `field` matches `pattern`
	#
	# To read more about the available options, see:
	# https://docs.mongodb.com/manual/reference/operator/query/regex/#op._S_regex
	#
	# ~~~json
	# {field: {$regex: 'pattern', $options: '<options>'} }
	# ~~~
	#
	# Provides regular expression capabilities for pattern matching strings in queries.
	# MongoDB uses Perl compatible regular expressions (i.e. "PCRE" ).
	fun regex(field: String, pattern: String, options: nullable String): MongoMatch do
		var q = new JsonObject
		q["$regex"] = pattern
		if options != null then q["$options"] = options
		self[field] = q
		return self
	end

	# Match documents where `field` is in `values`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/in/
	#
	# ~~~json
	# { field: { $in: [<value1>, <value2>, ... <valueN> ] } }
	# ~~~
	#
	# `$in` selects the documents where the value of a field equals any value
	# in the specified array.
	fun is_in(field: String, values: Array[nullable Serializable]): MongoMatch do
		op("in", field, new JsonArray.from(values))
		return self
	end

	# Match documents where `field` is not in `values`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/nin/
	#
	# ~~~json
	# { field: { $nin: [<value1>, <value2>, ... <valueN> ] } }
	# ~~~
	#
	# `$nin` selects the documents where:
	# * the field value is not in the specified array or
	# * the field does not exist.
	fun is_nin(field: String, values: Array[nullable Serializable]): MongoMatch do
		op("nin", field, new JsonArray.from(values))
		return self
	end

	# Logical `or`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/or/#op._S_or
	#
	# The `$or` operator performs a logical OR operation on an array of two or
	# more `expressions` and selects the documents that satisfy at least one of
	# the `expressions`.
	#
	# The `$or` has the following syntax:
	#
	# ~~~json
	# { field: { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } }
	# ~~~
	fun lor(field: nullable String, expressions: Array[Serializable]): MongoMatch do
		op("or", field, new JsonArray.from(expressions))
		return self
	end

	# Logical `and`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/and/#op._S_and
	#
	# The `$and` operator performs a logical AND operation on an array of two or
	# more `expressions` and selects the documents that satisfy all of the `expressions`.
	#
	# The `$and` has the following syntax:
	#
	# ~~~json
	# { field: { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } }
	# ~~~
	fun land(field: nullable String, expressions: Array[Serializable]): MongoMatch do
		op("and", field, new JsonArray.from(expressions))
		return self
	end

	# Logical `not`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/not/#op._S_not
	#
	# `$not` performs a logical NOT operation on the specified `expression` and
	# selects the documents that do not match the `expression`.
	# This includes documents that do not contain the field.
	#
	# The $not has the following syntax:
	#
	# ~~~json
	# { field: { $not: { <expression> } } }
	# ~~~
	fun lnot(field: nullable String, expression: Serializable): MongoMatch do
		op("not", field, expression)
		return self
	end

	# Logical `nor`
	#
	# https://docs.mongodb.com/manual/reference/operator/query/nor/#op._S_nor
	#
	# `$nor` performs a logical NOR operation on an array of one or more query
	# expression and selects the documents that fail all the query expressions
	# in the array.
	#
	# The $nor has the following syntax:
	#
	# ~~~json
	# { field: { $nor: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } }
	# ~~~
	fun lnor(field: nullable String, expressions: Array[Serializable]): MongoMatch do
		op("nor", field, new JsonArray.from(expressions))
		return self
	end

	# Array contains all
	#
	# https://docs.mongodb.com/manual/reference/operator/query/all/#op._S_all
	#
	# `$all` selects the documents where the value of a field is an array that
	# contains all the specified elements.
	#
	# ~~~json
	# { field: { $all: [ <value1>, <value2>, ... ] } }
	# ~~~
	fun all(field: nullable String, values: Array[Serializable]): MongoMatch do
		op("all", field, new JsonArray.from(values))
		return self
	end

	# Array element match
	#
	# https://docs.mongodb.com/manual/reference/operator/query/elemMatch/#op._S_elemMatch
	#
	# `$elemMatch` matches documents that contain an array field with at least
	# one element that matches all the specified query criteria.
	#
	# ~~~json
	# { field: { $elemMatch: <query> } }
	# ~~~
	fun elem_match(field: nullable String, query: Serializable): MongoMatch do
		op("elemMatch", field, query)
		return self
	end

	# Array size match
	#
	# https://docs.mongodb.com/manual/reference/operator/query/size/#op._S_size
	#
	# `$size` matches any array with the number of elements specified by the argument
	#
	# ~~~json
	# { field: { $size: <size> } }
	# ~~~
	fun size(field: nullable String, size: Int): MongoMatch do
		op("size", field, size)
		return self
	end
end