Active Markers: {map_size(@active_markers)}
Historical: {map_size(@historical_markers)}
Zoom: {@map_zoom}
Center: {Float.round(@map_center.lat, 4)}, {Float.round(@map_center.lng, 4)}
<%= if @geolocation_error do %>
Location Error: {@geolocation_error}
<% end %>
<%= if @loading do %>
Loading markers...
<% end %>
<%= if @replay_active do %>
#{callsign} #{if historical, do: "(Historical)", else: ""}
Position: #{Float.round(packet.lat, 4)}°, #{Float.round(packet.lon, 4)}°
Type: #{packet.data_type}
#{if data_extended["comment"], do: "Comment: #{data_extended["comment"]}
", else: ""}
Path: #{packet.path}
Time: #{timestamp}
"""
end
defp update_active_markers(socket, packets) do
active_markers =
Map.new(packets, fn packet ->
callsign = packet.base_callsign <> if packet.ssid, do: "-#{packet.ssid}", else: ""
{callsign, %{packet: packet, added_at: DateTime.utc_now()}}
end)
assign(socket, :active_markers, active_markers)
end
defp add_packet_marker(socket, packet, historical) do
if has_position_data?(packet) do
marker_data = packet_to_marker_data(packet)
marker_data = Map.put(marker_data, :historical, historical)
socket = push_event(socket, "add_marker", marker_data)
# Update marker tracking
callsign = marker_data.id
marker_info = %{packet: packet, added_at: DateTime.utc_now()}
if historical do
Phoenix.Component.update(socket, :historical_markers, &Map.put(&1, callsign, marker_info))
else
Phoenix.Component.update(socket, :active_markers, &Map.put(&1, callsign, marker_info))
end
else
socket
end
end
defp cleanup_old_markers(socket) do
cutoff_time = DateTime.add(DateTime.utc_now(), -@packet_retention_minutes * 60, :second)
# Find old markers
old_markers =
socket.assigns.active_markers
|> Enum.filter(fn {_callsign, %{added_at: added_at}} ->
DateTime.before?(added_at, cutoff_time)
end)
|> Enum.map(fn {callsign, _} -> callsign end)
# Only update the client if the marker is present
socket =
if old_markers == [] do
socket
else
Enum.reduce(old_markers, socket, fn callsign, acc_socket ->
push_event(acc_socket, "remove_marker", %{id: callsign})
end)
end
# Use Map.drop/2 for better performance
active_markers = Map.drop(socket.assigns.active_markers, old_markers)
assign(socket, :active_markers, active_markers)
end
defp start_replay(socket) do
# Fetch historical packets for replay
bounds = socket.assigns.map_bounds
one_hour_ago = DateTime.add(DateTime.utc_now(), -3600, :second)
two_hours_ago = DateTime.add(DateTime.utc_now(), -7200, :second)
packets = fetch_historical_packets(bounds, two_hours_ago, one_hour_ago)
socket =
socket
|> assign(:replay_active, true)
|> assign(:replay_packets, packets)
|> assign(:replay_index, 0)
|> assign(:replay_paused, false)
# Start replay timer
timer = Process.send_after(self(), :replay_next, socket.assigns.replay_speed)
assign(socket, :replay_timer, timer)
end
defp stop_replay(socket) do
# Cancel timer if running
if socket.assigns.replay_timer do
Process.cancel_timer(socket.assigns.replay_timer)
end
# Clear historical markers
socket = push_event(socket, "clear_markers", %{})
socket
|> assign(:replay_active, false)
|> assign(:replay_timer, nil)
|> assign(:replay_packets, [])
|> assign(:replay_index, 0)
|> assign(:historical_markers, %{})
# Reload current markers
|> load_markers_in_bounds()
end
defp process_next_replay_packet(socket) do
packets = socket.assigns.replay_packets
index = socket.assigns.replay_index
if index < length(packets) do
packet = Enum.at(packets, index)
socket = add_packet_marker(socket, packet, true)
# Schedule next packet
timer = Process.send_after(self(), :replay_next, socket.assigns.replay_speed)
socket
|> assign(:replay_index, index + 1)
|> assign(:replay_timer, timer)
else
# Replay finished
assign(socket, :replay_timer, nil)
end
end
defp fetch_historical_packets(bounds, start_time, end_time) do
# Create a bounding box polygon for PostGIS spatial query
bbox_wkt =
"POLYGON((#{bounds["west"]} #{bounds["south"]}, #{bounds["east"]} #{bounds["south"]}, #{bounds["east"]} #{bounds["north"]}, #{bounds["west"]} #{bounds["north"]}, #{bounds["west"]} #{bounds["south"]}))"
Repo.all(
from(p in Packet,
where: p.has_position == true,
where: p.received_at >= ^start_time,
where: p.received_at <= ^end_time,
where: not is_nil(p.location),
where: fragment("ST_Within(?, ST_GeomFromText(?, 4326))", p.location, ^bbox_wkt),
order_by: [asc: p.received_at],
limit: 1000,
select: %{p | lat: fragment("ST_Y(?)", p.location), lon: fragment("ST_X(?)", p.location)}
)
)
end
defp has_position_data?(packet) do
lat = Map.get(packet, :lat) || Map.get(packet, "lat")
lon = Map.get(packet, :lon) || Map.get(packet, "lon")
not is_nil(lat) and not is_nil(lon)
end
defp within_bounds?(packet, bounds) do
lat = packet.lat
lng = packet.lon
lat >= bounds["south"] and lat <= bounds["north"] and
lng >= bounds["west"] and lng <= bounds["east"]
end
end