#include "LibLsp/lsp/method

#pragma once
#include "LibLsp/lsp/method_type.h"

#include <stdexcept>
#include "LibLsp/JsonRpc/message.h"
#include "LibLsp/lsp/lsDocumentUri.h"
#include "LibLsp/lsp/lsAny.h"
#include "InitializeParams.h"
#include "LibLsp/lsp/textDocument/SemanticTokens.h"

extern void Reflect(Reader&, std::pair<optional<lsTextDocumentSyncKind>, optional<lsTextDocumentSyncOptions>>&);

//
// Code Action options.
//
struct CodeActionOptions : WorkDoneProgressOptions
{
//
// CodeActionKinds that this server may return.
//
// The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server
// may list out every specific kind they provide.
//
typedef std::string CodeActionKind;
std::vector<CodeActionKind> codeActionKinds;

MAKE_SWAP_METHOD(CodeActionOptions, workDoneProgress, codeActionKinds);
};
MAKE_REFLECT_STRUCT(CodeActionOptions, workDoneProgress, codeActionKinds)
struct CodeLensOptions : WorkDoneProgressOptions
{
//
// Code lens has a resolve provider as well.
//
optional<bool> resolveProvider;
MAKE_SWAP_METHOD(CodeLensOptions, workDoneProgress, resolveProvider);
};
MAKE_REFLECT_STRUCT(CodeLensOptions, workDoneProgress, resolveProvider)

// Format document on type options
struct lsDocumentOnTypeFormattingOptions : WorkDoneProgressOptions
{
// A character on which formatting should be triggered, like `}`.
std::string firstTriggerCharacter;

// More trigger characters.
std::vector<std::string> moreTriggerCharacter;
MAKE_SWAP_METHOD(lsDocumentOnTypeFormattingOptions, workDoneProgress, firstTriggerCharacter, moreTriggerCharacter);
};
MAKE_REFLECT_STRUCT(lsDocumentOnTypeFormattingOptions, workDoneProgress, firstTriggerCharacter, moreTriggerCharacter);
struct RenameOptions : WorkDoneProgressOptions
{
//
// Renames should be checked and tested before being executed.
//
optional<bool> prepareProvider;
MAKE_SWAP_METHOD(RenameOptions, workDoneProgress, prepareProvider);
};
MAKE_REFLECT_STRUCT(RenameOptions, workDoneProgress, prepareProvider)

struct DocumentFilter
{
//
// A language id, like `typescript`.
//
optional<std::string> language;
//
// A Uri [scheme](#Uri.scheme), like `file` or `untitled`.
//
optional<std::string> scheme;
//
// A glob pattern, like `*.{ts,js}`.
//
// Glob patterns can have the following syntax:
// - `*` to match one or more characters in a path segment
// - `?` to match on one character in a path segment
// - `**` to match any number of path segments, including none
// - `{}` to group sub patterns into an OR expression. (e.g. `**/*.{ts,js}
// matches all TypeScript and JavaScript files)
// - `[]` to declare a range of characters to match in a path segment
// (e.g., `example.[0-9]` to match on `example.0`, `example.1`,...)
// - `[!...]` to negate a range of characters to match in a path segment
// (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but
// not `example.0`)
//
optional<std::string> pattern;
MAKE_SWAP_METHOD(DocumentFilter, language, scheme, pattern)
};
MAKE_REFLECT_STRUCT(DocumentFilter, language, scheme, pattern)

//A document selector is the combination of one or more document filters.
using DocumentSelector = std::vector<DocumentFilter>;

// Document link options
struct lsDocumentLinkOptions : WorkDoneProgressOptions
{
// Document links have a resolve provider as well.
optional<bool> resolveProvider;
MAKE_SWAP_METHOD(lsDocumentLinkOptions, workDoneProgress, resolveProvider);
};
MAKE_REFLECT_STRUCT(lsDocumentLinkOptions, workDoneProgress, resolveProvider);

// Execute command options.
struct lsExecuteCommandOptions : WorkDoneProgressOptions
{
// The commands to be executed on the server
std::vector<std::string> commands;
MAKE_SWAP_METHOD(lsExecuteCommandOptions, workDoneProgress, commands);
};
MAKE_REFLECT_STRUCT(lsExecuteCommandOptions, workDoneProgress, commands);

struct TextDocumentRegistrationOptions
{
//
// A document selector to identify the scope of the registration. If set to null
// the document selector provided on the client side will be used.
//
optional<DocumentSelector> documentSelector;

MAKE_SWAP_METHOD(TextDocumentRegistrationOptions, documentSelector);
};
MAKE_REFLECT_STRUCT(TextDocumentRegistrationOptions, documentSelector);

