laburnum 1.17.1

#![allow(unused)]
// Copyright Two Neutron Stars Incorporated and contributors
// SPDX-License-Identifier: BlueOak-1.0.0

mod basic;
mod call_hierarchy;
mod code_action;
mod code_lens;
mod color;
mod completion;
mod diagnostic;
mod document_diagnostic;
mod document_highlight;
mod document_link;
mod document_symbols;
mod execute_command;
mod file_operations;
mod folding_range;
mod formatting;
mod goto;
mod hover;
mod initialize;
mod inlay_hint;
mod inline_completion;
mod inline_value;
mod linked_editing;
mod moniker;
mod notebook;
mod progress;
mod references;
mod rename;
mod selection_range;
mod semantic_tokens;
mod signature_help;

mod text_document;
mod text_document_position;
mod trace;
mod type_hierarchy;
mod window;
mod workspace;
mod workspace_diagnostic;
mod workspace_folders;
mod workspace_symbols;

pub use {
  crate::partitions::text_document_references::*,
  basic::*,
  call_hierarchy::*,
  code_action::*,
  code_lens::*,
  color::*,
  completion::*,
  diagnostic::*,
  document_diagnostic::*,
  document_highlight::*,
  document_link::*,
  document_symbols::*,
  execute_command::*,
  file_operations::*,
  folding_range::*,
  formatting::*,
  goto::*,
  hover::*,
  initialize::*,
  inlay_hint::*,
  inline_completion::*,
  inline_value::*,
  linked_editing::*,
  moniker::*,
  notebook::*,
  progress::*,
  references::*,
  rename::*,
  selection_range::*,
  semantic_tokens::*,
  signature_help::*,
  text_document::*,
  text_document_position::*,
  trace::*,
  type_hierarchy::*,
  window::*,
  workspace::*,
  workspace_diagnostic::*,
  workspace_folders::*,
  workspace_symbols::*,
};
use {
  crate::{
    Uri,
    database::storage::Partitions,
    protocol::macros::lsp_enum,
  },
  serde::{
    Deserialize,
    Serialize,
    de::Error,
  },
  std::{
    collections::HashMap,
    default,
  },
};

/// Metadata about which files the language server should watch and process.
///
/// Implement this to tell laburnum which file extensions your language uses.
pub trait SourceFileMeta {
  /// Returns glob patterns for source files this language server handles.
  ///
  /// # Example
  ///
  /// ```
  /// # struct MyServer;
  /// impl laburnum::protocol::lsp::SourceFileMeta for MyServer {
  ///   fn source_files_glob(&self) -> Vec<String> {
  ///     vec!["**/*.myext".to_string(), "**/*.my".to_string()]
  ///   }
  /// }
  /// ```
  fn source_files_glob(&self) -> Vec<String> {
    vec![]
  }
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct CancelParams {
  /// The request id to cancel.
  pub id: NumberOrString,
}

/// The LSP any type
///
/// @since 3.17.0
pub type LSPAny = serde_json::Value;

/// LSP object definition.
///
/// @since 3.17.0
pub type LSPObject = serde_json::Map<String, serde_json::Value>;

/// LSP arrays.
///
/// @since 3.17.0
pub type LSPArray = Vec<serde_json::Value>;

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged)]
pub enum DocumentChanges {
  Edits(Vec<TextDocumentEdit>),
  Operations(Vec<DocumentChangeOperation>),
}

// TODO: Once https://github.com/serde-rs/serde/issues/912 is solved
// we can remove ResourceOp and switch to the following implementation
// of DocumentChangeOperation:
//
// #[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
// #[serde(tag = "kind", rename_all="lowercase" )]
// pub enum DocumentChangeOperation {
//     Create(CreateFile),
//     Rename(RenameFile),
//     Delete(DeleteFile),
//
//     #[serde(other)]
//     Edit(TextDocumentEdit),
// }

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged, rename_all = "lowercase")]
pub enum DocumentChangeOperation {
  Op(ResourceOp),
  Edit(TextDocumentEdit),
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(tag = "kind", rename_all = "lowercase")]
pub enum ResourceOp {
  Create(CreateFile),
  Rename(RenameFile),
  Delete(DeleteFile),
}

pub type DidChangeConfigurationClientCapabilities =
  DynamicRegistrationClientCapabilities;

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigurationParams {
  pub items: Vec<ConfigurationItem>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigurationItem {
  /// The scope to get the configuration section for.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub scope_uri: Option<Uri>,

  /// The configuration section asked for.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub section: Option<String>,
}

// ========================= Actual Protocol =========================

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct ClientInfo {
  /// The name of the client as defined by the client.
  pub name:    String,
  /// The client's version as defined by the client.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct GenericRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,

  #[serde(flatten)]
  pub options: GenericOptions,

  #[serde(flatten)]
  pub static_registration_options: StaticRegistrationOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct GenericOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct GenericParams {
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,

  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,

  #[serde(flatten)]
  pub partial_result_params: PartialResultParams,
}

#[derive(
  Debug, Default, Clone, Copy, PartialEq, Eq, Deserialize, Serialize,
)]
#[serde(rename_all = "camelCase")]
pub struct DynamicRegistrationClientCapabilities {
  /// This capability supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub dynamic_registration: Option<bool>,
}

