defmodule GenAI.Graph.Root do
  @vsn 1.0
  @moduledoc """
  The root data structure that contains nested graphs, nodes and other structures.
  """

  import GenAI.Records.Link

  require GenAI.Records.Link
  require GenAI.Types.Graph

  defstruct [
    # Entry Point
    graph: nil,
    # uuid => element_lookup, handle => {:resolver, %{paths => element_entry}} | element_entry
    lookup_table: %{by_element: %{}, by_handle: %{}},
    # id of last inserted node
    last_node: nil,
    # id of last inserted link
    last_link: nil
  ]

  @doc """
  Retrieve a element_lookup entry by element id.
  """
  def element_entry(this, element)
  def element_entry(_, error = {:error, _}), do: error
  def element_entry(this, element_lookup(element: element)), do: element_entry(this, element)

  def element_entry(%__MODULE__{} = this, id) do
    if entry = this.lookup_table.by_element[id] do
      {:ok, entry}
    else
      {:error, {:element, :not_found}}
    end
  end

  @doc """
  Retrieve an element_lookup entry by handle and base node
  """
  def handle_entry(this, handle, base \\ nil)

  def handle_entry(%__MODULE__{} = this, graph_handle(name: handle), base),
    do: handle_entry(this, handle, base)

  def handle_entry(%__MODULE__{} = this, handle, base) do
    if global_entry = this.lookup_table.by_handle[graph_handle(scope: :global, name: handle)] do
      element_entry(this, global_entry)
    else
      standard_entry = this.lookup_table.by_handle[graph_handle(scope: :standard, name: handle)]
      local_entries = this.lookup_table.by_handle[graph_handle(scope: :local, name: handle)] || []

      with {:ok, element_lookup(path: path)} <- element_entry(this, base) do
        {_, entry} =
          local_entries
          |> Enum.reduce(
            {0, standard_entry},
            fn
              {entry_path, entry_element}, b = {b_depth, _} ->
                e_depth = length(entry_path)

                cond do
                  e_depth > b_depth && List.starts_with?(path, entry_path) ->
                    {e_depth, entry_element}

                  :else ->
                    b
                end
            end
          )

        if entry,
          do: element_entry(this, entry),
          else: {:error, {:element, :not_found}}
      else
        _ ->
          if standard_entry,
            do: element_entry(this, standard_entry),
            else: {:error, {:element, :not_found}}
      end
    end
  end

  @max_depth 1_000_000

  defp if_element_under_path(this, element, under)
  defp if_element_under_path(_, nil, _), do: nil

  defp if_element_under_path(this, element, element_lookup(path: under_path)) do
    case element_entry(this, element) do
      entry = {:ok, element_lookup(path: entry_path)} ->
        if List.starts_with?(entry_path, under_path), do: entry

      _ ->
        nil
    end
  end

  @doc """
  Retrieve closest nested handle nested under base.
  If a global entry is found and under base it will be used.
  If a standard entry is found and under base it will be used.
  Only if no standard or global entry under base exists will locals be checked.
  """
  def nearest_handle_entry(this, handle, base)

  def nearest_handle_entry(%__MODULE__{} = this, graph_handle(name: handle), base),
    do: nearest_handle_entry(this, handle, base)

  def nearest_handle_entry(%__MODULE__{} = this, handle, base = element_lookup(path: under_path)) do
    global_entry = this.lookup_table.by_handle[graph_handle(scope: :global, name: handle)]
    standard_entry = this.lookup_table.by_handle[graph_handle(scope: :standard, name: handle)]
    local_entries = this.lookup_table.by_handle[graph_handle(scope: :local, name: handle)] || []

    cond do
      x = if_element_under_path(this, global_entry, base) ->
        x

      x = if_element_under_path(this, standard_entry, base) ->
        x

      :else ->
        {_, entry} =
          local_entries
          |> Enum.reduce(
            {@max_depth, nil},
            fn
              {entry_path, entry_element}, b = {b_depth, _} ->
                e_depth = length(entry_path)

                cond do
                  e_depth < b_depth && List.starts_with?(entry_path, under_path) ->
                    {e_depth, entry_element}

                  :else ->
                    b
                end
            end
          )

        if entry,
          do: element_entry(this, entry),
          else: {:error, {:element, :not_found}}
    end
  end

  @doc """
  Retrieve a nested element by id from graph
  """
  def element(%__MODULE__{} = this, id) do
    with {:ok, element_lookup(path: [_ | path])} <- element_entry(this, id) do
      get_nested_element(this.graph, path)
    end
  end

  @doc """
  Retrieve a nested element by handle from graph
  """
  def element_by_handle(%__MODULE__{} = this, handle, base \\ nil) do
    with {:ok, element_lookup(path: [_ | path])} <- handle_entry(this, handle, base) do
      get_nested_element(this.graph, path)
    end
  end

  @doc """
  extract nested entry by path from source element.
  """
  def get_nested_element(source, path)

  def get_nested_element(nil, _) do
    {:error, {:element, :not_found}}
  end

  def get_nested_element(element, []) do
    {:ok, element}
  end

  def get_nested_element(element, [h | t]) do
    with {:ok, nested} <- element.__struct__.node(element, h) do
      get_nested_element(nested, t)
    end
  end

  @doc """
  Merge element lookup entries
  """
  def merge_lookup_table_entries(%__MODULE__{} = this, entries) do
    update_in(
      this,
      [Access.key(:lookup_table), Access.key(:by_element)],
      &Enum.into(entries, &1 || %{})
    )
  end

  @doc """
  Merge list of {handle, element or path to element} entries into lookup table.
  """
  def merge_handles(%__MODULE__{} = this, handles) when is_list(handles) do
    Enum.reduce(handles, this, &merge_handle(&2, &1))
  end

  @doc """
  Merge a single graph handle entry into lookup table.
  """
  def merge_handle(this, {handle = graph_handle(scope: :global), element}) do
    put_in(this, [Access.key(:lookup_table), Access.key(:by_handle), handle], element)
  end

  def merge_handle(this, {handle = graph_handle(scope: :standard), element}) do
    put_in(this, [Access.key(:lookup_table), Access.key(:by_handle), handle], element)
  end

  def merge_handle(this, {handle = graph_handle(scope: :local), elements}) do
    elements = (is_list(elements) && elements) || [elements]

    update_in(
      this,
      [Access.key(:lookup_table), Access.key(:by_handle), handle],
      &(elements ++ (&1 || []))
    )
  end

  @doc """
  Retrieve graph context by link
  """
  def graph_context_by_link(this, link, from_element)

  def graph_context_by_link(
        this,
        %GenAI.Graph.Link{target: connector(node: target)} = link,
        from_element
      ) do
    {:ok, base} = GenAI.Graph.NodeProtocol.id(from_element || this.graph)
    base = element_entry(this, base)

    case target do
      anchor_link(anchor_handle: anchor, local_handle: path) ->
        anchor_base = handle_entry(this, anchor, base)
        graph_context_by_link__to_anchor_path(this, link, path, anchor_base)

      handle = graph_handle() ->
        graph_context_by_link__to_handle(this, link, handle, base)

      element ->
        graph_context_by_link__to_element(this, link, element)
    end
  end

  # --------------
  # graph_context_by_link__to_anchor_path/5
  # --------------
  defp graph_context_by_link__to_anchor_path(this, link, path, base)

  defp graph_context_by_link__to_anchor_path(this, link, path, base) when is_list(path) do
    entry = reduce_anchor_path(this, path, base)
    graph_context_by_link__entry(this, link, entry)
  end

  defp graph_context_by_link__to_anchor_path(this, link, nil, base),
    do: graph_context_by_link__to_anchor_path(this, link, [], base)

  defp graph_context_by_link__to_anchor_path(this, link, path, base) when not is_list(path),
    do: graph_context_by_link__to_anchor_path(this, link, [path], base)

  # --------------
  # graph_context_by_link__to_handle/4
  # --------------
  defp graph_context_by_link__to_handle(this, link, handle, base) do
    # return element context for a given element handle under base
    graph_context_by_link__entry(this, link, handle_entry(this, handle, base))
  end

  # --------------
  # graph_context_by_link__to_element/3
  # --------------
  defp graph_context_by_link__to_element(this, link, element) do
    # return element context for a given element identifier
    graph_context_by_link__entry(this, link, element_entry(this, element))
  end

  # --------------
  # graph_context_by_link__entry/3
  # --------------
  defp graph_context_by_link__entry(this, link, entry)

  defp graph_context_by_link__entry(this, link, {:ok, entry}),
    do: graph_context_by_link__entry(this, link, entry)

  defp graph_context_by_link__entry(this, link, element_lookup(path: [_ | path])) do
    # return element context for a given element lookup entry
    with {container_path, target_path} <- Enum.split(path, -1),
         {:ok, target_container} <- get_nested_element(this.graph, container_path),
         {:ok, target_element} <- get_nested_element(target_container, target_path) do
      {:ok, element_context(element: target_element, link: link, container: target_container)}
    end
  end

  defp graph_context_by_link__entry(_, _, entry = {:error, _}),
    do: entry

  # --------------
  # nearest_handle_entry/3
  # --------------
  defp reduce_anchor_path(this, path, base)

  defp reduce_anchor_path(this, path, {:ok, base}),
    do: reduce_anchor_path(this, path, base)

  defp reduce_anchor_path(_, _, error = {:error, _}),
    do: error

  defp reduce_anchor_path(this, path, base) do
    Enum.reduce(path, {:ok, base}, fn
      handle, {:ok, base} ->
        nearest_handle_entry(this, handle, base)

      _, error ->
        error
    end)
  end

  def process_node(subject, _, _, session, context, options) do
    subject =
      subject
      |> GenAI.Graph.Root.merge_lookup_table_entries(
        GenAI.Graph.NodeProtocol.build_node_lookup(subject.graph, [])
      )
      |> GenAI.Graph.Root.merge_handles(
        GenAI.Graph.NodeProtocol.build_handle_lookup(subject.graph, [])
      )

    session = %{session | root: subject}
    GenAI.Graph.NodeProtocol.process_node(subject.graph, nil, subject, session, context, options)
  end
end

#
# defimpl GenAI.Thread.SessionProtocol, for: GenAI.Graph.Root do
#  require GenAI.Records.Session
#  alias GenAI.Records.Session, as: Node
#
#  def process_node(subject, scope, context, options) do
#    subject = subject
#              |> GenAI.Graph.Root.merge_lookup_table_entries(GenAI.Graph.NodeProtocol.build_node_lookup(subject.graph, []))
#              |> GenAI.Graph.Root.merge_handles(GenAI.Graph.NodeProtocol.build_handle_lookup(subject.graph, []))
#
#    updated_scope = Node.scope(
#      scope,
#      graph_node: subject.graph,
#      graph_link: nil,
#      graph_container: subject,
#      session_root: subject
#    )
#    GenAI.Thread.SessionProtocol.process_node(subject.graph, updated_scope, context, options)
#  end
# end