redef class AModule
	init init_amodule (
		n_moduledecl: nullable AModuledecl,
		n_imports: Collection[Object], # Should be Collection[AImport]
		n_extern_code_blocks: Collection[Object], # Should be Collection[AExternCodeBlock]
		n_classdefs: Collection[Object] # Should be Collection[AClassdef]
	)
	do
		_n_moduledecl = n_moduledecl
		if n_moduledecl != null then n_moduledecl.parent = self
		self.n_imports.unsafe_add_all(n_imports)
		self.n_extern_code_blocks.unsafe_add_all(n_extern_code_blocks)
		self.n_classdefs.unsafe_add_all(n_classdefs)
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_moduledecl == old_child then
			n_moduledecl = new_child.as(nullable AModuledecl)
			return
		end
		if n_imports.replace_child(old_child, new_child) then return
		if n_extern_code_blocks.replace_child(old_child, new_child) then return
		if n_classdefs.replace_child(old_child, new_child) then return
	end

	redef fun n_moduledecl=(node)
	do
		_n_moduledecl = node
		if node != null then node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		v.enter_visit(_n_moduledecl)
		n_imports.visit_all(v)
		n_extern_code_blocks.visit_all(v)
		n_classdefs.visit_all(v)
	end
end

redef class AModule
	# Visit the module to detect easy warnings that does not need the metamodel or the importation
	# Warnings are displayed on the toolcontext
	fun do_simple_misc_analysis(toolcontext: ToolContext)
	do
		var v = new SimpleMiscVisitor(toolcontext)
		v.enter_visit(self)

		var t = location.file.first_token
		while t != null do
			t.accept_simple_misc_token(v)
			t = t.next_token
		end
	end
end

redef class AModule
	# Visit the module to compute the real value of the literal-related node of the AST.
	# Warnings and errors are displayed on the toolcontext.
	fun do_literal(toolcontext: ToolContext)
	do
		var v = new LiteralVisitor(toolcontext)
		v.enter_visit(self)
	end
end

redef class AModule
	# The associated MModule once build by a `ModelBuilder`
	var mmodule: nullable MModule = null

	# Flag that indicate if the importation is already completed
	var is_importation_done: Bool = false
end

redef class AModule
	# Flag that indicate if the class building is already completed
	var build_classes_is_done: Bool = false
	# What is the AClassdef associated to a `MClass`?
	# Used to check multiple definition of a class.
	var mclass2nclassdef: Map[MClass, AClassdef] = new HashMap[MClass, AClassdef]
end

redef class AModule
	redef fun accept_pretty_printer(v) do
		v.catch_up start_token
		v.visit n_moduledecl

		if not n_imports.is_empty then
			if v.skip_empty then v.addn

			for n_import in n_imports do
				v.catch_up n_import
				v.visit n_import
			end
		end

		if not n_extern_code_blocks.is_empty then
			v.addn

			for n_extern_block in n_extern_code_blocks do
				v.catch_up n_extern_block
				v.visit n_extern_block
				v.addn
				if n_extern_block != n_extern_code_blocks.last then v.addn
			end

			if not n_classdefs.is_empty then v.addn
		end

		if not n_classdefs.is_empty then
			if v.skip_empty then v.addn

			for n_classdef in n_classdefs do
				v.catch_up n_classdef
				v.visit n_classdef
				if n_classdef != n_classdefs.last then v.addn
			end
		end

		assert v.indent == 0
	end

	# Skip doc if any.
	redef fun start_token do
		if n_moduledecl != null then return n_moduledecl.first_token
		if not n_imports.is_empty then return n_imports.first.first_token
		if not n_classdefs.is_empty then return n_classdefs.first.first_token
		return first_token
	end

	redef fun is_inlinable do return false
end

