defmodule EexToHeex do
  @moduledoc """
  EexToHeex performs best effort conversion of html.eex templates to heex.

  The output is not guaranteed to be correct. However, conversion works
  correctly for a sufficiently wide range of input templates
  that the amount of manual conversion work can be significantly reduced.

  See
  https://github.com/phoenixframework/phoenix_live_view/blob/master/CHANGELOG.md#new-html-engine
  for information on the differences between eex and heex templates.
  """

  alias Phoenix.LiveView.HTMLEngine

  @doc """
  Performs best effort conversion of an html.eex template to a heex template.
  Returns `{:ok, output_string}` if successful, or `{:error, output_string, error}`
  on error. In the latter case, `output_string` may be `nil` if the error occurred
  before any output was generated.

  On success, the output is guaranteed to be a valid heex template
  (since it has passed successfully through `HTMLEngine.compile`).
  However, there is no general guarantee that the output template will
  have exactly the same behavior as the input template.
  """
  @spec eex_to_heex(String.t()) :: {:ok, String.t()} | {:error, String.t() | nil, any()}
  def eex_to_heex(str) do
    with {:ok, toks} <-
           EEx.Tokenizer.tokenize(str, _start_line = 1, _start_col = 0, %{
             trim: false,
             indentation: 0
           }) do
      toks = fudge_tokens(toks)

      attrs = find_attrs(false, false, [], toks)

      attr_reps =
        Enum.flat_map(attrs, fn {quoted, subs} -> attr_replacements(str, quoted, subs) end)

      forms = find_form_tags([], toks)
      form_reps = form_replacements(str, forms)

      output = multireplace(str, attr_reps ++ form_reps)
      check_output(output)
    else
      {:error, err} ->
        {:error, nil, err}
    end
  end

  @doc """
  Performs best effort conversion of inline ~L templates to ~H templates.
  Returns `{:ok, output_string}` if successful, or `{:error, output_string,
  error}` on error. In the latter case, `output_string` may be `nil` if the
  error occurred before any output was generated.

  On success, the inline ~H templates are guaranteed to be valid, (since they've
  passed successfully through `HTMLEngine.compile`). However, there is no
  general guarantee that the output templates will have exactly the same
  behavior as the input templates.
  """
  @spec eex_to_heex(String.t()) :: {:ok, String.t()} | {:error, String.t() | nil, any()}
  def ex_to_heex(str) do
    with {:ok, ast} <- Code.string_to_quoted(str, columns: true) do
      {_, transformed} = Macro.prewalk(ast, {:ok, str}, &transform_ex/2)

      transformed
    else
      {:error, err} ->
        {:error, nil, err}
    end
  end

  defp transform_ex(
         {:sigil_L, [delimiter: _, line: line, column: column], children} = ast,
         {:ok, str}
       ) do
    transformed =
      str
      |> replace(line, column, "~L", "~H")
      |> transform_leex(children)

    {ast, transformed}
  end

  defp transform_ex(ast, str), do: {ast, str}

  defp transform_leex(str, [{:<<>>, [line: line, column: column], [leex]}, []]) do
    case eex_to_heex(leex) do
      {:ok, replacement} ->
        indentation = String.length("~L|")
        replacement = replace(str, line, column + indentation, leex, replacement)
        {:ok, replacement}

      other ->
        other
    end
  end

  defp transform_leex(str, [
         {:<<>>, [indentation: indentation, line: line, column: _], [leex]},
         []
       ]) do
    case eex_to_heex(leex) do
      {:ok, heex} ->
        replacement =
          leex
          |> String.split("\n")
          |> Enum.zip(String.split(heex, "\n"))
          |> Enum.with_index()
          |> Enum.reduce(str, fn {{from, to}, index}, str ->
            replace(str, line + index + 1, indentation + 1, from, to)
          end)

        {:ok, replacement}

      other ->
        other
    end
  end

  defp replace(text, line_num, column_num, from, to) do
    for {line, line_index} <- text |> String.split("\n") |> Enum.with_index() do
      if line_index + 1 == line_num do
        replace_at(line, column_num - 1, from, to)
      else
        line
      end
    end
    |> Enum.join("\n")
  end

  defp replace_at(text, position, from, to) do
    {a, b} = String.split_at(text, position)
    to_replace = String.slice(b, 0, String.length(from))

    if to_replace != from do
      raise "Attempted to replace:\n\n#{from}\n\nbut found:\n\n#{to_replace}\n\nat position #{
              position
            }"
    end

    a <> String.replace_prefix(b, from, to)
  end

  defp check_output(output) do
    with {:ok, tmp_path} <- Briefly.create(),
         :ok <- File.write(tmp_path, output) do
      try do
        # Phoenix.LiveView.HTMLEngine ignores its second param
        HTMLEngine.compile(tmp_path, "foo.html.heex")
        {:ok, output}
      rescue
        err ->
          {:error, output, err}
      end
    else
      {:error, err} ->
        {:error, output, err}
    end
  end

  # Column information for some tokens is systematically off by a few chars.
  defp fudge_tokens(tokens) do
    Enum.map(tokens, fn tok ->
      case tok do
        {:text, l, c, t} ->
          {:text, l,
           if l == 1 do
             c
           else
             c - 1
           end, t}

        {:expr, l, c, eq, expr} ->
          {:expr, l,
           if l == 1 do
             c + 3
           else
             c + 2
           end, eq, expr}

        _ ->
          tok
      end
    end)
  end

  defp find_form_tags(accum, [t = {:expr, _, _, '=', txt} | rest]) do
    txt = to_string(txt)

    if txt =~ ~r/^\s*[[:alnum:]_]+\s*=\s*form_for[\s|(]/ and not (txt =~ ~r/\s->\s*$/) do
      find_form_tags([{:open, true, t} | accum], rest)
    else
      find_form_tags(accum, rest)
    end
  end

  defp find_form_tags(accum, [t = {:text, _, _, txt} | rest]) do
    txt = to_string(txt)
    forms = Regex.scan(~r{</?form[>\s]}i, txt, return: :index)

    accums =
      Enum.map(
        forms,
        fn [{i, l}] ->
          if String.starts_with?(String.downcase(String.slice(txt, i, l)), "<form") do
            {:open, false, t}
          else
            {:close, i, t}
          end
        end
      )

    find_form_tags(Enum.reverse(accums) ++ accum, rest)
  end

  defp find_form_tags(accum, [_ | rest]) do
    find_form_tags(accum, rest)
  end

  defp find_form_tags(accum, []) do
    Enum.reverse(accum)
  end

  defp pair_open_close_forms(accum, _currently_open, []) do
    Enum.reverse(accum)
  end

  defp pair_open_close_forms(accum, currently_open, [f = {:open, _is_live, _tok} | rest]) do
    pair_open_close_forms(accum, [f | currently_open], rest)
  end

  defp pair_open_close_forms(accum, [], [{:close, _i, _tok} | rest]) do
    # Ignore unmatched closers
    pair_open_close_forms(accum, [], rest)
  end

  defp pair_open_close_forms(accum, [o | os], [c = {:close, _i, _tok} | rest]) do
    pair_open_close_forms([{o, c} | accum], os, rest)
  end

  defp form_replacements(str, forms) do
    open_close_pairs = pair_open_close_forms([], [], forms)

    open_close_pairs
    |> Enum.flat_map(fn {{:open, is_live, otok}, {:close, ci, ctok}} ->
      if is_live do
        # <%= f = form_for ... %> -> <.form ...>
        {:expr, tl, tc, '=', expr} = otok
        expr = to_string(expr)
        dot_form = mung_form_for(Code.string_to_quoted!(expr))
        ff_start = get_index(str, tl, tc)

        {:text, l, c, _} = ctok
        close_start = get_index(str, l, c) + ci

        ff_repl = {
          scan_to_char(str, "<", -1, ff_start),
          scan_to_char(str, ">", 1, ff_start + String.length(expr)) + 1,
          dot_form
        }

        close_repl = {close_start, close_start + String.length("</form>"), "</.form>"}

        [close_repl, ff_repl]
      else
        []
      end
    end)
  end

  defp mung_form_for(
         {:=, _,
          [
            f = {_, _, _},
            {:form_for, _,
             [
               changeset,
               url
               | more_args
             ]}
          ]}
       ) do
    extras =
      Enum.reduce(
        List.first(more_args) || [],
        "",
        fn {k, v}, s ->
          s <> " #{String.replace(Atom.to_string(k), "_", "-")}=#{brace_wrap(Macro.to_string(v))}"
        end
      )

    "<.form let={#{Macro.to_string(f)}} for=#{brace_wrap(Macro.to_string(changeset))} url=#{
      brace_wrap(Macro.to_string(url))
    }#{extras}>"
  end

  defp brace_wrap(s = "\"" <> _) do
    s
  end

  defp brace_wrap(val) do
    "{#{val}}"
  end

  defp find_attrs(
         inside_tag?,
         just_subbed?,
         accum,
         [{:text, _, _, txt}, e = {:expr, _, _, '=', _contents} | rest]
       ) do
    txt = to_string(txt)

    # Strip the trailing part of the last attr of this tag if there was one and it was quoted.
    txt =
      case {just_subbed?, List.first(accum)} do
        {true, {quoted, _}} when quoted != nil ->
          String.replace(txt, ~r/^[^#{quoted}]+/, "")

        _ ->
          txt
      end

    {inside_tag?, _offset} = update_inside_tag(inside_tag?, txt)

    if inside_tag? do
      case Regex.run(
             ~r/\s*[[:alnum:]-]+=\s*(?:(?:\s*)|(?:"([^"]*))|(?:'([^']*)))$/,
             String.slice(txt, 0..-1)
           ) do
        [_, prefix] ->
          {subs, rest} = find_subs("\"", [{e, prefix, ""}], rest)
          find_attrs(inside_tag?, _just_subbed? = true, [{_quoted = "\"", subs} | accum], rest)

        [_, _, prefix] ->
          {subs, rest} = find_subs("'", [{e, prefix, ""}], rest)
          find_attrs(inside_tag?, _just_subbed? = true, [{_quoted = "'", subs} | accum], rest)

        [_] ->
          find_attrs(
            inside_tag?,
            _just_subbed? = true,
            [{_quoted = nil, [{e, "", ""}]} | accum],
            rest
          )

        _ ->
          find_attrs(inside_tag?, _just_subbed? = false, accum, rest)
      end
    else
      find_attrs(inside_tag?, _just_subbed? = false, accum, rest)
    end
  end

  defp find_attrs(inside_tag?, _just_subbed?, accum, [{:text, _, _, txt} | rest]) do
    txt = to_string(txt)
    {inside_tag?, _} = update_inside_tag(inside_tag?, txt)
    find_attrs(inside_tag?, _just_subbed? = false, accum, rest)
  end

  defp find_attrs(inside_tag?, _just_subbed?, accum, [_ | rest]) do
    find_attrs(inside_tag?, _just_subbed? = false, accum, rest)
  end

  defp find_attrs(_inside_tag?, _just_subbed?, accum, []) do
    Enum.reverse(accum)
  end

  defp update_inside_tag(inside_tag?, txt) do
    case Regex.run(~r/<[[:alnum:]_]+[\s>][^>]*$/, txt, return: :index) do
      [{offset, _}] ->
        {true, offset}

      nil ->
        {inside_tag? and not String.contains?(txt, ">"), 0}
    end
  end

  defp find_subs(
         quoted,
         accum = [{e, prefix, _suffix} | arest],
         toks = [{:text, _, _, txt} | trest]
       ) do
    txt = to_string(txt)

    case Regex.run(~r/^([^#{quoted}]*)(.?)/, txt) do
      [_, suffix, en] ->
        accum = [{e, prefix, suffix} | arest]

        if en == quoted do
          {Enum.reverse(accum), toks}
        else
          find_subs(quoted, accum, trest)
        end

      nil ->
        find_subs(quoted, accum, trest)
    end
  end

  defp find_subs(quoted, accum, [e = {:expr, _, _, '=', _contents} | rest]) do
    find_subs(quoted, [{e, "", ""} | accum], rest)
  end

  defp find_subs(_quoted, accum, toks) do
    {Enum.reverse(accum), toks}
  end

  defp attr_replacements(str, _quoted = nil, [{{:expr, l, c, _, expr}, "", ""}]) do
    expr = to_string(expr)
    expr_start = get_index(str, l, c)
    expr_end = expr_start + String.length(expr)

    open = scan_to_char(str, "<", -1, expr_start)

    close = scan_to_char(str, ">", 1, expr_end)

    [{open, expr_start, "{\"\#{"}, {expr_start, expr_end, expr}, {expr_end, close + 1, "}\"}"}]
  end

  defp attr_replacements(str, quoted, subs = [_ | _]) do
    subs_len = length(subs)

    subs
    |> Enum.with_index()
    |> Enum.flat_map(fn {{{:expr, l, c, _, expr}, prefix, suffix}, i} ->
      expr = to_string(expr)
      expr_start = get_index(str, l, c)
      expr_end = expr_start + String.length(expr)

      opener =
        if i == 0 do
          open = scan_to_char(str, quoted, -1, expr_start)
          {open, expr_start, "{\""}
        else
          open = scan_to_char(str, "<", -1, expr_start)
          {open, expr_start, ""}
        end

      closer =
        if i == subs_len - 1 do
          close = scan_to_char(str, quoted, 1, expr_end)
          {expr_end, close + 1, "\"}"}
        else
          close = scan_to_char(str, ">", 1, expr_end)
          {expr_end, close + 1 + String.length(suffix), ""}
        end

      [opener] ++
        [{expr_start, expr_end, "#{estring(prefix)}\#{#{expr}}#{estring(suffix)}"}] ++
        [closer]
    end)
  end

  defp estring("" <> str) do
    decoded = HtmlEntities.decode(str)
    s = inspect(decoded)
    String.slice(s, 1, String.length(s) - 2)
  end

  defp scan_to_char(str, c, inc, i) do
    cond do
      i < 0 || i >= String.length(str) ->
        -1

      String.at(str, i) == c ->
        i

      true ->
        scan_to_char(str, c, inc, i + inc)
    end
  end

  defp multireplace(str, replacements) do
    {_, new_s} =
      replacements
      |> Enum.sort_by(fn {i, _, _} -> i end)
      |> Enum.reduce(
        {0, str},
        fn {i, j, rep}, {offset, new_s} ->
          {
            offset + String.length(rep) - (j - i),
            String.slice(new_s, 0, i + offset) <>
              rep <> String.slice(new_s, j + offset, String.length(new_s))
          }
        end
      )

    new_s
  end

  defp get_index(s, line, col) do
    get_index_helper(s, line, col, 1, 0, 0)
  end

  defp get_index_helper(_, line, col, line, col, index) do
    index
  end

  defp get_index_helper("", _line, _col, _current_line, _current_col, _index) do
    -1
  end

  defp get_index_helper("\n" <> rest, line, col, current_line, _current_col, index) do
    get_index_helper(rest, line, col, current_line + 1, _current_col = 0, index + 1)
  end

  defp get_index_helper(str, line, col, current_line, current_col, index) do
    get_index_helper(
      String.slice(str, 1..-1),
      line,
      col,
      current_line,
      current_col + 1,
      index + 1
    )
  end
end