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

# Handles serialization and deserialization of objects to/from JSON
#
# ## Writing JSON with metadata
#
# `JsonSerializer` write Nit objects that subclass `Serializable` to JSON,
# and `JsonDeserializer` can read them. They both use metadata added to the
# generated JSON to recreate the Nit instances with the exact original type.
#
# For more information on Nit serialization, see: ../serialization/README.md
#
# ## Writing plain JSON
#
# The attribute `JsonSerializer::plain_json` triggers generating plain and
# clean JSON. This format is easier to read for an human and a non-Nit program,
# but it cannot be fully deserialized. It can still be read by services from
# `json::static` and `json::dynamic`.
#
# A shortcut to these writing services is provided by `Serializable::serialize_to_json`.
#
# ### Usage Example
#
# ~~~nitish
# import json::serialization
#
# class Person
#     serialize
#
#     var name: String
#     var year_of_birth: Int
#     var next_of_kin: nullable Person
# end
#
# var bob = new Person("Bob", 1986)
# var alice = new Person("Alice", 1978, bob)
#
# assert bob.serialize_to_json(pretty=true, plain=true) == """
#{
#	"name": "Bob",
#	"year_of_birth": 1986,
#	"next_of_kin": null
#}"""
#
# assert alice.serialize_to_json(pretty=true, plain=true) == """
#{
#	"name": "Alice",
#	"year_of_birth": 1978,
#	"next_of_kin": {
#		"name": "Bob",
#		"year_of_birth": 1986,
#		"next_of_kin": null
#	}
#}"""
# ~~~
#
# ## JSON to Nit objects
#
# The `JsonDeserializer` support reading JSON code with minimal metadata
# to easily create Nit object from client-side code or configuration files.
# Each JSON object must define the `__class` attribute with the corresponding
# Nit class and the expected attributes with its name in Nit followed by its value.
#
# ### Usage Example
#
# ~~~nitish
# import json::serialization
#
# class MeetupConfig
#     serialize
#
#     var description: String
#     var max_participants: nullable Int
#     var answers: Array[FlatString]
# end
#
# var json_code = """
# {"__class": "MeetupConfig", "description": "My Awesome Meetup", "max_participants": null, "answers": ["Pepperoni", "Chicken"]}"""
# var deserializer = new JsonDeserializer(json_code)
#
# var meet = deserializer.deserialize
#
# # Check for errors
# assert deserializer.errors.is_empty
#
# assert meet isa MeetupConfig
# assert meet.description == "My Awesome Meetup"
# assert meet.max_participants == null
# assert meet.answers == ["Pepperoni", "Chicken"]
# ~~~
module serialization

import ::serialization::caching
private import ::serialization::engine_tools
private import static
private import string_parser

# Serializer of Nit objects to Json string.
class JsonSerializer
	super CachingSerializer

	# Target writing stream
	var stream: Writer

	# Write plain JSON? Standard JSON without metadata for deserialization
	#
	# If `false`, the default, serialize to support deserialization:
	#
	# * Write metadata, including the types of the serialized objects so they can
	#   be deserialized to their original form using `JsonDeserializer`.
	# * Use references when an object has already been serialized so to not duplicate it.
	# * Support cycles in references.
	# * Preserve the Nit `Char` type as an object because it does not exist in JSON.
	# * The generated JSON is standard and can be read by non-Nit programs.
	#   However, some Nit types are not represented by the simplest possible JSON representation.
	#   With the added metadata, it can be complex to read.
	#
	# If `true`, serialize for other programs:
	#
	# * Nit objects are serialized to pure and standard JSON so they can
	#   be easily read by non-Nit programs and humans.
	# * Nit objects are serialized for every references, so they can be duplicated.
	#   It is easier to read but it creates a larger output.
	# * Does not support cycles, will replace the problematic references by `null`.
	# * Does not serialize the metadata needed to deserialize the objects
	#   back to regular Nit objects.
	# * Keys of Nit `HashMap` are converted to their string representation using `to_s`.
	var plain_json = false is writable

	# Write pretty JSON for human eyes?
	#
	# Toggles skipping lines between attributes of an object and
	# properly indent the written JSON.
	var pretty_json = false is writable

	# Current indentation level used for writing `pretty_json`
	private var indent_level = 0

	# List of the current open objects, the first is the main target of the serialization
	#
	# Used only when `plain_json == true` to detect cycles in serialization.
	private var open_objects = new Array[Object]

	# Has the first attribute of the current object already been serialized?
	#
	# Used only when `plain_json == true`.
	private var first_attribute = false

	redef fun serialize(object)
	do
		if object == null then
			stream.write "null"
		else
			if plain_json then
				for o in open_objects do
					if object.is_same_serialized(o) then
						# Cycle, can't be managed in plain json
						warn "Cycle detected in serialized object, replacing reference with 'null'."
						stream.write "null"
						return
					end
				end

				open_objects.add object
			end

			first_attribute = true
			object.accept_json_serializer self
			first_attribute = false

			if plain_json then open_objects.pop
		end
	end

	redef fun serialize_attribute(name, value)
	do
		if not plain_json or not first_attribute then
			stream.write ","
			first_attribute = false
		end

		new_line_and_indent
		stream.write "\""
		stream.write name
		stream.write "\": "
		super
	end

	redef fun serialize_reference(object)
	do
		if not plain_json and cache.has_object(object) then
			# if already serialized, add local reference
			var id = cache.id_for(object)
			stream.write "\{"
			indent_level += 1
			new_line_and_indent
			stream.write "\"__kind\": \"ref\", \"__id\": "
			stream.write id.to_s
			indent_level -= 1
			new_line_and_indent
			stream.write "\}"
		else
			# serialize here
			serialize object
		end
	end

	# Write a new line and indent it, only if `pretty_json`
	private fun new_line_and_indent
	do
		if pretty_json then
			stream.write "\n"
			for i in indent_level.times do stream.write "\t"
		end
	end
