redef class PageMEntity
	# Concerns to display in this page.
	var concerns: nullable ConcernsTree = null

	redef fun apply_structure(doc) do
		build_main(doc)
		build_api(doc)
		build_dependencies(doc)
	end

	# Build the main tab (the one that contains the MDoc)
	fun build_main(doc: DocModel) do
		var mentity = self.mentity

		var sq = new CmdSummary(doc.model, doc.filter, mentity,
			markdown_processor = doc.inline_processor)
		sq.init_command

		main_tab.content.add new CardMDoc(mentity, mentity.mdoc_or_fallback)

		var summary = sq.summary
		if summary != null then
			main_tab.sidebar.cards.add new CardMdSummary(headlines = summary, md_processor = doc.inline_processor)
		end
	end

	# Build the API tab
	fun build_api(doc: DocModel) do
		var summary = new CardSummary

		var title = "All definitions"
		if mentity isa MPackage then title = "All groups and modules"
		if mentity isa MGroup then title = "All subgroups and modules"
		if mentity isa MModule then title = "All class definitions"
		if mentity isa MClass or mentity isa MClassDef then title = "All properties"

		var section = new CardSection(2, title)
		api_tab.content.add section
		summary.cards.add section

		var dq = new CmdFeatures(doc.model, doc.filter, mentity)
		dq.init_command
		var mentities = dq.results
		if mentities == null then return

		var list = new CardList("api", "API")
		for m in mentities do
			var card = new CardMEntity(m)
			card.id = "api_{card.id}" # avoid id conflicts with main tab
			list.cards.add card
			summary.cards.add card
		end
		api_tab.content.add list

		if summary.cards.not_empty then
			api_tab.sidebar.cards.add summary
		end
	end

	# Build the dependencies tab
	fun build_dependencies(doc: DocModel) do
		var summary = new CardSummary

		var model = doc.model
		var mainmodule = doc.mainmodule
		var filter = doc.filter

		if not doc.no_dot then
			var gq = new CmdInheritanceGraph(model, mainmodule, filter, mentity)
			gq.init_command
			var graph = gq.graph
			if graph != null then
				graph.draw(2, 2)
				dep_tab.content.add new CardGraph(mentity, graph)
			end
		end

		# No inheritance lists for `Object`
		if mentity isa MClass and mentity.name == "Object" then return

		var inh = new HashMap[String, CmdEntityList]
		inh["Ancestors"] = new CmdAncestors(model, mainmodule, filter, mentity, parents = false)
		inh["Parents"] = new CmdParents(model, mainmodule, filter, mentity)
		inh["Children"] = new CmdChildren(model, mainmodule, filter, mentity)
		inh["Descendants"] = new CmdDescendants(model, mainmodule, filter, mentity, children = false)

		for title, cmd in inh do
			cmd.init_command
			var results = cmd.results
			if results == null or results.is_empty then continue
			var section = new CardSection(3, title)
			dep_tab.content.add section
			summary.cards.add section

			var list = new CardList("inh", "Inheritance")
			for mentity in results do
				var card = new CardMEntity(mentity)
				list.cards.add card
				summary.cards.add card
			end
			dep_tab.content.add list
		end

		if summary.cards.not_empty then
			dep_tab.sidebar.cards.add summary
		end
	end

	# Build the code panel
	fun build_code(doc: DocModel) do
		var code_url = doc.code_url

		if not doc.no_code then
			var cq = new CmdEntityCode(doc.model, doc.modelbuilder, doc.filter, mentity)
			cq.init_command

			var code = cq.node
			if code == null then return
			code_tab.content.add new CardCode(mentity, code)
		else if doc.code_url != null then
			code_tab = new DocTabLink("code", "Code", "console", mentity.source_url(code_url))
		end
	end

	# Build the linearization panel
	fun build_linearization(doc: DocModel) do
		var summary = new CardSummary

		var lq = new CmdLinearization(doc.model, doc.mainmodule, doc.filter, mentity)
		lq.init_command

		var mentities = lq.results
		if mentities == null then return

		if mentity isa MClass or mentity isa MClassDef then
			if mentity.name == "Object" then return # No linearization for `Object`
			if mentity.name == "Sys" then return # No linearization for `Sys`
			var section = new CardSection(2, "Class definitions")
			lin_tab.content.add section
			summary.cards.add section
		else if mentity isa MProperty or mentity isa MPropDef then
			if mentity.name == "init" then return # No linearization for `init`
			if mentity.name == "SELF" then return # No linearization for `SELF`
			if mentity.name == "to_s" then return # No linearization for `to_s`
			var section = new CardSection(2, "Property definitions")
			lin_tab.content.add section
			summary.cards.add section
		end

		var list = new CardLinearizationList(mentity)
		for m in mentities do
			var url = mentity.source_url(doc.code_url)
			var node = doc.modelbuilder.mentity2node(m)
			if node == null then continue
			if doc.no_code then node = null
			if m == mentity or
			  (m isa MClassDef and m.is_intro) or
			  (m isa MPropDef and m.is_intro) then
				var card = new CardLinearizationDef(m, node, is_active = true, url)
				list.cards.add card
				summary.cards.add card
			else
				var card = new CardLinearizationDef(m, node, is_active = false, url)
				list.cards.add card
				summary.cards.add card
			end
		end
		lin_tab.content.add list

		if summary.cards.not_empty then
			lin_tab.sidebar.cards.add summary
		end
	end
end

redef class PageMEntity
	redef var html_url is lazy do return mentity.html_url
	redef fun init_title(doc) do title = mentity.html_name

	redef fun render_content do
		addn new CardPageHeader(
			mentity.html_declaration.write_to_string,
			mentity.html_namespace.write_to_string)
		super
	end

	redef fun init_topmenu(doc) do
		super
		for m in mentity.nitdoc_breadcrumbs do
			topmenu.add_li new ListItem(new Link(m.html_url, m.html_name))
		end
		topmenu.active_item = topmenu.items.last
	end
end