#[derive(
  Debug, Default, Clone, Copy, PartialEq, Eq, Deserialize, Serialize,
)]
#[serde(rename_all = "camelCase")]
pub struct GotoCapability {
  #[serde(skip_serializing_if = "Option::is_none")]
  pub dynamic_registration: Option<bool>,

  /// The client supports additional metadata in the form of definition links.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub link_support: Option<bool>,
}

/// Specific capabilities for the `SymbolKind` in the `workspace/symbol`
/// request.
#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SymbolKindCapability {
  /// The symbol kind values the client supports. When this
  /// property exists the client also guarantees that it will
  /// handle values outside its set gracefully and falls back
  /// to a default value when unknown.
  ///
  /// If this property is not present the client only supports
  /// the symbol kinds from `File` to `Array` as defined in
  /// the initial version of the protocol.
  pub value_set: Option<Vec<SymbolKind>>,
}

/// Workspace specific client capabilities.
#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceClientCapabilities {
  /// The client supports applying batch edits to the workspace by supporting
  /// the request `workspace/applyEdit`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub apply_edit: Option<bool>,

  /// Capabilities specific to `WorkspaceEdit`s
  #[serde(skip_serializing_if = "Option::is_none")]
  pub workspace_edit: Option<WorkspaceEditClientCapabilities>,

  /// Capabilities specific to the `workspace/didChangeConfiguration`
  /// notification.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub did_change_configuration:
    Option<DidChangeConfigurationClientCapabilities>,

  /// Capabilities specific to the `workspace/didChangeWatchedFiles`
  /// notification.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub did_change_watched_files: Option<DidChangeWatchedFilesClientCapabilities>,

  /// Capabilities specific to the `workspace/symbol` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub symbol: Option<WorkspaceSymbolClientCapabilities>,

  /// Capabilities specific to the `workspace/executeCommand` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub execute_command: Option<ExecuteCommandClientCapabilities>,

  /// The client has support for workspace folders.
  ///
  /// @since 3.6.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub workspace_folders: Option<bool>,

  /// The client supports `workspace/configuration` requests.
  ///
  /// @since 3.6.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub configuration: Option<bool>,

  /// Capabilities specific to the semantic token requests scoped to the
  /// workspace.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub semantic_tokens: Option<SemanticTokensWorkspaceClientCapabilities>,

  /// Capabilities specific to the code lens requests scoped to the workspace.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub code_lens: Option<CodeLensWorkspaceClientCapabilities>,

  /// The client has support for file requests/notifications.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub file_operations: Option<WorkspaceFileOperationsClientCapabilities>,

  /// Client workspace capabilities specific to inline values.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub inline_value: Option<InlineValueWorkspaceClientCapabilities>,

  /// Client workspace capabilities specific to inlay hints.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub inlay_hint: Option<InlayHintWorkspaceClientCapabilities>,

  /// Client workspace capabilities specific to diagnostics.
  /// since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub diagnostics: Option<DiagnosticWorkspaceClientCapabilities>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentSyncClientCapabilities {
  /// Whether text document synchronization supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub dynamic_registration: Option<bool>,

  /// The client supports sending will save notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub will_save: Option<bool>,

  /// The client supports sending a will save request and
  /// waits for a response providing text edits which will
  /// be applied to the document before it is saved.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub will_save_wait_until: Option<bool>,

  /// The client supports did save notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub did_save: Option<bool>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PublishDiagnosticsClientCapabilities {
  /// Whether the clients accepts diagnostics with related information.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub related_information: Option<bool>,

  /// Client supports the tag property to provide meta data about a diagnostic.
  /// Clients supporting tags have to handle unknown tags gracefully.
  #[serde(
    default,
    skip_serializing_if = "Option::is_none",
    deserialize_with = "TagSupport::deserialize_compat"
  )]
  pub tag_support: Option<TagSupport<DiagnosticTag>>,

  /// Whether the client interprets the version property of the
  /// `textDocument/publishDiagnostics` notification's parameter.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version_support: Option<bool>,

  /// Client supports a codeDescription property
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub code_description_support: Option<bool>,

  /// Whether code action supports the `data` property which is
  /// preserved between a `textDocument/publishDiagnostics` and
  /// `textDocument/codeAction` request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data_support: Option<bool>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TagSupport<T> {
  /// The tags supported by the client.
  pub value_set: Vec<T>,
}

impl<T> TagSupport<T> {
  /// Support for deserializing a boolean tag Support, in case it's present.
  ///
  /// This is currently the case for vscode 1.41.1
  fn deserialize_compat<'de, S>(serializer: S) -> Result<Option<Self>, S::Error>
  where
    S: serde::Deserializer<'de>,
    T: serde::Deserialize<'de>,
  {
    Ok(
      match Option::<serde_json::Value>::deserialize(serializer)
        .map_err(serde::de::Error::custom)?
      {
        | Some(serde_json::Value::Bool(false)) | None => None,
        | Some(serde_json::Value::Bool(true)) => {
          Some(Self { value_set: vec![] })
        },
        | Some(other) => {
          Some(Self::deserialize(other).map_err(serde::de::Error::custom)?)
        },
      },
    )
  }
}

