redef class MGroup
	# The loaded modules of this group
	var mmodules = new Array[MModule]

	# The default module of a group (if any, and if loaded)
	#
	# The default module of a group is the one that has the same name.
	# Return `null` if the group has no default module or if the default
	# module is not loaded.
	var default_mmodule: nullable MModule = null

	redef fun mdoc_or_fallback
	do
		if mdoc != null then return mdoc
		var default_mmodule = self.default_mmodule
		if default_mmodule == null then return null
		return default_mmodule.mdoc_or_fallback
	end
end

redef class MGroup
	redef var is_test is lazy do
		var parent = self.parent
		if parent != null and parent.is_test then return true
		return name == "tests"
	end
end

redef class MGroup
	# Is the group interesting for a final user?
	#
	# Groups are mandatory in the model but for simple packages they are not
	# always interesting.
	#
	# A interesting group has, at least, one of the following true:
	#
	# * it has 2 modules or more
	# * it has a subgroup
	# * it has a documentation
	fun is_interesting: Bool
	do
		return mmodules.length > 1 or
			not in_nesting.direct_smallers.is_empty or
			mdoc != null or
			(mmodules.length == 1 and default_mmodule == null)
	end

	# Are files and directories in self scanned?
	#
	# See `ModelBuilder::scan_group`.
	var scanned = false

	# Return the modules in self and subgroups named `name`.
	#
	# If `self` is not scanned (see `ModelBuilder::scan_group`) the
	# results might be partial.
	fun mmodules_by_name(name: String): Array[MModule]
	do
		var res = new Array[MModule]
		for g in in_nesting.smallers do
			for mp in g.mmodules do
				if mp.name == name then
					res.add mp
				end
			end
		end
		return res
	end
end

redef class MGroup
	redef var is_example is lazy do
		var parent = self.parent
		if parent != null and parent.is_example then return true
		return name == "examples"
	end

	redef fun examples do
		var res = super
		for mmodule in mmodules do
			for example in mmodule.examples do
				if not res.has(example) then res.add example
			end
		end
		return res
	end
end

redef class MGroup
	redef fun to_node(nodes: HashMap[MEntity, NeoNode], model_name: nullable String): NeoNode do
		if nodes.has_key(self) then return nodes[self]
		var node = super
		var parent = parent
		node.out_edges.add(new NeoEdge(node, "PROJECT", mpackage.to_node(nodes, model_name)))
		if parent != null then
			node.out_edges.add(new NeoEdge(node, "PARENT", parent.to_node(nodes, model_name)))
		end
		for mmodule in mmodules do
			node.out_edges.add(new NeoEdge(node, "DECLARES", mmodule.to_node(nodes, model_name)))
		end
		for subgroup in in_nesting.direct_smallers do
			node.in_edges.add(new NeoEdge(node, "NESTS", subgroup.to_node(nodes, model_name)))
		end
		return node
	end
end

redef class MGroup

	redef fun collect_modifiers do return super + ["group"]

	# Collect all groups directly import by `self`
	redef fun collect_parents(mainmodule, filter) do
		var res = new HashSet[MENTITY]
		for mmodule in mmodules do
			for parent in mmodule.collect_parents(mainmodule, filter) do
				var mgroup = parent.mgroup
				if mgroup == null or mgroup == self then continue
				if filter == null or filter.accept_mentity(mgroup) then res.add(mgroup)
			end
		end
		return res
	end

	# Collect all group that directly import `self`
	redef fun collect_children(mainmodule, filter) do
		var res = new HashSet[MENTITY]
		for mgroup in model.collect_mgroups(filter) do
			if mgroup == self then continue
			if filter != null and not filter.accept_mentity(mgroup) then continue
			if mgroup.collect_parents(mainmodule, filter).has(self) then res.add mgroup
		end
		return res
	end

	# Collect all groups contained in `self`
	fun collect_mgroups(filter: nullable ModelFilter): HashSet[MENTITY] do
		var res = new HashSet[MENTITY]
		for mgroup in in_nesting.direct_smallers do
			if filter == null or filter.accept_mentity(mgroup) then res.add(mgroup)
		end
		return res
	end

	# Collect all modules contained in `self`
	fun collect_all_mmodules(filter: nullable ModelFilter): HashSet[MModule] do
		var res = new HashSet[MModule]
		for mgroup in collect_mgroups(filter) do
			res.add_all mgroup.collect_all_mmodules(filter)
		end
		return res
	end

	# Collect all modules contained in `self`
	fun collect_mmodules(filter: nullable ModelFilter): HashSet[MModule] do
		var res = new HashSet[MModule]
		for mmodule in mmodules do
			if filter == null or filter.accept_mentity(mmodule) then res.add(mmodule)
		end
		return res
	end
end

redef class MGroup
	# Visit all the subgroups and modules of the group.
	redef fun visit_all(v) do
		for x in in_nesting.direct_smallers do v.enter_visit(x)
		for x in mmodules do v.enter_visit(x)
	end
end

redef class MGroup
	redef fun mentity_kind_rank do return 2
end

redef class MGroup
	redef fun html_icon do return new BSIcon("folder-close", ["text-muted"])

	redef fun html_namespace do
		var tpl = new Template
		var parent = self.parent
		if parent != null then
			tpl.add parent.html_namespace
			tpl.add " > "
		end
		tpl.add html_link
		return tpl
	end
end

redef class MGroup
	redef fun to_dot_node do
		var node = super
		node["shape"] = "folder"
		return node
	end
end

redef class MGroup
	redef fun json_namespace do
		var ns = new JsonNamespace
		if parent != null then
			ns.prepend parent.as(not null).json_namespace
		end
		ns.add to_json_ref
		ns.add ">"
		return ns
	end
end

redef class MGroup
	redef var nitdoc_breadcrumbs is lazy do
		var parent = self.parent
		if parent != null then
			return parent.nitdoc_breadcrumbs + [self]
		end
		return mpackage.nitdoc_breadcrumbs
	end
end

redef class MGroup
	redef var html_url is lazy do return "group_{super}"
end