defmodule ExSni.Menu.Server do
  @moduledoc false

  use GenServer

  alias ExSni.Menu

  defmodule SignalsState do
    defstruct layout_updated: {0, false},
              items_properties_updated: {0, false},
              activation_request: {0, false}

    @type signal_tracking() ::
            {last_requested_timestamp :: non_neg_integer(), queued? :: boolean()}
    @type t() :: %__MODULE__{
            layout_updated: signal_tracking(),
            items_properties_updated: signal_tracking(),
            activation_request: signal_tracking()
          }
  end

  defmodule State do
    defstruct menu: %Menu{version: 1},
              backup_server: nil,
              dbus_service: nil,
              menu_queue: []

    @type method_tracking() ::
            {last_requested_timestamp :: non_neg_integer(), payload :: any()}
    @type t() :: %__MODULE__{
            menu: Menu.t(),
            backup_server: nil | GenServer.server(),
            dbus_service: nil | GenServer.server(),
            menu_queue: list(Menu.t())
          }
  end

  def start_link(opts, gen_opts \\ []) do
    GenServer.start_link(
      __MODULE__,
      opts,
      gen_opts
    )
  end

  @impl true
  def init(options) do
    backup_server = Keyword.get(options, :backup_server)

    init_menu =
      case Keyword.get(options, :menu, nil) do
        %Menu{} = menu -> menu
        _ -> %Menu{version: 1}
      end

    state =
      %State{
        menu: init_menu,
        dbus_service: Keyword.get(options, :dbus_service, nil),
        backup_server: backup_server
      }
      |> restore_backup_menu()

    {:ok, state}
  end

  def method(server_pid, name, arguments) do
    GenServer.call(server_pid, {:method, name, arguments})
  end

  def get_property(server_pid, property_name) do
    GenServer.call(server_pid, {:get_property, property_name})
  end

  def set(server_pid, menu) do
    GenServer.cast(server_pid, {:set, menu})
  end

  def get(server_pid) do
    GenServer.call(server_pid, :get)
  end

  def reset(server_pid) do
    GenServer.cast(server_pid, {:set, nil})
  end

  # GenServer implementations

  @impl true
  def handle_cast({:set, menu}, state) do
    state =
      case add_menu_to_queue(state, menu) do
        %{menu_queue: [_ | _]} = state ->
          queue_menu_update(state)

        _ ->
          state
      end

    {:noreply, state}
  end

  @impl true
  def handle_call(:get, _from, %{menu: menu} = state) do
    {:reply, {:ok, menu}, state}
  end

  def handle_call({:method, method_name, arguments}, from, state) do
    handle_method(method_name, arguments, from, state)
  end

  def handle_call(
        {:get_property, property_name},
        _from,
        %{menu: menu} = state
      ) do
    ret = ExSni.DbusProtocol.get_property(menu, property_name)
    {:reply, ret, state}
  end

  def handle_call(
        {:get_property, _property_name},
        _from,
        state
      ) do
    {:reply, {:error, "org.freedesktop.DBus.Error.UnknownProperty", "Invalid property"}, state}
  end

  @impl true
  def handle_info(:menu_update, state) do
    case do_menu_update(state) do
      {:skip, state} ->
        {:noreply, state}

      {:ok, state} ->
        {:noreply, state}
    end
  end

  def handle_info(
        {:signal_layout_updated, [version, item_id]},
        %{dbus_service: dbus_service} = state
      ) do
    Debouncer.immediate(
      {__MODULE__, self(), "LayoutUpdated"},
      fn ->
        send_dbus_signal(dbus_service, "LayoutUpdated", [version, item_id])
      end,
      3000
    )

    {:noreply, state}
  end

  def handle_info(
        {:signal_items_properties_updated, [properties_updated, properties_removed]},
        %{dbus_service: dbus_service} = state
      ) do
    send_dbus_signal(dbus_service, "ItemsPropertiesUpdated", [
      properties_updated,
      properties_removed
    ])

    {:noreply, state}
  end

  def handle_info(_, state) do
    {:noreply, state}
  end

  # Private methods

  # Menu queue is empty, so current menu is still valid
  # Return that we want to skip any dbus menu updates
  defp do_menu_update(%{menu_queue: []} = state) do
    {:skip, state}
  end

  # Current menu is nil and a reset is queued
  # Skip the reset and try again
  defp do_menu_update(%{menu: %Menu{root: nil}, menu_queue: [:reset | menu_queue]} = state) do
    state
    |> set_menu_queue(menu_queue)
    |> do_menu_update()
  end

  # There is a reset pending, and the current menu is not empty
  # Action on the reset.
  defp do_menu_update(
         %{menu: %Menu{version: old_version} = old_menu, menu_queue: [:reset | menu_queue]} =
           state
       ) do
    # Increment the version of an empty menu
    menu = %Menu{old_menu | root: nil, version: old_version + 1}

    # Update the queue
    # Send a LayoutUpdated signal, so that D-Bus can fetch the new empty menu

    {:ok,
     state
     |> set_current_menu(menu)
     |> set_menu_queue(menu_queue)}
  end

  # Current menu is nil, no reset pending and full new menu
  defp do_menu_update(
         %{menu: %Menu{version: old_version}, menu_queue: [{:nodiff, new_menu}]} = state
       ) do
    if menu_empty?(new_menu) do
      {:skip, set_menu_queue(state, [])}
    else
      menu = %Menu{new_menu | version: old_version + 1}
      # Update the queue
      # Send a LayoutUpdated signal, so that D-Bus can fetch the new empty menu
      {:ok,
       state
       |> set_current_menu(menu)
       |> set_menu_queue([])}
    end
  end

  # No reset pending, just a possible menu update
  defp do_menu_update(
         %{
           menu: %Menu{version: old_version},
           menu_queue: [%Menu{} = new_menu]
         } = state
       ) do
    if menu_empty?(new_menu) do
      {:skip, set_menu_queue(state, [])}
    else
      menu = %Menu{new_menu | version: old_version + 1}
      # Update the queue
      # Send a LayoutUpdated signal, so that D-Bus can fetch the new empty menu
      {:ok,
       state
       |> set_current_menu(menu)
       |> set_menu_queue([])}
    end
  end

  defp queue_menu_update(state) do
    pid = self()

    Debouncer.immediate(
      {__MODULE__, pid, :menu_update},
      fn ->
        send(pid, :menu_update)
      end,
      1000
    )

    state
  end

  defp trigger_layout_update_signal(%{menu: %Menu{version: version}} = state, item_id \\ 0) do
    send(self(), {:signal_layout_updated, [version, item_id]})
    state
  end

  defp send_dbus_signal(service_pid, "LayoutUpdated" = signal, args) do
    service_send_signal(service_pid, signal, {"ui", [:uint32, :int32], args})
  end

  defp send_dbus_signal(service_pid, "ItemsPropertiesUpdated" = signal, args) do
    service_send_signal(service_pid, signal, {
      "a(ia{sv})a(ias)",
      [
        {:array, {:struct, [:int32, {:dict, :string, :variant}]}},
        {:array, {:struct, [:int32, {:array, :string}]}}
      ],
      args
    })
  end

  defp service_send_signal(service_pid, signal, args) do
    # IO.inspect([signal, args], label: "Sending D-Bus signal", limit: :infinity)

    ExDBus.Service.send_signal(
      service_pid,
      "/MenuBar",
      "com.canonical.dbusmenu",
      signal,
      args
    )
  end

  # Method handling

  defp handle_method("GetLayout", {parentId, depth, properties}, _from, state) do
    {:reply, method_reply("GetLayout", {parentId, depth, properties}, state), state}
  end

  defp handle_method("GetGroupProperties", {ids, properties}, _from, state) do
    {:reply, method_reply("GetGroupProperties", {ids, properties}, state), state}
  end

  # This is called by the applet to notify the application
  # that it is about to show the menu under the specified item.

  # Params:
  #   - id::uint32 - Which menu item represents
  #                 the parent of the item about to be shown.
  # Returns:
  #   - needUpdate::boolean() - Whether this AboutToShow event
  #                   should result in the menu being updated.
  defp handle_method("AboutToShow", id, _from, state) do
    {:reply, method_reply("AboutToShow", id, state), state}
  end

  # This is called by the applet to notify the application
  # an event happened on a menu item.

  # Params:
  #   - id::uint32      - the id of the item which received the event
  #   - eventId::string - the type of event
  #           ("clicked", "hovered", "opened", "closed")
  #   - data::variant   - event-specific data
  #   - timestamp::uint32 - The time that the event occured if available
  #         or the time the message was sent if not
  # Returns:
  #   - needUpdate::boolean() - Whether this AboutToShow event
  #                   should result in the menu being updated.
  defp handle_method("Event", {id, eventId, data, timestamp}, _from, state) do
    {:reply, method_reply("Event", {id, eventId, data, timestamp}, state), state}
  end

  # Reject all other method calls
  defp handle_method(_method, _arguments, _from, state) do
    {:reply, :skip, state}
  end

  defp method_reply("GetLayout", {parentId, depth, properties}, %{menu: menu}) do
    # IO.inspect({parentId, depth, properties},
    #   label: "[#{System.os_time(:millisecond)}] [ExSni][Menu.Server] GetLayout"
    # )

    Menu.get_layout(menu, parentId, depth, properties)
    # |> IO.inspect(label: "GetLayout reply", limit: :infinity)
  end

  defp method_reply("GetGroupProperties", {ids, properties}, %{menu: menu}) do
    # IO.inspect({ids, properties},
    #   label: "[#{System.os_time(:millisecond)}] [ExSni][Menu.Server] GetGroupProperties"
    # )

    result = Menu.get_group_properties(menu, ids, properties)
    # |> IO.inspect(label: "GetGroupProperties reply", limit: :infinity)

    {:ok, [{:array, {:struct, [:int32, {:dict, :string, :variant}]}}], [result]}
  end

  defp method_reply("AboutToShow", id, %{menu: menu}) do
    ret = Menu.onAboutToShow(menu, id)
    {:ok, [:boolean], [ret]}
  end

  defp method_reply("Event", {id, eventId, data, timestamp}, %{menu: menu}) do
    # IO.inspect({id, eventId, data, timestamp},
    #   label: "[#{System.os_time(:millisecond)}] [ExSni][Menu.Server] Menu OnEvent"
    # )

    Menu.onEvent(menu, eventId, id, data, timestamp)
    {:ok, [], []}
  end

  defp method_reply(_, _, _) do
    :skip
  end

  # Other private functions

  # A menu queue (`menu_queue`) holds the next menus to process
  # Queueing a menu will always take care of pruning the menu queue so that
  # it would only hold the bare minimum to process on next round.
  #
  # There are only 3 types of queued menus:
  # - An empty menu (where root is nil, or the root element has no children)
  # - A menu that holds items
  # - :reset - a special entry that means we need to force sending an empty menu to DBus
  # so that it would clear up the current menu. This entry must never be removed from the queue
  # once it has been set. It can only be consumed by menu processing.
  #
  # The queue is always either empty or contains two queued entries at most:
  # - 0 entries:  No changes queued; the current dbus menu
  #               can be either in a nil/cleared state or have items
  # - 1 entry:    One change queued
  # - 2 entries:  This is always going to be a `:reset` followed by a non-empty menu
  #               menu_queue = [:reset, non_empty_menu]
  #
  # Queuing the menus with the below functions,
  # must always ensure the correct format for the menu_queue.
  # Never store multiple :reset entries in the queue.
  #
  # If for example, menu_queue == [:reset] then we never remove it from the queue
  # and never push empty menus or further resets after it.
  # If menu_queue == [:reset, non_empty_menu] then if we want to queue an empty menu
  # we just take the non_empty_menu out, leaving menu_queue = [:reset]. However, when
  # the menu we want to queue is not an empty menu, we only replace the non_empty_menu entry
  # leaving menu_queue = [:reset, new_non_empty_menu]
  # If menu_queue == [non_empty_menu] we replace it with whatever we want to queue,
  # setting menu_queue = [new_menu], regardless if the new menu is empty, non-empty or a reset

  # Handle queueing :reset
  defp add_menu_to_queue(%{menu_queue: _queue, menu: _current_menu} = state, :reset) do
    # Reset is very straight-forward when queueing.

    # Clear the queue and add :reset to it
    set_menu_queue(state, [:reset])
  end

  # Handling of empty menus that do not have root: nil, but have a root without children

  defp add_menu_to_queue(state, %Menu{root: %Menu.Item{type: :root, children: []}} = new_menu) do
    # Menu is actually empty, because there are no children in the root item
    # Forward it as %Menu{root: nil}
    add_menu_to_queue(state, {:nodiff, new_menu})
  end

  defp add_menu_to_queue(
         state,
         {:nodiff, %Menu{root: %Menu.Item{type: :root, children: []}} = new_menu}
       ) do
    # Menu is actually empty, because there are no children in the root item
    # Forward it as %Menu{root: nil}
    add_menu_to_queue(state, {:nodiff, %{new_menu | root: nil}})
  end

  # Handle queueing nil menu
  defp add_menu_to_queue(
         state,
         %Menu{root: nil} = empty_menu
       ) do
    add_menu_to_queue(state, {:nodiff, empty_menu})
  end

  defp add_menu_to_queue(
         %{menu_queue: queue, menu: current_menu} = state,
         {:nodiff, %Menu{root: nil} = empty_menu}
       ) do
    case queue do
      [] ->
        # Handle empty queue
        if menu_empty?(current_menu) do
          # Do not update D-Bus with empty menus if the current D-Bus menu is already empty.
          state
        else
          set_menu_queue(state, [{:nodiff, empty_menu}])
        end

      [:reset] ->
        # The reset will also clear the current menu, just as the empty menu would do,
        # but it's an enforced clear that we need to keep
        state

      [%Menu{}] ->
        if menu_empty?(current_menu) do
          # The current menu is already cleared, so clear the queue
          set_menu_queue(state, [])
        else
          # The current menu is non-empty. Queue clearing the menu
          set_menu_queue(state, [{:nodiff, empty_menu}])
        end

      [{:nodiff, %Menu{}}] ->
        if menu_empty?(current_menu) do
          # The current menu is already cleared, so clear the queue
          set_menu_queue(state, [])
        else
          # The current menu is non-empty. Queue clearing the menu
          set_menu_queue(state, [{:nodiff, empty_menu}])
        end

      [_, :reset] ->
        # If there is a reset queued, regardless of the next item in queue,
        # because we ask to update to an empty menu, keep the :reset only
        set_menu_queue(state, [:reset])
    end
  end

  # Queue non-empty menu when the queue is empty
  defp add_menu_to_queue(%{menu_queue: []} = state, {:nodiff, %Menu{} = new_menu}) do
    # Just add it to the queue
    set_menu_queue(state, [{:nodiff, new_menu}])
  end

  defp add_menu_to_queue(%{menu_queue: []} = state, %Menu{} = new_menu) do
    # Just add it to the queue
    set_menu_queue(state, [new_menu])
  end

  # Queue non-empty menu when there's a reset in the queue
  defp add_menu_to_queue(%{menu_queue: [:reset | _]} = state, {:nodiff, %Menu{} = new_menu}) do
    set_menu_queue(state, [:reset, {:nodiff, new_menu}])
  end

  defp add_menu_to_queue(%{menu_queue: [:reset | _]} = state, %Menu{} = new_menu) do
    set_menu_queue(state, [:reset, new_menu])
  end

  # Queue non-empty menu when there's another menu in the queue
  defp add_menu_to_queue(%{menu_queue: [_]} = state, {:nodiff, %Menu{} = new_menu}) do
    # There is a non-empty menu queued. Replace it
    set_menu_queue(state, [{:nodiff, new_menu}])
  end

  defp add_menu_to_queue(%{menu_queue: [_]} = state, %Menu{} = new_menu) do
    # There is a non-empty menu queued. Replace it
    set_menu_queue(state, [new_menu])
  end

  defp set_current_menu(
         %State{menu: %{item_cache: items} = old_menu} = state,
         %Menu{root: root} = menu
       ) do
    root = strip_menu(root)

    if old_menu != nil and strip_menu(old_menu.root) == root do
      state
    else
      {last_id, version} =
        case old_menu do
          %Menu{last_id: last_id, version: version} -> {max(last_id, 100), version}
          nil -> {100, 1}
        end

      cache = Enum.map(items, fn {item, _time} -> {strip_menu(item), item} end) |> Map.new()
      {root, last_id} = update_menu(root, last_id, cache)

      menu = %Menu{menu | version: version + 1, last_id: last_id, root: root}
      now = System.os_time(:millisecond)

      new_items =
        Menu.get_children(old_menu)
        |> Enum.map(fn item -> {item, now} end)
        |> Map.new()

      items =
        Enum.reject(items, fn {_, time} -> now - time > 10_000 end)
        |> Map.new()
        |> Map.merge(new_items)

      backup_current_menu(%State{state | menu: Map.put(menu, :item_cache, items)})
      |> trigger_layout_update_signal()
    end
  end

  defp update_menu(%Menu.Item{children: children} = item, id, cache) do
    {children, id} =
      Enum.map_reduce(children, id, fn item = %Menu.Item{type: type}, id ->
        case cache[item] do
          nil ->
            id = id + 1
            item = Menu.Item.set_id(item, id)

            if type == :menu do
              update_menu(item, id, cache)
            else
              {item, id}
            end

          old_item ->
            {old_item, id}
        end
      end)

    {%Menu.Item{item | children: children}, id}
  end

  defp strip_menu(nil), do: nil

  defp strip_menu(%Menu.Item{children: children} = item) do
    children =
      Enum.map(children, fn item = %Menu.Item{type: type} ->
        item = Menu.Item.set_id(item, nil)

        if type == :menu do
          strip_menu(item)
        else
          item
        end
      end)

    %Menu.Item{item | children: children}
  end

  defp restore_backup_menu(%{backup_server: nil} = state) do
    state
  end

  defp restore_backup_menu(%{backup_server: server, menu: init_menu} = state) do
    try do
      menu = GenServer.call(server, {:restore_menu, init_menu})
      %{state | menu: menu}
    rescue
      _error -> state
    end
  end

  defp backup_current_menu(%{backup_server: nil} = state) do
    state
  end

  defp backup_current_menu(%{backup_server: server, menu: menu} = state) do
    try do
      GenServer.cast(server, {:save_menu, menu})
    rescue
      _ -> :ok
    end

    state
  end

  defp set_menu_queue(state, queue) do
    %{state | menu_queue: queue}
  end

  defp menu_empty?(nil) do
    true
  end

  defp menu_empty?({:nodiff, menu}) do
    menu_empty?(menu)
  end

  defp menu_empty?(%Menu{root: nil}) do
    true
  end

  defp menu_empty?(%Menu{root: %Menu.Item{type: :root, children: []}}) do
    true
  end

  defp menu_empty?(%Menu{root: %Menu.Item{}}) do
    false
  end
end