//
// Static registration options to be returned in the initialize request.
//
struct StaticRegistrationOptions : public TextDocumentRegistrationOptions
{
//
// The id used to register the request. The id can be used to deregister
// the request again. See also Registration#id.
//
optional<std::string> id;
MAKE_SWAP_METHOD(StaticRegistrationOptions, documentSelector, id)
};
MAKE_REFLECT_STRUCT(StaticRegistrationOptions, documentSelector, id)

//
// The server supports workspace folder.
//
// Since 3.6.0
//

struct WorkspaceFoldersOptions
{
//
// The server has support for workspace folders
//
optional<bool> supported;

//
// Whether the server wants to receive workspace folder
// change notifications.
//
// If a string is provided, the string is treated as an ID
// under which the notification is registered on the client
// side. The ID can be used to unregister for these events
// using the `client/unregisterCapability` request.
//
optional<std::pair<optional<std::string>, optional<bool>>> changeNotifications;
MAKE_SWAP_METHOD(WorkspaceFoldersOptions, supported, changeNotifications);
};
MAKE_REFLECT_STRUCT(WorkspaceFoldersOptions, supported, changeNotifications);

//
// A pattern kind describing if a glob pattern matches a file a folder or
// both.
//
// @since 3.16.0
//
enum lsFileOperationPatternKind
{
file,
folder
};
MAKE_REFLECT_TYPE_PROXY(lsFileOperationPatternKind)

//
// Matching options for the file operation pattern.
//
// @since 3.16.0
//
struct lsFileOperationPatternOptions
{

//
// The pattern should be matched ignoring casing.
//
optional<bool> ignoreCase;
MAKE_SWAP_METHOD(lsFileOperationPatternOptions, ignoreCase)
};
MAKE_REFLECT_STRUCT(lsFileOperationPatternOptions, ignoreCase)
//
// A pattern to describe in which file operation requests or notifications
// the server is interested in.
//
// @since 3.16.0
//
struct lsFileOperationPattern
{
//
// The glob pattern to match. Glob patterns can have the following syntax:
// - `*` to match one or more characters in a path segment
// - `?` to match on one character in a path segment
// - `**` to match any number of path segments, including none
// - `{}` to group sub patterns into an OR expression. (e.g. `**/*.{ts,js}`
// matches all TypeScript and JavaScript files)
// - `[]` to declare a range of characters to match in a path segment
// (e.g., `example.[0-9]` to match on `example.0`, `example.1`,...)
// - `[!...]` to negate a range of characters to match in a path segment
// (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but
// not `example.0`)
//
std::string glob;

//
// Whether to match files or folders with this pattern.
//
// Matches both if undefined.
//
optional<lsFileOperationPatternKind> matches;

//
// Additional options used during matching.
//
optional<lsFileOperationPatternOptions> options;
MAKE_SWAP_METHOD(lsFileOperationPattern, glob, matches, options)
};
MAKE_REFLECT_STRUCT(lsFileOperationPattern, glob, matches, options)
//
// A filter to describe in which file operation requests or notifications
// the server is interested in.
//
// @since 3.16.0
//
struct lsFileOperationFilter
{

//
// A Uri like `file` or `untitled`.
//
optional<std::string> scheme;

//
// The actual file operation pattern.
//
optional<lsFileOperationPattern> pattern;
MAKE_SWAP_METHOD(lsFileOperationFilter, scheme, pattern)
};
MAKE_REFLECT_STRUCT(lsFileOperationFilter, scheme, pattern)
//
// The options to register for file operations.
//
// @since 3.16.0
//
struct lsFileOperationRegistrationOptions
{
//
// The actual filters.
//
optional<std::vector<lsFileOperationFilter>> filters;
MAKE_SWAP_METHOD(lsFileOperationRegistrationOptions, filters)
};
MAKE_REFLECT_STRUCT(lsFileOperationRegistrationOptions, filters)

struct WorkspaceServerCapabilities
{
//
// The server supports workspace folder.
//
// Since 3.6.0
//
WorkspaceFoldersOptions workspaceFolders;

//
// The server is interested in file notifications/requests.
//
// @since 3.16.0
//
struct lsFileOperations
{
//
// The server is interested in receiving didCreateFiles
// notifications.
//
optional<lsFileOperationRegistrationOptions> didCreate;

//
// The server is interested in receiving willCreateFiles requests.
//
optional<lsFileOperationRegistrationOptions> willCreate;

//
// The server is interested in receiving didRenameFiles
// notifications.
//
optional<lsFileOperationRegistrationOptions> didRename;

//
// The server is interested in receiving willRenameFiles requests.
//
optional<lsFileOperationRegistrationOptions> willRename;

//
// The server is interested in receiving didDeleteFiles file
// notifications.
//
optional<lsFileOperationRegistrationOptions> didDelete;

//
// The server is interested in receiving willDeleteFiles file
// requests.
//
optional<lsFileOperationRegistrationOptions> willDelete;
MAKE_SWAP_METHOD(lsFileOperations, didCreate, willCreate, didRename, willRename, didDelete, willDelete)
};
optional<lsFileOperations> fileOperations;

MAKE_SWAP_METHOD(WorkspaceServerCapabilities, workspaceFolders, fileOperations)
};
MAKE_REFLECT_STRUCT(WorkspaceServerCapabilities, workspaceFolders, fileOperations)
MAKE_REFLECT_STRUCT(
WorkspaceServerCapabilities::lsFileOperations, didCreate, willCreate, didRename, willRename, didDelete, willDelete
)

