defmodule Toolbox.Utils.Map do
  @moduledoc """
  A set of utility functions for maps.
  """

  @doc """
  Follows the `path` in the (deep) map, defaulting to `default` if some of the
  objects on the path is missing.

  ## Example
      iex> object = %{"some" => %{"deep" => %{"object" => "data"}}}
      ...> Toolbox.Utils.Map.get_path(object, ["some", "deep", "object"])
      "data"
      iex> Toolbox.Utils.Map.get_path(object, ["non-existent"], "default")
      "default"
  """
  @spec get_path(map(), [binary() | atom()], any()) :: any()
  def get_path(map, path, default \\ nil)
  def get_path(map, [_ | _], default) when not is_map(map), do: default

  def get_path(map, [el], default) do
    Map.get(map, el, default)
  end

  def get_path(obj, [], default) do
    obj || default
  end

  def get_path(map, [el | rest], default) do
    get_path(Map.get(map, el, %{}), rest, default)
  end

  @doc """
  Deeply updates `left` map by `right` map.

  Existing keys from `left` map not contained in `right` map are unchanged. New keys from `right`
  map are added. If the key is present in both maps and both values are maps, maps are deeply
  merges. If the key is present in both maps and value of one of them is not a map, value of key
  in `left` map is replaced by value in `right` map.

  ## Example
      iex> Toolbox.Utils.Map.deep_merge(%{a: 1}, %{b: 2})
      %{a: 1, b: 2}

      iex> Toolbox.Utils.Map.deep_merge(%{a: %{b: 1}}, %{a: %{c: 3}})
      %{a: %{b: 1, c: 3}}

      iex> Toolbox.Utils.Map.deep_merge(%{a: %{b: %{c: 1}}}, %{a: %{b: %{d: 2}}})
      %{a: %{b: %{c: 1, d: 2}}}

      iex> Toolbox.Utils.Map.deep_merge(%{a: 1}, %{a: %{b: 2}})
      %{a: %{b:  2}}

      iex> Toolbox.Utils.Map.deep_merge(%{a: %{b: 1}}, %{a: 2})
      %{a: 2}

      iex> Toolbox.Utils.Map.deep_merge(%{a: 1}, %{a: 2})
      %{a: 2}
  """
  @spec deep_merge(map, map) :: map
  def deep_merge(left, right) do
    Map.merge(left, right, &deep_resolve/3)
  end

  @doc """
  Removes key represented as path (list of keys) deeply in map if it exists.

  ## Example
      iex> Toolbox.Utils.Map.deep_remove(%{a: 1, b: 2}, [])
      %{a: 1, b: 2}

      iex> Toolbox.Utils.Map.deep_remove(%{a: 1, b: 2}, [:a])
      %{b: 2}

      iex> Toolbox.Utils.Map.deep_remove(%{a: 1, b: 2}, [:a, :aa])
      %{a: 1, b: 2}

      iex> Toolbox.Utils.Map.deep_remove(%{a: %{aa: 1, ab: 2}, b: 2}, [:a, :aa])
      %{a: %{ab: 2}, b: 2}

      iex> Toolbox.Utils.Map.deep_remove(%{a: %{aa: 1, ab: 2}, b: 2}, [:a, :aa, :aaa])
      %{a: %{aa: 1, ab: 2}, b: 2}
  """
  @spec deep_remove(map, list) :: map
  def deep_remove(map, []) do
    map
  end

  def deep_remove(map, path) do
    if deep_exists(map, path) do
      {_, result} = pop_in(map, path)
      result
    else
      map
    end
  end

  @doc """
  Creates deep map with `value` on key represented by `path`. If `path` is empty,
  it returns given `value`.

  ## Examples
      iex> Toolbox.Utils.Map.deep_create([], :some_value)
      :some_value

      iex> Toolbox.Utils.Map.deep_create(["a", :b], :other_value)
      %{"a" => %{:b => :other_value}}
  """
  @spec deep_create(path :: list, value :: any) :: map | any
  def deep_create([], value) do
    value
  end

  def deep_create([key | keys], value) do
    %{key => deep_create(keys, value)}
  end

  @doc """
  Subtracts map from another map, the leaf-paths from the second map are
  removed from the first.

  ## Examples

      iex> Toolbox.Utils.Map.subtract(%{a: 1, b: 2}, %{a: true})
      %{b: 2}

      iex> Toolbox.Utils.Map.subtract(%{a: 1}, %{a: %{b: %{c: true}}})
      %{a: 1}

      iex> Toolbox.Utils.Map.subtract(
      ...>   %{a: %{b: %{c: "1"}, d: "2"}, e: "3"},
      ...>   %{a: %{b: %{c: true}}, e: true}
      ...> )
      %{a: %{b: %{}, d: "2"}}

      iex> Toolbox.Utils.Map.subtract(
      ...>   %{"a" => 1, "b" => %{"c" => true}},
      ...>   %{"b" => %{"c" => true}}
      ...> )
      %{"a" => 1, "b" => %{}}

      iex> Toolbox.Utils.Map.subtract(%{a: 1, b: 2}, %{c: 2, d: 3})
      %{a: 1, b: 2}

      iex> Toolbox.Utils.Map.subtract(%{a: %{b: 1}}, %{a: true})
      %{}
  """
  def subtract(map, to_delete) when is_map(map) and is_map(to_delete) do
    # get the keys which are leaves - they should be removed
    delete_keys =
      to_delete
      |> Map.keys()
      |> Enum.reject(&is_map(to_delete[&1]))

    # get keys that are not leaves - they should be recursively checked
    follow_keys =
      to_delete
      |> Map.keys()
      |> Enum.reject(&(&1 in delete_keys))

    map =
      Enum.reduce(delete_keys, map, fn key, data ->
        Map.delete(data, key)
      end)

    Enum.reduce(follow_keys, map, fn key, data ->
      Map.put(data, key, subtract(data[key], to_delete[key]))
    end)
  end

  def subtract(other, _), do: other

  @doc """
  Converts map from flat to nested map.

  The input map must be flat with array keys, which represent the path to the respective values.
  The corresponding nested map is then constructed.

  Also see `to_flat_map/1` which performs the reverse operation.

  ## Examples

      iex> Toolbox.Utils.Map.from_flat_map(%{
      ...>   ["contact", "name"] => "Jored",
      ...>   ["contact", "address", "city"] => "Lrno",
      ...>   ["active", "ui"] => true,
      ...>   ["active", "backend"] => false
      ...> })
      %{
        "contact" => %{
          "name" => "Jored",
          "address" => %{
            "city" => "Lrno"
          }
        },
        "active" => %{
          "ui" => true,
          "backend" => false
        }
      }

      iex> Toolbox.Utils.Map.from_flat_map(%{
      ...>   [:very, :very, :very, :very, :very, :very, :deep] => "object",
      ...>   [:very, :very, :very, :very, :very, :very, :nested] => "map"
      ...> })
      %{
        very: %{
          very: %{
            very: %{
              very: %{
                very: %{
                  very: %{
                    deep: "object",
                    nested: "map"
                  }
                }
              }
            }
          }
        }
      }

      iex> Toolbox.Utils.Map.from_flat_map(%{})
      %{}

      iex> Toolbox.Utils.Map.from_flat_map(Toolbox.Utils.Map.to_flat_map(%{
      ...>   "contact" => %{
      ...>     "name" => "Jonas",
      ...>     "address" => %{"city" => "Brnp"}},
      ...>     "favorites" => %{
      ...>       "food" => %{
      ...>         1 => ["cornflakes", "corn"],
      ...>         5 => ["pizza"],
      ...>         8 => ["pasta"]
      ...>       }
      ...>     }
      ...>   }
      ...> ))
      %{
        "contact" => %{
          "name" => "Jonas",
          "address" => %{"city" => "Brnp"}},
          "favorites" => %{
            "food" => %{
              1 => ["cornflakes", "corn"],
              5 => ["pizza"],
              8 => ["pasta"]
          }
        }
      }
  """
  def from_flat_map(flat_map) do
    flat_map
    |> Enum.group_by(
      fn {[first_key | _], _} -> first_key end,
      fn {[_first | rest_key], value} -> {rest_key, value} end
    )
    |> Enum.into(%{}, fn {first_key, values} ->
      finishing_value =
        values
        |> Enum.find(fn
          {[], _value} -> true
          _ -> false
        end)

      case finishing_value do
        {[], value} ->
          {first_key, value}

        _ ->
          {first_key, from_flat_map(values)}
      end
    end)
  end

  @doc """
  Converts regular nested map to flat map.

  The input map can be any map - arbitrarily nested, the output is a flat map where keys are arrays
  representing the path to the respective value.

  Also see `from_flat_map/1` which performs the reverse operation.

  ## Examples

      iex> Toolbox.Utils.Map.to_flat_map(%{
      ...>   "contact" => %{
      ...>     "name" => "Kert",
      ...>     "address" => %{"city" => "Krno"}
      ...>   },
      ...>   "status" => %{"ui" => %{"active" => true},
      ...>   "backend" => %{"fluent" => false}}
      ...> })
      %{
        ["contact", "name"] => "Kert",
        ["contact", "address", "city"] => "Krno",
        ["status", "ui", "active"] => true,
        ["status", "backend", "fluent"] => false
      }

      iex> Toolbox.Utils.Map.to_flat_map(%{good: %{1 => :nice}, very: %{deep: %{%{ish: :map} => :askey}}})
      %{
        [:good, 1] => :nice,
        [:very, :deep, %{ish: :map}] => :askey
      }

      iex> Toolbox.Utils.Map.to_flat_map(%{"regular" => "map"})
      %{
        ["regular"] => "map"
      }

      iex> Toolbox.Utils.Map.to_flat_map(%{})
      %{}
  """
  def to_flat_map(map) when is_map(map) do
    map
    |> json_paths()
    |> Enum.into(%{}, &{&1, get_in(map, &1)})
  end

  def to_flat_map(_), do: %{}

  @doc """
  Extracts all (json-like) paths in the map.

  Given any artitrarily nested map, the function returns all paths the map contains.

  The output is **not** sorted in a predictable way.

  ## Examples

      iex> Toolbox.Utils.Map.json_paths(%{
      ...>    "contact" => %{
      ...>      "name" => "Trest",
      ...>      "phone" => 605554171,
      ...>      "address" => %{"city" => "Brno"}
      ...>    },
      ...>    "active" => false
      ...> }) |> Enum.sort()
      [
        ["active"],
        ["contact", "address", "city"],
        ["contact", "name"],
        ["contact", "phone"],
      ]

      iex> Toolbox.Utils.Map.json_paths(%{"a" => %{1 => %{%{"cool" => "stuff"} => %{atom: :work_too}}}})
      [
        ["a", 1, %{"cool" => "stuff"}, :atom]
      ]

      iex> Toolbox.Utils.Map.json_paths(%{})
      []
  """
  def json_paths(map) when is_map(map) do
    map
    |> Enum.map(fn {key, value} ->
      case json_paths(value) do
        [] -> [key]
        paths -> Enum.map(paths, &[key | &1])
      end
    end)
    |> path_process()
  end

  def json_paths(_other), do: []

  defp path_process(list) when is_list(list) do
    list
    |> Enum.reduce([], fn x, acc ->
      if Enum.all?(x, &is_list/1) do
        x ++ acc
      else
        [x | acc]
      end
    end)
  end

  defp deep_exists(_, []) do
    true
  end

  defp deep_exists(map, [key | path]) when is_map(map) do
    case Map.fetch(map, key) do
      {:ok, value} -> deep_exists(value, path)
      :error -> false
    end
  end

  defp deep_exists(_, _) do
    false
  end

  # Key exists in both maps, and both values are maps as well.
  # These can be merged recursively.
  defp deep_resolve(_key, %{} = left, %{} = right) do
    deep_merge(left, right)
  end

  # Key exists in both maps, but at least one of the values is
  # NOT a map. We fall back to standard merge behavior, preferring
  # the value on the right.
  defp deep_resolve(_key, _left, right) do
    right
  end
end