/// Text document specific client capabilities.
#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentClientCapabilities {
  #[serde(skip_serializing_if = "Option::is_none")]
  pub synchronization: Option<TextDocumentSyncClientCapabilities>,
  /// Capabilities specific to the `textDocument/completion`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub completion:      Option<CompletionClientCapabilities>,

  /// Capabilities specific to the `textDocument/hover`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub hover: Option<HoverClientCapabilities>,

  /// Capabilities specific to the `textDocument/signatureHelp`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub signature_help: Option<SignatureHelpClientCapabilities>,

  /// Capabilities specific to the `textDocument/references`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub references: Option<ReferenceClientCapabilities>,

  /// Capabilities specific to the `textDocument/documentHighlight`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_highlight: Option<DocumentHighlightClientCapabilities>,

  /// Capabilities specific to the `textDocument/documentSymbol`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_symbol: Option<DocumentSymbolClientCapabilities>,
  /// Capabilities specific to the `textDocument/formatting`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub formatting:      Option<DocumentFormattingClientCapabilities>,

  /// Capabilities specific to the `textDocument/rangeFormatting`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub range_formatting: Option<DocumentRangeFormattingClientCapabilities>,

  /// Capabilities specific to the `textDocument/onTypeFormatting`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub on_type_formatting: Option<DocumentOnTypeFormattingClientCapabilities>,

  /// Capabilities specific to the `textDocument/declaration`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub declaration: Option<GotoCapability>,

  /// Capabilities specific to the `textDocument/definition`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub definition: Option<GotoCapability>,

  /// Capabilities specific to the `textDocument/typeDefinition`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub type_definition: Option<GotoCapability>,

  /// Capabilities specific to the `textDocument/implementation`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub implementation: Option<GotoCapability>,

  /// Capabilities specific to the `textDocument/codeAction`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub code_action: Option<CodeActionClientCapabilities>,

  /// Capabilities specific to the `textDocument/codeLens`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub code_lens: Option<CodeLensClientCapabilities>,

  /// Capabilities specific to the `textDocument/documentLink`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_link: Option<DocumentLinkClientCapabilities>,

  /// Capabilities specific to the `textDocument/documentColor` and the
  /// `textDocument/colorPresentation` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub color_provider: Option<DocumentColorClientCapabilities>,

  /// Capabilities specific to the `textDocument/rename`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub rename: Option<RenameClientCapabilities>,

  /// Capabilities specific to `textDocument/publishDiagnostics`.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub publish_diagnostics: Option<PublishDiagnosticsClientCapabilities>,

  /// Capabilities specific to `textDocument/foldingRange` requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub folding_range: Option<FoldingRangeClientCapabilities>,

  /// Capabilities specific to the `textDocument/selectionRange` request.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub selection_range: Option<SelectionRangeClientCapabilities>,

  /// Capabilities specific to `textDocument/linkedEditingRange` requests.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub linked_editing_range: Option<LinkedEditingRangeClientCapabilities>,

  /// Capabilities specific to the various call hierarchy requests.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub call_hierarchy: Option<CallHierarchyClientCapabilities>,

  /// Capabilities specific to the `textDocument/semanticTokens/*` requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub semantic_tokens: Option<SemanticTokensClientCapabilities>,

  /// Capabilities specific to the `textDocument/moniker` request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub moniker: Option<MonikerClientCapabilities>,

  /// Capabilities specific to the various type hierarchy requests.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub type_hierarchy: Option<TypeHierarchyClientCapabilities>,

  /// Capabilities specific to the `textDocument/inlineValue` request.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub inline_value: Option<InlineValueClientCapabilities>,

  /// Capabilities specific to the `textDocument/inlayHint` request.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub inlay_hint: Option<InlayHintClientCapabilities>,

  /// Capabilities specific to the diagnostic pull model.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub diagnostic: Option<DiagnosticClientCapabilities>,

  /// Capabilities specific to the `textDocument/inlineCompletion` request.
  ///
  /// @since 3.18.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[cfg(feature = "proposed")]
  pub inline_completion: Option<InlineCompletionClientCapabilities>,
}

/// Where `ClientCapabilities` are currently empty:
#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientCapabilities {
  /// Workspace specific client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub workspace: Option<WorkspaceClientCapabilities>,

  /// Text document specific client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub text_document: Option<TextDocumentClientCapabilities>,

  /// Capabilities specific to the notebook document support.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub notebook_document: Option<NotebookDocumentClientCapabilities>,

  /// Window specific client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub window: Option<WindowClientCapabilities>,

  /// General client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub general: Option<GeneralClientCapabilities>,

  /// Unofficial UT8-offsets extension.
  ///
  /// See <https://clangd.llvm.org/extensions.html#utf-8-offsets>.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[cfg(feature = "proposed")]
  pub offset_encoding: Option<Vec<String>>,

  /// Experimental client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub experimental: Option<serde_json::Value>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GeneralClientCapabilities {
  /// Client capabilities specific to regular expressions.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub regular_expressions: Option<RegularExpressionsClientCapabilities>,

  /// Client capabilities specific to the client's markdown parser.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub markdown: Option<MarkdownClientCapabilities>,

  /// Client capability that signals how the client handles stale requests
  /// (e.g. a request for which the client will not process the response
  /// anymore since the information is outdated).
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub stale_request_support: Option<StaleRequestSupportClientCapabilities>,

  /// The position encodings supported by the client. Client and server
  /// have to agree on the same position encoding to ensure that offsets
  /// (e.g. character position in a line) are interpreted the same on both
  /// side.
  ///
  /// To keep the protocol backwards compatible the following applies: if
  /// the value `utf-16` is missing from the array of position encodings
  /// servers can assume that the client supports UTF-16. UTF-16 is
  /// therefore a mandatory encoding.
  ///
  /// If omitted it defaults to `["utf-16"]`.
  ///
  /// Implementation considerations: since the conversion from one encoding
  /// into another requires the content of the file / line the conversion
  /// is best done where the file is read which is usually on the server
  /// side.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub position_encodings: Option<Vec<PositionEncodingKind>>,
}

