defmodule AprsmeWeb.MapLive.Index do
  @moduledoc """
  LiveView for displaying real-time APRS packets on a map
  """
  use AprsmeWeb, :live_view

  import AprsmeWeb.Live.Shared.PacketUtils, only: [get_callsign_key: 1]
  import AprsmeWeb.MapLive.Components
  import AprsmeWeb.TimeHelpers, only: [time_ago_in_words: 1]
  import Phoenix.LiveView, only: [connected?: 1, push_event: 3, push_patch: 2, put_flash: 3]

  # Import the new components module
  alias Aprsme.Packets
  alias Aprsme.Packets.Clustering
  alias AprsmeWeb.Endpoint
  alias AprsmeWeb.Live.Shared.BoundsUtils
  alias AprsmeWeb.Live.Shared.CoordinateUtils
  alias AprsmeWeb.Live.Shared.PacketUtils, as: SharedPacketUtils
  alias AprsmeWeb.Live.Shared.ParamUtils
  alias AprsmeWeb.MapLive.BoundsManager
  alias AprsmeWeb.MapLive.DataBuilder
  alias AprsmeWeb.MapLive.DisplayManager
  alias AprsmeWeb.MapLive.HistoricalLoader
  alias AprsmeWeb.MapLive.MapHelpers
  alias AprsmeWeb.MapLive.Navigation
  alias AprsmeWeb.MapLive.PacketBatcher
  alias AprsmeWeb.MapLive.PacketManager
  alias AprsmeWeb.MapLive.PacketProcessor
  alias AprsmeWeb.MapLive.RfPath
  alias AprsmeWeb.MapLive.UrlParams
  alias AprsmeWeb.TimeUtils
  alias Phoenix.LiveView.Socket
  alias Phoenix.Socket.Broadcast

  @impl true
  def mount(params, session, socket) do
    socket = setup_subscriptions(socket)

    # Basic setup
    deployed_at = Aprsme.Release.deployed_at()
    one_hour_ago = TimeUtils.one_day_ago()

    # Parse and determine map location
    {map_center, map_zoom, should_skip_initial_url_update} = Navigation.determine_map_location(params, session)

    # Parse trail duration and historical hours from URL
    trail_duration = params |> Map.get("trail", "1") |> parse_trail_duration() |> to_string()
    historical_hours = params |> Map.get("hist", "1") |> parse_historical_hours() |> to_string()

    # Calculate packet age threshold based on trail duration
    hours = String.to_integer(trail_duration)
    packet_age_threshold = DateTime.add(DateTime.utc_now(), -hours * 3600, :second)

    # Setup defaults with parsed values
    socket = assign_defaults(socket, packet_age_threshold)

    socket =
      assign(socket,
        initial_historical_completed: false,
        trail_duration: trail_duration,
        historical_hours: historical_hours
      )

    # Setup additional subscriptions if connected
    socket = setup_additional_subscriptions(socket)

    # Handle callsign tracking - check path params first, then query params
    tracked_callsign =
      case Map.get(params, "callsign", Map.get(params, "call", "")) do
        "" -> ""
        nil -> ""
        callsign -> callsign |> String.trim() |> String.upcase()
      end

    {final_map_center, final_map_zoom} =
      Navigation.handle_callsign_tracking(
        tracked_callsign,
        map_center,
        map_zoom,
        UrlParams.has_explicit_url_params?(params)
      )

    # Calculate initial bounds
    initial_bounds = BoundsManager.calculate_bounds_from_center_and_zoom(final_map_center, final_map_zoom)

    # Final socket assignment
    {:ok,
     finalize_mount_assigns(socket, %{
       initial_bounds: initial_bounds,
       final_map_center: final_map_center,
       final_map_zoom: final_map_zoom,
       should_skip_initial_url_update: should_skip_initial_url_update,
       tracked_callsign: tracked_callsign,
       deployed_at: deployed_at,
       one_hour_ago: one_hour_ago
     })}
  end

  defp setup_subscriptions(socket) do
    do_setup_subscriptions(socket, connected?(socket))
  end

  defp do_setup_subscriptions(socket, true) do
    # Check if we should accept new connections
    if Application.get_env(:aprsme, :cluster_enabled, false) and
         not Aprsme.ConnectionMonitor.accepting_connections?() do
      # Redirect to another node or show message
      socket
      |> put_flash(:info, "This server is currently at capacity. Please try again in a moment.")
      |> push_event("redirect_to_least_loaded", %{})
      |> assign(:connection_draining, true)
    else
      # Generate a unique client ID for this LiveView instance
      client_id = "liveview_#{:erlang.phash2(self())}"

      # Register with connection monitor
      if Application.get_env(:aprsme, :cluster_enabled, false) do
        Aprsme.ConnectionMonitor.register_connection()
        # Subscribe to drain events for this node
        Phoenix.PubSub.subscribe(Aprsme.PubSub, "connection:drain:#{Node.self()}")
      end

      # Register with spatial PubSub (will get viewport later)
      # Start with a default viewport that will be updated when we get actual bounds
      default_bounds = %{north: 90.0, south: -90.0, east: 180.0, west: -180.0}
      {:ok, spatial_topic} = Aprsme.SpatialPubSub.register_viewport(client_id, default_bounds)

      # Subscribe to the spatial topic for this client
      Phoenix.PubSub.subscribe(Aprsme.PubSub, spatial_topic)

      # Still subscribe to bad packets (they don't have location)
      Phoenix.PubSub.subscribe(Aprsme.PubSub, "bad_packets")

      # Subscribe to deployment events
      Phoenix.PubSub.subscribe(Aprsme.PubSub, "deployment_events")

      # Subscribe to StreamingPacketsPubSub with initial bounds
      Aprsme.StreamingPacketsPubSub.subscribe_to_bounds(self(), default_bounds)

      Process.send_after(self(), :cleanup_old_packets, 60_000)
      # Schedule UI update timer to refresh "time ago" display every 30 seconds
      Process.send_after(self(), :update_time_display, 30_000)

      socket
      |> assign(:spatial_client_id, client_id)
      |> assign(:spatial_topic, spatial_topic)
      |> assign(:connection_draining, false)
    end
  end

  defp do_setup_subscriptions(socket, false), do: socket

  defp setup_additional_subscriptions(socket) do
    do_setup_additional_subscriptions(socket, connected?(socket))
  end

  defp do_setup_additional_subscriptions(socket, true) do
    Endpoint.subscribe("aprs_messages")
    Phoenix.PubSub.subscribe(Aprsme.PubSub, "postgres:aprsme_packets")
    socket
  end

  defp do_setup_additional_subscriptions(socket, false), do: socket

  defp finalize_mount_assigns(socket, %{
         initial_bounds: initial_bounds,
         final_map_center: final_map_center,
         final_map_zoom: final_map_zoom,
         should_skip_initial_url_update: should_skip_initial_url_update,
         tracked_callsign: tracked_callsign,
         deployed_at: deployed_at,
         one_hour_ago: one_hour_ago
       }) do
    # Don't override trail_duration and historical_hours if they're already set
    trail_duration = Map.get(socket.assigns, :trail_duration, "1")
    historical_hours = Map.get(socket.assigns, :historical_hours, "1")
    packet_age_threshold = Map.get(socket.assigns, :packet_age_threshold, one_hour_ago)

    # If tracking a specific callsign, fetch their latest packet
    tracked_callsign_latest_packet =
      if tracked_callsign == "" do
        nil
      else
        try do
          Packets.get_latest_packet_for_callsign(tracked_callsign)
        rescue
          # Handle database connection errors gracefully (especially in tests)
          DBConnection.OwnershipError ->
            nil

          _ ->
            nil
        end
      end

    # Start packet batcher for efficient updates
    {:ok, batcher_pid} = PacketBatcher.start_link(self())

    assign(socket,
      map_ready: false,
      map_bounds: initial_bounds,
      map_center: final_map_center,
      map_zoom: final_map_zoom,
      should_skip_initial_url_update: should_skip_initial_url_update,
      packet_state: PacketManager.init_packet_state(),
      overlay_callsign: "",
      tracked_callsign: tracked_callsign,
      tracked_callsign_latest_packet: tracked_callsign_latest_packet,
      trail_duration: trail_duration,
      historical_hours: historical_hours,
      packet_age_threshold: packet_age_threshold,
      slideover_open: true,
      deployed_at: deployed_at,
      map_page: true,
      packet_buffer: [],
      buffer_timer: nil,
      batcher_pid: batcher_pid,
      station_popup_open: false,
      initial_bounds_loaded: false,
      # Always load historical data on initial page load
      needs_initial_historical_load: true,
      # Loading state management
      historical_loading: false,
      loading_generation: 0,
      pending_batch_tasks: [],
      # Add missing assigns for components
      loading: false,
      connection_status: get_initial_connection_status(),
      show_all_packets: true
    )
  end

  defp get_initial_connection_status do
    # Check if APRS connection is disabled
    connection_disabled = Application.get_env(:aprsme, :disable_aprs_connection, false)
    if connection_disabled, do: "disconnected", else: "connected"
  end

  @spec assign_defaults(Socket.t(), DateTime.t()) :: Socket.t()
  defp assign_defaults(socket, one_hour_ago) do
    assign(socket,
      packets: [],
      all_packets: %{},
      visible_packets: %{},
      historical_packets: %{},
      page_title: "APRS Map",
      packet_state: PacketManager.init_packet_state(),
      station_popup_open: false,
      map_bounds: %{
        north: 49.0,
        south: 24.0,
        east: -66.0,
        west: -125.0
      },
      map_center: UrlParams.default_center(),
      map_zoom: UrlParams.default_zoom(),
      packet_age_threshold: one_hour_ago,
      map_ready: false,
      historical_loaded: false,
      bounds_update_timer: nil,
      pending_bounds: nil,
      initial_bounds_loaded: false,
      # Loading state management
      historical_loading: false,
      loading_generation: 0,
      pending_batch_tasks: [],
      # Overlay controls
      overlay_callsign: "",
      # Slideover state - will be set based on screen size
      slideover_open: true,
      # Track when last update occurred for real-time display in map sidebar
      # Updated when packets are processed or map bounds change
      last_update_at: DateTime.utc_now(),
      # Add missing assigns for components
      loading: false,
      connection_status: get_initial_connection_status(),
      show_all_packets: true
    )
  end

  # Handle both bounds_changed and update_bounds events
  @impl true
  def handle_event(event, %{"bounds" => bounds}, socket) when event in ["bounds_changed", "update_bounds"] do
    require Logger

    Logger.debug("Received #{event} event with bounds: #{inspect(bounds)}")
    handle_bounds_update(bounds, socket)
  end

  @impl true
  def handle_event("locate_me", _params, socket) do
    # Send JavaScript command to request browser geolocation
    {:noreply, push_event(socket, "request_geolocation", %{})}
  end

  @impl true
  def handle_event("set_location", %{"lat" => lat, "lng" => lng}, socket) do
    # Update map center and zoom when location is received
    # Parse and validate coordinates
    lat_float = UrlParams.parse_latitude(lat)
    lng_float = UrlParams.parse_longitude(lng)

    # Additional validation - ensure we got valid coordinates
    if UrlParams.valid_coordinates?(lat_float, lng_float) do
      socket = Navigation.update_and_zoom_to_location(socket, lat_float, lng_float, 12)
      {:noreply, socket}
    else
      # Invalid coordinates - ignore the event
      {:noreply, socket}
    end
  end

  @impl true
  def handle_event("clear_and_reload_markers", _params, socket) do
    # Get current visible packets from PacketManager
    current_packets = PacketManager.get_visible_packets(socket.assigns.packet_state)

    # Filter by time and bounds
    filtered_packets =
      filter_packets_by_time_and_bounds_with_tracked(
        Map.new(current_packets, fn packet ->
          {get_callsign_key(packet), packet}
        end),
        socket.assigns.map_bounds,
        socket.assigns.packet_age_threshold,
        socket.assigns.tracked_callsign,
        socket.assigns.tracked_callsign_latest_packet
      )

    visible_packets_list = DataBuilder.build_packet_data_list_from_map(filtered_packets, false, socket)

    # Check zoom level to decide between heat map and markers
    socket =
      if socket.assigns.map_zoom <= 8 do
        # Use heat map for low zoom levels
        send_heat_map_data(socket, filtered_packets)
      else
        # Use regular markers for high zoom levels
        add_markers_if_any(socket, visible_packets_list)
      end

    {:noreply, socket}
  end

  @impl true
  def handle_event("map_ready", _params, socket) do
    require Logger

    # Mark map as ready - preserve existing needs_initial_historical_load state
    # (it's already set correctly in mount based on whether we're tracking a callsign)
    socket = assign(socket, map_ready: true)

    # If we have non-default center coordinates (e.g., from geolocation), apply them now
    default_center = UrlParams.default_center()

    socket =
      if socket.assigns.map_center.lat == default_center.lat and
           socket.assigns.map_center.lng == default_center.lng do
        socket
      else
        Navigation.zoom_to_current_location(socket)
      end

    # If we're tracking a callsign and have its latest packet, display it immediately
    socket =
      if socket.assigns.tracked_callsign != "" and socket.assigns.tracked_callsign_latest_packet do
        packet = socket.assigns.tracked_callsign_latest_packet
        packet_data = DataBuilder.build_packet_data(packet)

        push_event(socket, "add_historical_packets_batch", %{
          packets: [packet_data],
          batch: 0,
          is_final: false
        })
      else
        socket
      end

    # Wait for JavaScript to send the actual map bounds before loading historical packets
    # The calculated bounds might be too small/inaccurate
    Logger.debug("Map ready - waiting for JavaScript to send actual bounds before loading historical packets")

    # If we need initial historical load and have bounds, trigger it
    socket =
      if socket.assigns.needs_initial_historical_load and socket.assigns.map_bounds do
        Logger.debug("Map ready with needs_initial_historical_load=true, triggering historical loading")
        # Send a message to trigger bounds processing
        send(self(), {:process_bounds_update, socket.assigns.map_bounds})
        socket
      else
        socket
      end

    {:noreply, socket}
  end

  @impl true
  def handle_event("marker_clicked", _params, socket) do
    # When a marker is clicked, mark that a station popup is open
    {:noreply, assign(socket, station_popup_open: true)}
  end

  @impl true
  def handle_event("marker_hover_start", %{"id" => _id, "path" => path, "lat" => lat, "lng" => lng}, socket) do
    require Logger

    # Cancel any pending hover end timer
    socket =
      if socket.assigns[:hover_end_timer] do
        Process.cancel_timer(socket.assigns.hover_end_timer)
        assign(socket, hover_end_timer: nil)
      else
        socket
      end

    # Validate coordinates first
    lat_float = ParamUtils.safe_parse_coordinate(lat, 0.0, -90.0, 90.0)
    lng_float = ParamUtils.safe_parse_coordinate(lng, 0.0, -180.0, 180.0)

    # Validate path string
    safe_path = ParamUtils.sanitize_path_string(path)

    # Parse the path to find digipeater/igate stations
    path_stations = RfPath.parse_rf_path(safe_path)

    # Query for positions of path stations
    path_station_positions = RfPath.get_path_station_positions(path_stations, socket)

    # Send event to draw the RF path lines
    socket =
      if path_station_positions == [] do
        socket
      else
        push_event(socket, "draw_rf_path", %{
          station_lat: lat_float,
          station_lng: lng_float,
          path_stations: path_station_positions
        })
      end

    {:noreply, socket}
  end

  @impl true
  def handle_event("marker_hover_end", _params, socket) do
    # Debounce hover end to prevent flicker during rapid mouse movements
    timer = Process.send_after(self(), :clear_rf_path, 100)
    {:noreply, assign(socket, hover_end_timer: timer)}
  end

  @impl true
  def handle_event("update_callsign", %{"callsign" => callsign}, socket) do
    {:noreply, assign(socket, overlay_callsign: callsign)}
  end

  @impl true
  def handle_event("track_callsign", %{"callsign" => callsign}, socket) do
    normalized_callsign = String.upcase(String.trim(callsign))

    socket =
      if normalized_callsign == "" do
        # Clear tracking
        socket
        |> assign(tracked_callsign: "")
        |> update_url_with_current_state()
      else
        # Set tracking and navigate to callsign URL
        socket
        |> assign(tracked_callsign: normalized_callsign)
        |> push_patch(to: "/#{normalized_callsign}")
      end

    {:noreply, socket}
  end

  @impl true
  def handle_event("clear_tracking", _params, socket) do
    socket =
      socket
      |> assign(tracked_callsign: "", overlay_callsign: "")
      |> update_url_with_current_state()

    {:noreply, socket}
  end

  @impl true
  def handle_event("update_trail_duration", %{"trail_duration" => duration}, socket) do
    # Validate and convert duration string to hours
    hours = parse_trail_duration(duration)

    # Calculate new threshold safely
    new_threshold = DateTime.add(DateTime.utc_now(), -hours * 3600, :second)

    socket = assign(socket, trail_duration: duration, packet_age_threshold: new_threshold)

    # Update client-side TrailManager with new duration
    socket = push_event(socket, "update_trail_duration", %{duration_hours: hours})

    # Update URL with new trail duration
    socket = update_url_with_current_state(socket)

    # Trigger cleanup to remove packets that are now outside the new duration
    send(self(), :cleanup_old_packets)

    {:noreply, socket}
  end

  @impl true
  def handle_event("update_historical_hours", %{"historical_hours" => hours}, socket) do
    # Validate hours value
    validated_hours = parse_historical_hours(hours)
    socket = assign(socket, historical_hours: to_string(validated_hours))

    # Update URL with new historical hours
    socket = update_url_with_current_state(socket)

    # Trigger a reload of historical packets with the new time range
    if socket.assigns.map_ready do
      send(self(), :reload_historical_packets)
    end

    {:noreply, socket}
  end

  @impl true
  def handle_event("search_callsign", %{"callsign" => callsign}, socket) do
    callsign
    |> String.trim()
    |> String.upcase()
    |> handle_callsign_search(socket)
  end

  @impl true
  def handle_event("toggle_slideover", _params, socket) do
    {:noreply, assign(socket, slideover_open: !socket.assigns.slideover_open)}
  end

  @impl true
  def handle_event("set_slideover_state", %{"open" => open}, socket) do
    {:noreply, assign(socket, slideover_open: open)}
  end

  @impl true
  def handle_event("geolocation_error", %{"error" => _error}, socket) do
    # Handle geolocation errors gracefully - just continue without geolocation
    {:noreply, socket}
  end

  @impl true
  def handle_event("request_geolocation", _params, socket) do
    # This event is handled by the JavaScript hook
    {:noreply, socket}
  end

  @impl true
  def handle_event("popup_closed", _params, socket) do
    # When any popup is closed, mark that no station popup is open
    {:noreply, assign(socket, station_popup_open: false)}
  end

  @impl true
  def handle_event("get_assigns", _params, socket) do
    send(self(), {:test_assigns, socket.assigns})
    {:noreply, socket}
  end

  @impl true
  def handle_event("update_map_state", %{"center" => center, "zoom" => zoom} = params, socket) do
    require Logger

    Logger.debug("update_map_state event received: center=#{inspect(center)}, zoom=#{zoom}")

    # Parse and validate coordinates
    {lat, lng} = parse_center_coordinates(center, socket)
    zoom = clamp_zoom(zoom)
    map_center = %{lat: lat, lng: lng}

    # Update map state
    socket = update_map_state(socket, map_center, zoom)

    # Handle URL updates
    socket = handle_url_update(socket, lat, lng, zoom)

    # Process bounds if included
    socket = process_bounds_from_params(socket, params)

    {:noreply, socket}
  end

  @impl true
  def handle_event(
        "error_boundary_triggered",
        %{"message" => message, "stack" => stack, "component_id" => component_id},
        socket
      ) do
    # Log the error for monitoring
    require Logger

    Logger.error("Error boundary triggered in component #{component_id}: #{message}\n#{stack}")

    # You could also send this to an error tracking service here
    # ErrorTracker.report_error(message, stack, %{component: component_id, user_id: socket.assigns[:current_user_id]})

    {:noreply, socket}
  end

  defp parse_center_coordinates(center, socket) when is_map(center) do
    CoordinateUtils.parse_center_coordinates(center, socket)
  end

  defp parse_center_coordinates(_, socket) do
    CoordinateUtils.parse_center_coordinates(nil, socket)
  end

  defp clamp_zoom(zoom) do
    ParamUtils.clamp_zoom(zoom)
  end

  defp update_map_state(socket, map_center, zoom) do
    old_zoom = socket.assigns.map_zoom
    crossing_threshold = crossing_zoom_threshold?(old_zoom, zoom)

    socket = assign(socket, map_center: map_center, map_zoom: zoom)

    if crossing_threshold do
      handle_zoom_threshold_crossing(socket, zoom)
    else
      socket
    end
  end

  defp crossing_zoom_threshold?(old_zoom, new_zoom) do
    DisplayManager.crossing_zoom_threshold?(old_zoom, new_zoom)
  end

  defp handle_zoom_threshold_crossing(socket, zoom) do
    DisplayManager.handle_zoom_threshold_crossing(socket, zoom)
  end

  defp update_url_with_current_state(socket) do
    lat = socket.assigns.map_center.lat
    lng = socket.assigns.map_center.lng
    zoom = socket.assigns.map_zoom
    handle_url_update(socket, lat, lng, zoom)
  end

  defp handle_url_update(socket, lat, lng, zoom) do
    if socket.assigns[:should_skip_initial_url_update] && !socket.assigns[:initial_bounds_loaded] do
      require Logger

      Logger.debug("Skipping URL update on initial load")
      assign(socket, should_skip_initial_url_update: false)
    else
      require Logger

      # Include trail duration and historical hours in URL
      trail_param =
        if socket.assigns[:trail_duration] && socket.assigns[:trail_duration] != "1",
          do: "&trail=#{socket.assigns[:trail_duration]}",
          else: ""

      hist_param =
        if socket.assigns[:historical_hours] && socket.assigns[:historical_hours] != "1",
          do: "&hist=#{socket.assigns[:historical_hours]}",
          else: ""

      # Preserve callsign in path if tracking
      base_path =
        if socket.assigns.tracked_callsign == "" do
          "/"
        else
          "/#{socket.assigns.tracked_callsign}"
        end

      new_path = "#{base_path}?lat=#{lat}&lng=#{lng}&z=#{zoom}#{trail_param}#{hist_param}"
      Logger.debug("Updating URL to: #{new_path}")
      push_patch(socket, to: new_path, replace: true)
    end
  end

  defp process_bounds_from_params(socket, params) do
    case Map.get(params, "bounds") do
      %{"north" => north, "south" => south, "east" => east, "west" => west} ->
        map_bounds = %{north: north, south: south, east: east, west: west}

        if should_process_bounds?(socket, map_bounds) do
          require Logger

          Logger.debug(
            "Sending bounds update (initial_load: #{!socket.assigns[:initial_bounds_loaded]}, " <>
              "needs_historical: #{socket.assigns[:needs_initial_historical_load]}): #{inspect(map_bounds)}"
          )

          send(self(), {:process_bounds_update, map_bounds})
        end

        socket

      _ ->
        socket
    end
  end

  defp should_process_bounds?(socket, new_bounds) do
    socket.assigns.map_bounds != new_bounds or
      !socket.assigns[:initial_bounds_loaded] or
      socket.assigns[:needs_initial_historical_load]
  end

  defp handle_callsign_search(callsign, socket) do
    Navigation.handle_callsign_search(callsign, socket)
  end

  @impl true
  def handle_params(params, _url, socket) do
    # Check if we should skip this update (e.g., when using IP geolocation on initial load)
    if Map.get(socket.assigns, :should_skip_initial_url_update, false) and
         not Map.get(socket.assigns, :map_ready, false) do
      # Skip the URL parameter update to preserve IP geolocation
      socket = assign(socket, should_skip_initial_url_update: false)
      {:noreply, socket}
    else
      # Parse new map state from URL parameters
      {map_center, map_zoom} = UrlParams.parse_map_params(params)

      # Parse trail duration and historical hours from URL
      trail_duration = params |> Map.get("trail", "1") |> parse_trail_duration() |> to_string()
      historical_hours = params |> Map.get("hist", "1") |> parse_historical_hours() |> to_string()

      # Update socket state
      socket =
        socket
        |> assign(map_center: map_center, map_zoom: map_zoom)
        |> assign(trail_duration: trail_duration, historical_hours: historical_hours)

      # Update packet age threshold based on trail duration
      hours = String.to_integer(trail_duration)
      new_threshold = DateTime.add(DateTime.utc_now(), -hours * 3600, :second)
      socket = assign(socket, packet_age_threshold: new_threshold)

      # If map is ready, update the client-side map and trail duration
      socket =
        if socket.assigns.map_ready do
          socket
          |> push_event("zoom_to_location", %{
            lat: map_center.lat,
            lng: map_center.lng,
            zoom: map_zoom
          })
          |> push_event("update_trail_duration", %{duration_hours: hours})
        else
          socket
        end

      # Trigger cleanup and reload if settings changed
      if socket.assigns[:map_ready] do
        send(self(), :cleanup_old_packets)
        send(self(), :reload_historical_packets)
      end

      {:noreply, socket}
    end
  end

  # Parse trail duration with validation and bounds checking
  defp parse_trail_duration(duration), do: SharedPacketUtils.parse_trail_duration(duration)

  # Parse historical hours with validation
  defp parse_historical_hours(hours), do: SharedPacketUtils.parse_historical_hours(hours)

  @impl true
  def handle_info({:process_bounds_update, map_bounds}, socket),
    do: handle_info_process_bounds_update(map_bounds, socket)

  def handle_info(:initialize_replay, socket), do: handle_info_initialize_replay(socket)

  def handle_info(:cleanup_old_packets, socket), do: handle_cleanup_old_packets(socket)

  def handle_info(:update_time_display, socket), do: handle_update_time_display(socket)

  def handle_info(:reload_historical_packets, socket), do: handle_reload_historical_packets(socket)

  def handle_info({:postgres_packet, packet}, socket) do
    # Add packet to batcher instead of processing immediately
    if socket.assigns[:batcher_pid] do
      PacketBatcher.add_packet(socket.assigns.batcher_pid, packet)
    else
      handle_info_postgres_packet(packet, socket)
    end

    {:noreply, socket}
  end

  def handle_info({:spatial_packet, packet}, socket) do
    # Add packet to batcher instead of processing immediately
    if socket.assigns[:batcher_pid] do
      PacketBatcher.add_packet(socket.assigns.batcher_pid, packet)
    else
      handle_info_postgres_packet(packet, socket)
    end

    {:noreply, socket}
  end

  def handle_info({:streaming_packet, packet}, socket) do
    # Add packet to batcher instead of processing immediately
    if socket.assigns[:batcher_pid] do
      PacketBatcher.add_packet(socket.assigns.batcher_pid, packet)
    else
      handle_info_postgres_packet(packet, socket)
    end

    {:noreply, socket}
  end

  def handle_info({:packet_batch, packets}, socket) do
    # Process batch of packets efficiently
    socket =
      Enum.reduce(packets, socket, fn packet, acc_socket ->
        case handle_info_postgres_packet(packet, acc_socket) do
          {:noreply, new_socket} -> new_socket
          _ -> acc_socket
        end
      end)

    {:noreply, socket}
  end

  def handle_info(:clear_rf_path, socket) do
    # Clear the RF path lines with debouncing
    {:noreply, push_event(socket, "clear_rf_path", %{})}
  end

  def handle_info(
        %Broadcast{topic: "deployment_events", payload: {:new_deployment, %{deployed_at: deployed_at}}},
        socket
      ) do
    {:noreply, assign(socket, :deployed_at, deployed_at)}
  end

  def handle_info({:drain_connections, to_drain}, socket) do
    # Check if this connection should be drained
    # Use a random selection to determine if this connection should disconnect
    if :rand.uniform(100) <= to_drain * 10 do
      # Gracefully disconnect this client
      socket
      |> put_flash(:info, "Server load balancing in progress. Reconnecting...")
      |> push_event("reconnect", %{delay: :rand.uniform(5000)})
    else
      {:noreply, socket}
    end
  end

  def handle_info({:load_rf_path_station_packets, stations}, socket) do
    # Load the most recent packet for each RF path station
    station_packets =
      stations
      |> Enum.map(fn callsign ->
        Packets.get_latest_packet_for_callsign(callsign)
      end)
      |> Enum.filter(& &1)

    socket =
      if Enum.any?(station_packets) do
        # Build packet data for the RF path stations
        packet_data_list = DataBuilder.build_packet_data_list(station_packets)

        # Send these packets to the frontend
        DisplayManager.add_markers_if_any(socket, packet_data_list)
      else
        socket
      end

    {:noreply, socket}
  end

  def handle_info({:process_pending_bounds}, socket) do
    if socket.assigns.pending_bounds && !socket.assigns.historical_loading do
      # Process the pending bounds update
      bounds = socket.assigns.pending_bounds
      socket = assign(socket, pending_bounds: nil)
      handle_bounds_update(bounds, socket)
    else
      {:noreply, socket}
    end
  end

  def handle_info({:load_historical_batch, batch_offset}, socket) do
    # For backward compatibility with old messages
    socket = HistoricalLoader.load_historical_batch(socket, batch_offset, socket.assigns.loading_generation)
    {:noreply, socket}
  end

  def handle_info({:load_historical_batch, batch_offset, generation}, socket) do
    # Only process if generation matches current loading generation
    if generation == socket.assigns.loading_generation do
      socket = HistoricalLoader.load_historical_batch(socket, batch_offset, generation)
      {:noreply, socket}
    else
      # Stale request, ignore it
      {:noreply, socket}
    end
  end

  def handle_info({:historical_loading_timeout, generation}, socket) do
    # Only process if generation matches current loading generation and we're still loading
    if generation == socket.assigns.loading_generation && socket.assigns.historical_loading do
      require Logger

      Logger.warning("Historical loading timeout reached, forcing completion")

      socket =
        socket
        |> assign(:historical_loading, false)
        |> assign(:loading_batch, socket.assigns.total_batches || 1)

      {:noreply, socket}
    else
      # Stale timeout or already completed, ignore it
      {:noreply, socket}
    end
  end

  def handle_info(%Broadcast{topic: "aprs_messages", event: "packet", payload: packet}, socket),
    do: handle_info({:postgres_packet, packet}, socket)

  def handle_info({:show_error, message}, socket) do
    socket = put_flash(socket, :error, message)
    {:noreply, socket}
  end

  # Private handler functions for each message type

  defp handle_info_process_bounds_update(map_bounds, socket) do
    require Logger

    # Check if this is a stale update (newer bounds have been scheduled)
    if socket.assigns[:pending_bounds] && socket.assigns.pending_bounds != map_bounds do
      Logger.debug("Skipping stale bounds update, newer bounds pending")
      {:noreply, socket}
    else
      # Clear the timer reference since we're processing this update
      socket = assign(socket, bounds_update_timer: nil, pending_bounds: nil)

      # Check if we need to process this bounds update
      should_process =
        !socket.assigns[:initial_bounds_loaded] or
          socket.assigns[:needs_initial_historical_load] or
          not BoundsUtils.compare_bounds(map_bounds, socket.assigns.map_bounds)

      Logger.debug(
        "handle_info_process_bounds_update - should_process: #{should_process}, initial_bounds_loaded: #{socket.assigns[:initial_bounds_loaded]}, needs_initial_historical_load: #{socket.assigns[:needs_initial_historical_load]}"
      )

      if should_process do
        Logger.debug("Processing bounds update: #{inspect(map_bounds)}")
        socket = process_bounds_update(map_bounds, socket)
        socket = assign(socket, initial_bounds_loaded: true)
        {:noreply, socket}
      else
        Logger.debug("Skipping bounds update - no change detected")
        {:noreply, socket}
      end
    end
  end

  defp handle_info_initialize_replay(socket) do
    if not socket.assigns.historical_loaded and socket.assigns.map_ready do
      # Only proceed if we have actual map bounds - don't use world bounds
      if socket.assigns.map_bounds do
        # Use progressive loading for better performance
        socket = HistoricalLoader.start_progressive_historical_loading(socket)
        socket = assign(socket, historical_loaded: true)
        {:noreply, socket}
      else
        # Wait a bit longer for map bounds to be available
        # Increase delay to give client more time to send real bounds
        Process.send_after(self(), :initialize_replay, 500)
        {:noreply, socket}
      end
    else
      {:noreply, socket}
    end
  end

  defp handle_info_postgres_packet(packet, socket) do
    # Check if we're tracking a specific callsign
    # Only process if this packet is from the tracked callsign
    if socket.assigns.tracked_callsign == "" do
      # No tracking - show all packets
      process_packet_for_display(packet, socket)
    else
      packet_sender = Map.get(packet, :sender, Map.get(packet, "sender", ""))

      if String.upcase(packet_sender) == String.upcase(socket.assigns.tracked_callsign) do
        # Update the tracked callsign's latest packet
        socket = assign(socket, :tracked_callsign_latest_packet, packet)
        process_packet_for_display(packet, socket)
      else
        {:noreply, socket}
      end
    end
  end

  defp process_packet_for_display(packet, socket) do
    PacketProcessor.process_packet_for_display(packet, socket)
  end

  # Handle replaying the next historical packet

  @impl true
  def render(assigns) do
    ~H"""
    <.map_styles />

    <.map_container
      slideover_open={@slideover_open}
      map_center={@map_center}
      map_zoom={@map_zoom}
    />

    <.locate_button />

    <.slideover_panel
      slideover_open={@slideover_open}
      loading={@loading}
      connection_status={@connection_status}
      packets={@packets}
      show_all_packets={@show_all_packets}
      tracked_callsign={@tracked_callsign}
      tracked_callsign_latest_packet={@tracked_callsign_latest_packet}
    />

    <.toggle_button slideover_open={@slideover_open} />

    <.bottom_controls {assigns} />
    """
  end

  # Additional component functions that weren't extracted yet
  defp locate_button(assigns) do
    ~H"""
    <button class="locate-button" phx-click="locate_me" title="Locate me">
      <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor">
        <path
          fill-rule="evenodd"
          d="M5.05 4.05a7 7 0 119.9 9.9L10 18.9l-4.95-4.95a7 7 0 010-9.9zM10 11a2 2 0 100-4 2 2 0 000 4z"
          clip-rule="evenodd"
        />
      </svg>
    </button>
    """
  end

  defp toggle_button(assigns) do
    ~H"""
    <button
      phx-click="toggle_slideover"
      class={[
        "fixed right-4 top-4 z-40 bg-white rounded-lg shadow-lg p-3",
        "hover:bg-gray-50 transition-colors lg:hidden",
        @slideover_open && "hidden"
      ]}
    >
      <.icon name="hero-bars-3" class="w-6 h-6 text-gray-700" />
    </button>
    """
  end

  defp bottom_controls(assigns) do
    ~H"""
    <%!-- Existing bottom controls code will go here --%>
    <style>
      #aprs-map {
        position: absolute;
        top: 0;
        left: 0;
        bottom: 0;
        height: 100vh;
        z-index: 1;
        transition: right 0.3s ease-in-out;
      }

      /* Desktop styles */
      @media (min-width: 1024px) {
        #aprs-map.slideover-open {
          right: 352px;
        }

        #aprs-map.slideover-closed {
          right: 0;
        }
      }

      /* Slideover panel base styles */
      .slideover-panel {
        position: fixed;
        top: 0;
        right: 0;
        bottom: 0;
        width: 352px;
        background: white;
        box-shadow: -2px 0 8px rgba(0, 0, 0, 0.1);
        z-index: 50;
        display: flex;
        flex-direction: column;
        transition: transform 0.3s ease-in-out;
        overflow: hidden;
      }

      .slideover-panel.slideover-open {
        transform: translateX(0);
      }

      .slideover-panel.slideover-closed {
        transform: translateX(100%);
      }

      /* Mobile styles */
      @media (max-width: 1023px) {
        #aprs-map {
          right: 0 !important;
        }
        
        .slideover-panel {
          width: 90vw !important;
          max-width: 400px;
        }
        
        .locate-button {
          top: 65px;
          width: 44px;
          height: 44px;
          display: flex;
          align-items: center;
          justify-content: center;
        }
      }

      .locate-button {
        position: absolute;
        left: 10px;
        top: 80px;
        z-index: 1000;
        background: white;
        border: 2px solid rgba(0,0,0,0.2);
        border-radius: 4px;
        padding: 5px;
        cursor: pointer;
      }

      @media (prefers-color-scheme: dark) {
        .locate-button {
          background: rgb(30 41 59); /* slate-800 */
          border-color: rgba(255, 255, 255, 0.1);
          box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
        }
        
        .locate-button svg {
          fill: #e2e8f0; /* slate-200 */
        }
      }

      .locate-button:hover {
        background: #f4f4f4;
      }

      @media (prefers-color-scheme: dark) {
        .locate-button:hover {
          background: rgb(51 65 85); /* slate-700 */
        }
      }

      .aprs-marker {
        background: transparent !important;
        border: none !important;
      }

      .historical-marker {
        opacity: 0.7;
      }

      .aprs-popup {
        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
        font-size: 12px;
        line-height: 1.4;
        max-width: 200px;
      }

      .aprs-callsign {
        font-size: 14px;
        font-weight: bold;
        color: #1e40af;
        margin-bottom: 4px;
      }

      .aprs-info-link {
        font-size: 11px;
        color: #007cba;
        text-decoration: none;
        font-weight: normal;
        margin-left: 8px;
        padding: 2px 4px;
        border-radius: 3px;
        transition: background-color 0.2s;
      }

      .aprs-info-link:hover {
        background-color: rgba(0, 124, 186, 0.1);
        text-decoration: none;
      }

      .aprs-comment {
        color: #374151;
        margin-bottom: 4px;
        word-wrap: break-word;
      }

      .aprs-coords {
        color: #6b7280;
        font-size: 11px;
        font-family: monospace;
      }

      .aprs-timestamp {
        color: #6b7280;
        font-size: 11px;
        font-family: monospace;
        padding-top: 4px;
      }

      /* Leaflet popup improvements for APRS data */
      .leaflet-popup-content-wrapper {
        border-radius: 8px;
      }

      .leaflet-popup-content {
        margin: 8px 12px;
      }

      /* Slideover panel styles */
      .slideover-panel {
        position: fixed;
        top: 0;
        right: 0;
        height: 100vh;
        background: white;
        box-shadow: -4px 0 16px rgba(0, 0, 0, 0.1);
        z-index: 1000;
        display: flex;
        flex-direction: column;
        transition: transform 0.3s ease-in-out;
        overflow: hidden;
        box-sizing: border-box;
      }

      @media (prefers-color-scheme: dark) {
        .slideover-panel {
          background: rgb(15 23 42); /* slate-900 */
          box-shadow: -4px 0 16px rgba(0, 0, 0, 0.3);
        }
      }

      /* Ensure proper box-sizing for all children */
      .slideover-panel * {
        box-sizing: border-box;
      }

      /* Desktop styles */
      @media (min-width: 1024px) {
        .slideover-panel {
          width: 352px;
          transform: translateX(0);
        }

        .slideover-panel.slideover-closed {
          transform: translateX(100%);
        }
      }

      /* Mobile styles - override the desktop styles */
      @media (max-width: 1023px) {
        .slideover-panel {
          width: 90vw !important;
          max-width: 400px;
        }

        .slideover-panel.slideover-closed {
          transform: translateX(100%);
        }

        .slideover-panel.slideover-open {
          transform: translateX(0);
        }
      }

      /* Slideover toggle button */
      .slideover-toggle {
        position: fixed;
        top: 50%;
        transform: translateY(-50%);
        z-index: 999;
        background: white;
        border: 2px solid rgba(0, 0, 0, 0.1);
        border-radius: 8px 0 0 8px;
        padding: 12px 8px;
        cursor: pointer;
        transition: all 0.3s ease-in-out;
        box-shadow: -2px 0 8px rgba(0, 0, 0, 0.1);
      }

      @media (prefers-color-scheme: dark) {
        .slideover-toggle {
          background: rgb(30 41 59); /* slate-800 */
          border-color: rgba(255, 255, 255, 0.1);
          box-shadow: -2px 0 8px rgba(0, 0, 0, 0.3);
        }
      }

      .slideover-toggle.slideover-open {
        right: 352px;
      }

      .slideover-toggle.slideover-closed {
        right: 0;
        border-right: none;
      }

      @media (max-width: 1023px) {
        .slideover-toggle {
          display: none;
        }
      }

      .slideover-toggle:hover {
        background: #f3f4f6;
      }

      @media (prefers-color-scheme: dark) {
        .slideover-toggle:hover {
          background: rgb(51 65 85); /* slate-700 */
        }
      }
    </style>

    <!-- Slideover Toggle Button -->
    <button
      class={["slideover-toggle", if(@slideover_open, do: "slideover-open", else: "slideover-closed")]}
      phx-click="toggle_slideover"
      title={
        if @slideover_open,
          do: Gettext.gettext(AprsmeWeb.Gettext, "Hide controls"),
          else: Gettext.gettext(AprsmeWeb.Gettext, "Show controls")
      }
    >
      <%= if @slideover_open do %>
        <svg
          xmlns="http://www.w3.org/2000/svg"
          width="20"
          height="20"
          viewBox="0 0 24 24"
          fill="none"
          stroke="currentColor"
          stroke-width="2"
          stroke-linecap="round"
          stroke-linejoin="round"
        >
          <path d="m9 18 6-6-6-6" />
        </svg>
      <% else %>
        <svg
          xmlns="http://www.w3.org/2000/svg"
          width="20"
          height="20"
          viewBox="0 0 24 24"
          fill="none"
          stroke="currentColor"
          stroke-width="2"
          stroke-linecap="round"
          stroke-linejoin="round"
        >
          <path d="m15 18-6-6 6-6" />
        </svg>
      <% end %>
    </button>

    <!-- Loading Indicator -->
    <%= if @historical_loading do %>
      <div class="absolute bottom-4 left-1/2 transform -translate-x-1/2 z-[1000]
                  bg-white rounded-lg shadow-lg px-4 py-2 flex items-center space-x-2">
        <div class="animate-spin rounded-full h-4 w-4 border-b-2 border-indigo-600"></div>
        <span class="text-sm text-gray-600">
          {gettext("Loading historical data...")}
          <%= if @loading_batch && @total_batches do %>
            ({@loading_batch}/{@total_batches})
          <% end %>
        </span>
      </div>
    <% end %>

    <!-- Mobile Backdrop -->
    <%= if @slideover_open do %>
      <div class="fixed inset-0 bg-black bg-opacity-50 z-[999] lg:hidden backdrop-blur-sm" phx-click="toggle_slideover">
      </div>
    <% end %>

    <!-- Control Panel Overlay -->
    <div
      id="slideover-panel"
      class={[
        "slideover-panel",
        if(@slideover_open, do: "slideover-open", else: "slideover-closed")
      ]}
      phx-hook="ResponsiveSlideoverHook"
    >
      <!-- Header -->
      <div class="flex items-center justify-between p-6 border-b border-slate-200 dark:border-slate-700 bg-gradient-to-r from-indigo-600 to-purple-600 text-white">
        <div class="flex items-center space-x-2">
          <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
            <path
              stroke-linecap="round"
              stroke-linejoin="round"
              stroke-width="2"
              d="M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z"
            />
          </svg>
          <h2 class="text-xl font-bold">APRS.me</h2>
        </div>
        
    <!-- Close button for mobile -->
        <button
          class="lg:hidden text-white hover:text-slate-200 transition-colors"
          phx-click="toggle_slideover"
          title={Gettext.gettext(AprsmeWeb.Gettext, "Close controls")}
        >
          <svg
            xmlns="http://www.w3.org/2000/svg"
            width="24"
            height="24"
            viewBox="0 0 24 24"
            fill="none"
            stroke="currentColor"
            stroke-width="2"
            stroke-linecap="round"
            stroke-linejoin="round"
          >
            <path d="m18 6-12 12" />
            <path d="m6 6 12 12" />
          </svg>
        </button>
      </div>
      
    <!-- Content -->
      <div class="p-6 space-y-6 bg-slate-50 dark:bg-slate-900 flex-1 overflow-y-auto">
        <!-- Callsign Search -->
        <div class="space-y-4">
          <label class="block text-sm font-semibold text-slate-700 dark:text-slate-300 flex items-center space-x-2">
            <svg class="w-4 h-4 text-indigo-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
              <path
                stroke-linecap="round"
                stroke-linejoin="round"
                stroke-width="2"
                d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"
              />
            </svg>
            <span>{gettext("Search Callsign")}</span>
          </label>
          <form phx-submit="track_callsign" class="flex flex-col space-y-2">
            <div class="flex space-x-2 w-full">
              <input
                type="text"
                name="callsign"
                value={@tracked_callsign || @overlay_callsign}
                phx-change="update_callsign"
                placeholder={gettext("Enter callsign...")}
                class="flex-1 px-4 py-3 border border-slate-300 dark:border-slate-600 rounded-xl shadow-sm focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 text-sm uppercase placeholder-slate-400 dark:placeholder-slate-500 transition-all duration-200 hover:border-slate-400 dark:hover:border-slate-500 bg-white dark:bg-slate-800 text-gray-900 dark:text-white"
              />
              <button
                type="submit"
                class="px-4 py-3 bg-gradient-to-r from-indigo-600 to-purple-600 text-white rounded-xl hover:from-indigo-700 hover:to-purple-700 focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:ring-offset-2 transition-all duration-200 text-sm font-semibold shadow-lg hover:shadow-xl whitespace-nowrap flex-shrink-0"
              >
                {gettext("Track")}
              </button>
            </div>
            <%= if @tracked_callsign != "" do %>
              <div class="flex items-center justify-between bg-blue-50 px-3 py-2 rounded-lg">
                <span class="text-sm text-blue-700 font-medium">
                  {gettext("Tracking:")} <span class="font-bold">{@tracked_callsign}</span>
                </span>
                <button
                  type="button"
                  phx-click="clear_tracking"
                  class="text-blue-600 hover:text-blue-800 font-medium text-sm"
                >
                  {gettext("Clear")}
                </button>
              </div>
            <% end %>
          </form>
        </div>
        
    <!-- Trail Duration -->
        <div class="space-y-4">
          <label class="block text-sm font-semibold text-slate-700 dark:text-slate-300 flex items-center space-x-2">
            <svg class="w-4 h-4 text-emerald-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
              <path
                stroke-linecap="round"
                stroke-linejoin="round"
                stroke-width="2"
                d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z"
              />
            </svg>
            <span>{gettext("Trail Duration")}</span>
          </label>
          <form phx-change="update_trail_duration" class="relative">
            <select
              name="trail_duration"
              class="w-full px-4 py-3 border border-slate-300 dark:border-slate-600 rounded-xl shadow-sm focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 text-sm bg-white dark:bg-slate-800 text-gray-900 dark:text-white appearance-none transition-all duration-200 hover:border-slate-400 dark:hover:border-slate-500"
            >
              <option value="1" selected={@trail_duration == "1"}>
                {ngettext("1 Hour", "%{count} Hours", 1)}
              </option>
              <option value="6" selected={@trail_duration == "6"}>
                {ngettext("1 Hour", "%{count} Hours", 6)}
              </option>
              <option value="12" selected={@trail_duration == "12"}>
                {ngettext("1 Hour", "%{count} Hours", 12)}
              </option>
              <option value="24" selected={@trail_duration == "24"}>
                {ngettext("1 Hour", "%{count} Hours", 24)}
              </option>
              <option value="48" selected={@trail_duration == "48"}>
                {ngettext("1 Hour", "%{count} Hours", 48)}
              </option>
              <option value="168" selected={@trail_duration == "168"}>
                {gettext("1 Week")}
              </option>
            </select>
            <div class="absolute inset-y-0 right-0 flex items-center pr-3 pointer-events-none">
              <svg class="w-4 h-4 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7" />
              </svg>
            </div>
          </form>
        </div>
        
    <!-- Historical Data -->
        <div class="space-y-4">
          <label class="block text-sm font-semibold text-slate-700 dark:text-slate-300 flex items-center space-x-2">
            <svg class="w-4 h-4 text-amber-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
              <path
                stroke-linecap="round"
                stroke-linejoin="round"
                stroke-width="2"
                d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z"
              />
            </svg>
            <span>{gettext("Historical Data")}</span>
          </label>
          <form phx-change="update_historical_hours" class="relative">
            <select
              name="historical_hours"
              class="w-full px-4 py-3 border border-slate-300 dark:border-slate-600 rounded-xl shadow-sm focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 text-sm bg-white dark:bg-slate-800 text-gray-900 dark:text-white appearance-none transition-all duration-200 hover:border-slate-400 dark:hover:border-slate-500"
            >
              <option value="1" selected={@historical_hours == "1"}>
                {ngettext("1 Hour", "%{count} Hours", 1)}
              </option>
              <option value="3" selected={@historical_hours == "3"}>
                {ngettext("1 Hour", "%{count} Hours", 3)}
              </option>
              <option value="6" selected={@historical_hours == "6"}>
                {ngettext("1 Hour", "%{count} Hours", 6)}
              </option>
              <option value="12" selected={@historical_hours == "12"}>
                {ngettext("1 Hour", "%{count} Hours", 12)}
              </option>
              <option value="24" selected={@historical_hours == "24"}>
                {ngettext("1 Hour", "%{count} Hours", 24)}
              </option>
            </select>
            <div class="absolute inset-y-0 right-0 flex items-center pr-3 pointer-events-none">
              <svg class="w-4 h-4 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7" />
              </svg>
            </div>
          </form>
        </div>
        
    <!-- Navigation -->
        <div class="pt-4 border-t border-slate-200 dark:border-slate-700 space-y-3">
          <div class="flex items-center space-x-2 text-sm text-slate-600 dark:text-slate-400 mb-3">
            <svg class="w-4 h-4 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
              <path
                stroke-linecap="round"
                stroke-linejoin="round"
                stroke-width="2"
                d="M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2H5a2 2 0 00-2-2z"
              />
            </svg>
            <span class="font-medium">{gettext("Navigation")}</span>
          </div>
          <.navigation
            variant={:vertical}
            class="text-sm"
            current_user={@current_user}
            map_state={%{lat: @map_center.lat, lng: @map_center.lng, zoom: @map_zoom}}
            tracked_callsign={@tracked_callsign}
          />
        </div>
        
    <!-- Last Update -->
        <div class="pt-4 border-t border-slate-200 dark:border-slate-700 space-y-3">
          <div class="flex items-center space-x-2 text-sm text-slate-600 dark:text-slate-400">
            <svg class="w-4 h-4 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
              <path
                stroke-linecap="round"
                stroke-linejoin="round"
                stroke-width="2"
                d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"
              />
            </svg>
            <span class="font-medium">{gettext("Last Update")}</span>
          </div>
          <div class="text-xs text-slate-500 dark:text-slate-400">
            <%= if @last_update_at do %>
              <div class="font-mono">{time_ago_in_words(@last_update_at)}</div>
              <div class="font-mono text-slate-400 dark:text-slate-500">
                {Calendar.strftime(@last_update_at, "%Y-%m-%d %H:%M UTC")}
              </div>
            <% else %>
              <div class="font-mono text-slate-500 dark:text-slate-400">No updates yet</div>
            <% end %>
          </div>
        </div>
        
    <!-- Deployment Information -->
        <div class="pt-4 border-t border-slate-200 dark:border-slate-700 space-y-3">
          <div class="flex items-center space-x-2 text-sm text-slate-600 dark:text-slate-400">
            <svg class="w-4 h-4 text-slate-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
              <path
                stroke-linecap="round"
                stroke-linejoin="round"
                stroke-width="2"
                d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z"
              />
            </svg>
            <span class="font-medium">{gettext("Last Deploy")}</span>
          </div>
          <div class="text-xs text-slate-500 dark:text-slate-400">
            <div class="font-mono">{time_ago_in_words(@deployed_at)}</div>
            <div class="font-mono text-slate-400">
              {Calendar.strftime(@deployed_at, "%Y-%m-%d %H:%M UTC")}
            </div>
          </div>
        </div>
      </div>
    </div>
    """
  end

  # Clean up expired markers from visible_packets and client, but do not re-query the DB
  defp handle_cleanup_old_packets(socket) do
    # Schedule next cleanup
    Process.send_after(self(), :cleanup_old_packets, 60_000)

    # Use the current packet_age_threshold instead of hardcoded one hour
    threshold = socket.assigns.packet_age_threshold

    # Remove expired packets using PacketManager predicate
    updated_packet_state =
      PacketManager.remove_packets_where(socket.assigns.packet_state, fn packet ->
        SharedPacketUtils.packet_within_time_threshold?(packet, threshold)
      end)

    # Get expired packet IDs that need to be removed from client
    current_packets = PacketManager.get_visible_packets(socket.assigns.packet_state)
    remaining_packets = PacketManager.get_visible_packets(updated_packet_state)

    expired_keys =
      current_packets
      |> Enum.reject(fn current_packet ->
        Enum.any?(remaining_packets, fn remaining_packet ->
          get_callsign_key(current_packet) == get_callsign_key(remaining_packet)
        end)
      end)
      |> Enum.map(&get_callsign_key/1)

    # Only update the client if there are expired markers
    socket = DisplayManager.remove_markers_batch(socket, expired_keys)

    {:noreply, assign(socket, packet_state: updated_packet_state)}
  end

  defp handle_update_time_display(socket) do
    # Schedule next update
    Process.send_after(self(), :update_time_display, 30_000)

    # Simply triggering a re-render will cause time_ago_in_words to recalculate
    # No need to update any assigns, just return the socket
    {:noreply, socket}
  end

  defp handle_reload_historical_packets(socket) do
    require Logger

    Logger.debug(
      "handle_reload_historical_packets called - map_ready: #{socket.assigns.map_ready}, map_bounds: #{inspect(socket.assigns.map_bounds)}"
    )

    if socket.assigns.map_ready and socket.assigns.map_bounds do
      # Clear existing historical packets
      socket = push_event(socket, "clear_historical_packets", %{})

      # Start progressive loading using LiveView's efficient batching
      socket = HistoricalLoader.start_progressive_historical_loading(socket)

      {:noreply, socket}
    else
      Logger.debug("Skipping historical reload - conditions not met")
      {:noreply, socket}
    end
  end

  # Helper functions

  # Fetch historical packets from the database

  # Select the best packet to display for a callsign - prioritize position over weather

  @spec within_bounds?(map() | struct(), map()) :: boolean()
  defp within_bounds?(packet, bounds) do
    {lat, lon, _data_extended} = MapHelpers.get_coordinates(packet)

    # Basic validation
    check_coordinate_bounds(lat, lon, bounds)
  end

  defp check_coordinate_bounds(nil, _, _), do: false
  defp check_coordinate_bounds(_, nil, _), do: false

  defp check_coordinate_bounds(lat, lon, bounds) do
    # Check latitude bounds (straightforward)
    lat_in_bounds = lat >= bounds.south && lat <= bounds.north

    # Check longitude bounds (handle potential wrapping)
    lng_in_bounds = check_longitude_bounds(lon, bounds.west, bounds.east)

    lat_in_bounds && lng_in_bounds
  end

  defp check_longitude_bounds(lon, west, east) when west <= east do
    # Normal case: bounds don't cross antimeridian
    lon >= west && lon <= east
  end

  defp check_longitude_bounds(lon, west, east) do
    # Bounds cross antimeridian (e.g., west=170, east=-170)
    lon >= west || lon <= east
  end

  # Helper functions to reduce duplicate filtering logic

  @spec filter_packets_by_bounds(map(), map()) :: map()
  defp filter_packets_by_bounds(packets_map, bounds) when is_map(packets_map) do
    packets_map
    |> Enum.filter(fn {_k, packet} -> within_bounds?(packet, bounds) end)
    |> Map.new()
  end

  @spec filter_packets_by_bounds(list(), map()) :: list()
  defp filter_packets_by_bounds(packets_list, bounds) when is_list(packets_list) do
    Enum.filter(packets_list, &within_bounds?(&1, bounds))
  end

  @spec reject_packets_by_bounds(map(), map()) :: list()
  defp reject_packets_by_bounds(packets_map, bounds) when is_map(packets_map) do
    packets_map
    |> Enum.reject(fn {_k, packet} -> within_bounds?(packet, bounds) end)
    |> Enum.map(fn {k, _} -> k end)
  end

  @spec filter_packets_by_time_and_bounds(map(), map(), DateTime.t()) :: map()
  defp filter_packets_by_time_and_bounds(packets, bounds, time_threshold) do
    packets
    |> Enum.filter(fn {_callsign, packet} ->
      within_bounds?(packet, bounds) &&
        SharedPacketUtils.packet_within_time_threshold?(packet, time_threshold)
    end)
    |> Map.new()
  end

  @spec filter_packets_by_time_and_bounds_with_tracked(map(), map(), DateTime.t(), String.t(), map() | nil) :: map()
  defp filter_packets_by_time_and_bounds_with_tracked(
         packets,
         bounds,
         time_threshold,
         tracked_callsign,
         tracked_latest_packet
       ) do
    filtered = filter_packets_by_time_and_bounds(packets, bounds, time_threshold)

    # Always include the tracked callsign's latest packet if we have one
    if tracked_callsign != "" and tracked_latest_packet do
      key = get_callsign_key(tracked_latest_packet)
      Map.put(filtered, key, tracked_latest_packet)
    else
      filtered
    end
  end

  # Helper functions for marker operations

  @spec remove_markers_batch(Socket.t(), list()) :: Socket.t()
  defp remove_markers_batch(socket, []), do: socket

  defp remove_markers_batch(socket, marker_ids) do
    Enum.reduce(marker_ids, socket, fn id, acc ->
      push_event(acc, "remove_marker", %{id: id})
    end)
  end

  @spec add_markers_if_any(Socket.t(), list()) :: Socket.t()
  defp add_markers_if_any(socket, []), do: socket

  defp add_markers_if_any(socket, markers) do
    push_event(socket, "add_markers", %{markers: markers})
  end

  @impl true
  def terminate(_reason, socket) do
    # Unregister from connection monitor
    if Application.get_env(:aprsme, :cluster_enabled, false) and
         not socket.assigns[:connection_draining] do
      Aprsme.ConnectionMonitor.unregister_connection()
    end

    # Cleanup spatial registration if we have a client ID
    if socket.assigns[:spatial_client_id] do
      Aprsme.SpatialPubSub.unregister_client(socket.assigns.spatial_client_id)
    end

    # Unsubscribe from StreamingPacketsPubSub
    Aprsme.StreamingPacketsPubSub.unsubscribe(self())

    if socket.assigns.buffer_timer, do: Process.cancel_timer(socket.assigns.buffer_timer)
    # Clean up any pending bounds update timer
    if socket.assigns[:bounds_update_timer] do
      Process.cancel_timer(socket.assigns.bounds_update_timer)
    end

    # Clean up any pending batch tasks
    if socket.assigns[:pending_batch_tasks] do
      Enum.each(socket.assigns.pending_batch_tasks, &Process.cancel_timer/1)
    end

    :ok
  end

  # Bounds comparison now handled by shared utilities

  # --- Private bounds update helpers ---
  @spec handle_bounds_update(map(), Socket.t()) :: {:noreply, Socket.t()}
  defp handle_bounds_update(bounds, socket) do
    # Skip if we're currently loading historical data
    if socket.assigns.historical_loading do
      # Defer the bounds update
      {:noreply, assign(socket, pending_bounds: bounds)}
    else
      # Update the map bounds from the client, converting to atom keys
      map_bounds = MapHelpers.normalize_bounds(bounds)

      # Validate bounds to prevent invalid coordinates
      if valid_bounds?(map_bounds) do
        handle_valid_bounds_update(map_bounds, socket)
      else
        # Invalid bounds, skip update
        {:noreply, socket}
      end
    end
  end

  defp valid_bounds?(map_bounds) do
    map_bounds.north <= 90 and map_bounds.south >= -90 and map_bounds.north > map_bounds.south
  end

  defp handle_valid_bounds_update(map_bounds, socket) do
    # Force processing if we need initial historical load, regardless of bounds comparison
    cond do
      socket.assigns[:needs_initial_historical_load] ->
        require Logger

        Logger.debug("Processing initial bounds update immediately (forced): #{inspect(map_bounds)}")
        socket = process_bounds_update(map_bounds, socket)
        {:noreply, socket}

      BoundsUtils.compare_bounds(map_bounds, socket.assigns.map_bounds) ->
        {:noreply, socket}

      true ->
        # For subsequent updates, use the timer to debounce
        schedule_bounds_update(map_bounds, socket)
    end
  end

  # Configurable debounce delay (in milliseconds)
  @bounds_update_debounce_ms Application.compile_env(:aprsme, :bounds_update_debounce_ms, 400)

  defp schedule_bounds_update(map_bounds, socket) do
    # Cancel existing timer if present
    if socket.assigns[:bounds_update_timer] do
      case Process.cancel_timer(socket.assigns.bounds_update_timer) do
        false ->
          # Timer already fired, receive the message to clear it
          receive do
            {:process_bounds_update, _} -> :ok
          after
            0 -> :ok
          end

        _ ->
          :ok
      end
    end

    # Cancel any in-progress historical loading to prevent race conditions
    socket = HistoricalLoader.cancel_pending_loads(socket)

    # Use configurable debounce time for better stability during rapid zooming
    timer_ref = Process.send_after(self(), {:process_bounds_update, map_bounds}, @bounds_update_debounce_ms)
    socket = assign(socket, bounds_update_timer: timer_ref, pending_bounds: map_bounds)
    {:noreply, socket}
  end

  defp send_heat_map_data(socket, filtered_packets) do
    # Convert map of packets to list
    packet_list = Map.values(filtered_packets)
    send_heat_map_for_packets(socket, packet_list)
  end

  # Common heat map display logic
  defp send_heat_map_for_packets(socket, packets) do
    # Get clustering data
    case Clustering.cluster_packets(packets, socket.assigns.map_zoom) do
      {:heat_map, heat_points} ->
        push_event(socket, "show_heat_map", %{heat_points: heat_points})

      {:raw_packets, _packets} ->
        # Shouldn't happen at zoom <= 8, but handle it anyway
        socket
    end
  end

  @spec process_bounds_update(map(), Socket.t()) :: Socket.t()
  defp process_bounds_update(map_bounds, socket) do
    require Logger

    Logger.debug("process_bounds_update called with bounds: #{inspect(map_bounds)}")

    # Update spatial viewport if we have a client ID
    if socket.assigns[:spatial_client_id] do
      Aprsme.SpatialPubSub.update_viewport(socket.assigns.spatial_client_id, map_bounds)
    end

    # Update StreamingPacketsPubSub subscription with new bounds
    Aprsme.StreamingPacketsPubSub.subscribe_to_bounds(self(), map_bounds)

    # Check if this is the initial load or if bounds have actually changed
    is_initial_load = socket.assigns[:needs_initial_historical_load] || !socket.assigns[:initial_bounds_loaded]
    bounds_changed = socket.assigns.map_bounds && not BoundsUtils.compare_bounds(map_bounds, socket.assigns.map_bounds)

    # Check if we've completed the initial historical load
    initial_historical_completed = socket.assigns[:initial_historical_completed] || false

    Logger.debug(
      "is_initial_load: #{is_initial_load}, bounds_changed: #{bounds_changed}, initial_historical_completed: #{initial_historical_completed}"
    )

    # Remove out-of-bounds packets and markers immediately
    current_packets = PacketManager.get_visible_packets(socket.assigns.packet_state)
    current_packets_map = Map.new(current_packets, fn packet -> {get_callsign_key(packet), packet} end)

    new_visible_packets = filter_packets_by_bounds(current_packets_map, map_bounds)
    packets_to_remove = reject_packets_by_bounds(current_packets_map, map_bounds)

    # Remove markers for out-of-bounds packets
    socket = remove_markers_batch(socket, packets_to_remove)

    # Only clear historical packets if:
    # 1. Bounds actually changed AND
    # 2. This is not the initial load AND
    # 3. We've already completed the initial historical load
    socket =
      if bounds_changed and not is_initial_load and initial_historical_completed do
        Logger.debug("Bounds changed after initial load - clearing historical packets")
        push_event(socket, "clear_historical_packets", %{})
      else
        Logger.debug("Initial load or no significant change - keeping existing markers")
        socket
      end

    # Always filter markers by bounds
    socket = push_event(socket, "filter_markers_by_bounds", %{bounds: map_bounds})

    # Update packet state to keep only packets within bounds
    filtered_packets = Map.values(new_visible_packets)
    {updated_packet_state, _} = PacketManager.add_visible_packets(socket.assigns.packet_state, filtered_packets)

    # Update map bounds FIRST so progressive loading uses the correct bounds
    socket =
      socket
      |> assign(map_bounds: map_bounds, packet_state: updated_packet_state)
      |> assign(needs_initial_historical_load: false)

    # Load historical packets for the new bounds (now socket.assigns.map_bounds is correct)
    Logger.debug("Starting progressive historical loading for new bounds")

    Logger.debug(
      "Current assigns: historical_loading=#{socket.assigns.historical_loading}, map_bounds=#{inspect(socket.assigns.map_bounds)}"
    )

    socket = HistoricalLoader.start_progressive_historical_loading(socket)

    # Mark initial historical as completed if this was the initial load
    if is_initial_load do
      assign(socket, initial_historical_completed: true)
    else
      socket
    end
  end
end