//
// Semantic highlighting server capabilities.
//
// 
// Note: the <a href=
// "https://github.com/Microsoft/vscode-languageserver-node/pull/367">{@code textDocument/semanticHighlighting}
// language feature</a> is not yet part of the official LSP specification.
//

struct SemanticHighlightingServerCapabilities
{
//
// A "lookup table" of semantic highlighting <a href="https://manual.macromates.com/en/language_grammars">TextMate scopes</a>
// supported by the language server. If not defined or empty, then the server does not support the semantic highlighting
// feature. Otherwise, clients should reuse this "lookup table" when receiving semantic highlighting notifications from
// the server.
//
std::vector<std::vector<std::string>> scopes;
MAKE_SWAP_METHOD(SemanticHighlightingServerCapabilities, scopes)
};
MAKE_REFLECT_STRUCT(SemanticHighlightingServerCapabilities, scopes)

struct SemanticTokensServerFull
{
//
// The server supports deltas for full documents.
//
bool delta = false;
MAKE_SWAP_METHOD(SemanticTokensServerFull, delta)
};
MAKE_REFLECT_STRUCT(SemanticTokensServerFull, delta)
struct SemanticTokensWithRegistrationOptions
{
SemanticTokensLegend legend;

//
// Server supports providing semantic tokens for a specific range
// of a document.
//
optional<std::pair<optional<bool>, optional<lsp::Any>>> range;

//
// Server supports providing semantic tokens for a full document.
//
optional<std::pair<optional<bool>, optional<SemanticTokensServerFull>>> full;

//
// A document selector to identify the scope of the registration. If set to null
// the document selector provided on the client side will be used.
//
optional<std::vector<DocumentFilter>> documentSelector;
//
// The id used to register the request. The id can be used to deregister
// the request again. See also Registration#id.
//
optional<std::string> id;
MAKE_SWAP_METHOD(SemanticTokensWithRegistrationOptions, legend, range, full, documentSelector, id)
};
MAKE_REFLECT_STRUCT(SemanticTokensWithRegistrationOptions, legend, range, full, documentSelector, id)

using DocumentColorOptions = WorkDoneProgressOptions;
using FoldingRangeOptions = WorkDoneProgressOptions;

struct InlayHintOptions : WorkDoneProgressOptions
{

/**
* The server provides support to resolve additional
* information for an inlay hint item.
*/
optional<bool> resolveProvider;

MAKE_SWAP_METHOD(InlayHintOptions, workDoneProgress, resolveProvider);
};

MAKE_REFLECT_STRUCT(InlayHintOptions, workDoneProgress, resolveProvider)