/// Client capability that signals how the client
/// handles stale requests (e.g. a request
/// for which the client will not process the response
/// anymore since the information is outdated).
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StaleRequestSupportClientCapabilities {
  /// The client will actively cancel the request.
  pub cancel: bool,

  /// The list of requests for which the client
  /// will retry the request if it receives a
  /// response with error code `ContentModified`
  pub retry_on_content_modified: Vec<String>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct ServerInfo {
  /// The name of the server as defined by the server.
  pub name:    String,
  /// The servers's version as defined by the server.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version: Option<String>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct InitializeError {
  /// Indicates whether the client execute the following retry logic:
  ///
  /// - (1) show the message provided by the `ResponseError` to the user
  /// - (2) user selects retry or cancel
  /// - (3) if user selected retry the initialize method is sent again.
  pub retry: bool,
}

/// Save options.
#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SaveOptions {
  /// The client is supposed to include the content on save.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub include_text: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged)]
pub enum TextDocumentSyncSaveOptions {
  Supported(bool),
  SaveOptions(SaveOptions),
}

impl From<SaveOptions> for TextDocumentSyncSaveOptions {
  fn from(from: SaveOptions) -> Self {
    Self::SaveOptions(from)
  }
}

impl From<bool> for TextDocumentSyncSaveOptions {
  fn from(from: bool) -> Self {
    Self::Supported(from)
  }
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentSyncOptions {
  /// Open and close notifications are sent to the server.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub open_close: Option<bool>,

  /// Change notifications are sent to the server. See
  /// TextDocumentSyncKind.None, TextDocumentSyncKind.Full
  /// and TextDocumentSyncKind.Incremental.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub change: Option<TextDocumentSyncKind>,

  /// Will save notifications are sent to the server.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub will_save: Option<bool>,

  /// Will save wait until requests are sent to the server.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub will_save_wait_until: Option<bool>,

  /// Save notifications are sent to the server.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub save: Option<TextDocumentSyncSaveOptions>,
}

#[derive(
  Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize,
)]
#[serde(untagged)]
pub enum OneOf<A, B> {
  Left(A),
  Right(B),
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged)]
pub enum TextDocumentSyncCapability {
  Kind(TextDocumentSyncKind),
  Options(TextDocumentSyncOptions),
}

impl From<TextDocumentSyncOptions> for TextDocumentSyncCapability {
  fn from(from: TextDocumentSyncOptions) -> Self {
    Self::Options(from)
  }
}

impl From<TextDocumentSyncKind> for TextDocumentSyncCapability {
  fn from(from: TextDocumentSyncKind) -> Self {
    Self::Kind(from)
  }
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged)]
pub enum ImplementationProviderCapability {
  Simple(bool),
  Options(StaticTextDocumentRegistrationOptions),
}

impl From<StaticTextDocumentRegistrationOptions>
  for ImplementationProviderCapability
{
  fn from(from: StaticTextDocumentRegistrationOptions) -> Self {
    Self::Options(from)
  }
}

impl From<bool> for ImplementationProviderCapability {
  fn from(from: bool) -> Self {
    Self::Simple(from)
  }
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged)]
pub enum TypeDefinitionProviderCapability {
  Simple(bool),
  Options(StaticTextDocumentRegistrationOptions),
}

impl From<StaticTextDocumentRegistrationOptions>
  for TypeDefinitionProviderCapability
{
  fn from(from: StaticTextDocumentRegistrationOptions) -> Self {
    Self::Options(from)
  }
}

