module Steep
  module Server
    module LSPFormatter
      include Services

      LSP = LanguageServer::Protocol

      module_function

      def markup_content(string = nil, &block)
        if block
          string = yield()
        end

        if string
          LSP::Interface::MarkupContent.new(kind: LSP::Constant::MarkupKind::MARKDOWN, value: string)
        end
      end

      def format_hover_content(content)
        case content
        when HoverProvider::Ruby::VariableContent
          local_variable(content.name, content.type)

        when HoverProvider::Ruby::MethodCallContent
          io = StringIO.new
          call = content.method_call

          case call
          when TypeInference::MethodCall::Typed
            io.puts <<~MD
              ```rbs
              #{call.actual_method_type.type.return_type}
              ```

              ----
            MD

            method_decls = call.method_decls.sort_by {|decl| decl.method_name.to_s }
            method_types = method_decls.map(&:method_type)

            if call.is_a?(TypeInference::MethodCall::Special)
              method_types = [
                call.actual_method_type.with(
                  type: call.actual_method_type.type.with(return_type: call.return_type)
                )
              ]

              header = <<~MD
                **💡 Custom typing rule applies**

                ----
              MD
            end
          when TypeInference::MethodCall::Error
            method_decls = call.method_decls.sort_by {|decl| decl.method_name.to_s }
            method_types = method_decls.map {|decl| decl.method_type }

            header = <<~MD
              **🚨 No compatible method type found**

              ----
            MD
          end

          method_names = method_decls.map {|decl| decl.method_name.relative }
          docs = method_decls.map {|decl| [decl.method_name, decl.method_def.comment] }.to_h

          if header
            io.puts header
          end

          io.puts(
            format_method_item_doc(method_types, method_names, docs)
          )

          io.string

        when HoverProvider::Ruby::DefinitionContent
          io = StringIO.new

          method_name =
            if content.method_name.is_a?(SingletonMethodName)
              "self.#{content.method_name.method_name}"
            else
              content.method_name.method_name
            end

          prefix_size = "def ".size + method_name.size
          method_types = content.definition.method_types

          io.puts <<~MD
            ```rbs
            def #{method_name}: #{method_types.join("\n" + " "*prefix_size + "| ") }
            ```

            ----
          MD

          if content.definition.method_types.size > 1
            io.puts "**Internal method type**"
            io.puts <<~MD
              ```rbs
              #{content.method_type}
              ```

              ----
            MD
          end

          io.puts format_comments(
            content.definition.comments.map {|comment|
              [content.method_name.relative.to_s, comment] #: [String, RBS::AST::Comment?]
            }
          )

          io.string
        when HoverProvider::Ruby::ConstantContent
          io = StringIO.new

          decl_summary =
            case
            when decl = content.class_decl
              declaration_summary(decl.primary.decl)
            when decl = content.constant_decl
              declaration_summary(decl.decl)
            when decl = content.class_alias
              declaration_summary(decl.decl)
            end

          io.puts <<~MD
            ```rbs
            #{decl_summary}
            ```
          MD

          comments = content.comments.map {|comment|
            [content.full_name.relative!.to_s, comment] #: [String, RBS::AST::Comment?]
          }

          unless comments.all?(&:nil?)
            io.puts "----"
            io.puts format_comments(comments)
          end

          io.string
        when HoverProvider::Ruby::TypeContent
          <<~MD
            ```rbs
            #{content.type}
            ```
          MD

        when HoverProvider::Ruby::TypeAssertionContent
          <<~MD
            ```rbs
            #{content.asserted_type}
            ```

            ↑ Converted from `#{content.original_type.to_s}`
          MD

        when HoverProvider::RBS::TypeAliasContent, HoverProvider::RBS::InterfaceContent
          io = StringIO.new()

          io.puts <<~MD
            ```rbs
            #{declaration_summary(content.decl)}
            ```
          MD

          if comment = content.decl.comment
            io.puts
            io.puts "----"

            io.puts format_comment(comment, header: content.decl.name.relative!.to_s)
          end

          io.string

        when HoverProvider::RBS::ClassContent
          io = StringIO.new

          io << <<~MD
          ```rbs
          #{declaration_summary(content.decl)}
          ```
          MD

          if content.decl.comment
            io.puts "----"

            class_name =
              case content.decl
              when RBS::AST::Declarations::ModuleAlias, RBS::AST::Declarations::ClassAlias
                content.decl.new_name
              when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
                content.decl.name
              else
                raise
              end

            io << format_comments([[class_name.relative!.to_s, content.decl.comment]])
          end

          io.string
        else
          raise content.class.to_s
        end
      end

      def format_completion_docs(item)
        case item
        when Services::CompletionProvider::LocalVariableItem
          local_variable(item.identifier, item.type)
        when Services::CompletionProvider::ConstantItem
          io = StringIO.new

          io.puts <<~MD
            ```rbs
            #{declaration_summary(item.decl)}
            ```
          MD

          unless item.comments.all?(&:nil?)
            io.puts "----"
            io.puts format_comments(
              item.comments.map {|comment|
                [item.full_name.relative!.to_s, comment] #: [String, RBS::AST::Comment?]
              }
            )
          end

          io.string
        when Services::CompletionProvider::InstanceVariableItem
          instance_variable(item.identifier, item.type)
        when Services::CompletionProvider::SimpleMethodNameItem
          format_method_item_doc(item.method_types, [], { item.method_name => item.method_member.comment })
        when Services::CompletionProvider::ComplexMethodNameItem
          method_names = item.method_names.map(&:relative).uniq
          comments = item.method_definitions.transform_values {|member| member.comment }
          format_method_item_doc(item.method_types, method_names, comments)
        when Services::CompletionProvider::GeneratedMethodNameItem
          format_method_item_doc(item.method_types, [], {}, "🤖 Generated method for receiver type")
        when Services::CompletionProvider::TypeNameItem
          io = StringIO.new

          io.puts <<~MD
            ```rbs
            #{declaration_summary(item.decl)}
            ```
          MD

          unless item.comments.empty?
            io.puts "----"
            io.puts format_comments(
              item.comments.map {|comment|
                [item.absolute_type_name.relative!.to_s, comment] #: [String, RBS::AST::Comment?]
              }
            )
          end

          io.string
        when Services::CompletionProvider::KeywordArgumentItem
          <<~MD
            **Keyword argument**: `#{item.identifier}`
          MD
        else
          raise
        end
      end

      def format_rbs_completion_docs(type_name, decl, comments)
        io = StringIO.new

        io.puts <<~MD
        ```rbs
        #{declaration_summary(decl)}
        ```
        MD

        unless comments.empty?
          io.puts
          io.puts "----"

          io.puts format_comments(
            comments.map {|comment|
              [type_name.relative!.to_s, comment] #: [String, RBS::AST::Comment?]
            }
          )
        end

        io.string
      end

      def format_comments(comments)
        io = StringIO.new

        with_docs = [] #: Array[[String, RBS::AST::Comment]]
        without_docs = [] #: Array[String]

        comments.each do |title, comment|
          if comment
            with_docs << [title, comment]
          else
            without_docs << title
          end
        end

        unless with_docs.empty?
          with_docs.each do |title, comment|
            io.puts format_comment(comment, header: title)
            io.puts
          end

          unless without_docs.empty?
            io.puts
            io.puts "----"
            if without_docs.size == 1
              io.puts "🔍 One more definition without docs"
            else
              io.puts "🔍 #{without_docs.size} more definitions without docs"
            end
          end
        end

        io.string
      end

      def format_comment(comment, header: nil, &block)
        return unless comment

        io = StringIO.new
        if header
          io.puts "### 📚 #{header.gsub("_", "\\_")}"
          io.puts
        end
        io.puts comment.string.rstrip.gsub(/^[ \t]*<!--(?~-->)-->\n/, "").gsub(/\A([ \t]*\n)+/, "")

        if block
          yield io.string
        else
          io.string
        end
      end

      def local_variable(name, type)
        <<~MD
          **Local variable** `#{name}: #{type}`
        MD
      end

      def instance_variable(name, type)
        <<~MD
          **Instance variable** `#{name}: #{type}`
        MD
      end

      def name_and_params(name, params)
        if params.empty?
          "#{name}"
        else
          ps = params.each.map do |param|
            s = ""
            if param.unchecked?
              s << "unchecked "
            end
            case param.variance
            when :invariant
              # nop
            when :covariant
              s << "out "
            when :contravariant
              s << "in "
            end
            s << param.name.to_s

            if param.upper_bound_type
              s << " < #{param.upper_bound_type.to_s}"
            end

            s
          end

          "#{name}[#{ps.join(", ")}]"
        end
      end

      def name_and_args(name, args)
        if args.empty?
          "#{name}"
        else
          "#{name}[#{args.map(&:to_s).join(", ")}]"
        end
      end

      def declaration_summary(decl)
        # Note that all names in the declarations is absolute
        case decl
        when RBS::AST::Declarations::Class
          super_class = if super_class = decl.super_class
                          " < #{name_and_args(super_class.name, super_class.args)}"
                        end
          "class #{name_and_params(decl.name.relative!, decl.type_params)}#{super_class}"
        when RBS::AST::Declarations::Module
          self_type = unless decl.self_types.empty?
                        " : #{decl.self_types.map {|s| name_and_args(s.name, s.args) }.join(", ")}"
                      end
          "module #{name_and_params(decl.name.relative!, decl.type_params)}#{self_type}"
        when RBS::AST::Declarations::TypeAlias
          "type #{name_and_params(decl.name.relative!, decl.type_params)} = #{decl.type}"
        when RBS::AST::Declarations::Interface
          "interface #{name_and_params(decl.name.relative!, decl.type_params)}"
        when RBS::AST::Declarations::ClassAlias
          "class #{decl.new_name.relative!} = #{decl.old_name}"
        when RBS::AST::Declarations::ModuleAlias
          "module #{decl.new_name.relative!} = #{decl.old_name}"
        when RBS::AST::Declarations::Global
          "#{decl.name}: #{decl.type}"
        when RBS::AST::Declarations::Constant
          "#{decl.name.relative!}: #{decl.type}"
        end
      end

      def format_method_item_doc(method_types, method_names, comments, footer = "")
        io = StringIO.new

        io.puts "**Method type**:"
        io.puts "```rbs"
        if method_types.size == 1
          io.puts method_types[0].to_s
        else
          io.puts "  #{method_types.join("\n| ")}"
        end
        io.puts "```"

        if method_names.size > 1
          io.puts "**Possible methods**: #{method_names.map {|type| "`#{type.to_s}`" }.join(", ")}"
          io.puts
        end

        unless comments.each_value.all?(&:nil?)
          io.puts "----"
          io.puts format_comments(comments.transform_keys {|name| name.relative.to_s }.entries)
        end

        unless footer.empty?
          io.puts footer.rstrip
        end

        io.string
      end
    end
  end
end