redef class AModule

	# Ensures all of the general foreign code of the module has been analyzed.
	# Manages header blocks, extern class types and foreign dependancies between modules
	fun ensure_compile_ffi_wrapper
	do
		var mmodule = mmodule
		if mmodule == null or mmodule.ffi_ccu != null then return

		# ready extern code compiler
		var ffi_ccu = new CCompilationUnit
		mmodule.ffi_ccu = ffi_ccu

		# generate code
		for block in n_extern_code_blocks do
			var language = block.language
			assert language != null
			mmodule.present_languages.add(language)
			language.compile_module_block(block, ffi_ccu, mmodule)
		end

		ffi_ccu.header_c_base.add( "#include \"{mmodule.c_name}._nitni.h\"\n" )

		ffi_ccu.body_decl.add("#ifdef ANDROID\n")
		ffi_ccu.body_decl.add("	#include <android/log.h>\n")
		ffi_ccu.body_decl.add("	#define PRINT_ERROR(...) (void)__android_log_print(ANDROID_LOG_WARN, \"Nit\", __VA_ARGS__)\n")
		ffi_ccu.body_decl.add("#else\n")
		ffi_ccu.body_decl.add("	#define PRINT_ERROR(...) fprintf(stderr, __VA_ARGS__)\n")
		ffi_ccu.body_decl.add("#endif\n")

		for nclassdef in n_classdefs do
			# Does it declares an extern type?
			if nclassdef isa AStdClassdef and nclassdef.n_extern_code_block != null then
				mmodule.uses_ffi = true
				var language = nclassdef.n_extern_code_block.language
				assert language != null
				mmodule.present_languages.add(language)
				nclassdef.n_extern_code_block.language.compile_extern_class(
					nclassdef.n_extern_code_block.as(not null), nclassdef, ffi_ccu, mmodule)
			end
		end
	end
end

redef class AModule
	private fun deserializer_nclassdef: nullable AStdClassdef
	do
		for nclassdef in n_classdefs do
			if not nclassdef isa AStdClassdef then continue
			var n_qid = nclassdef.n_qid
			if n_qid != null and n_qid.n_id.text == "Deserializer" then return nclassdef
		end

		return null
	end

	private var inits_to_retype = new Array[AMethPropdef]

	redef fun is_serialize
	do
		var n_moduledecl = n_moduledecl
		return n_moduledecl != null and n_moduledecl.is_serialize
	end

	# `AStdClassdef` marked as serializable, itself or one of theur attribute
	private var auto_serializable_nclassdefs: Array[AStdClassdef] is lazy do
		var array = new Array[AStdClassdef]
		for nclassdef in n_classdefs do
			if nclassdef isa AStdClassdef and nclassdef.how_serialize != null then
				array.add nclassdef
			end
		end
		return array
	end
end

redef class AModule
	private fun has_public_c_header: Bool do
		for code_block in n_extern_code_blocks do if code_block.is_c_header then return true
		return false
	end
end

redef class AModule
	# Compile all contracts
	#
	# The implementation of the contracts is done in two visits.
	#
	# - First step, the visitor analyzes and constructs the contracts
	#   for each class (invariant) and method (expect, ensure).
	#
	# - Second step the visitor analyzes each `ASendExpr` to see
	#   if the callsite calls a method with a contract. If this is
	#	the case the callsite is replaced by another callsite to the contract method.
	fun do_contracts(toolcontext: ToolContext) do
		#
		var contract_visitor = new ContractsVisitor(toolcontext, toolcontext.modelbuilder.identified_modules.first, self, new ASTBuilder(mmodule.as(not null)))
		contract_visitor.enter_visit(self)
		#
		var callsite_visitor = new CallSiteVisitor(toolcontext)
		callsite_visitor.enter_visit(self)
	end
end