struct lsServerCapabilities
{
// Defines how text documents are synced. Is either a detailed structure
// defining each notification or for backwards compatibility the

// TextDocumentSyncKind number.
optional<std::pair<optional<lsTextDocumentSyncKind>, optional<lsTextDocumentSyncOptions>>> textDocumentSync;

// The server provides hover support.
optional<bool> hoverProvider;

// The server provides completion support.
optional<lsCompletionOptions> completionProvider;

// The server provides signature help support.
optional<lsSignatureHelpOptions> signatureHelpProvider;

// The server provides goto definition support.
optional<std::pair<optional<bool>, optional<WorkDoneProgressOptions>>> definitionProvider;

//
// The server provides Goto Type Definition support.
//
// Since 3.6.0
//
optional<std::pair<optional<bool>, optional<StaticRegistrationOptions>>> typeDefinitionProvider;

// The server provides implementation support.
optional<std::pair<optional<bool>, optional<StaticRegistrationOptions>>> implementationProvider;

// The server provides find references support.
optional<std::pair<optional<bool>, optional<WorkDoneProgressOptions>>> referencesProvider;

// The server provides document highlight support.
optional<std::pair<optional<bool>, optional<WorkDoneProgressOptions>>> documentHighlightProvider;

// The server provides document symbol support.
optional<std::pair<optional<bool>, optional<WorkDoneProgressOptions>>> documentSymbolProvider;

// The server provides workspace symbol support.
optional<std::pair<optional<bool>, optional<WorkDoneProgressOptions>>> workspaceSymbolProvider;

// The server provides code actions.
optional<std::pair<optional<bool>, optional<CodeActionOptions>>> codeActionProvider;

// The server provides code lens.
optional<CodeLensOptions> codeLensProvider;

// The server provides document formatting.
optional<std::pair<optional<bool>, optional<WorkDoneProgressOptions>>> documentFormattingProvider;

// The server provides document range formatting.
optional<std::pair<optional<bool>, optional<WorkDoneProgressOptions>>> documentRangeFormattingProvider;

// The server provides document formatting on typing.
optional<lsDocumentOnTypeFormattingOptions> documentOnTypeFormattingProvider;

// The server provides rename support.
optional<std::pair<optional<bool>, optional<RenameOptions>>> renameProvider;

// The server provides document link support.
optional<lsDocumentLinkOptions> documentLinkProvider;

//
// The server provides color provider support.
//
// @since 3.6.0
//
optional<std::pair<optional<bool>, optional<DocumentColorOptions>>> colorProvider;

//
// The server provides folding provider support.
//
// @since 3.10.0
//
optional<std::pair<optional<bool>, optional<FoldingRangeOptions>>> foldingRangeProvider;

// The server provides execute command support.
optional<lsExecuteCommandOptions> executeCommandProvider;

//
// Workspace specific server capabilities
//
optional<WorkspaceServerCapabilities> workspace;

//
// Semantic highlighting server capabilities.
//

optional<SemanticHighlightingServerCapabilities> semanticHighlighting;

//
// Server capability for calculating super- and subtype hierarchies.
// The LS supports the type hierarchy language feature, if this capability is set to {@code true}.
//
// 
// Note: the <a href=
// "https://github.com/Microsoft/vscode-languageserver-node/pull/426">{@code textDocument/typeHierarchy}
// language feature</a> is not yet part of the official LSP specification.
//

optional<std::pair<optional<bool>, optional<StaticRegistrationOptions>>> typeHierarchyProvider;

//
// The server provides Call Hierarchy support.
//

optional<std::pair<optional<bool>, optional<StaticRegistrationOptions>>> callHierarchyProvider;

//
// The server provides selection range support.
//
// Since 3.15.0
//
optional<std::pair<optional<bool>, optional<StaticRegistrationOptions>>> selectionRangeProvider;

//
// The server provides linked editing range support.
//
// Since 3.16.0
//
optional<std::pair<optional<bool>, optional<StaticRegistrationOptions>>> linkedEditingRangeProvider;

//
// The server provides semantic tokens support.
//
// Since 3.16.0
//
optional<SemanticTokensWithRegistrationOptions> semanticTokensProvider;

//
// Whether server provides moniker support.
//
// Since 3.16.0
//
optional<std::pair<optional<bool>, optional<StaticRegistrationOptions>>> monikerProvider;

/**
* The server provides inlay hints.
*
* @since 3.17.0
*/
optional<std::pair<optional<bool>, optional<InlayHintOptions>>> inlayHintProvider;

optional<lsp::Any> experimental;

MAKE_SWAP_METHOD(
lsServerCapabilities, textDocumentSync, hoverProvider, completionProvider, signatureHelpProvider,
definitionProvider, typeDefinitionProvider, implementationProvider, referencesProvider,
documentHighlightProvider, documentSymbolProvider, workspaceSymbolProvider, codeActionProvider,
codeLensProvider, documentFormattingProvider, documentRangeFormattingProvider, documentOnTypeFormattingProvider,
renameProvider, documentLinkProvider, executeCommandProvider, workspace, semanticHighlighting,
typeHierarchyProvider, callHierarchyProvider, selectionRangeProvider, experimental, colorProvider,
foldingRangeProvider, linkedEditingRangeProvider, monikerProvider, semanticTokensProvider
)
};
MAKE_REFLECT_STRUCT(
lsServerCapabilities, textDocumentSync, hoverProvider, completionProvider, signatureHelpProvider,
definitionProvider, typeDefinitionProvider, implementationProvider, referencesProvider, documentHighlightProvider,
documentSymbolProvider, workspaceSymbolProvider, codeActionProvider, codeLensProvider, documentFormattingProvider,
documentRangeFormattingProvider, documentOnTypeFormattingProvider, renameProvider, documentLinkProvider,
executeCommandProvider, workspace, semanticHighlighting, typeHierarchyProvider, callHierarchyProvider,
selectionRangeProvider, experimental, colorProvider, foldingRangeProvider, linkedEditingRangeProvider,
monikerProvider, semanticTokensProvider
)