impl From<bool> for TypeDefinitionProviderCapability {
  fn from(from: bool) -> Self {
    Self::Simple(from)
  }
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ServerCapabilities {
  /// The position encoding the server picked from the encodings offered
  /// by the client via the client capability `general.positionEncodings`.
  ///
  /// If the client didn't provide any position encodings the only valid
  /// value that a server can return is `utf-16`.
  ///
  /// If omitted it defaults to `utf-16`.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub position_encoding: Option<PositionEncodingKind>,

  /// Defines how text documents are synced.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub text_document_sync: Option<TextDocumentSyncCapability>,

  /// Defines how notebook documents are synced.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub notebook_document_sync: Option<
    OneOf<NotebookDocumentSyncOptions, NotebookDocumentSyncRegistrationOptions>,
  >,

  /// Capabilities specific to `textDocument/selectionRange` requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub selection_range_provider: Option<SelectionRangeProviderCapability>,

  /// The server provides hover support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub hover_provider: Option<HoverProviderCapability>,

  /// The server provides completion support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub completion_provider: Option<CompletionOptions>,

  /// The server provides signature help support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub signature_help_provider: Option<SignatureHelpOptions>,

  /// The server provides goto definition support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub definition_provider: Option<OneOf<bool, DefinitionOptions>>,

  /// The server provides goto type definition support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub type_definition_provider: Option<TypeDefinitionProviderCapability>,

  /// The server provides goto implementation support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub implementation_provider: Option<ImplementationProviderCapability>,

  /// The server provides find references support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub references_provider: Option<OneOf<bool, ReferenceOptions>>,

  /// The server provides document highlight support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_highlight_provider:
    Option<OneOf<bool, DocumentHighlightOptions>>,

  /// The server provides document symbol support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_symbol_provider: Option<OneOf<bool, DocumentSymbolOptions>>,

  /// The server provides workspace symbol support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub workspace_symbol_provider: Option<OneOf<bool, WorkspaceSymbolOptions>>,

  /// The server provides code actions.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub code_action_provider: Option<CodeActionProviderCapability>,

  /// The server provides code lens.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub code_lens_provider: Option<CodeLensOptions>,

  /// The server provides document formatting.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_formatting_provider:
    Option<OneOf<bool, DocumentFormattingOptions>>,

  /// The server provides document range formatting.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_range_formatting_provider:
    Option<OneOf<bool, DocumentRangeFormattingOptions>>,

  /// The server provides document formatting on typing.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_on_type_formatting_provider:
    Option<DocumentOnTypeFormattingOptions>,

  /// The server provides rename support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub rename_provider: Option<OneOf<bool, RenameOptions>>,

  /// The server provides document link support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub document_link_provider: Option<DocumentLinkOptions>,

  /// The server provides color provider support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub color_provider: Option<ColorProviderCapability>,

  /// The server provides folding provider support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub folding_range_provider: Option<FoldingRangeProviderCapability>,

  /// The server provides go to declaration support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub declaration_provider: Option<DeclarationCapability>,

  /// The server provides execute command support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub execute_command_provider: Option<ExecuteCommandOptions>,

  /// Workspace specific server capabilities
  #[serde(skip_serializing_if = "Option::is_none")]
  pub workspace: Option<WorkspaceServerCapabilities>,

  /// Call hierarchy provider capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub call_hierarchy_provider: Option<CallHierarchyServerCapability>,

  /// Semantic tokens server capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub semantic_tokens_provider: Option<SemanticTokensServerCapabilities>,

  /// Whether server provides moniker support.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub moniker_provider: Option<OneOf<bool, MonikerServerCapabilities>>,

  /// The server provides linked editing range support.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub linked_editing_range_provider:
    Option<LinkedEditingRangeServerCapabilities>,

  /// The server provides inline values.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub inline_value_provider: Option<OneOf<bool, InlineValueServerCapabilities>>,

  /// The server provides inlay hints.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub inlay_hint_provider: Option<OneOf<bool, InlayHintServerCapabilities>>,

  /// The server has support for pull model diagnostics.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub diagnostic_provider: Option<DiagnosticServerCapabilities>,

  /// The server provides inline completions.
  ///
  /// @since 3.18.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[cfg(feature = "proposed")]
  pub inline_completion_provider: Option<OneOf<bool, InlineCompletionOptions>>,

  /// Experimental server capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub experimental: Option<serde_json::Value>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceServerCapabilities {
  /// The server supports workspace folder.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub workspace_folders: Option<WorkspaceFoldersServerCapabilities>,

  #[serde(skip_serializing_if = "Option::is_none")]
  pub file_operations: Option<WorkspaceFileOperationsServerCapabilities>,
}

/// General parameters to to register for a capability.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Registration {
  /// The id used to register the request. The id can be used to deregister
  /// the request again.
  pub id: String,

  /// The method / capability to register for.
  pub method: String,

  /// Options necessary for the registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub register_options: Option<serde_json::Value>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct RegistrationParams {
  pub registrations: Vec<Registration>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged)]
