defmodule AprsmeWeb.MapLive.PacketProcessor do
  @moduledoc """
  Handles real-time packet processing, filtering, and display logic.
  """

  import Phoenix.Component, only: [assign: 3]

  alias Aprsme.GeoUtils
  alias AprsmeWeb.Live.Shared.BoundsUtils
  alias AprsmeWeb.Live.Shared.CoordinateUtils
  alias AprsmeWeb.Live.Shared.PacketUtils, as: SharedPacketUtils
  alias AprsmeWeb.MapLive.PacketUtils
  alias Phoenix.LiveView
  alias Phoenix.LiveView.Socket

  @max_visible_packets 1000
  @max_all_packets 2000

  @doc """
  Process a packet for display on the map.
  """
  @spec process_packet_for_display(map(), Socket.t()) :: {:noreply, Socket.t()}
  def process_packet_for_display(packet, socket) do
    {lat, lon, _data_extended} = CoordinateUtils.get_coordinates(packet)
    callsign_key = SharedPacketUtils.get_callsign_key(packet)

    # Update all_packets with memory limit
    all_packets = Map.put(socket.assigns.all_packets, callsign_key, packet)

    all_packets =
      if map_size(all_packets) > @max_all_packets do
        SharedPacketUtils.prune_oldest_packets(all_packets, @max_all_packets)
      else
        all_packets
      end

    socket = assign(socket, :all_packets, all_packets)

    # Handle packet visibility logic
    socket = handle_packet_visibility(packet, lat, lon, callsign_key, socket)

    # Update last update timestamp for real-time display in map sidebar
    # This timestamp is shown to users to indicate when data was last refreshed
    socket = assign(socket, :last_update_at, DateTime.utc_now())

    {:noreply, socket}
  end

  @doc """
  Handle packet visibility logic based on bounds and existing markers.
  """
  @spec handle_packet_visibility(map(), number() | nil, number() | nil, binary(), Socket.t()) :: Socket.t()
  def handle_packet_visibility(packet, lat, lon, callsign_key, socket) do
    visibility_action(packet, lat, lon, callsign_key, socket)
  end

  defp visibility_action(packet, lat, lon, callsign_key, socket) when not is_nil(lat) and not is_nil(lon) do
    in_bounds = within_bounds?(%{lat: lat, lon: lon}, socket.assigns.map_bounds)
    has_marker = Map.has_key?(socket.assigns.visible_packets, callsign_key)
    dispatch_visibility({in_bounds, has_marker}, packet, lat, lon, callsign_key, socket)
  end

  defp visibility_action(_packet, _lat, _lon, _callsign_key, socket), do: socket

  defp dispatch_visibility({false, true}, _packet, _lat, _lon, callsign_key, socket) do
    remove_marker_from_map(callsign_key, socket)
  end

  defp dispatch_visibility({true, false}, packet, lat, lon, _callsign_key, socket) do
    handle_valid_postgres_packet(packet, lat, lon, socket)
  end

  defp dispatch_visibility({true, true}, packet, lat, lon, callsign_key, socket) do
    existing_packet = socket.assigns.visible_packets[callsign_key]
    {existing_lat, existing_lon, _} = CoordinateUtils.get_coordinates(existing_packet)

    if is_number(existing_lat) and is_number(existing_lon) and
         GeoUtils.significant_movement?(existing_lat, existing_lon, lat, lon, 50) do
      handle_valid_postgres_packet(packet, lat, lon, socket)
    else
      new_visible_packets = Map.put(socket.assigns.visible_packets, callsign_key, packet)
      assign(socket, :visible_packets, new_visible_packets)
    end
  end

  defp dispatch_visibility(_, _packet, _lat, _lon, _callsign_key, socket), do: socket

  @doc """
  Handle valid postgres packet by adding it to visible packets and displaying it.
  """
  @spec handle_valid_postgres_packet(map(), number() | nil, number() | nil, Socket.t()) :: Socket.t()
  def handle_valid_postgres_packet(packet, _lat, _lon, socket) do
    # Add the packet to visible_packets and push a marker immediately
    callsign_key = SharedPacketUtils.get_callsign_key(packet)

    new_visible_packets = Map.put(socket.assigns.visible_packets, callsign_key, packet)

    # Enforce memory limits
    new_visible_packets =
      if map_size(new_visible_packets) > @max_visible_packets do
        SharedPacketUtils.prune_oldest_packets(new_visible_packets, @max_visible_packets)
      else
        new_visible_packets
      end

    socket = assign(socket, :visible_packets, new_visible_packets)

    # Check zoom level to decide how to display the packet
    if socket.assigns.map_zoom <= 8 do
      # We're in heat map mode - update the heat map with all current data
      send_heat_map_for_current_bounds(socket)
    else
      # We're in marker mode - send individual marker
      marker_data = PacketUtils.build_packet_data(packet, true, get_locale(socket))

      if marker_data do
        send_marker_with_popup_check(socket, marker_data)
      else
        socket
      end
    end
  end

  @doc """
  Remove marker from map and update visible packets.
  """
  @spec remove_marker_from_map(binary(), Socket.t()) :: Socket.t()
  def remove_marker_from_map(callsign_key, socket) do
    socket = LiveView.push_event(socket, "remove_marker", %{id: callsign_key})
    new_visible_packets = Map.delete(socket.assigns.visible_packets, callsign_key)
    assign(socket, :visible_packets, new_visible_packets)
  end

  # Private helper functions

  # Use shared bounds utility
  defp within_bounds?(coords, bounds) do
    BoundsUtils.within_bounds?(coords, bounds)
  end

  # Helper to get locale from socket
  defp get_locale(socket) do
    Map.get(socket.assigns, :locale, "en")
  end

  # Placeholder for heat map function - this should be moved to DisplayManager
  defp send_heat_map_for_current_bounds(socket) do
    # This function should be moved to DisplayManager module
    socket
  end

  defp send_marker_with_popup_check(socket, marker_data) do
    if socket.assigns.station_popup_open do
      # Send without opening popup to avoid interrupting user
      LiveView.push_event(socket, "new_packet", Map.put(marker_data, :openPopup, false))
    else
      LiveView.push_event(socket, "new_packet", marker_data)
    end
  end
end