# This file is part of NIT ( http://www.nitlanguage.org ).
#
# 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.

# Deserialize full Nit objects from MessagePack format
#
# See the package `msgpack` for more details on the serialization
# of Nit objects.
module serialization_read

import serialization::caching
import serialization::safe
private import json # for class_inheritance_metamodel
private import serialization::engine_tools

import serialization_common
private import read
import ext

# ---
# Easy services

redef class Bytes

	# Deserialize full Nit `nullable Object` from MessagePack formated data
	#
	# The dynamic type of the deserialized object can be limited to `static_type`.
	#
	# Warning: Deserialization errors are reported with `print_error`,
	# the returned object may be partial or fall back on `null`.
	# To handle the errors programmatically, use a `MsgPackDeserializer`.
	fun deserialize_msgpack(static_type: nullable String): nullable Object
	do
		var stream = new BytesReader(self)
		var res = stream.deserialize_msgpack(static_type)
		stream.close
		return res
	end
end

redef class Reader

	# Deserialize full Nit `nullable Object` from MessagePack formated data
	#
	# This method use metadata in the MessagePack source to recreate full
	# Nit objects serialized by `Writer::serialize_msgpack` or
	# `MsgPackSerializer`.
	#
	# The dynamic type of the deserialized object can be limited to `static_type`.
	#
	# Warning: Deserialization errors are reported with `print_error`,
	# the returned object may be partial or fall back on `null`.
	# To handle the errors programmatically, use a `MsgPackDeserializer`.
	fun deserialize_msgpack(static_type: nullable String): nullable Object
	do
		var deserializer = new MsgPackDeserializer(self)
		var res = deserializer.deserialize(static_type)

		if deserializer.errors.length == 1 then
			print_error deserializer.errors.join("")
		else if deserializer.errors.not_empty then
			print_error "Deserialization Errors:\n* {deserializer.errors.join("\n* ")}"
		end

		return res
	end
end

# ---
# Engine

