# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2013 Alexis Laferrière <alexis.laf@xymus.net>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# FFI support for the compilers
module compiler_ffi

intrude import abstract_compiler
intrude import ffi
import nitni

redef class MModule
	private var foreign_callbacks = new ForeignCallbackSet
	var nitni_ccu: nullable CCompilationUnit = null

	private fun nmodule(v: AbstractCompilerVisitor): nullable AModule
	do
		return v.compiler.modelbuilder.mmodule2node(self)
	end

	redef fun finalize_ffi(compiler: AbstractCompiler)
	do
		if not uses_ffi then return

		var v = compiler.new_visitor
		var n = nmodule(v)
		if n == null then return
		n.ensure_compile_ffi_wrapper
		finalize_ffi_wrapper(v.compiler.modelbuilder.compile_dir, v.compiler.mainmodule)
		for file in ffi_files do v.compiler.extern_bodies.add(file)

		ensure_compile_nitni_base(v)

		nitni_ccu.header_c_types.add("#include \"{c_name}._ffi.h\"\n")
		nitni_ccu.header_c_types.add """
extern void nitni_global_ref_incr(void*);
extern void nitni_global_ref_decr(void*);
"""

		nitni_ccu.write_as_nitni(self, v.compiler.modelbuilder.compile_dir)

		for file in nitni_ccu.files do
			var f = new ExternCFile(file, cflags)
			f.pkgconfigs.add_all pkgconfigs
			v.compiler.extern_bodies.add(f)
		end

		# reset FFI things so the next compilation job, if any, starts with a clean context
		# FIXME clean and rationalize this
		nitni_ccu = null
		compiled_ffi_methods.clear
		ffi_ccu = null
		ffi_files.clear
		compiled_callbacks.clear
		#Do not reset `foreign_callbacks` and `ffi_callbacks` because they are computed in previous phases
	end

	private fun ensure_compile_nitni_base(v: AbstractCompilerVisitor)
	do
		if nitni_ccu != null then return

		nitni_ccu = new CCompilationUnit
	end

	redef fun collect_linker_libs
	do
		var s = ldflags
		if s.is_empty then return null
		var res = new ArraySet[String]
		res.add s
		return res
	end

	private var compiled_callbacks = new Array[NitniCallback]

	# Returns true if callbacks has yet to be generated and register it as being generated
	private fun check_callback_compilation(cb: NitniCallback): Bool
	do
		var compiled = compiled_callbacks.has(cb)
		if not compiled then compiled_callbacks.add(cb)
		return not compiled
	end
end