pub enum DeclarationCapability {
  Simple(bool),
  RegistrationOptions(DeclarationRegistrationOptions),
  Options(DeclarationOptions),
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DeclarationRegistrationOptions {
  #[serde(flatten)]
  pub declaration_options: DeclarationOptions,

  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,

  #[serde(flatten)]
  pub static_registration_options: StaticRegistrationOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DeclarationOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StaticRegistrationOptions {
  #[serde(skip_serializing_if = "Option::is_none")]
  pub id: Option<String>,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DocumentFormattingOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DocumentRangeFormattingOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DefinitionOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DocumentSymbolOptions {
  /// A human-readable string that is shown when multiple outlines trees are
  /// shown for the same document.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub label: Option<String>,

  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DocumentSymbolRegistrationOptions {
  #[serde(flatten)]
  text_document_registration_options: TextDocumentRegistrationOptions,

  #[serde(flatten)]
  document_symbol_options: DocumentSymbolOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReferenceOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DocumentHighlightOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceSymbolOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,

  /// The server provides support to resolve additional
  /// information for a workspace symbol.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub resolve_provider: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StaticTextDocumentRegistrationOptions {
  /// 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.
  pub document_selector: Option<DocumentSelector>,

  #[serde(skip_serializing_if = "Option::is_none")]
  pub id: Option<String>,
}

/// General parameters to unregister a capability.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct Unregistration {
  /// The id used to unregister the request or notification. Usually an id
  /// provided during the register request.
  pub id: String,

  /// The method / capability to unregister for.
  pub method: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct UnregistrationParams {
  pub unregisterations: Vec<Unregistration>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct DidChangeConfigurationParams {
  /// The actual changed settings
  pub settings: serde_json::Value,
}

#[derive(
  Debug, Default, Clone, Copy, PartialEq, Eq, Deserialize, Serialize,
)]
#[serde(rename_all = "camelCase")]
pub struct DidChangeWatchedFilesClientCapabilities {
  /// Did change watched files notification supports dynamic registration.
  /// Please note that the current protocol doesn't support static
  /// configuration for file changes from the server side.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub dynamic_registration: Option<bool>,

  /// Whether the client has support for relative patterns
  /// or not.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub relative_pattern_support: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct DidChangeWatchedFilesParams {
  /// The actual file events.
  pub changes: Vec<FileEvent>,
}

/// The file event type.
#[derive(Clone, Copy, PartialEq, Eq, Deserialize, Serialize, Hash)]
#[serde(transparent)]
pub struct FileChangeType(i32);

lsp_enum! {
    impl FileChangeType {
        /// The file got created.
        const CREATED = 1;
        /// The file got changed.
        const CHANGED = 2;
        /// The file got deleted.
        const DELETED = 3;
    }
}

/// An event describing a file change.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Hash)]
pub struct FileEvent {
  /// The file's URI.
  pub uri: Uri,

  /// The change type.
  #[serde(rename = "type")]
  pub typ: FileChangeType,
}

impl FileEvent {
  #[must_use]
  pub const fn new(uri: Uri, typ: FileChangeType) -> Self {
    Self { uri, typ }
  }
}

/// Describe options to be used when registered for text document change events.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct DidChangeWatchedFilesRegistrationOptions {
  /// The watchers to register.
  pub watchers: Vec<FileSystemWatcher>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FileSystemWatcher {
  /// The glob pattern to watch. See {@link `GlobPattern` glob pattern}
  /// for more detail.
  ///
  /// @since 3.17.0 support for relative patterns.
  pub glob_pattern: GlobPattern,

  /// The kind of events of interest. If omitted it defaults to
  /// WatchKind.Create | WatchKind.Change | WatchKind.Delete which is 7.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub kind: Option<WatchKind>,
}

bitflags::bitflags! {
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    pub struct WatchKind: u8 {
        /// Interested in create events.
        const Create = 1;
        /// Interested in change events
        const Change = 2;
        /// Interested in delete events
        const Delete = 4;
    }
}

impl<'de> serde::Deserialize<'de> for WatchKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: serde::Deserializer<'de>,
  {
    let i = u8::deserialize(deserializer)?;
    Self::from_bits(i).ok_or_else(|| {
      D::Error::invalid_value(
        serde::de::Unexpected::Unsigned(u64::from(i)),
        &"Unknown flag",
      )
    })
  }
}

impl serde::Serialize for WatchKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: serde::Serializer,
  {
    serializer.serialize_u8(self.bits())
  }
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct PublishDiagnosticsParams {
  /// The URI for which diagnostic information is reported.
  pub uri: Uri,

  /// An array of diagnostic information items.
  pub diagnostics: Vec<Diagnostic>,

  /// Optional the version number of the document the diagnostics are published
  /// for.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version: Option<i32>,
}

impl PublishDiagnosticsParams {
  #[must_use]
  pub const fn new(
    uri: Uri,
    diagnostics: Vec<Diagnostic>,
    version: Option<i32>,
  ) -> Self {
    Self {
      uri,
      diagnostics,
      version,
    }
  }
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged)]
pub enum Documentation {
  String(String),
  MarkupContent(MarkupContent),
}

/// `MarkedString` can be used to render human readable text. It is either a
/// markdown string or a code-block that provides a language and a code snippet.
/// The language identifier is semantically equal to the optional language
/// identifier in fenced code blocks in GitHub issues.
///
/// The pair of a language and a value is an equivalent to markdown:
///
/// ```LANGUAGE
/// VALUE
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(untagged)]
pub enum MarkedString {
  String(String),
  LanguageString(LanguageString),
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
pub struct LanguageString {
  pub language: String,
  pub value:    String,
}

impl MarkedString {
  #[must_use]
  pub const fn from_markdown(markdown: String) -> Self {
    Self::String(markdown)
  }

