defmodule GenLSP do
  @moduledoc "README.md"
             |> File.read!()
             |> String.split("<!-- MDOC !-->")
             |> Enum.fetch!(1)

  defmodule InvalidRequest do
    defexception message: nil

    @impl true
    def exception({request, errors}) do
      msg = """
      Invalid request from the client

      Received: #{inspect(request)}
      Errors: #{inspect(errors)}
      """

      %__MODULE__{message: msg}
    end
  end

  defmodule InvalidResponse do
    defexception message: nil

    @impl true
    def exception({method, response, errors}) do
      msg = """
      Invalid response for request #{method}.

      Response: #{inspect(response)}
      Errors: #{inspect(errors)}
      """

      %__MODULE__{message: msg}
    end
  end

  defmodule InvalidNotification do
    defexception message: nil

    @impl true
    def exception({notification, errors}) do
      msg = """
      Invalid notification from the client

      Given: #{inspect(notification)}
      Errors: #{inspect(errors)}
      """

      %__MODULE__{message: msg}
    end
  end

  alias GenLSP.LSP

  defmacro __using__(_) do
    quote do
      @behaviour GenLSP

      require Logger

      import GenLSP.LSP

      def child_spec(opts) do
        %{
          id: __MODULE__,
          start: {__MODULE__, :start_link, [opts]},
          type: :worker,
          restart: :permanent,
          shutdown: 500
        }
      end

      @impl true
      def handle_info(_, state) do
        Logger.warning("Unhandled message passed to handle_info/2")

        {:noreply, state}
      end

      defoverridable handle_info: 2
    end
  end

  require Logger

  @doc """
  The callback responsible for initializing the process.

  Receives the `t:GenLSP.LSP.t/0` token as the first argument and the arguments that were passed to `GenLSP.start_link/3` as the second.

  ## Usage

  ```elixir
  @impl true
  def init(lsp, args) do
    some_arg = Keyword.fetch!(args, :some_arg)

    {:ok, assign(lsp, static_assign: :some_assign, some_arg: some_arg)}
  end
  ```
  """
  @callback init(lsp :: GenLSP.LSP.t(), init_arg :: term()) :: {:ok, GenLSP.LSP.t()}
  @doc """
  The callback responsible for handling requests from the client.

  Receives the request struct as the first argument and the LSP token `t:GenLSP.LSP.t/0` as the second.

  ## Usage

  ```elixir
  @impl true
  def handle_request(%Initialize{params: %InitializeParams{root_uri: root_uri}}, lsp) do
    {:reply,
     %InitializeResult{
       capabilities: %ServerCapabilities{
         text_document_sync: %TextDocumentSyncOptions{
           open_close: true,
           save: %SaveOptions{include_text: true},
           change: TextDocumentSyncKind.full()
         }
       },
       server_info: %{name: "MyLSP"}
     }, assign(lsp, root_uri: root_uri)}
  end
  ```
  """
  @callback handle_request(request :: term(), state) ::
              {:reply, reply :: term(), state} | {:noreply, state}
            when state: GenLSP.LSP.t()
  @doc """
  The callback responsible for handling notifications from the client.

  Receives the notification struct as the first argument and the LSP token `t:GenLSP.LSP.t/0` as the second.

  ## Usage

  ```elixir
  @impl true
  def handle_notification(%Initialized{}, lsp) do
    # handle the notification

    {:noreply, lsp}
  end
  ```
  """
  @callback handle_notification(notification :: term(), state) :: {:noreply, state}
            when state: GenLSP.LSP.t()
  @doc """
  The callback responsible for handling normal messages.

  Receives the message as the first argument and the LSP token `t:GenLSP.LSP.t/0` as the second.

  ## Usage

  ```elixir
  @impl true
  def handle_info(message, lsp) do
    # handle the message

    {:noreply, lsp}
  end
  ```
  """
  @callback handle_info(message :: any(), state) :: {:noreply, state} when state: GenLSP.LSP.t()

  @default_sync_notifications [
    GenLSP.Notifications.TextDocumentDidOpen,
    GenLSP.Notifications.TextDocumentDidChange,
    GenLSP.Notifications.TextDocumentDidClose,
    GenLSP.Notifications.TextDocumentDidSave,
    GenLSP.Notifications.TextDocumentWillSave,
    GenLSP.Notifications.WorkspaceDidChangeWatchedFiles,
    GenLSP.Notifications.WorkspaceDidChangeWorkspaceFolders,
    GenLSP.Notifications.WorkspaceDidChangeConfiguration,
    GenLSP.Notifications.Initialized,
    GenLSP.Notifications.Exit
  ]

  @options_schema NimbleOptions.new!(
                    buffer: [
                      type: {:or, [:pid, :atom]},
                      doc: "The `t:pid/0` or name of the `GenLSP.Buffer` process."
                    ],
                    assigns: [
                      type: {:or, [:pid, :atom]},
                      doc: "The `t:pid/0` or name of the `GenLSP.Assigns` process."
                    ],
                    task_supervisor: [
                      type: {:or, [:pid, :atom]},
                      doc: "The Task.Supervisor for the task queue"
                    ],
                    name: [
                      type: :atom,
                      doc:
                        "Used for name registration as described in the \"Name registration\" section in the documentation for `GenServer`."
                    ],
                    sync_notifications: [
                      type: {:list, :atom},
                      doc:
                        "List of notification to process synchronously. Defaults to document lifecycle notifications."
                    ]
                  )

  @doc """
  Starts a `GenLSP` process that is linked to the current process.

  ## Options

  #{NimbleOptions.docs(@options_schema)}
  """
  def start_link(module, init_args, opts) do
    opts = NimbleOptions.validate!(opts, @options_schema)

    :proc_lib.start_link(__MODULE__, :init, [
      {module, init_args,
       Keyword.take(opts, [:name, :buffer, :assigns, :task_supervisor, :sync_notifications]),
       self()}
    ])
  end

  @doc false
  def init({module, init_args, opts, parent}) do
    me = self()
    buffer = opts[:buffer]
    assigns = opts[:assigns]
    task_supervisor = opts[:task_supervisor]
    sync_notifications = opts[:sync_notifications] || @default_sync_notifications

    lsp = %LSP{
      mod: module,
      pid: me,
      buffer: buffer,
      assigns: assigns,
      task_supervisor: task_supervisor,
      tasks: Map.new(),
      sync_notifications: MapSet.new(sync_notifications)
    }

    case module.init(lsp, init_args) do
      {:ok, %LSP{} = lsp} ->
        deb = :sys.debug_options([])
        if opts[:name], do: Process.register(self(), opts[:name])
        :proc_lib.init_ack(parent, {:ok, me})

        GenLSP.Buffer.listen(buffer, me)

        loop(lsp, parent, deb)
    end
  end

  @doc """
  Sends a request from the client to the LSP process.

  Generally used by the `GenLSP.Communication.Adapter` implementation to forward messages from the buffer to the LSP process.

  You shouldn't need to use this to implement a language server.
  """
  @spec request_server(pid(), message) :: message when message: term()
  def request_server(pid, request) do
    from = self()
    message = {:request, from, request}
    send(pid, message)
  end

  @doc """
  Sends a notification from the client to the LSP process.

  Generally used by the `GenLSP.Communication.Adapter` implementation to forward messages from the buffer to the LSP process.

  You shouldn't need to use this to implement a language server.
  """
  @spec notify_server(pid(), message) :: message when message: term()
  def notify_server(pid, notification) do
    from = self()
    send(pid, {:notification, from, notification})
  end

  @doc ~S'''
  Sends a notification to the client from the LSP process.

  ## Usage

  ```elixir
  GenLSP.notify(lsp, %TextDocumentPublishDiagnostics{
    params: %PublishDiagnosticsParams{
      uri: "file://#{file}",
      diagnostics: diagnostics
    }
  })
  ```
  '''
  @spec notify(GenLSP.LSP.t(), notification :: any()) :: :ok
  def notify(%{buffer: buffer}, notification) do
    Logger.debug("sent notification server -> client #{notification.method}",
      method: notification.method
    )

    :telemetry.span([:gen_lsp, :notify, :server], %{}, fn ->
      result =
        GenLSP.Buffer.outgoing(buffer, dump!(notification.__struct__.schema(), notification))

      {result, %{method: notification.method}}
    end)
  end

  @doc ~S'''
  Sends a request to the client from the LSP process.

  ## Usage

  ```elixir
  GenLSP.request(lsp, %ClientRegisterCapability{
    id: System.unique_integer([:positive]),
    params: params
  })
  ```
  '''
  @spec request(GenLSP.LSP.t(), request :: any(), timeout :: atom() | non_neg_integer()) :: any()
  def request(%{buffer: buffer}, request, timeout \\ :infinity) do
    Logger.debug("sent request server -> client #{request.method}",
      id: request.id,
      method: request.method
    )

    :telemetry.span([:gen_lsp, :request, :server], %{}, fn ->
      result =
        GenLSP.Buffer.outgoing_sync(
          buffer,
          dump!(request.__struct__.schema(), request),
          timeout
        )

      result = unify!(request.__struct__.result(), result)

      {result, %{id: request.id, method: request.method}}
    end)
  end

  defp write_debug(device, event, name) do
    IO.write(device, "#{inspect(name)} event = #{inspect(event)}\n")
  end

  defp loop(%LSP{} = lsp, parent, deb) do
    receive do
      {:system, from, request} ->
        :sys.handle_system_msg(request, from, parent, __MODULE__, deb, lsp)

      {:request, from, request} ->
        deb = :sys.handle_debug(deb, &write_debug/3, __MODULE__, {:in, :request, from})

        start = System.system_time(:microsecond)
        :telemetry.execute([:gen_lsp, :request, :client, :start], %{})

        id = request["id"]

        {:ok, task} =
          attempt(
            lsp,
            "Last message received: handle_request #{inspect(request)}",
            [:gen_lsp, :request, :client],
            fn
              {:error, error} ->
                {:ok, output} =
                  Schematic.dump(
                    GenLSP.ErrorResponse.schema(),
                    %GenLSP.ErrorResponse{
                      code: GenLSP.Enumerations.ErrorCodes.internal_error(),
                      message: error
                    }
                  )

                packet = %{
                  "jsonrpc" => "2.0",
                  "id" => id,
                  "error" => output
                }

                # deb =
                #   :sys.handle_debug(deb, &write_debug/3, __MODULE__, {:out, :request, from})

                GenLSP.Buffer.outgoing(lsp.buffer, packet)

              _ ->
                case GenLSP.Requests.new(request) do
                  {:ok, req} ->
                    result =
                      :telemetry.span([:gen_lsp, :handle_request], %{method: req.method}, fn ->
                        {lsp.mod.handle_request(req, lsp), %{}}
                      end)

                    case result do
                      {:reply, reply, %LSP{} = lsp} ->
                        response_key =
                          case reply do
                            %GenLSP.ErrorResponse{} -> "error"
                            _ -> "result"
                          end

                        # if result is valid, continue, if not, we return an internal error
                        {response_key, response} =
                          case Schematic.dump(req.__struct__.result(), reply) do
                            {:ok, output} ->
                              {response_key, output}

                            {:error, errors} ->
                              exception = InvalidResponse.exception({req.method, reply, errors})

                              Logger.error(Exception.format(:error, exception))

                              {:ok, output} =
                                Schematic.dump(
                                  GenLSP.ErrorResponse.schema(),
                                  %GenLSP.ErrorResponse{
                                    code: GenLSP.Enumerations.ErrorCodes.internal_error(),
                                    message: exception.message
                                  }
                                )

                              {"error", output}
                          end

                        packet = %{
                          "jsonrpc" => "2.0",
                          "id" => id,
                          response_key => response
                        }

                        GenLSP.Buffer.outgoing(lsp.buffer, packet)

                        duration = System.system_time(:microsecond) - start

                        Logger.debug(
                          "handled request client -> server #{req.method} in #{format_time(duration)}",
                          id: req.id,
                          method: req.method
                        )

                        :telemetry.execute([:gen_lsp, :request, :client, :stop], %{
                          duration: duration
                        })

                      {:noreply, _lsp} ->
                        duration = System.system_time(:microsecond) - start

                        Logger.debug(
                          "handled request client -> server #{req.method} in #{format_time(duration)}",
                          id: req.id,
                          method: req.method
                        )

                        :telemetry.execute([:gen_lsp, :request, :client, :stop], %{
                          duration: duration
                        })
                    end

                  {:error, errors} ->
                    # the payload is not parseable at all, other than being valid JSON and having
                    # an `id` property to signal its a request
                    exception = InvalidRequest.exception({request, errors})

                    Logger.error(Exception.format(:error, exception))

                    {:ok, output} =
                      Schematic.dump(
                        GenLSP.ErrorResponse.schema(),
                        %GenLSP.ErrorResponse{
                          code: GenLSP.Enumerations.ErrorCodes.invalid_request(),
                          message: exception.message
                        }
                      )

                    packet = %{
                      "jsonrpc" => "2.0",
                      "id" => id,
                      "error" => output
                    }

                    GenLSP.Buffer.outgoing(lsp.buffer, packet)
                end
            end
          )

        tasks = Map.put(lsp.tasks, id, task)

        lsp = put_in(lsp.tasks, tasks)

        loop(lsp, parent, deb)

      {:notification, from, notification} ->
        deb = :sys.handle_debug(deb, &write_debug/3, __MODULE__, {:in, :notification, from})
        start = System.system_time(:microsecond)
        :telemetry.execute([:gen_lsp, :notification, :client, :start], %{})

        case GenLSP.Notifications.new(notification) do
          {:ok, %GenLSP.Notifications.DollarCancelRequest{} = note} ->
            handle_cancel_request(lsp, note, start)

          {:ok, note} ->
            if MapSet.member?(lsp.sync_notifications, note.__struct__) do
              handle_notification_sync(lsp, note, start)
            else
              handle_notification_async(lsp, note, start)
            end

          {:error, errors} ->
            # the payload is not parseable at all, other than being valid JSON
            exception = InvalidNotification.exception({notification, errors})
            Logger.warning(Exception.format(:error, exception))
        end

        loop(lsp, parent, deb)

      message ->
        deb = :sys.handle_debug(deb, &write_debug/3, __MODULE__, {:in, :info, message})
        start = System.system_time(:microsecond)
        :telemetry.execute([:gen_lsp, :info, :start], %{})

        attempt(
          lsp,
          "Last message received: handle_info #{inspect(message)}",
          [:gen_lsp, :info],
          fn
            {:error, _} ->
              Logger.warning("handle_info #{inspect(message)} crashed")

            _ ->
              result =
                :telemetry.span([:gen_lsp, :handle_info], %{}, fn ->
                  {lsp.mod.handle_info(message, lsp), %{}}
                end)

              case result do
                {:noreply, %LSP{} = _lsp} ->
                  duration = System.system_time(:microsecond) - start
                  :telemetry.execute([:gen_lsp, :info, :stop], %{duration: duration})
              end
          end
        )

        loop(lsp, parent, deb)
    end
  end

  defp format_time(time) when time < 1000 do
    "#{time}µs"
  end

  defp format_time(time) do
    "#{System.convert_time_unit(time, :microsecond, :millisecond)}ms"
  end

  @spec attempt(LSP.t(), String.t(), list(atom()), (:try | {:error, String.t()} -> any())) ::
          DynamicSupervisor.on_start_child()
  defp attempt(lsp, message, prefix, callback) do
    Task.Supervisor.start_child(lsp.task_supervisor, fn ->
      try do
        callback.(:try)
      rescue
        e ->
          :telemetry.execute(prefix ++ [:exception], %{message: message})

          message = Exception.format(:error, e, __STACKTRACE__)
          Logger.error(message)
          error(lsp, message)

          callback.({:error, message})
      end
    end)
  end

  defp handle_cancel_request(lsp, note, start) do
    result =
      :telemetry.span([:gen_lsp, :handle_notification], %{method: note.method}, fn ->
        with pid when is_pid(pid) <- lsp.tasks[note.params.id] do
          Task.Supervisor.terminate_child(lsp.task_supervisor, pid)
        end

        {{:noreply, lsp}, %{}}
      end)

    case result do
      {:noreply, %LSP{}} ->
        duration = System.system_time(:microsecond) - start

        Logger.debug(
          "handled notification client -> server #{note.method} in #{format_time(duration)}",
          method: note.method
        )

        :telemetry.execute([:gen_lsp, :notification, :client, :stop], %{duration: duration})
    end
  end

  defp handle_notification_sync(lsp, note, start) do
    try do
      result =
        :telemetry.span([:gen_lsp, :handle_notification], %{method: note.method}, fn ->
          {lsp.mod.handle_notification(note, lsp), %{}}
        end)

      case result do
        {:noreply, %LSP{}} ->
          duration = System.system_time(:microsecond) - start

          Logger.debug(
            "handled notification client -> server #{note.method} in #{format_time(duration)}",
            method: note.method
          )

          :telemetry.execute([:gen_lsp, :notification, :client, :stop], %{duration: duration})
      end
    rescue
      e ->
        :telemetry.execute([:gen_lsp, :notification, :client, :exception], %{
          message: "Last message received: handle_notification #{inspect(note)}"
        })

        message = Exception.format(:error, e, __STACKTRACE__)
        Logger.error(message)
        error(lsp, message)
    end
  end

  defp handle_notification_async(lsp, note, start) do
    attempt(
      lsp,
      "Last message received: handle_notification #{inspect(note)}",
      [:gen_lsp, :notification, :client],
      fn
        {:error, _} ->
          :ok

        _ ->
          result =
            :telemetry.span([:gen_lsp, :handle_notification], %{method: note.method}, fn ->
              {lsp.mod.handle_notification(note, lsp), %{}}
            end)

          case result do
            {:noreply, %LSP{}} ->
              duration = System.system_time(:microsecond) - start

              Logger.debug(
                "handled notification client -> server #{note.method} in #{format_time(duration)}",
                method: note.method
              )

              :telemetry.execute([:gen_lsp, :notification, :client, :stop], %{duration: duration})
          end
      end
    )
  end

  defp dump!(schematic, structure) do
    {:ok, output} = Schematic.dump(schematic, structure)
    output
  end

  defp unify!(schematic, structure) do
    {:ok, output} = Schematic.unify(schematic, structure)
    output
  end

  @doc false
  def system_continue(parent, deb, state) do
    loop(state, parent, deb)
  end

  @doc false
  def system_terminate(reason, _parent, _deb, _chs) do
    exit(reason)
  end

  @doc false
  def system_get_state(state) do
    {:ok, state}
  end

  @doc false
  def system_replace_state(state_fun, state) do
    new_state = state_fun.(state)

    {:ok, new_state, new_state}
  end

  @doc """
  Send a `window/logMessage` error notification to the client.

  See `GenLSP.Enumerations.MessageType.error/0`.

  ## Usage

  ```elixir
  GenLSP.error(lsp, "Failed to compiled!")
  ```
  """
  @spec error(GenLSP.LSP.t(), String.t()) :: :ok
  def error(lsp, message) do
    log_message(lsp, GenLSP.Enumerations.MessageType.error(), message)
  end

  @doc """
  Send a `window/logMessage` error notification to the client.

  See `GenLSP.Enumerations.MessageType.warning/0`.

  ## Usage

  ```elixir
  GenLSP.warning(lsp, "Variable `foo` is unused.")
  ```
  """
  @spec warning(GenLSP.LSP.t(), String.t()) :: :ok
  def warning(lsp, message) do
    log_message(lsp, GenLSP.Enumerations.MessageType.warning(), message)
  end

  @doc """
  Send a `window/logMessage` info notification to the client.

  See `GenLSP.Enumerations.MessageType.info/0`.

  ## Usage

  ```elixir
  GenLSP.info(lsp, "Compilation complete!")
  ```
  """
  @spec info(GenLSP.LSP.t(), String.t()) :: :ok
  def info(lsp, message) do
    log_message(lsp, GenLSP.Enumerations.MessageType.info(), message)
  end

  @doc """
  Send a `window/logMessage` log notification to the client.

  See `GenLSP.Enumerations.MessageType.log/0`.

  ## Usage

  ```elixir
  GenLSP.log(lsp, "Starting compilation.")
  ```
  """
  @spec log(GenLSP.LSP.t(), String.t()) :: :ok
  def log(lsp, message) do
    log_message(lsp, GenLSP.Enumerations.MessageType.log(), message)
  end

  defp log_message(lsp, level, message) do
    GenLSP.notify(lsp, %GenLSP.Notifications.WindowLogMessage{
      params: %GenLSP.Structures.LogMessageParams{
        type: level,
        message: message
      }
    })
  end
end
