/******************************************************************************
 * Copyright (c) 2016-2019 TypeFox and others.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 ******************************************************************************/
package org.eclipse.lsp4j.test.services

import com.google.gson.JsonArray
import com.google.gson.JsonObject
import com.google.gson.internal.LazilyParsedNumber
import java.util.ArrayList
import java.util.Collection
import java.util.HashMap
import java.util.List
import org.eclipse.lsp4j.ClientCapabilities
import org.eclipse.lsp4j.CodeAction
import org.eclipse.lsp4j.CodeActionCapabilities
import org.eclipse.lsp4j.CodeLens
import org.eclipse.lsp4j.CodeLensCapabilities
import org.eclipse.lsp4j.ColorProviderCapabilities
import org.eclipse.lsp4j.Command
import org.eclipse.lsp4j.CompletionCapabilities
import org.eclipse.lsp4j.CompletionItemCapabilities
import org.eclipse.lsp4j.CompletionItemKind
import org.eclipse.lsp4j.CompletionItemKindCapabilities
import org.eclipse.lsp4j.CompletionParams
import org.eclipse.lsp4j.CreateFile
import org.eclipse.lsp4j.CreateFileOptions
import org.eclipse.lsp4j.DefinitionCapabilities
import org.eclipse.lsp4j.DeleteFile
import org.eclipse.lsp4j.Diagnostic
import org.eclipse.lsp4j.DiagnosticSeverity
import org.eclipse.lsp4j.DidChangeTextDocumentParams
import org.eclipse.lsp4j.DocumentFormattingParams
import org.eclipse.lsp4j.DocumentHighlightCapabilities
import org.eclipse.lsp4j.DocumentLinkCapabilities
import org.eclipse.lsp4j.DocumentSymbol
import org.eclipse.lsp4j.DocumentSymbolCapabilities
import org.eclipse.lsp4j.FormattingCapabilities
import org.eclipse.lsp4j.FormattingOptions
import org.eclipse.lsp4j.Hover
import org.eclipse.lsp4j.HoverCapabilities
import org.eclipse.lsp4j.ImplementationCapabilities
import org.eclipse.lsp4j.InitializeParams
import org.eclipse.lsp4j.Location
import org.eclipse.lsp4j.LocationLink
import org.eclipse.lsp4j.MarkedString
import org.eclipse.lsp4j.MarkupContent
import org.eclipse.lsp4j.MarkupKind
import org.eclipse.lsp4j.OnTypeFormattingCapabilities
import org.eclipse.lsp4j.ParameterInformation
import org.eclipse.lsp4j.Position
import org.eclipse.lsp4j.PrepareRenameResult
import org.eclipse.lsp4j.ProgressParams
import org.eclipse.lsp4j.PublishDiagnosticsParams
import org.eclipse.lsp4j.Range
import org.eclipse.lsp4j.RangeFormattingCapabilities
import org.eclipse.lsp4j.ReferencesCapabilities
import org.eclipse.lsp4j.RenameCapabilities
import org.eclipse.lsp4j.RenameFile
import org.eclipse.lsp4j.ResourceOperation
import org.eclipse.lsp4j.SignatureHelp
import org.eclipse.lsp4j.SignatureHelpCapabilities
import org.eclipse.lsp4j.SignatureInformation
import org.eclipse.lsp4j.SignatureInformationCapabilities
import org.eclipse.lsp4j.SymbolInformation
import org.eclipse.lsp4j.SymbolKind
import org.eclipse.lsp4j.SymbolKindCapabilities
import org.eclipse.lsp4j.SynchronizationCapabilities
import org.eclipse.lsp4j.TextDocumentClientCapabilities
import org.eclipse.lsp4j.TextDocumentContentChangeEvent
import org.eclipse.lsp4j.TextDocumentEdit
import org.eclipse.lsp4j.TextDocumentIdentifier
import org.eclipse.lsp4j.TextEdit
import org.eclipse.lsp4j.TypeDefinitionCapabilities
import org.eclipse.lsp4j.VersionedTextDocumentIdentifier
import org.eclipse.lsp4j.WorkDoneProgressCancelParams
import org.eclipse.lsp4j.WorkDoneProgressCreateParams
import org.eclipse.lsp4j.WorkDoneProgressEnd
import org.eclipse.lsp4j.WorkDoneProgressNotification
import org.eclipse.lsp4j.WorkspaceClientCapabilities
import org.eclipse.lsp4j.WorkspaceEdit
import org.eclipse.lsp4j.jsonrpc.json.MessageJsonHandler
import org.eclipse.lsp4j.jsonrpc.messages.Either
import org.eclipse.lsp4j.jsonrpc.messages.Message
import org.eclipse.lsp4j.jsonrpc.messages.MessageIssue
import org.eclipse.lsp4j.jsonrpc.messages.NotificationMessage
import org.eclipse.lsp4j.jsonrpc.messages.RequestMessage
import org.eclipse.lsp4j.jsonrpc.messages.ResponseError
import org.eclipse.lsp4j.jsonrpc.messages.ResponseErrorCode
import org.eclipse.lsp4j.jsonrpc.messages.ResponseMessage
import org.eclipse.lsp4j.jsonrpc.messages.Tuple
import org.eclipse.lsp4j.jsonrpc.services.ServiceEndpoints
import org.eclipse.lsp4j.services.LanguageClient
import org.eclipse.lsp4j.services.LanguageServer
import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
import org.junit.Before
import org.junit.Test

