# Copyright 2026 Cole Christensen

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

defmodule ExGitObjectstore.Diff do

  @moduledoc """

  Tree-level diff and line-level diff with hunk formatting.

  """

  alias ExGitObjectstore.Diff.Myers

  alias ExGitObjectstore.Object.{Blob, Tree}

  alias ExGitObjectstore.{ObjectResolver, Repo}

  @max_tree_depth 64

  @type file_change :: %{

          path: String.t(),

          status: :added | :deleted | :modified | :renamed,

          old_sha: String.t() | nil,

          new_sha: String.t() | nil,

          old_mode: String.t() | nil,

          new_mode: String.t() | nil

        }

  @type hunk :: %{

          old_start: non_neg_integer(),

          old_count: non_neg_integer(),

          new_start: non_neg_integer(),

          new_count: non_neg_integer(),

          lines: [{:context | :add | :del, String.t()}]

        }

  @type file_diff :: %{

          path: String.t(),

          status: :added | :deleted | :modified,

          hunks: [hunk()]

        }

  @doc """

  Compute tree-level diff between two tree SHAs.

  Returns a list of file changes.

  """

  @spec diff_trees(Repo.t(), String.t() | nil, String.t() | nil) ::

          {:ok, [file_change()]} | {:error, term()}

  def diff_trees(repo, old_tree_sha, new_tree_sha) do

    old_entries = load_tree_entries(repo, old_tree_sha)

    new_entries = load_tree_entries(repo, new_tree_sha)

    try do

      changes = diff_tree_entries(repo, old_entries, new_entries, "", 0)

      {:ok, List.flatten(changes)}

    catch

      :throw, {:error, _} = err -> err

    end

  end

  @doc """

  Compute line-level diff for a file change.

  Returns hunks with context lines.

  """

  @spec diff_blobs(Repo.t(), String.t() | nil, String.t() | nil, keyword()) ::

          {:ok, [hunk()]}

          | {:ok, :binary, %{old_size: non_neg_integer(), new_size: non_neg_integer()}}

          | {:error, term()}

  def diff_blobs(repo, old_sha, new_sha, opts \\ []) do

    context = Keyword.get(opts, :context, 3)

    old_content = load_blob_content(repo, old_sha)

    new_content = load_blob_content(repo, new_sha)

    if binary?(old_content) or binary?(new_content) do

      {:ok, :binary, %{old_size: byte_size(old_content), new_size: byte_size(new_content)}}

    else

      edits = Myers.diff_lines(old_content, new_content)

      hunks = edits_to_hunks(edits, context)

      {:ok, hunks}

    end

  end

  @doc """

  Compute full diff (tree changes + line diffs) between two commits.

  """

  @spec diff_commits(Repo.t(), String.t(), String.t(), keyword()) ::

          {:ok, [file_diff()]} | {:error, term()}

  def diff_commits(repo, old_commit_sha, new_commit_sha, opts \\ []) do

    with {:ok, old_commit} <- ObjectResolver.read(repo, old_commit_sha),

         {:ok, new_commit} <- ObjectResolver.read(repo, new_commit_sha),

         {:ok, changes} <- diff_trees(repo, old_commit.tree, new_commit.tree) do

      file_diffs = Enum.map(changes, &build_file_diff(repo, &1, opts))

      {:ok, file_diffs}

    end

  end

  defp build_file_diff(repo, change, opts) do

    case diff_blobs(repo, change.old_sha, change.new_sha, opts) do

      {:ok, :binary, sizes} ->

        %{

          path: change.path,

          status: change.status,

          hunks: [],

          binary: true,

          old_size: sizes.old_size,

          new_size: sizes.new_size

        }

      {:ok, hunks} ->

        %{path: change.path, status: change.status, hunks: hunks}

    end

  end

  @doc """

  Format hunks into unified diff text.

  """

  @spec format_unified(String.t(), [hunk()], keyword()) :: String.t()

  def format_unified(path, hunks, opts \\ []) do

    old_content = Keyword.get(opts, :old_content)

    new_content = Keyword.get(opts, :new_content)

    no_newline_old =

      old_content != nil and old_content != "" and not String.ends_with?(old_content, "\n")

    no_newline_new =

      new_content != nil and new_content != "" and not String.ends_with?(new_content, "\n")

    header = "--- a/#{path}\n+++ b/#{path}\n"

    body =

      Enum.map(hunks, fn hunk ->

        hunk_header =

          "@@ -#{hunk.old_start},#{hunk.old_count} +#{hunk.new_start},#{hunk.new_count} @@\n"

        lines = format_hunk_lines(hunk.lines, no_newline_old, no_newline_new)

        [hunk_header | lines]

      end)

    IO.iodata_to_binary([header | body])

  end

  defp format_hunk_lines(lines, no_newline_old, no_newline_new) do

    lines

    |> Enum.with_index()

    |> Enum.flat_map(fn {{type, line}, idx} ->

      remaining = Enum.drop(lines, idx + 1)

      formatted = format_line_by_type(type, line)

      markers = no_newline_markers(type, remaining, no_newline_old, no_newline_new)

      [formatted | markers]

    end)

  end

  defp format_line_by_type(:context, line), do: " #{line}\n"

  defp format_line_by_type(:add, line), do: "+#{line}\n"

  defp format_line_by_type(:del, line), do: "-#{line}\n"

  defp no_newline_markers(type, remaining, no_newline_old, no_newline_new) do

    last_old? = type in [:del, :context] and no_more_old_lines?(remaining)

    last_new? = type in [:add, :context] and no_more_new_lines?(remaining)

    if (last_old? and no_newline_old) or (last_new? and no_newline_new) do

      ["\\ No newline at end of file\n"]

    else

      []

    end

  end

  defp no_more_old_lines?(remaining) do

    not Enum.any?(remaining, fn {t, _} -> t in [:del, :context] end)

  end

  defp no_more_new_lines?(remaining) do

    not Enum.any?(remaining, fn {t, _} -> t in [:add, :context] end)

  end

  # -- Private --

  defp load_tree_entries(_repo, nil), do: %{}

  defp load_tree_entries(repo, tree_sha) do

    case ObjectResolver.read(repo, tree_sha) do

      {:ok, %Tree{entries: entries}} ->

        Map.new(entries, fn entry -> {entry.name, entry} end)

      _ ->

        %{}

    end

  end

  defp binary?(content) when byte_size(content) == 0, do: false

  defp binary?(content) do

    chunk = binary_part(content, 0, min(byte_size(content), 8192))

    :binary.match(chunk, <<0>>) != :nomatch

  end

  defp load_blob_content(_repo, nil), do: ""

  defp load_blob_content(repo, sha) do

    case ObjectResolver.read(repo, sha) do

      {:ok, %Blob{content: content}} -> content

      _ -> ""

    end

  end

  defp diff_tree_entries(_repo, _old_entries, _new_entries, _prefix, depth)

       when depth > @max_tree_depth do

    throw({:error, :max_tree_depth_exceeded})

  end

  defp diff_tree_entries(repo, old_entries, new_entries, prefix, depth) do

    all_names =

      MapSet.union(

        MapSet.new(Map.keys(old_entries)),

        MapSet.new(Map.keys(new_entries))

      )

      |> Enum.sort()

    Enum.flat_map(all_names, fn name ->

      path = if prefix == "", do: name, else: "#{prefix}/#{name}"

      old = Map.get(old_entries, name)

      new = Map.get(new_entries, name)

      diff_single_entry(repo, old, new, path, depth)

    end)

  end

  defp diff_single_entry(repo, nil, new, path, depth) do

    diff_added_entry(repo, new, path, depth)

  end

  defp diff_single_entry(repo, old, nil, path, depth) do

    diff_deleted_entry(repo, old, path, depth)

  end

  defp diff_single_entry(_repo, old, new, _path, _depth)

       when old.sha == new.sha and old.mode == new.mode do

    []

  end

  defp diff_single_entry(repo, old, new, path, depth)

       when old.mode == "40000" and new.mode == "40000" do

    old_sub = load_tree_entries(repo, old.sha)

    new_sub = load_tree_entries(repo, new.sha)

    diff_tree_entries(repo, old_sub, new_sub, path, depth + 1)

  end

  defp diff_single_entry(_repo, old, new, path, _depth) do

    [

      %{

        path: path,

        status: :modified,

        old_sha: old.sha,

        new_sha: new.sha,

        old_mode: old.mode,

        new_mode: new.mode

      }

    ]

  end

  defp diff_added_entry(repo, %{mode: "40000"} = new, path, depth) do

    new_sub = load_tree_entries(repo, new.sha)

    diff_tree_entries(repo, %{}, new_sub, path, depth + 1)

  end

  defp diff_added_entry(_repo, new, path, _depth) do

    [

      %{

        path: path,

        status: :added,

        old_sha: nil,

        new_sha: new.sha,

        old_mode: nil,

        new_mode: new.mode

      }

    ]

  end

  defp diff_deleted_entry(repo, %{mode: "40000"} = old, path, depth) do

    old_sub = load_tree_entries(repo, old.sha)

    diff_tree_entries(repo, old_sub, %{}, path, depth + 1)

  end

  defp diff_deleted_entry(_repo, old, path, _depth) do

    [

      %{

        path: path,

        status: :deleted,

        old_sha: old.sha,

        new_sha: nil,

        old_mode: old.mode,

        new_mode: nil

      }

    ]

  end

  defp edits_to_hunks(edits, context) do

    indexed = index_edits(edits)

    indexed_vec = :array.from_list(indexed)

    total = :array.size(indexed_vec)

    # Find indices of all change (add/del) lines

    change_indices =

      indexed

      |> Enum.with_index()

      |> Enum.filter(fn {{type, _, _, _}, _idx} -> type in [:add, :del] end)

      |> Enum.map(fn {_, idx} -> idx end)

    if change_indices == [] do

      []

    else

      # Expand each change index into a range with context, then merge overlapping ranges

      ranges =

        change_indices

        |> Enum.map(fn idx -> {max(0, idx - context), min(total - 1, idx + context)} end)

        |> merge_ranges()

      # Build a hunk from each merged range

      Enum.map(ranges, &range_to_hunk(&1, indexed_vec))

    end

  end

  defp range_to_hunk({start_idx, end_idx}, indexed_vec) do

    lines = for i <- start_idx..end_idx, do: :array.get(i, indexed_vec)

    build_hunk(lines)

  end

  defp merge_ranges([]), do: []

  defp merge_ranges([first | rest]) do

    Enum.reduce(rest, [first], fn {s, e}, [{prev_s, prev_e} | acc] ->

      if s <= prev_e + 1 do

        [{prev_s, max(prev_e, e)} | acc]

      else

        [{s, e}, {prev_s, prev_e} | acc]

      end

    end)

    |> Enum.reverse()

  end

  defp index_edits(edits) do

    {result, _old_line, _new_line} =

      Enum.reduce(edits, {[], 1, 1}, fn

        {:eq, line}, {acc, old, new} ->

          {[{:context, line, old, new} | acc], old + 1, new + 1}

        {:del, line}, {acc, old, new} ->

          {[{:del, line, old, new} | acc], old + 1, new}

        {:ins, line}, {acc, old, new} ->

          {[{:add, line, old, new} | acc], old, new + 1}

      end)

    Enum.reverse(result)

  end

  defp build_hunk(lines) do

    # Filter out trailing empty context that's just the last empty-string split artifact

    lines = drop_trailing_empty_context(lines)

    {old_lines, new_lines, formatted} =

      Enum.reduce(lines, {0, 0, []}, fn

        {:context, line, _old, _new}, {old_c, new_c, acc} ->

          {old_c + 1, new_c + 1, [{:context, line} | acc]}

        {:del, line, _old, _new}, {old_c, new_c, acc} ->

          {old_c + 1, new_c, [{:del, line} | acc]}

        {:add, line, _old, _new}, {old_c, new_c, acc} ->

          {old_c, new_c + 1, [{:add, line} | acc]}

      end)

    # Find the starting line numbers

    first_old = find_first_old_line(lines)

    first_new = find_first_new_line(lines)

    %{

      old_start: first_old,

      old_count: old_lines,

      new_start: first_new,

      new_count: new_lines,

      lines: Enum.reverse(formatted)

    }

  end

  defp find_first_old_line(lines) do

    lines

    |> Enum.find(fn

      {:context, _, _, _} -> true

      {:del, _, _, _} -> true

      _ -> false

    end)

    |> case do

      {:context, _, old, _} -> old

      {:del, _, old, _} -> old

      nil -> 1

    end

  end

  defp find_first_new_line(lines) do

    lines

    |> Enum.find(fn

      {:context, _, _, _} -> true

      {:add, _, _, _} -> true

      _ -> false

    end)

    |> case do

      {:context, _, _, new} -> new

      {:add, _, _, new} -> new

      nil -> 1

    end

  end

  defp drop_trailing_empty_context(lines) do

    lines

    |> Enum.reverse()

    |> Enum.drop_while(fn

      {:context, "", _, _} -> true

      _ -> false

    end)

    |> Enum.reverse()

  end

end