end

# Deserializer from a Json string.
class JsonDeserializer
	super CachingDeserializer

	# Json text to deserialize from.
	private var text: Text

	# Root json object parsed from input text.
	private var root: nullable Object is noinit

	# Depth-first path in the serialized object tree.
	private var path = new Array[Map[String, nullable Object]]

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

	init do
		var root = text.parse_json
		if root isa Map[String, nullable Object] then path.add(root)
		self.root = root
	end

	redef fun deserialize_attribute(name)
	do
		assert not path.is_empty # This is an internal error, abort
		var current = path.last

		if not current.keys.has(name) then
			errors.add new Error("Deserialization Error: JSON object has not attribute '{name}'.")
			return null
		end

		var value = current[name]

		return convert_object(value)
	end

	# This may be called multiple times by the same object from constructors
	# in different nclassdef
	redef fun notify_of_creation(new_object)
	do
		var id = just_opened_id
		if id == null then return # Register `new_object` only once
		cache[id] = new_object
	end

	# Convert from simple Json object to Nit object
	private fun convert_object(object: nullable Object): nullable Object
	do
		if object isa JsonParseError then
			errors.add object
			return null
		end

		if object isa Map[String, nullable Object] then
			var kind = null
			if object.keys.has("__kind") then
				kind = object["__kind"]
			end

			# ref?
			if kind == "ref" then
				if not object.keys.has("__id") then
					errors.add new Error("Serialization Error: JSON object reference does not declare a `__id`.")
					return object
				end

				var id = object["__id"]
				if not id isa Int then
					errors.add new Error("Serialization Error: JSON object reference declares a non-integer `__id`.")
					return object
				end

				if not cache.has_id(id) then
					errors.add new Error("Serialization Error: JSON object reference has an unknown `__id`.")
					return object
				end

				return cache.object_for(id)
			end

			# obj?
			if kind == "obj" or kind == null then
				var id = null
				if object.keys.has("__id") then
					id = object["__id"]

					if not id isa Int then
						errors.add new Error("Serialization Error: JSON object declaration declares a non-integer `__id`.")
						return object
					end

					if cache.has_id(id) then
						errors.add new Error("Serialization Error: JSON object with `__id` {id} is deserialized twice.")
						# Keep going
					end
				end

				var class_name = object.get_or_null("__class")
				if class_name == null then
					# Fallback to custom heuristic
					class_name = class_name_heuristic(object)
				end

				if class_name == null then
					errors.add new Error("Serialization Error: JSON object declaration does not declare a `__class`.")
					return object
				end

				if not class_name isa String then
					errors.add new Error("Serialization Error: JSON object declaration declares a non-string `__class`.")
					return object
				end

				# advance on path
				path.push object

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

				# revert on path
				path.pop

				return value
			end

			# char?
			if kind == "char" then
				if not object.keys.has("__val") then
					errors.add new Error("Serialization Error: JSON `char` object does not declare a `__val`.")
					return object
				end

				var val = object["__val"]

				if not val isa String or val.is_empty then
					errors.add new Error("Serialization Error: JSON `char` object does not declare a single char in `__val`.")
					return object
				end

				return val.chars.first
			end

			errors.add new Error("Serialization Error: JSON object has an unknown `__kind`.")
			return object
		end

		# Simple JSON array without serialization metadata
		if object isa Array[nullable Object] then
			var array = new Array[nullable Object]
			var types = new HashSet[String]
			var has_nullable = false
			for e in object do
				var res = convert_object(e)
				array.add res

				if res != null then
					types.add res.class_name
				else has_nullable = true
			end

			if types.length == 1 then
				var array_type = types.first

				var typed_array
				if array_type == "ASCIIFlatString" or array_type == "UnicodeFlatString" then
					if has_nullable then
						typed_array = new Array[nullable FlatString]
					else typed_array = new Array[FlatString]
				else if array_type == "Int" then
					if has_nullable then
						typed_array = new Array[nullable Int]
					else typed_array = new Array[Int]
				else if array_type == "Float" then
					if has_nullable then
						typed_array = new Array[nullable Float]
					else typed_array = new Array[Float]
				else
					# TODO support all array types when we separate the constructor
					# `from_deserializer` from the filling of the items.

					if not has_nullable then
						typed_array = new Array[Object]
					else
						# Unsupported array type, return as `Array[nullable Object]`
						return array
					end
				end

				assert typed_array isa Array[nullable Object]

				# Copy item to the new array
				for e in array do typed_array.add e
				return typed_array
			end

			# Uninferable type, return as `Array[nullable Object]`
			return array
		end

		return object
	end

	redef fun deserialize
	do
		errors.clear
		return convert_object(root)
	end

	# User customizable heuristic to get the name of the Nit class to deserialize `json_object`
	#
	# This method is called only when deserializing an object without the metadata `__class`.
	# Return the class name as a `String` when it can be inferred.
	# Return `null` when the class name cannot be found.
	#
	# If a valid class name is returned, `json_object` will then be deserialized normally.
	# So it must contain the attributes of the corresponding class, as usual.
	#
	# ~~~nitish
	# class MyData
	#     serialize
	#
	#     var data: String
	# end
	#
	# class MyError
	#     serialize
	#
	#     var error: String
	# end
	#
	# class MyJsonDeserializer
	#     super JsonDeserializer
	#
	#     redef fun class_name_heuristic(json_object)
	#     do
	#         if json_object.keys.has("error") then return "MyError"
	#         if json_object.keys.has("data") then return "MyData"
	#         return null
	#     end
	# end
	#
	# var json = """{"data": "some other data"}"""
	# var deserializer = new MyJsonDeserializer(json)
	# var deserialized = deserializer.deserialize
	# assert deserialized isa MyData
	#
	# json = """{"error": "some error message"}"""
	# deserializer = new MyJsonDeserializer(json)
	# deserialized = deserializer.deserialize
	# assert deserialized isa MyError
	# ~~~
	protected fun class_name_heuristic(json_object: Map[String, nullable Object]): nullable String
	do
		return null
	end
