credo

defmodule Credo.CLI.Command.Explain.Output.Default do
  @moduledoc false

  alias Credo.CLI.Output
  alias Credo.CLI.Output.UI
  alias Credo.Code.Scope

  @indent 8
  @params_min_indent 20

  @doc "Called before the analysis is run."
  def print_before_info(source_files, exec) do
    UI.puts()

    case Enum.count(source_files) do
      0 -> UI.puts("No files found!")
      1 -> UI.puts("Checking 1 source file ...")
      count -> UI.puts("Checking #{count} source files ...")
    end

    Output.print_skipped_checks(exec)
  end

  @doc "Called after the analysis has run."
  def print_after_info(explanations, exec, line_no, column) do
    term_width = Output.term_columns()

    print_explanations(explanations, exec, term_width, line_no, column)
  end

  defp print_explanations(
         explanations,
         _exec,
         term_width,
         _line_no,
         _column
       ) do
    first_explanation = explanations |> List.first()
    scope_name = Scope.mod_name(first_explanation.scope)
    color = Output.check_color(first_explanation.check)

    UI.puts()

    [
      :bright,
      "#{color}_background" |> String.to_atom(),
      color,
      " ",
      Output.foreground_color(color),
      :normal,
      " #{scope_name}" |> String.pad_trailing(term_width - 1)
    ]
    |> UI.puts()

    UI.puts_edge(color)

    explanations
    |> Enum.each(&print_issue(&1, term_width))
  end

  defp print_issue(
         %{
           category: category,
           check: check,
           column: column,
           explanation_for_issue: explanation_for_issue,
           filename: filename,
           trigger: trigger,
           line_no: line_no,
           message: message,
           priority: priority,
           related_code: related_code,
           scope: scope
         },
         term_width
       ) do
    pos = pos_string(line_no, column)

    outer_color = Output.check_color(category)
    inner_color = Output.check_color(category)
    message_color = inner_color
    filename_color = :default_color

    tag_style =
      if outer_color == inner_color do
        :faint
      else
        :bright
      end

    [
      UI.edge(outer_color),
      inner_color,
      tag_style,
      "  ",
      Output.check_tag(check.category),
      :reset,
      " Category: #{check.category} "
    ]
    |> UI.puts()

    [
      UI.edge(outer_color),
      inner_color,
      tag_style,
      "   ",
      priority |> Output.priority_arrow(),
      :reset,
      "  Priority: #{Output.priority_name(priority)} "
    ]
    |> UI.puts()

    UI.puts_edge(outer_color)

    [
      UI.edge(outer_color),
      inner_color,
      tag_style,
      "    ",
      :normal,
      message_color,
      "  ",
      message
    ]
    |> UI.puts()

    [
      UI.edge(outer_color, @indent),
      filename_color,
      :faint,
      to_string(filename),
      :default_color,
      :faint,
      pos,
      :faint,
      " (#{scope})"
    ]
    |> UI.puts()

    if line_no do
      print_issue_line_no(
        term_width,
        line_no,
        column,
        trigger,
        related_code,
        outer_color,
        inner_color
      )
    end

    UI.puts_edge([outer_color, :faint], @indent)

    [
      UI.edge([outer_color, :faint]),
      :reset,
      :color239,
      String.duplicate(" ", @indent - 5),
      "__ WHY IT MATTERS"
    ]
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])

    (explanation_for_issue || "TODO: Insert explanation")
    |> String.trim()
    |> String.split("\n")
    |> Enum.flat_map(&format_explanation(&1, outer_color))
    |> Enum.slice(0..-2)
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])

    print_params_explanation(check, outer_color)

    UI.puts_edge([outer_color, :faint])
  end

  def format_explanation(line, outer_color) do
    [
      UI.edge([outer_color, :faint], @indent),
      :reset,
      line |> format_explanation_text,
      "\n"
    ]
  end

  def format_explanation_text("    " <> line) do
    [:yellow, :faint, "    ", line]
  end

  def format_explanation_text(line) do
    # TODO: format things in backticks in help texts
    # case Regex.run(~r/(\`[a-zA-Z_\.]+\`)/, line) do
    #  v ->
    #    # IO.inspect(v)
    [:reset, line]
    # end
  end

  defp pos_string(nil, nil), do: ""
  defp pos_string(line_no, nil), do: ":#{line_no}"
  defp pos_string(line_no, column), do: ":#{line_no}:#{column}"

  def print_params_explanation(nil, _), do: nil

  def print_params_explanation(check, outer_color) do
    check_name = check |> to_string |> String.replace(~r/^Elixir\./, "")

    [
      UI.edge([outer_color, :faint]),
      :reset,
      :color239,
      String.duplicate(" ", @indent - 5),
      "__ CONFIGURATION OPTIONS"
    ]
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])

    print_params_explanation(
      outer_color,
      check_name,
      check.explanation_for_params,
      check.params_defaults
    )
  end

  def print_params_explanation(outer_color, check_name, [], _defaults) do
    [
      UI.edge([outer_color, :faint]),
      :reset,
      String.duplicate(" ", @indent - 2),
      "You can disable this check by using this tuple"
    ]
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])

    [
      UI.edge([outer_color, :faint]),
      :reset,
      String.duplicate(" ", @indent - 2),
      "  {",
      :cyan,
      check_name,
      :reset,
      ", ",
      :cyan,
      "false",
      :reset,
      "}"
    ]
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])

    [
      UI.edge([outer_color, :faint]),
      :reset,
      String.duplicate(" ", @indent - 2),
      "There are no other configuration options."
    ]
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])
  end

  def print_params_explanation(outer_color, check_name, keywords, defaults) do
    [
      UI.edge([outer_color, :faint]),
      :reset,
      String.duplicate(" ", @indent - 2),
      "To configure this check, use this tuple"
    ]
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])

    [
      UI.edge([outer_color, :faint]),
      :reset,
      String.duplicate(" ", @indent - 2),
      "  {",
      :cyan,
      check_name,
      :reset,
      ", ",
      :cyan,
      :faint,
      "<params>",
      :reset,
      "}"
    ]
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])

    [
      UI.edge([outer_color, :faint]),
      :reset,
      String.duplicate(" ", @indent - 2),
      "with ",
      :cyan,
      :faint,
      "<params>",
      :reset,
      " being ",
      :cyan,
      "false",
      :reset,
      " or any combination of these keywords:"
    ]
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])

    params_indent = get_params_indent(keywords, @params_min_indent)

    keywords
    |> Enum.each(fn {param, text} ->
      [
        UI.edge([outer_color, :faint]),
        :reset,
        String.duplicate(" ", @indent - 2),
        :cyan,
        "  #{param}:" |> String.pad_trailing(params_indent + 3),
        :reset,
        text
      ]
      |> UI.puts()

      default = defaults[param]

      if default do
        default_text = "(defaults to #{inspect(default)})"

        [
          UI.edge([outer_color, :faint]),
          :reset,
          String.duplicate(" ", @indent - 2),
          :cyan,
          " " |> String.pad_trailing(params_indent + 3),
          :reset,
          :faint,
          default_text
        ]
        |> UI.puts()
      end
    end)
  end

  defp get_params_indent(keywords, min_indent) do
    params_indent =
      Enum.reduce(keywords, min_indent, fn {param, _text}, current ->
        size = param |> to_string |> String.length()

        if size > current do
          size
        else
          current
        end
      end)

    # Round up to the next multiple of 2
    (trunc(params_indent / 2) + 1) * 2
  end

  defp print_issue_column(column, trigger, outer_color, inner_color) do
    offset = 0
    # column is one-based
    x = max(column - offset - 1, 0)

    w =
      if is_nil(trigger) do
        1
      else
        trigger
        |> to_string()
        |> String.length()
      end

    [
      UI.edge([outer_color, :faint], @indent),
      inner_color,
      String.duplicate(" ", x),
      :faint,
      String.duplicate("^", w)
    ]
    |> UI.puts()
  end

  defp print_issue_line_no(
         term_width,
         line_no,
         column,
         trigger,
         related_code,
         outer_color,
         inner_color
       ) do
    UI.puts_edge([outer_color, :faint])

    [
      UI.edge([outer_color, :faint]),
      :reset,
      :color239,
      String.duplicate(" ", @indent - 5),
      "__ CODE IN QUESTION"
    ]
    |> UI.puts()

    UI.puts_edge([outer_color, :faint])

    code_color = :faint

    print_source_line(
      related_code,
      line_no - 2,
      term_width,
      code_color,
      outer_color
    )

    print_source_line(
      related_code,
      line_no - 1,
      term_width,
      code_color,
      outer_color
    )

    print_source_line(
      related_code,
      line_no,
      term_width,
      [:cyan, :bright],
      outer_color
    )

    if column, do: print_issue_column(column, trigger, outer_color, inner_color)

    print_source_line(
      related_code,
      line_no + 1,
      term_width,
      code_color,
      outer_color
    )

    print_source_line(
      related_code,
      line_no + 2,
      term_width,
      code_color,
      outer_color
    )
  end

  defp print_source_line(related_code, line_no, term_width, code_color, outer_color) do
    line =
      related_code
      |> Enum.find_value(fn
        {line_no2, line} when line_no2 == line_no -> line
        _ -> nil
      end)

    if line do
      line_no_str =
        "#{line_no} "
        |> String.pad_leading(@indent - 2)

      [
        UI.edge([outer_color, :faint]),
        :reset,
        :faint,
        line_no_str,
        :reset,
        code_color,
        UI.truncate(line, term_width - @indent)
      ]
      |> UI.puts()
    end
  end
end