# Deserialize MessagePack format to full Nit objects
class MsgPackDeserializer
	super CachingDeserializer
	super MsgPackEngine
	super SafeDeserializer

	# Source stream
	var stream: Reader

	# Map of attributes from the root deserialized object to the current object
	private var path = new Array[Map[nullable Serializable, nullable Serializable]]

	# Metadata arrays with from the root deserialized object to the current object
	var path_arrays = new Array[nullable Array[nullable Object]]

	# Names of the attributes from the root to the object currently being deserialized
	var attributes_path = new Array[String]

	# Last encountered object reference id.
	#
	# See `id_to_object`.
	private var just_opened_id: nullable Int = null

	redef fun deserialize_attribute(name, static_type)
	do
		if path.is_empty then
			# The was a parsing error or the root is not an object
			deserialize_attribute_missing = false
			return null
		end

		var current = path.last

		var serialized_value = null
		var serialized_value_found = false
		if current.keys.has(name) then
			# Non-cached string
			serialized_value = current[name]
			serialized_value_found = true
		else
			# It may be cached, deserialize all keys until we find it
			for key in current.keys.to_a do
				if key isa Array[nullable Serializable] or key isa MsgPackExt then
					var str = convert_object(key, "String")
					if str isa String then
						var value = current[key]
						current.keys.remove key
						current[str] = value

						if str == name then
							serialized_value = value
							serialized_value_found = true
							break
						end
					end
				end
			end
		end

		if not serialized_value_found then
			# Let the generated code / caller of `deserialize_attribute` raise the missing attribute error
			deserialize_attribute_missing = true
			return null
		end

		attributes_path.add name
		var res = convert_object(serialized_value, static_type)
		attributes_path.pop

		deserialize_attribute_missing = false
		return res
	end

	# This may be called multiple times by the same object from defs of a same constructor
	redef fun notify_of_creation(new_object)
	do
		var id = just_opened_id
		if id == null then return
		cache[id] = new_object
	end

	# Convert the simple JSON `object` to a Nit object
	private fun convert_object(object: nullable Object, static_type: nullable String): nullable Object
	do
		#print "convert_object {if object != null then object.class_name else "null"}"
		if object isa Array[nullable Object] and object.length >= 1 then
			# Serialized object?
			var first = object.first
			if first isa MsgPackExt then
				if first.typ == ext_typ_obj then
					# An array starts with a *ext*, it must be a serialized object

					# New object declaration
					var id = first.data.to_i

					if cache.has_id(id) then
						# FIXME use Warning
						errors.add new Error("Deserialization Error: object with id {id} is deserialized twice.")
						# Keep going
					end

					var type_name = null
					var i = 1

					# Read dynamic type
					if object.length >= 2 then

						# Try to get the type name as a string
						var o = object[i]
						if o isa String and static_type == "String" and object.length == 2 then
							cache[id] = o
							return o
						else
							var typ = convert_object(object[i], "String")
							if typ isa String then
								type_name = typ
								i += 1
							end
						end
					end

					if type_name == null then
						# There was no dynamic type

						# We could use a `class_name_heuristic` here...

						# Fallback to the static type
						if static_type != null then
							type_name = static_type.strip_nullable
						end

						if type_name == null then
							errors.add new Error("Deserialization Error: could not determine dynamic type of `{object}`.")
							return null
						end
					end

					if not accept(type_name, static_type) then return null

					var attributes = null
					if object.length > i then attributes = object[i]
					if not attributes isa Map[nullable Serializable, nullable Serializable] then
						# Some other type (could be an error), or there's no attributes
						attributes = new Map[nullable Serializable, nullable Serializable]
					end

					# advance on path
					path.push attributes
					path_arrays.push object

					just_opened_id = id
					var value = deserialize_class(type_name)
					just_opened_id = null

					# revert on path
					path.pop
					path_arrays.pop

					return value
				else
					errors.add new Error("Deserialization Error: unknown MessagePack ext '{first.typ}'.")
				end
			end

			# Plain array? Try to convert it to the desired static_type
			if static_type != null then
				return deserialize_class(static_type.strip_nullable)
			end
			return object
		end

		if object isa Map[nullable Serializable, nullable Serializable] then
			# Plain map
			# TODO parse it as an instance of `static_type`

			if static_type != null then
				path.push object
				path_arrays.push null

				just_opened_id = null
				var value = deserialize_class(static_type.strip_nullable)

				path.pop
				path_arrays.pop

				return value
			end

			return object
		end

		if object isa MsgPackExt then

			# First try the custom extensions
			var custom = deserialize_ext(object, static_type)
			if custom == null then

				# No custom, go for deser standard references
				if object.typ == ext_typ_ref then
					# Reference to an object
					var id = object.data.to_i
					if not cache.has_id(id) then
						errors.add new Error("Deserialization Error: object reference id unknown.")
						return object
					end
					return cache.object_for(id)

				else if object.typ == ext_typ_char then
					# Char
					return object.data.to_s.first

				else if object.typ == ext_typ_byte then
					# Byte
					return object.data.first
				end
			end
		end

		if object isa String and object.length == 1 and static_type == "Char" then
			# Char serialized as a string
			return object.chars.first
		end

		if object isa Int and static_type == "Byte" then
			# Byte serialized as an integer
			return object.to_b
		end

		return object
	end

	redef fun deserialize(static_type)
	do
		errors.clear

		var root = stream.read_msgpack
		return convert_object(root, static_type)
	end

	# Hook to customize the deserialization of MessagePack extensions
	#
	# Redefine this method in subclasses to return custom Nit objects from
	# an application specific extension.
	#
	# This method is invoked before dealing with the extensions used by the
	# Nit serialization metadata [0x40..0x43]. In general, you should ignore
	# them by returning `null`, but they can also be intercepted to comply to
	# a format from a remote server.
	protected fun deserialize_ext(ext: MsgPackExt, static_type: nullable String): nullable Object
	do
		return null
	end
end

redef class SimpleCollection[E]
	redef init from_deserializer(v)
	do
		super
		if v isa MsgPackDeserializer then
			v.notify_of_creation self
			init

			var open_array = v.path_arrays.last
			var msgpack_items = null
			if open_array != null then msgpack_items = open_array.last

			if not msgpack_items isa Array[nullable Serializable] then
				v.errors.add new Error("Deserialization Error: no items in source of `{class_name}`")
				return
			end

			# Name of the dynamic name of E
			var items_type_name = (new GetName[E]).to_s

			# Fill array
			for o in msgpack_items do
				var obj = v.convert_object(o, items_type_name)
				if obj isa E then
					add obj
				else v.errors.add new AttributeTypeError(self, "items", obj, items_type_name)
			end
		end
	end
end

redef class Map[K, V]
	redef init from_deserializer(v)
	do
		super

		if v isa MsgPackDeserializer then
			v.notify_of_creation self
			init

			var open_object = v.path_arrays.last
			var msgpack_items
			if open_object != null then
				# Metadata available
				msgpack_items = open_object.last
			else
				msgpack_items = v.path.last
			end

			if not msgpack_items isa Map[nullable Object, nullable Object] then
				v.errors.add new Error("Deserialization Error: no key/values in source of `{class_name}`")
				return
			end

			var keys_type_name = (new GetName[K]).to_s
			var values_type_name = (new GetName[V]).to_s

			for key_src, value_src in msgpack_items do
				var key = v.convert_object(key_src, keys_type_name)
				if not key isa K then
					v.errors.add new AttributeTypeError(self, "keys", key, keys_type_name)
					continue
				end

				var value = v.convert_object(value_src, values_type_name)
				if not value isa V then
					v.errors.add new AttributeTypeError(self, "values", value, values_type_name)
					continue
				end

				self[key] = value
			end
		end
	end
end