redef class AMethPropdef
	private fun compile_ffi_support_to_c(v: AbstractCompilerVisitor)
	do
		var mmodule = mpropdef.mclassdef.mmodule
		var mainmodule = v.compiler.mainmodule
		var amodule = v.compiler.modelbuilder.mmodule2node(mmodule)
		var mclass_type = mpropdef.mclassdef.bound_mtype

		# Declare as extern
		var csignature = mpropdef.mproperty.build_csignature(mclass_type, mmodule, "___impl", long_signature, internal_call_context)
		v.declare_once("{csignature};")

		# FFI part
		amodule.ensure_compile_ffi_wrapper
		compile_ffi_method(mmodule)

		# nitni - Compile missing callbacks
		mmodule.ensure_compile_nitni_base(v)
		var ccu = mmodule.nitni_ccu.as(not null)

		for mtype in foreign_callbacks.types do
			if not mtype.is_cprimitive then
				mtype.compile_extern_type(v, ccu)

				# has callbacks already been compiled? (this may very well happen with global compilation)
				mtype.compile_extern_helper_functions(v, ccu, mmodule.check_callback_compilation(mtype))
			end
		end

		# compile callbacks
		for cb in foreign_callbacks.callbacks do
			cb.compile_extern_callback(v, ccu, mainmodule.check_callback_compilation(cb))
		end

		for cb in foreign_callbacks.supers do
			cb.compile_extern_callback(v, ccu, mainmodule.check_callback_compilation(cb))
		end

		for cb in foreign_callbacks.casts do
			cb.compile_extern_callbacks(v, ccu, mainmodule.check_callback_compilation(cb))
		end

		# manage nitni callback set
		mmodule.foreign_callbacks.join(foreign_callbacks)
	end

	redef fun compile_externmeth_to_c(v, mpropdef, arguments)
	do
		# if using the old native interface fallback on previous implementation
		if n_extern_code_block == null then return super

		var mmodule = mpropdef.mclassdef.mmodule
		mmodule.uses_ffi = true

		var mclass_type = mpropdef.mclassdef.bound_mtype

		# Outgoing code in compiler
		var externname = mpropdef.mproperty.build_cname(mpropdef.mclassdef.bound_mtype, mmodule, "___impl", long_signature)
		var recv_var: nullable RuntimeVariable = null
		var return_mtype = mpropdef.msignature.return_mtype
		if return_mtype != null then
			return_mtype = return_mtype.anchor_to(mmodule, mclass_type)
			recv_var = v.new_var(return_mtype)
		end

		v.adapt_signature(mpropdef, arguments)
		v.unbox_signature_extern(mpropdef, arguments)

		var arguments_for_c = new Array[String]
		for a in [0..arguments.length[ do
			var arg = arguments[a]
			var param_mtype: MType
			if a == 0 then
				param_mtype = mpropdef.mclassdef.mclass.mclass_type
			else param_mtype = mpropdef.msignature.mparameters[a-1].mtype

			param_mtype = param_mtype.anchor_to(mmodule, mclass_type)

			if param_mtype.is_cprimitive then
				arguments_for_c.add(arg.name)
			else
				v.add("struct nitni_instance* var_for_c_{a};")
				v.add("var_for_c_{a} = nit_alloc(sizeof(struct nitni_instance));")
				v.add("var_for_c_{a}->value = {arg.name};")
				arguments_for_c.add("var_for_c_{a}")
			end
		end

		if recv_var == null then
			v.add("{externname}({arguments_for_c.join(", ")});")
		else
			assert return_mtype != null
			if return_mtype.is_cprimitive then
				v.add("{recv_var} = {externname}({arguments_for_c.join(", ")});")
			else
				v.add("struct nitni_instance* ret_var;")
				v.add("ret_var = {externname}({arguments_for_c.join(", ")});")
				v.add("{recv_var} = ret_var->value;")
			end
			recv_var = v.box_extern(recv_var, return_mtype)
			v.ret(recv_var)
		end

		compile_ffi_support_to_c(v)
		return true
	end

	redef fun compile_externinit_to_c(v, mpropdef, arguments)
	do
		# if using the old native interface fallback on previous implementation
		if n_extern_code_block == null then return super

		var mmodule = mpropdef.mclassdef.mmodule
		mmodule.uses_ffi = true

		var mclass_type = mpropdef.mclassdef.bound_mtype

		var externname = mpropdef.mproperty.build_cname(mpropdef.mclassdef.bound_mtype, mmodule, "___impl", long_signature)
		var return_mtype = arguments.first.mtype
		var recv_var = v.new_var(return_mtype)

		v.adapt_signature(mpropdef, arguments)
		v.unbox_signature_extern(mpropdef, arguments)

		arguments.shift

		var arguments_for_c = new Array[String]
		for a in [0..arguments.length[ do
			var arg = arguments[a]
			var param_mtype: MType
			param_mtype = mpropdef.msignature.mparameters[a].mtype
			param_mtype = param_mtype.anchor_to(mmodule, mclass_type)

			if param_mtype.is_cprimitive then
				arguments_for_c.add(arg.name)
			else
				v.add("struct nitni_instance* var_for_c_{a};")
				v.add("var_for_c_{a} = nit_alloc(sizeof(struct nitni_instance));")
				v.add("var_for_c_{a}->value = {arg.name};")
				arguments_for_c.add("var_for_c_{a}")
			end
		end

		if return_mtype.is_cprimitive then
			v.add("{recv_var} = {externname}({arguments_for_c.join(", ")});")
		else
			v.add("struct nitni_instance* ret_var;")
			v.add("ret_var = {externname}({arguments_for_c.join(", ")});")
			v.add("{recv_var} = ret_var->value;")
		end
		recv_var = v.box_extern(recv_var, return_mtype)
		v.ret(recv_var)

		compile_ffi_support_to_c(v)
		return true
	end
end

redef class CCompilationUnit
	fun write_as_nitni(mmodule: MModule, compdir: String)
	do
		var base_name = "{mmodule.c_name}._nitni"

		var h_file = "{base_name}.h"
		write_header_to_file( mmodule, "{compdir}/{h_file}", new Array[String],
			"{mmodule.c_name.to_s.to_upper}_NITG_NITNI_H")

		var c_file = "{base_name}.c"
		write_body_to_file( mmodule, "{compdir}/{c_file}", ["\"{h_file}\""] )

		files.add( "{compdir}/{c_file}" )
	end
end

redef class AbstractCompiler
	# Cache to avoid multiple compilation of NULL values
	# see FIXME in `MNullableType#compile_extern_helper_functions`
	private var compiled_null_types = new Array[MNullableType]
end

redef class AbstractCompilerVisitor
	# Create a `RuntimeVariable` for this C variable originating from C user code
	private fun var_from_c(name: String, mtype: MType): RuntimeVariable
	do
		if mtype.is_cprimitive then
			return new RuntimeVariable(name, mtype, mtype)
		else
			return new RuntimeVariable("{name}->value", mtype, mtype)
		end
	end

	# Return a `RuntimeVarible` to C user code
	private fun ret_to_c(src: RuntimeVariable, mtype: MType)
	do
		if mtype.is_cprimitive then
			add("return {src};")
		else
			add("struct nitni_instance* ret_for_c;")
			add("ret_for_c = nit_alloc(sizeof(struct nitni_instance));")
			add("ret_for_c->value = {src};")
			add("return ret_for_c;")
		end
	end
end

redef class MType
	private fun compile_extern_type(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
	do
		assert not is_cprimitive

		# define friendly type
		ccu.header_c_types.add("#ifndef NIT_TYPE_{cname}\n")
		ccu.header_c_types.add("#define NIT_TYPE_{cname} 1\n")
		ccu.header_c_types.add("typedef struct nitni_instance *{cname};\n")
		ccu.header_c_types.add("#endif\n")
	end

	private fun compile_extern_helper_functions(v: AbstractCompilerVisitor, ccu: CCompilationUnit, compile_implementation_too: Bool)
	do
		# actually, we do not need to do anything when using the bohem garbage collector
		var call_context = from_c_call_context

		# incr_ref
		ccu.header_decl.add "#ifndef {mangled_cname}_incr_ref\n"
		ccu.header_decl.add "	#define {mangled_cname}_incr_ref(from) nitni_global_ref_incr(({call_context.name_mtype(self)})(from))\n"
		ccu.header_decl.add "#endif\n"

		# decr_ref
		ccu.header_decl.add "#ifndef {mangled_cname}_decr_ref\n"
		ccu.header_decl.add "	#define {mangled_cname}_decr_ref(from) nitni_global_ref_decr(({call_context.name_mtype(self)})(from))\n"
		ccu.header_decl.add "#endif\n"
	end
end

redef class MNullableType
	redef fun compile_extern_helper_functions(v, ccu, compile_implementation_too)
	do
		super

		var base_cname = "null_{mtype.mangled_cname}"
		var full_cname = "NIT_NULL___{base_cname}"

		# In nitni files, declare internal function as extern
		var full_friendly_csignature = "{cname_blind} {full_cname}()"
		ccu.header_decl.add("extern {full_friendly_csignature};\n")

		# In nitni files, #define friendly as extern
		ccu.header_decl.add("#define {base_cname} {full_cname}\n")

		if not compile_implementation_too then return

		# FIXME: This is ugly an broke the separate compilation principle
		# The real function MUST be compiled only once, #define pragma only protect the compiler, not the loader
		# However, I am not sure of the right approach here (eg. week refs are ugly)
		if v.compiler.compiled_null_types.has(self) then return
		v.compiler.compiled_null_types.add self

		# Internally, implement internal function
		var nitni_visitor = v.compiler.new_visitor
		nitni_visitor.frame = v.frame
		var full_internal_csignature = "{cname_blind} {full_cname}()"
		nitni_visitor.add("{full_internal_csignature} \{")
		nitni_visitor.add("struct nitni_instance* ret_for_c;")
		nitni_visitor.add("ret_for_c = nit_alloc(sizeof(struct nitni_instance));")
		nitni_visitor.add("ret_for_c->value = NULL;")
		nitni_visitor.add("return ret_for_c;")
		nitni_visitor.add("\}")
	end
end

redef class MExplicitCall
	private fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit, compile_implementation_too: Bool)
	do
		var mproperty = mproperty
		assert mproperty isa MMethod

		# In nitni files, declare internal function as extern
		var full_friendly_csignature = mproperty.build_csignature(recv_mtype, v.compiler.mainmodule, null, long_signature, internal_call_context)
		ccu.header_decl.add("extern {full_friendly_csignature};\n")

		if not compile_implementation_too then return

		# Internally, implement internal function
		var nitni_visitor = v.compiler.new_visitor
		nitni_visitor.frame = v.frame
		var msignature = mproperty.lookup_first_definition(v.compiler.mainmodule, recv_mtype).msignature
		var csignature_blind = mproperty.build_csignature(recv_mtype, v.compiler.mainmodule, null, long_signature, internal_call_context)

		nitni_visitor.add_decl("/* nitni callback for {mproperty.full_name} */")
		nitni_visitor.add_decl("{csignature_blind} \{")

		var vars = new Array[RuntimeVariable]
		var mtype: MType = recv_mtype
		var recv_var = null
		if mproperty.is_init then
			var recv_mtype = recv_mtype
			recv_var = nitni_visitor.init_instance(recv_mtype)
			nitni_visitor.add("{mtype.ctype} recv /* var self: {mtype} */;")
			nitni_visitor.add("recv = {recv_var};")
		else
			mtype = mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
			recv_var = nitni_visitor.var_from_c("recv", mtype)
			recv_var = nitni_visitor.box_extern(recv_var, mtype)
		end

		vars.add(recv_var)

		for p in msignature.mparameters do
			var arg_mtype = p.mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
			var arg = nitni_visitor.var_from_c(p.name, arg_mtype)
			arg = nitni_visitor.box_extern(arg, arg_mtype)
			vars.add(arg)
		end

		var ret_var = nitni_visitor.send(mproperty, vars)

		var return_mtype = msignature.return_mtype
		if mproperty.is_init then
			if recv_mtype.mclass.kind != extern_kind then ret_var = recv_var
			return_mtype = recv_mtype
		end
		if return_mtype != null then
			assert ret_var != null
			return_mtype = return_mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
			ret_var = nitni_visitor.autobox(ret_var, return_mtype)
			ret_var = nitni_visitor.unbox_extern(ret_var, return_mtype)
			nitni_visitor.ret_to_c(ret_var, return_mtype)
		end
		nitni_visitor.add("\}")
	end
end

redef class MExplicitSuper
	private fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit, compile_implementation_too: Bool)
	do
		var mproperty = from.mproperty
		assert mproperty isa MMethod
		var mclass_type = from.mclassdef.mclass.mclass_type

		# In nitni files, declare internal function as extern
		var internal_csignature = mproperty.build_csignature(mclass_type, v.compiler.mainmodule, "___super", long_signature, internal_call_context)
		ccu.header_decl.add("extern {internal_csignature};\n")

		# In nitni files, #define friendly as extern
		var friendly_cname = mproperty.build_cname(mclass_type, v.compiler.mainmodule, "___super", short_signature)
		var internal_cname = mproperty.build_cname(mclass_type, v.compiler.mainmodule, "___super", long_signature)
		ccu.header_decl.add("#define {friendly_cname} {internal_cname}\n")

		if not compile_implementation_too then return

		# Internally, implement internal function
		var nitni_visitor = v.compiler.new_visitor
		nitni_visitor.frame = v.frame
		var msignature = mproperty.lookup_first_definition(v.compiler.mainmodule, mclass_type).msignature

		var csignature_blind = mproperty.build_csignature(mclass_type, v.compiler.mainmodule, "___super", long_signature, internal_call_context)

		nitni_visitor.add_decl("/* nitni callback to super for {mproperty.full_name} */")
		nitni_visitor.add_decl("{csignature_blind} \{")

		var vars = new Array[RuntimeVariable]

		var recv_var = nitni_visitor.var_from_c("recv", mclass_type)
		recv_var = nitni_visitor.box_extern(recv_var, mclass_type)
		vars.add(recv_var)

		for p in msignature.mparameters do
			var arg_mtype = v.anchor(p.mtype)
			var arg = nitni_visitor.var_from_c(p.name, arg_mtype)
			arg = nitni_visitor.box_extern(arg, arg_mtype)
			vars.add(arg)
		end

		var ret_var = nitni_visitor.supercall(from.as(MMethodDef), mclass_type, vars)

		var return_mtype = msignature.return_mtype
		if return_mtype != null then
			assert ret_var != null
			return_mtype = v.anchor(return_mtype)
			ret_var = nitni_visitor.autobox(ret_var, return_mtype)
			ret_var = nitni_visitor.unbox_extern(ret_var, return_mtype)
			nitni_visitor.ret_to_c(ret_var, return_mtype)
		end
		nitni_visitor.add("\}")
	end
end

redef class MExplicitCast
	private fun compile_extern_callbacks(v: AbstractCompilerVisitor, ccu: CCompilationUnit, compile_implementation_too: Bool)
	do
		var from = from
		var to = to

		#
		## check type
		#

		# In nitni files, declare internal function as extern
		var full_friendly_csignature = "int {v.compiler.mainmodule.name }___{from.mangled_cname}_is_a_{to.mangled_cname}({from.cname_blind})"
		ccu.header_decl.add("extern {full_friendly_csignature};\n")

		# In nitni files, #define friendly as extern
		ccu.header_decl.add("#define {check_cname} {v.compiler.mainmodule.name}___{check_cname}\n")

		if compile_implementation_too then
			# Internally, implement internal function
			var nitni_visitor = v.compiler.new_visitor
			nitni_visitor.frame = v.frame

			var full_internal_csignature = "int {v.compiler.mainmodule.name }___{from.mangled_cname}_is_a_{to.mangled_cname}({internal_call_context.name_mtype(from)} from)"

			nitni_visitor.add_decl("/* nitni check for {from} to {to} */")
			nitni_visitor.add_decl("{full_internal_csignature} \{")

			var from_var = nitni_visitor.var_from_c("from", from)
			from_var = nitni_visitor.box_extern(from_var, from)
			var recv_var = nitni_visitor.type_test(from_var, to, "FFI isa")
			nitni_visitor.add("return {recv_var};")

			nitni_visitor.add("\}")
		end

		# special checks
		if from == to.as_nullable then
			# format A_is_null
			ccu.header_decl.add("#define {from.mangled_cname}_is_null !{from.mangled_cname}_is_a_{to.mangled_cname}\n")
		end

		#
		## cast
		#

		# In nitni files, declare internal function as extern
		full_friendly_csignature = "{to.cname_blind} {v.compiler.mainmodule.name }___{from.mangled_cname}_as_{to.mangled_cname}({from.cname_blind})"
		ccu.header_decl.add("extern {full_friendly_csignature};\n")

		# In nitni files, #define friendly as extern
		ccu.header_decl.add("#define {cast_cname} {v.compiler.mainmodule.name}___{cast_cname}\n")

		if compile_implementation_too then
			# Internally, implement internal function
			var nitni_visitor = v.compiler.new_visitor
			nitni_visitor.frame = v.frame

			var full_internal_csignature = "{to.cname_blind} {v.compiler.mainmodule.name }___{from.mangled_cname}_as_{to.mangled_cname}({internal_call_context.name_mtype(from)} from)"
			nitni_visitor.add_decl("/* nitni cast for {from} to {to} */")
			nitni_visitor.add_decl("{full_internal_csignature} \{")

			var from_var = nitni_visitor.var_from_c("from", from)
			from_var = nitni_visitor.box_extern(from_var, from)

			## test type
			var check = nitni_visitor.type_test(from_var, to, "FFI cast")
			nitni_visitor.add("if (!{check}) \{")
			nitni_visitor.add_abort("FFI cast failed")
			nitni_visitor.add("\}")

			## internal cast
			var recv_var = nitni_visitor.autobox(from_var, to)
			recv_var = nitni_visitor.unbox_extern(recv_var, to)

			nitni_visitor.ret_to_c(recv_var, to)

			nitni_visitor.add("\}")
		end

		# special casts
		if from.as_nullable == to then
			# format A_as_nullable
			ccu.header_decl.add("#define {from.mangled_cname}_as_nullable {from.mangled_cname}_as_{to.mangled_cname}\n")
		end

		if from == to.as_nullable then
			# format A_as_nullable
			ccu.header_decl.add("#define {to.mangled_cname}_as_not_nullable {from.mangled_cname}_as_{to.mangled_cname}\n")
		end
	end
end