end

redef class Text

	# Deserialize a `nullable Object` from this JSON formatted string
	#
	# Warning: Deserialization errors are reported with `print_error` and
	# may be returned as a partial object or as `null`.
	#
	# This method is not appropriate when errors need to be handled programmatically,
	# manually use a `JsonDeserializer` in such cases.
	fun from_json_string: nullable Object
	do
		var deserializer = new JsonDeserializer(self)
		var res = deserializer.deserialize
		if deserializer.errors.not_empty then
			print_error "Deserialization Errors: {deserializer.errors.join(", ")}"
		end
		return res
	end

	redef fun accept_json_serializer(v) do v.stream.write(to_json)
end

redef class Serializable

	# Serialize `self` to JSON
	#
	# Set `plain = true` to generate standard JSON, without deserialization metadata.
	# Use this option if the generated JSON will be read by other programs or humans.
	# Use the default, `plain = false`, if the JSON is to be deserialized by a Nit program.
	#
	# Set `pretty = true` to generate pretty JSON for human eyes.
	# Use the default, `pretty = false`, to generate minified JSON.
	#
	# This method should not be refined by subclasses,
	# instead `accept_json_serializer` can customize the serialization of an object.
	#
	# See: `JsonSerializer`
	fun serialize_to_json(plain, pretty: nullable Bool): String
	do
		var stream = new StringWriter
		var serializer = new JsonSerializer(stream)
		serializer.plain_json = plain or else false
		serializer.pretty_json = pretty or else false
		serializer.serialize self
		stream.close
		return stream.to_s
	end

	# Refinable service to customize the serialization of this class to JSON
	#
	# This method can be refined to customize the serialization by either
	# writing pure JSON directly on the stream `v.stream` or
	# by using other services of `JsonSerializer`.
	#
	# Most of the time, it is preferable to refine the method `core_serialize_to`
	# which is used by all the serialization engines, not just JSON.
	protected fun accept_json_serializer(v: JsonSerializer)
	do
		var id = v.cache.new_id_for(self)
		v.stream.write "\{"
		v.indent_level += 1
		if not v.plain_json then
			v.new_line_and_indent
			v.stream.write "\"__kind\": \"obj\", \"__id\": "
			v.stream.write id.to_s
			v.stream.write ", \"__class\": \""
			v.stream.write class_name
			v.stream.write "\""
		end
		core_serialize_to(v)

		v.indent_level -= 1
		v.new_line_and_indent
		v.stream.write "\}"
	end