redef class AModule

	# Compile user FFI code and a standardized API into a `.so` file
	#
	# Returns `true` on success.
	fun compile_foreign_lib(v: NaiveInterpreter): Bool
	do
		var mmodule = mmodule
		assert mmodule != null

		var compile_dir = v.compile_dir
		var foreign_code_lib_path = v.foreign_code_lib_path(mmodule)

		if not compile_dir.file_exists then compile_dir.mkdir(0o700)

		# Compile the common FFI part
		ensure_compile_ffi_wrapper
		for mclassdef in mmodule.mclassdefs do for mpropdef in mclassdef.mpropdefs do
			var anode = v.modelbuilder.mpropdef2node(mpropdef)
			if mpropdef isa MMethodDef and anode isa AMethPropdef and anode.supported_by_dynamic_ffi then
				anode.compile_ffi_method(mmodule)
			end
		end
		mmodule.finalize_ffi_wrapper(compile_dir, mmodule)

		# Compile the standard API and its implementation for the .so file
		var ccu = compile_foreign_lib_api(compile_dir)

		var srcs = [for file in ccu.files do new ExternCFile(file, ""): ExternFile]
		srcs.add_all mmodule.ffi_files

		# Compiler options specific to this module
		var ldflags_array = mmodule.ldflags[""]
		if ldflags_array.has("-lrt") and system("sh -c 'uname -s 2>/dev/null || echo not' | grep Darwin >/dev/null") == 0 then
			# Remove -lrt on OS X
			ldflags_array.remove "-lrt"
		end
		var ldflags = ldflags_array.join(" ")

		# Protect pkg-config
		var pkgconfigs = mmodule.pkgconfigs
		var pkg_cflags = ""
		if not pkgconfigs.is_empty then

			# Check if the pkgconfig packages are available
			v.modelbuilder.toolcontext.check_pkgconfig_packages pkgconfigs
			if not v.modelbuilder.toolcontext.check_errors then return false

			pkg_cflags = "`pkg-config --cflags {pkgconfigs.join(" ")}`"
			ldflags += " `pkg-config --libs {pkgconfigs.join(" ")}`"
		end

		# Compile each source file to an object file (or equivalent)
		var object_files = new Array[String]
		for f in srcs do
			f.compile(v, mmodule, object_files, pkg_cflags)
		end

		# Link everything in a shared library
		var cmd = "{v.c_compiler} -Wall -shared -o {foreign_code_lib_path} {object_files.join(" ")} {ldflags}"
		if system(cmd) != 0 then
			v.fatal "FFI Error: Failed to link native code using `{cmd}`"
			return false
		end

		return true
	end

	# Compile the standard API of the `.so` file
	#
	# * The shared structure `nit_call_arg`.
	# * Standardized implementation functions entrypoints that relay calls
	#   to the FFI implementation functions.
	private fun compile_foreign_lib_api(compdir: String): CCompilationUnit
	do
		var mmodule = mmodule
		assert mmodule != null

		# ready extern code compiler
		var ecc = new CCompilationUnit

		ecc.body_decl.add """

#include <string.h>
#include <stdio.h>
#include <inttypes.h>

// C structure behind `CallArg` from the interpreter
typedef union nit_call_arg {
	long value_Int;
	int value_Bool;
	uint32_t value_Char;
	uint8_t value_Byte;
	int8_t value_Int8;
	int16_t value_Int16;
	uint16_t value_UInt16;
	int32_t value_Int32;
	uint32_t value_UInt32;
	double value_Float;
	void* value_Pointer;
} nit_call_arg;

"""

		# types
		var used_types = collect_mtypes
		for t in used_types do
			if not t.is_cprimitive then
				ecc.header_c_types.add "typedef void* {t.cname};\n"
			end
		end

		# TODO callbacks & casts

		for nclassdef in n_classdefs do for npropdef in nclassdef.n_propdefs do
			if npropdef isa AMethPropdef and npropdef.supported_by_dynamic_ffi then
				npropdef.mpropdef.compile_foreign_code_entry ecc
			end
		end

		ecc.write_as_foreign_lib_api(mmodule, compdir)

		return ecc
	end

	# Collect all `MType` use in extern methods within this module
	private fun collect_mtypes: Set[MType]
	do
		var used_types = new HashSet[MType]

		# collect callbacks
		for nclassdef in n_classdefs do for npropdef in nclassdef.n_propdefs do
			if npropdef isa AMethPropdef and npropdef.supported_by_dynamic_ffi then
				var fcs = npropdef.foreign_callbacks
				used_types.add_all fcs.types
			end
		end

		return used_types
	end
end

redef class AModule

	private var foreign_code_lib_cache: nullable ForeignCodeLib = null

	# Handle to the external library with FFI code
	private fun foreign_code_lib(v: NaiveInterpreter): nullable ForeignCodeLib
	do
		var lib = foreign_code_lib_cache
		if lib != null then return lib

		var mmodule = mmodule
		assert mmodule != null

		var foreign_code_lib_path = v.foreign_code_lib_path(mmodule)

		# Compile lib
		compile_foreign_lib v

		lib = new ForeignCodeLib.dlopen(foreign_code_lib_path.to_cstring)
		if lib.address_is_null then
			v.fatal "FFI Error: Cannot load foreign code library for {mmodule.name}: {dlerror.to_s}"
			return null
		end

		foreign_code_lib_cache = lib
		return lib
	end
end