  #[must_use]
  pub const fn from_language_code(
    language: String,
    code_block: String,
  ) -> Self {
    Self::LanguageString(LanguageString {
      language,
      value: code_block,
    })
  }
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplyWorkspaceEditParams {
  /// An optional label of the workspace edit. This label is
  /// presented in the user interface for example on an undo
  /// stack to undo the workspace edit.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub label: Option<String>,

  /// The edits to apply.
  pub edit: WorkspaceEdit,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplyWorkspaceEditResponse {
  /// Indicates whether the edit was applied or not.
  pub applied: bool,

  /// An optional textual description for why the edit was not applied.
  /// This may be used may be used by the server for diagnostic
  /// logging or to provide a suitable error for a request that
  /// triggered the edit
  #[serde(skip_serializing_if = "Option::is_none")]
  pub failure_reason: Option<String>,

  /// Depending on the client's failure handling strategy `failedChange` might
  /// contain the index of the change that failed. This property is only
  /// available if the client signals a `failureHandlingStrategy` in its
  /// client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub failed_change: Option<u32>,
}

/// A parameter literal used to pass a partial result token.
#[derive(Debug, Default, Clone, PartialEq, Eq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PartialResultParams {
  #[serde(skip_serializing_if = "Option::is_none")]
  pub partial_result_token: Option<ProgressToken>,
}

// A number of messages include an id/token that is either a number or a string.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Hash)]
#[serde(untagged)]
pub enum NumberOrString {
  Number(i32),
  String(String),
}

impl From<String> for NumberOrString {
  fn from(value: String) -> Self {
    Self::String(value)
  }
}

impl From<&str> for NumberOrString {
  fn from(value: &str) -> Self {
    value.to_string().into()
  }
}

impl From<i32> for NumberOrString {
  fn from(value: i32) -> Self {
    Self::Number(value)
  }
}

/// Main trait for implementing a language server with laburnum.
///
/// This trait composes all LSP service traits. You typically implement this
/// trait by implementing each service trait individually (usually with empty
/// impls to use the defaults).
///
/// # Service Traits
///
/// The language server is composed of 30+ service traits, each handling
/// specific LSP features:
///
/// **Core Services:**
/// - [`InitializeService`] - Server initialization
/// - [`HoverService`] - Hover information
/// - [`GotoService`] - Go to definition, references, implementation
/// - [`CompletionService`] - Code completion
/// - [`SignatureHelpService`] - Function signatures
///
/// **Document Services:**
/// - [`TextDocumentService`] - Document lifecycle (open, change, close)
/// - [`DocumentSymbolService`] - Outline view / breadcrumbs
/// - [`FoldingRangeService`] - Code folding
/// - [`FormattingService`] - Code formatting
///
/// **Symbol Services:**
/// - [`SymbolService`] - Symbol resolution
/// - [`WorkspaceSymbolsService`] - Global symbol search
/// - [`ReferenceService`] - Find all references
///
/// **Diagnostic Services:**
/// - [`DiagnosticService`] - Pull diagnostics
/// - [`WorkspaceDiagnosticService`] - Workspace diagnostics
///
/// **Advanced Services:**
/// - [`CodeActionService`], [`CodeLensService`], [`InlayHintService`],
///   [`SemanticTokensService`], [`CallHierarchyService`],
///   [`TypeHierarchyService`], and more...
///
/// # Default Implementations
///
/// **Most service traits have default implementations** that work with
/// laburnum's standard partitions. You only need to:
/// 1. Write records to standard partitions in `on_file_version`
/// 2. Implement partition record traits (DiagnosticRecord,
///    DocumentSymbolRecord, etc.)
/// 3. Add empty service trait impls
///
/// # Example
///
/// ```no_run
/// # struct MyStorage;
/// # impl laburnum::Partitions for MyStorage {
/// #   type Index = usize;
/// #   type RecordRef<'a> = &'a ();
/// #   type Builder = MyStorageBuilder;
/// #   fn get(&self, _: &Self::Index) -> Option<Self::RecordRef<'_>> { None }
/// #   fn hash_contents(&self, _: &mut laburnum::ContentHasher) {}
/// # }
/// # struct MyStorageBuilder;
/// # impl laburnum::database::storage::PartitionsBuilder for MyStorageBuilder {
/// #   type Storage = MyStorage;
/// #   type Record = ();
/// #   fn push(&mut self, _: Self::Record) -> usize { 0 }
/// #   fn build(self) -> Self::Storage { MyStorage }
/// # }
/// use laburnum::protocol::lsp::*;
///
/// pub struct MyLanguageServer;
///
/// // Implement individual service traits (using defaults)
/// impl InitializeService<MyStorage, MyLanguageServer> for MyLanguageServer {}
/// impl HoverService<MyStorage, MyLanguageServer> for MyLanguageServer {}
/// impl GotoService<MyStorage, MyLanguageServer> for MyLanguageServer {}
/// // ... implement all required traits
///
/// // LanguageServer is automatically implemented
/// // (blanket impl when all service traits are present)
/// ```
///
/// See your implementing crate for a complete working example.
pub trait LanguageServer<P: crate::database::storage::Partitions>:
  InitializeService<P, Self>
  + CallHierarchyService<P, Self>
  + CodeActionService<P, Self>
  + CodeLensService<P, Self>
  + CompletionService<P, Self>
  + DiagnosticService<P, Self>
  + DocumentColorService<P, Self>
  + DocumentHighlightService<P, Self>
  + DocumentLinkService<P, Self>
  + DocumentSymbolService<P, Self>
  + ExecuteCommandService<P, Self>
  + FoldingRangeService<P, Self>
  + FormattingService<P, Self>
  + GotoService<P, Self>
  + HoverService<P, Self>
  + InlayHintService<P, Self>
  + InlineValueService<P, Self>
  + LinkedEditingService<P, Self>
  + MonikerService<P, Self>
  + NotebookDocumentService<P, Self>
  + ReferenceService<P, Self>
  + RenameService<P, Self>
  + SelectionRangeService<P, Self>
  + SemanticTokensService<P, Self>
  + SignatureHelpService<P, Self>
  + SymbolService<P, Self>
  + TextDocumentService<P, Self>
  + TextDocumentHookService<P, Self>
  + TypeHierarchyService<P, Self>
  + WorkspaceDiagnosticService<P, Self>
  + WorkspaceService<P, Self>
  + WorkspaceHooksService<P, Self>
  + SourceFileMeta
  + crate::hooks::LaburnumHooks<P, Self>
  + crate::scheduler::key_watcher::KeyWatcher<P, Self>
  + Send
  + Sync
  + Sized
  + 'static
{
}

impl<P, T> LanguageServer<P> for T
where
  P: crate::database::storage::Partitions,
  T: InitializeService<P, Self>
    + CallHierarchyService<P, Self>
    + CodeActionService<P, Self>
    + CodeLensService<P, Self>
    + CompletionService<P, Self>
    + DiagnosticService<P, Self>
    + DocumentColorService<P, Self>
    + DocumentHighlightService<P, Self>
    + DocumentLinkService<P, Self>
    + DocumentSymbolService<P, Self>
    + ExecuteCommandService<P, Self>
    + FoldingRangeService<P, Self>
    + FormattingService<P, Self>
    + GotoService<P, Self>
    + HoverService<P, Self>
    + InlayHintService<P, Self>
    + InlineValueService<P, Self>
    + LinkedEditingService<P, Self>
    + MonikerService<P, Self>
    + NotebookDocumentService<P, Self>
    + ReferenceService<P, Self>
    + RenameService<P, Self>
    + SelectionRangeService<P, Self>
    + SemanticTokensService<P, Self>
    + SignatureHelpService<P, Self>
    + SymbolService<P, Self>
    + TextDocumentService<P, Self>
    + TextDocumentHookService<P, Self>
    + TypeHierarchyService<P, Self>
    + WorkspaceDiagnosticService<P, Self>
    + WorkspaceService<P, Self>
    + WorkspaceHooksService<P, Self>
    + SourceFileMeta
    + crate::hooks::LaburnumHooks<P, Self>
    + crate::scheduler::key_watcher::KeyWatcher<P, Self>
    + Send
    + Sync
    + 'static,
{
}

#[cfg(test)]
mod tests {
  use {
    super::*,
    crate::protocol::tests::test_serialization,
  };