end

redef class Int
	redef fun accept_json_serializer(v) do v.stream.write to_s
end

redef class Float
	redef fun accept_json_serializer(v) do v.stream.write to_s
end

redef class Bool
	redef fun accept_json_serializer(v) do v.stream.write to_s
end

redef class Char
	redef fun accept_json_serializer(v)
	do
		if v.plain_json then
			to_s.accept_json_serializer v
		else
			v.stream.write "\{\"__kind\": \"char\", \"__val\": "
			to_s.accept_json_serializer v
			v.stream.write "\}"
		end
	end
end

redef class NativeString
	redef fun accept_json_serializer(v) do to_s.accept_json_serializer(v)
end

redef class Collection[E]
	# Utility to serialize a normal Json array
	private fun serialize_to_pure_json(v: JsonSerializer)
	do
			v.stream.write "["
			v.indent_level += 1
			var is_first = true
			for e in self do
				if is_first then
					is_first = false
				else v.stream.write ","
				v.new_line_and_indent

				if not v.try_to_serialize(e) then
					assert e != null # null would have been serialized
					v.warn("element of type {e.class_name} is not serializable.")
				end
			end
			v.indent_level -= 1
			v.new_line_and_indent
			v.stream.write "]"
	end
end

redef class SimpleCollection[E]
	redef fun accept_json_serializer(v)
	do
		# Register as pseudo object
		if not v.plain_json then
			var id = v.cache.new_id_for(self)
			v.stream.write """{"""
			v.indent_level += 1
			v.new_line_and_indent
			v.stream.write """"__kind": "obj", "__id": """
			v.stream.write id.to_s
			v.stream.write """, "__class": """"
			v.stream.write class_name
			v.stream.write """","""
			v.new_line_and_indent
			v.stream.write """"__items": """
		end

		serialize_to_pure_json v

		if not v.plain_json then
			v.indent_level -= 1
			v.new_line_and_indent
			v.stream.write "\}"
		end
	end

	redef init from_deserializer(v)
	do
		super
		if v isa JsonDeserializer then
			v.notify_of_creation self
			init

			var arr = v.path.last["__items"].as(SequenceRead[nullable Object])
			for o in arr do
				var obj = v.convert_object(o)
				self.add obj
			end
		end
	end
end

redef class Map[K, V]
	redef fun accept_json_serializer(v)
	do
		# Register as pseudo object
		var id = v.cache.new_id_for(self)

		if v.plain_json then
			v.stream.write "\{"
			v.indent_level += 1
			var first = true
			for key, val in self do
				if not first then
					v.stream.write ","
				else first = false
				v.new_line_and_indent

				var k = key or else "null"
				k.to_s.accept_json_serializer v
				v.stream.write ": "
				if not v.try_to_serialize(val) then
					assert val != null # null would have been serialized
					v.warn("element of type {val.class_name} is not serializable.")
					v.stream.write "null"
				end
			end
			v.indent_level -= 1
			v.new_line_and_indent
			v.stream.write "\}"
		else
			v.stream.write "\{"
			v.indent_level += 1
			v.new_line_and_indent
			v.stream.write """"__kind": "obj", "__id": """
			v.stream.write id.to_s
			v.stream.write """, "__class": """"
			v.stream.write class_name
			v.stream.write """", "__length": """
			v.stream.write length.to_s

			v.stream.write ","
			v.new_line_and_indent
			v.stream.write """"__keys": """
			keys.serialize_to_pure_json v

			v.stream.write ","
			v.new_line_and_indent
			v.stream.write """"__values": """
			values.serialize_to_pure_json v

			v.indent_level -= 1
			v.new_line_and_indent
			v.stream.write "\}"
		end
	end

	redef init from_deserializer(v)
	do
		super

		if v isa JsonDeserializer then
			v.notify_of_creation self
			init

			var length = v.deserialize_attribute("__length").as(Int)
			var keys = v.path.last["__keys"].as(SequenceRead[nullable Object])
			var values = v.path.last["__values"].as(SequenceRead[nullable Object])
			for i in length.times do
				var key = v.convert_object(keys[i])
				var value = v.convert_object(values[i])
				self[key] = value
			end
		end
	end
end