import static org.junit.Assert.*

class JsonParseTest {

	/**
	 * Gson parses numbers with {@link LazilyParsedNumber}, which is not
	 * equals-compatible with {@link Integer}.
	 */
	@FinalFieldsConstructor
	private static class MyInteger extends Number {

		val int value

		override doubleValue() { value }
		override floatValue() { value }
		override intValue() { value }
		override longValue() { value }

		override equals(Object obj) {
			if (obj instanceof Number) {
				return value as double == obj.doubleValue
			}
			return false
		}

		override hashCode() {
			Integer.hashCode(value)
		}

		override toString() {
			Integer.toString(value)
		}

	}

	MessageJsonHandler jsonHandler

	@Before
	def void setup() {
		val methods = ServiceEndpoints.getSupportedMethods(LanguageServer)
		val clientMethods = ServiceEndpoints.getSupportedMethods(LanguageClient)
		val all = new HashMap
		all.putAll(methods)
		all.putAll(clientMethods)
		jsonHandler = new MessageJsonHandler(all)
	}

	private def void assertParse(CharSequence json, Message expected) {
		val actual = jsonHandler.parseMessage(json)
		assertEquals(expected.toString, actual.toString)
		assertEquals(expected, actual)
	}

	@Test
	def void testCompletion() {
		'''
			{
				"jsonrpc": "2.0",
				"id": 1,
				"method": "textDocument/completion",
				"params": {
					"textDocument": {
						"uri": "file:///tmp/foo"
					},
					"position": {
						"line": 4,
						"character": 22
					}
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = 1
			method = MessageMethods.DOC_COMPLETION
			params = new CompletionParams => [
				textDocument = new TextDocumentIdentifier => [
					uri = "file:///tmp/foo"
				]
				position = new Position => [
					line = 4
					character = 22
				]
			]
		])
	}


	@Test
	def void testDidChange() {
		'''
			{
				"jsonrpc": "2.0",
				"method": "textDocument/didChange",
				"params": {
					"textDocument": {
						"uri": "file:///tmp/foo",
						"version": 1234
					},
					"contentChanges": [
						{
							"range": {
								"start": {
									"line": 7,
									"character": 12
								},
								"end": {
									"line": 8,
									"character": 16
								}
							},
							"rangeLength": 20,
							"text": "bar"
						}
					]
				}
			}
		'''.assertParse(new NotificationMessage => [
			jsonrpc = "2.0"
			method = MessageMethods.DID_CHANGE_DOC
			params = new DidChangeTextDocumentParams => [
				textDocument = new VersionedTextDocumentIdentifier => [
					uri = "file:///tmp/foo"
					version = 1234
				]
				contentChanges = new ArrayList => [
					add(new TextDocumentContentChangeEvent => [
						range = new Range => [
							start = new Position(7, 12)
							end = new Position(8, 16)
						]
						rangeLength = 20
						text = "bar"
					])
				]
			]
		])
	}

	@Test
	def void testPublishDiagnostics() {
		'''
			{
				"jsonrpc": "2.0",
				"method": "textDocument/publishDiagnostics",
				"params": {
					"uri": "file:///tmp/foo",
					"diagnostics": [
						{
							"message": "Couldn\u0027t resolve reference to State \u0027bar\u0027.",
							"range": {
								"start": {
									"character": 22,
									"line": 4
								},
								"end": {
									"character": 25,
									"line": 4
								}
							},
							"severity": 1
						}
					],
					version: 1
				}
			}
		'''.assertParse(new NotificationMessage => [
			jsonrpc = "2.0"
			method = MessageMethods.SHOW_DIAGNOSTICS
			params = new PublishDiagnosticsParams => [
				uri = "file:///tmp/foo"
				diagnostics = new ArrayList => [
					add(new Diagnostic => [
						range = new Range => [
							start = new Position(4, 22)
							end = new Position(4, 25)
						]
						severity = DiagnosticSeverity.Error
						message = "Couldn't resolve reference to State 'bar'."
					])
				]
				version = 1
			]
		])
	}

	@Test
	def void testDocumentSymbolResponse1() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_SYMBOL
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": [
					{
						"name" : "foobar",
						"kind" : 9,
						"location" : {
							"uri": "file:/baz.txt",
							"range" : {
								"start": {
									"character": 22,
									"line": 4
								},
								"end": {
									"character": 25,
									"line": 4
								}
							}
						}
					}
				]
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = newArrayList(Either.forLeft(
				new SymbolInformation => [
					name = "foobar"
					kind = SymbolKind.Constructor
					location = new Location => [
						uri = "file:/baz.txt"
						range = new Range => [
							start = new Position(4, 22)
							end = new Position(4, 25)
						]
					]
				]
			))
		])
	}

	@Test
	def void testDocumentSymbolResponse2() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_SYMBOL
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": [
					{
						"name" : "foobar",
						"kind" : 9,
						"range" : {
							"start": {
								"character": 22,
								"line": 4
							},
							"end": {
								"character": 25,
								"line": 4
							}
						},
						"selectionRange": {
							"start": {
								"character": 22,
								"line": 4
							},
							"end": {
								"character": 25,
								"line": 4
							}
						}
					}
				]
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = newArrayList(Either.forRight(
				new DocumentSymbol => [
					name = "foobar"
					kind = SymbolKind.Constructor
					range = new Range => [
						start = new Position(4, 22)
						end = new Position(4, 25)
					]
					selectionRange = new Range => [
						start = new Position(4, 22)
						end = new Position(4, 25)
					]
				]
			))
		])
	}

	@Test
	def void testCodeActionResponse1() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_CODE_ACTION
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": [
					{
						"title": "fixme",
						"command": "fix"
					}
				]
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = newArrayList(Either.forLeft(
				new Command => [
					title = "fixme"
					command = "fix"
				]
			))
		])
	}

	@Test
	def void testCodeActionResponse2() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_CODE_ACTION
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": [
					{
						"title": "fixme",
						"kind": "fix",
						"diagnostics": [],
						"edit": {
							"changes": {
								"file:test1533196529126.lspt": [
									{
										"range": {
											"start": {
												"line": 0,
												"character": 0
											},
											"end": {
												"line": 0,
												"character": 5
											}
										},
										"newText": "fixed"
									}
								]
							}
						}
					}
				]
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = newArrayList(Either.forRight(
				new CodeAction => [
					title = "fixme"
					kind = "fix"
					diagnostics = newArrayList
					edit = new WorkspaceEdit => [
						changes.put("file:test1533196529126.lspt", newArrayList(
							new TextEdit => [
								range = new Range => [
									start = new Position(0, 0)
									end = new Position(0, 5)
								]
								newText = "fixed"
							]
						))
					]
				]
			))
		])
	}

	@Test
	def void testCodeActionResponse3() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_CODE_ACTION
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": [
					{
						"title": "fixme"
					}
				]
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = newArrayList(Either.forRight(
				new CodeAction => [
					title = "fixme"
				]
			))
		])
	}

	@Test
	def void testPrepareRenameResponse1() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_PREPARE_RENAME
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"range": {
						"start": {
							"character": 32,
							"line": 3
						},
						"end": {
							"character": 35,
							"line": 3
						}
					},
					"placeholder": "someVar"
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = Either.forRight(new PrepareRenameResult => [
				range = new Range => [
					start = new Position(3, 32)
					end = new Position(3, 35)
				]
				placeholder = "someVar"
			])
		])
	}

	@Test
	def void testPrepareRenameResponse2() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_PREPARE_RENAME
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"start": {
						"character": 32,
						"line": 3
					},
					"end": {
						"character": 35,
						"line": 3
					}
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result =  Either.forLeft(new Range => [
				start = new Position(3, 32)
				end = new Position(3, 35)
			])
		])
	}

	@Test
	def void testRenameResponse1() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_RENAME
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"changes": {
						"file:///tmp/foo": [
							{
								"range": {
									"start": {
										"character": 32,
										"line": 3
									},
									"end": {
										"character": 35,
										"line": 3
									}
								},
								"newText": "foobar"
							},
							{
								"range": {
									"start": {
										"character": 22,
										"line": 4
									},
									"end": {
										"character": 25,
										"line": 4
									}
								},
								"newText": "foobar"
							}
						]
					}
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = new WorkspaceEdit => [
				changes = new HashMap => [
					put("file:///tmp/foo", newArrayList(
						new TextEdit => [
							range = new Range => [
								start = new Position(3, 32)
								end = new Position(3, 35)
							]
							newText = "foobar"
						],
						new TextEdit => [
							range = new Range => [
								start = new Position(4, 22)
								end = new Position(4, 25)
							]
							newText = "foobar"
						]
					))
				]
			]
		])
	}

	@Test
	def void testRenameResponse3() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_RENAME
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"documentChanges": [
						{
							"kind": "create",
							"uri": "file:/foo.txt",
							"options": {
								"overwrite": true,
								"ignoreIfExists": true
							}
						},
						{
							"kind": "delete",
							"uri": "file:/foo.txt"
						},
						{
							"kind": "rename",
							"oldUri": "file:/foo.txt",
							"newUri": "file:/bar.txt"
						},
						{
							"textDocument": {
								"uri": "file:/baz.txt",
								"version": 17
							},
							"edits": [
								{
									"range": {
										"start": {
											"character": 32,
											"line": 3
										},
										"end": {
											"character": 35,
											"line": 3
										}
									},
									"newText": "asdfqweryxcv"
								}
							]
						}
					]
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = new WorkspaceEdit => [
				documentChanges = newArrayList(
					Either.forRight((new CreateFile => [
						uri = "file:/foo.txt"
						options = new CreateFileOptions => [
							overwrite = true
							ignoreIfExists = true
						]
					]) as ResourceOperation),
					Either.forRight((new DeleteFile => [
						uri = "file:/foo.txt"
					]) as ResourceOperation),
					Either.forRight((new RenameFile => [
						oldUri = "file:/foo.txt"
						newUri = "file:/bar.txt"
					]) as ResourceOperation),
					Either.forLeft(new TextDocumentEdit => [
						textDocument = new VersionedTextDocumentIdentifier("file:/baz.txt", 17)
						edits = newArrayList(
							new TextEdit => [
								range = new Range => [
									start = new Position(3, 32)
									end = new Position(3, 35)
								]
								newText = "asdfqweryxcv"
							]
						)
					])
				)
			]
		])
	}

	@Test
	def void testResponseError() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12':
					'textDocument/rename'
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"error": {
					"code": -32600,
					"message": "Could not parse request."
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			error = new ResponseError => [
				code = ResponseErrorCode.InvalidRequest
				message = "Could not parse request."
			]
		])
	}

	@Test
	def void testTelemetry() {
		'''
			{
				"jsonrpc": "2.0",
				"method": "telemetry/event",
				"params": {
					"foo": 12.3,
					"bar": "qwertz"
				}
			}
		'''.assertParse(new NotificationMessage => [
			jsonrpc = "2.0"
			method = MessageMethods.TELEMETRY_EVENT
			params = newLinkedHashMap('foo' -> 12.3, 'bar' -> 'qwertz')
		])
	}

	@Test
	def void testHoverResponse1() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_HOVER
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"range": {
						"start": {
							"character": 32,
							"line": 3
						},
						"end": {
							"character": 35,
							"line": 3
						}
					},
					"contents": [
						"foo",
						"boo shuby doo"
					]
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = new Hover => [
				range = new Range => [
					start = new Position(3, 32)
					end = new Position(3, 35)
				]
				contents = newArrayList(
					Either.forLeft("foo"),
					Either.forLeft("boo shuby doo")
				)
			]
		])
	}

	@Test
	def void testHoverResponse2() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_HOVER
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"contents": {
						"kind": "plaintext",
						"value": "foo"
					}
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = new Hover => [
				contents = new MarkupContent => [
					kind = "plaintext"
					value = "foo"
				]
			]
		])
	}

	@Test
	def void testHoverResponse3() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_HOVER
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"contents": "foo"
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = new Hover => [
				contents = newArrayList(Either.forLeft("foo"))
			]
		])
	}

	@Test
	def void testHoverResponse4() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_HOVER
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"contents": {
						"language": "plaintext",
						"value": "foo"
					}
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = new Hover => [
				contents = newArrayList(Either.forRight(new MarkedString => [
					language = "plaintext"
					value = "foo"
				]))
			]
		])
	}

	@Test
	def void testCodeLensResponse() {
		val json = '''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"range": {
						"start": {
							"character": 32,
							"line": 3
						},
						"end": {
							"character": 35,
							"line": 3
						}
					},
					"command": {
						"title": "save",
						"command": "saveCommand",
						"arguments": [
							{
								"uri": "file:/foo",
								"version": 5
							}
						]
					},
					"data": [
						42,
						"qwert",
						{
							"key": "value"
						}
					]
				}
			}
		'''
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_CODE_LENS
			}
		]
		val message = jsonHandler.parseMessage(json)
		assertTrue("Expected a ResponseMessage", message instanceof ResponseMessage)
		val response = message as ResponseMessage
		assertTrue("Expected a Collection in result", response.result instanceof Collection<?>)
		val result = response.result as Collection<?>
		assertTrue("Expected a CodeLens in result[0]", result.head instanceof CodeLens)
		val codeLens = result.head as CodeLens
		assertNotNull(codeLens.command)
		val argument = codeLens.command.arguments.head
		assertTrue("Expected a JsonObject in command.arguments[0]", argument instanceof JsonObject)
		assertEquals("file:/foo", (argument as JsonObject).get("uri").asString)
		assertEquals(5, (argument as JsonObject).get("version").asInt)
		assertTrue("Expected a JsonArray in data", codeLens.data instanceof JsonArray)
		val data = codeLens.data as JsonArray
		assertEquals(42, data.get(0).asInt)
		assertEquals("qwert", data.get(1).asString)
		assertTrue("Expected a JsonObject in data[2]", data.get(2) instanceof JsonObject)
		assertEquals("value", (data.get(2) as JsonObject).get("key").asString)
	}

	@Test
	def void testDeclarationResponse() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_DECLARATION
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": [
					{
						"uri": "foo",
						"range": {
							"start": {
								"line": 7,
								"character": 12
							},
							"end": {
								"line": 8,
								"character": 16
							}
						}
					}
				]
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = Either.<List<? extends Location>, List<? extends LocationLink>>forLeft(#[
				new Location('foo', new Range(new Position(7, 12), new Position(8, 16)))
			])
		])

	}

	@Test
	def void testItemInsteadOfListResponse() {
		//test parse direct item without the list
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_DECLARATION
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"uri": "foo",
					"range": {
						"start": {
							"line": 7,
							"character": 12
						},
						"end": {
							"line": 8,
							"character": 16
						}
					}
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = Either.<List<? extends Location>, List<? extends LocationLink>>forLeft(#[
				new Location('foo', new Range(new Position(7, 12), new Position(8, 16)))
			])
		])
	}

	@Test
	def void testDefinitionResponse1() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_DEFINITION
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": [
					{
						"targetUri": "foo",
						"targetRange": {
							"start": {
								"line": 7,
								"character": 12
							},
							"end": {
								"line": 8,
								"character": 16
							}
						}
					}
				]
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = Either.<List<? extends Location>, List<? extends LocationLink>>forRight(#[
				new LocationLink => [
					targetUri = 'foo'
					targetRange = new Range(new Position(7, 12), new Position(8, 16))
				]
			])
		])
	}

	@Test
	def void testDefinitionResponse2() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_DEFINITION
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": []
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = Either.<List<? extends Location>, List<? extends LocationLink>>forLeft(emptyList)
		])
	}

	@Test
	def void testTypeDefinitionResponse() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_TYPE_DEFINITION
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": [
					{
						"uri": "foo",
						"range": {
							"start": {
								"line": 7,
								"character": 12
							},
							"end": {
								"line": 8,
								"character": 16
							}
						}
					}
				]
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = Either.<List<? extends Location>, List<? extends LocationLink>>forLeft(#[
				new Location('foo', new Range(new Position(7, 12), new Position(8, 16)))
			])
		])
	}

	@Test
	def void testImplementationResponse() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_IMPLEMENTATION
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": [
					{
						"targetUri": "foo",
						"targetRange": {
							"start": {
								"line": 7,
								"character": 12
							},
							"end": {
								"line": 8,
								"character": 16
							}
						}
					}
				]
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = Either.<List<? extends Location>, List<? extends LocationLink>>forRight(#[
				new LocationLink => [
					targetUri = 'foo'
					targetRange = new Range(new Position(7, 12), new Position(8, 16))
				]
			])
		])
	}

	@Test
	def void testSignatureHelpResponse() {
		jsonHandler.methodProvider = [ id |
			switch id {
				case '12': MessageMethods.DOC_SIGNATURE_HELP
			}
		]
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"result": {
					"signatures": [
						{
							"label": "Foo",
							"parameters": [
								{
									"label": "label1"
								},
								{
									"label": [12, 25]
								}
							]
						}
					]
				}
			}
		'''.assertParse(new ResponseMessage => [
			jsonrpc = "2.0"
			id = "12"
			result = new SignatureHelp => [
				signatures = #[
					new SignatureInformation => [
						label = "Foo"
						parameters = #[
							new ParameterInformation => [
								label = Either.forLeft("label1")
							],
							new ParameterInformation => [
								label = Either.forRight(Tuple.two(12, 25))
							]
						]
					]
				]
			]
		])
	}

	@Test
	def void testDocumentFormatting() {
		'''
			{
				"jsonrpc": "2.0",
				"id": "12",
				"method": "textDocument/formatting",
				"params": {
					"textDocument": {
						"uri": "file:///tmp/foo"
					},
					"options": {
						"insertSpaces": false,
						"tabSize": 4,
						"customProperty": -7
					}
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = "12"
			method = MessageMethods.DOC_FORMATTING
			params = new DocumentFormattingParams => [
				textDocument = new TextDocumentIdentifier("file:///tmp/foo")
				options = new FormattingOptions => [
					insertSpaces = false
					putNumber('tabSize', new MyInteger(4))
					putNumber('customProperty', new MyInteger(-7))
				]
			]
		])
	}

	@Test
	def void testMessageIssue() {
		val issue = jsonHandler.gson.fromJson('''
			{
				"text": "Howdy!",
				"code": 1234,
				"cause": {
					"message": "Foo",
					"cause": {
						"message": "Bar"
					}
				}
			}
		''', MessageIssue)
		assertEquals('Howdy!', issue.text)
		assertEquals(1234, issue.issueCode)
		assertEquals('Foo', issue.cause.message)
		assertEquals('Bar', issue.cause.cause.message)
	}

	@Test
	def void testInitialize() {
		'''
			{
				"jsonrpc": "2.0",
				"id": "1",
				"method": "initialize",
				"params": {
					"rootUri": "file:///tmp/foo"
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = "1"
			method = MessageMethods.INITIALIZE
			params = new InitializeParams => [
				rootUri = "file:///tmp/foo"
			]
		])
	}

	@Test
	def void testInitializeClientCapabilities() {
		'''
			{
				"jsonrpc": "2.0",
				"id": "1",
				"method": "initialize",
				"params": {
					"rootUri": "file:///tmp/foo",
					"capabilities": {
						"textDocument": {
							"synchronization": {
								"dynamicRegistration": false,
								"willSave": true,
								"willSaveWaitUntil": false,
								"didSave": true
							},
							"completion": {
								"dynamicRegistration": false,
								"completionItem": {
									"snippetSupport": true,
									"commitCharactersSupport": true,
									"documentationFormat": ["plaintext", "markdown"]
								},
								"completionItemKind": {
									"valueSet": [2, 3]
								},
								"contextSupport": false
							},
							"hover": {
								"dynamicRegistration": false,
								"contentFormat": ["plaintext", "markdown"]
							},
							"signatureHelp": {
								"dynamicRegistration": false,
								"signatureInformation": {
									"documentationFormat": ["plaintext", "markdown"]
								}
							},
							"references": {
								"dynamicRegistration": false
							},
							"documentHighlight": {
								"dynamicRegistration": false
							},
							"documentSymbol": {
								"dynamicRegistration": false,
								"symbolKind": {
									valueSet: [2, 3, 4, 5]
								}
							},
							"formatting": {
								"dynamicRegistration": false
							},
							"rangeFormatting": {
								"dynamicRegistration": false
							},
							"onTypeFormatting": {
								"dynamicRegistration": false
							},
							"definition": {
								"dynamicRegistration": false
							},
							"typeDefinition": {
								"dynamicRegistration": false
							},
							"implementation": {
								"dynamicRegistration": false
							},
							"codeAction": {
								"dynamicRegistration": false
							},
							"codeLens": {
								"dynamicRegistration": false
							},
							"documentLink": {
								"dynamicRegistration": false
							},
							"colorProvider": {
								"dynamicRegistration": false
							},
							"rename": {
								"dynamicRegistration": false
							}
						},
						"workspace": {}
					}
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = "1"
			method = MessageMethods.INITIALIZE
			params = new InitializeParams => [
				rootUri = "file:///tmp/foo"
				capabilities = new ClientCapabilities => [
					textDocument = new TextDocumentClientCapabilities => [
						synchronization = new SynchronizationCapabilities => [
							dynamicRegistration = false
							willSave= true
							willSaveWaitUntil= false
							didSave = true
						]
						completion = new CompletionCapabilities => [
							dynamicRegistration = false
							completionItem = new CompletionItemCapabilities => [
								snippetSupport = true
								commitCharactersSupport = true
								documentationFormat = #[MarkupKind.PLAINTEXT, MarkupKind.MARKDOWN]
							]
							completionItemKind = new CompletionItemKindCapabilities => [
								valueSet = #[CompletionItemKind.Method, CompletionItemKind.Function]
							]
							contextSupport = false
						]
						hover = new HoverCapabilities => [
							dynamicRegistration = false
							contentFormat = #[MarkupKind.PLAINTEXT, MarkupKind.MARKDOWN]
						]
						signatureHelp = new SignatureHelpCapabilities => [
							dynamicRegistration = false
							signatureInformation = new SignatureInformationCapabilities => [
								documentationFormat = #[MarkupKind.PLAINTEXT, MarkupKind.MARKDOWN]
							]
						]
						references = new ReferencesCapabilities => [
							dynamicRegistration = false
						]
						documentHighlight = new DocumentHighlightCapabilities => [
							dynamicRegistration = false
						]
						documentSymbol = new DocumentSymbolCapabilities => [
							dynamicRegistration = false
							symbolKind = new SymbolKindCapabilities => [
								valueSet = #[SymbolKind.Module, SymbolKind.Namespace, SymbolKind.Package, SymbolKind.Class]
							]
						]
						formatting = new FormattingCapabilities => [
							dynamicRegistration = false
						]
						rangeFormatting = new RangeFormattingCapabilities => [
							dynamicRegistration = false
						]
						onTypeFormatting = new OnTypeFormattingCapabilities => [
							dynamicRegistration = false
						]
						definition= new DefinitionCapabilities => [
							dynamicRegistration = false
						]
						typeDefinition= new TypeDefinitionCapabilities => [
							dynamicRegistration = false
						]
						implementation= new ImplementationCapabilities => [
							dynamicRegistration = false
						]
						codeAction = new CodeActionCapabilities => [
							dynamicRegistration = false
						]
						codeLens= new CodeLensCapabilities => [
							dynamicRegistration = false
						]
						documentLink= new DocumentLinkCapabilities => [
							dynamicRegistration = false
						]
						colorProvider = new ColorProviderCapabilities => [
							dynamicRegistration = false
						]
						rename = new RenameCapabilities => [
							dynamicRegistration = false
						]
					]
					workspace = new WorkspaceClientCapabilities
				]
			]
		])
	}


	@Test
	def void testProgressCreate() {
		'''
			{
				"jsonrpc": "2.0",
				"id": 1,
				"method": "window/workDoneProgress/create",
				"params": {
					"token": "progress-token"
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = 1
			method = MessageMethods.PROGRESS_CREATE
			params = new WorkDoneProgressCreateParams => [
				token = Either.forLeft("progress-token")
			]
		])

		'''
			{
				"jsonrpc": "2.0",
				"id": 1,
				"method": "window/workDoneProgress/create",
				"params": {
					"token": 1234
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = 1
			method = MessageMethods.PROGRESS_CREATE
			params = new WorkDoneProgressCreateParams => [
				token = Either.forRight(1234)
			]
		])
	}

	@Test
	def void testProgressCancel() {
		'''
			{
				"jsonrpc": "2.0",
				"id": 1,
				"method": "window/workDoneProgress/cancel",
				"params": {
					"token": "progress-token"
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = 1
			method = MessageMethods.PROGRESS_CANCEL
			params = new WorkDoneProgressCancelParams => [
				token = Either.forLeft("progress-token")
			]
		])

		'''
			{
				"jsonrpc": "2.0",
				"id": 1,
				"method": "window/workDoneProgress/cancel",
				"params": {
					"token": 1234
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = 1
			method = MessageMethods.PROGRESS_CANCEL
			params = new WorkDoneProgressCancelParams => [
				token = Either.forRight(1234)
			]
		])
	}

	@Test
	def void testProgressNotify() {
		'''
			{
				"jsonrpc": "2.0",
				"id": 1,
				"method": "$/progress",
				"params": {
					"token": "progress-token",
					"value": {
						"kind": "end",
						"message": "message"
					}
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = 1
			method = MessageMethods.PROGRESS_NOTIFY
			params = new ProgressParams => [
				token = Either.forLeft("progress-token")
				value = Either.<WorkDoneProgressNotification, Object>forLeft(new WorkDoneProgressEnd => [
					message = "message"
				])
			]
		])

		'''
			{
				"jsonrpc": "2.0",
				"id": 1,
				"method": "$/progress",
				"params": {
					"token": 1234,
					"value": {
						"foo": "bar"
					}
				}
			}
		'''.assertParse(new RequestMessage => [
			jsonrpc = "2.0"
			id = 1
			method = MessageMethods.PROGRESS_NOTIFY
			params = new ProgressParams => [
				token = Either.forRight(1234)
				value = Either.<WorkDoneProgressNotification, Object>forRight(new JsonObject => [
					addProperty("foo", "bar")
				])
			]
		])
	}
}