  #[test]
  fn one_of() {
    test_serialization(&OneOf::<bool, ()>::Left(true), r"true");
    test_serialization(&OneOf::<String, ()>::Left("abcd".into()), r#""abcd""#);
    test_serialization(
      &OneOf::<String, WorkDoneProgressOptions>::Right(
        WorkDoneProgressOptions {
          work_done_progress: Some(false),
        },
      ),
      r#"{"workDoneProgress":false}"#,
    );
  }

  #[test]
  fn number_or_string() {
    test_serialization(&NumberOrString::Number(123), r"123");

    test_serialization(&NumberOrString::String("abcd".into()), r#""abcd""#);
  }

  #[test]
  fn marked_string() {
    test_serialization(&MarkedString::from_markdown("xxx".into()), r#""xxx""#);

    test_serialization(
      &MarkedString::from_language_code("lang".into(), "code".into()),
      r#"{"language":"lang","value":"code"}"#,
    );
  }

  #[test]
  fn language_string() {
    test_serialization(
      &LanguageString {
        language: "LL".into(),
        value:    "VV".into(),
      },
      r#"{"language":"LL","value":"VV"}"#,
    );
  }

  #[test]
  fn workspace_edit() {
    test_serialization(
      &WorkspaceEdit {
        changes: Some(vec![].into_iter().collect()),
        document_changes: None,
        ..Default::default()
      },
      r#"{"changes":{}}"#,
    );

    test_serialization(
      &WorkspaceEdit {
        changes: None,
        document_changes: None,
        ..Default::default()
      },
      r"{}",
    );

    test_serialization(
      &WorkspaceEdit {
        changes: Some(
          vec![("file://test".parse().unwrap(), vec![])]
            .into_iter()
            .collect(),
        ),
        document_changes: None,
        ..Default::default()
      },
      r#"{"changes":{"file://test":[]}}"#,
    );
  }

  #[test]
  fn root_uri_can_be_missing() {
    serde_json::from_str::<InitializeParams>(r#"{ "capabilities": {} }"#)
      .unwrap();
  }

  #[test]
  fn test_watch_kind() {
    test_serialization(&WatchKind::Create, "1");
    test_serialization(&(WatchKind::Create | WatchKind::Change), "3");
    test_serialization(
      &(WatchKind::Create | WatchKind::Change | WatchKind::Delete),
      "7",
    );
  }

  #[test]
  fn test_resource_operation_kind() {
    test_serialization(
      &vec![
        ResourceOperationKind::Create,
        ResourceOperationKind::Rename,
        ResourceOperationKind::Delete,
      ],
      r#"["create","rename","delete"]"#,
    );
  }
}