aprs.me/test/aprsme_web/live/map_live/movement_test.exs

defmodule AprsmeWeb.MapLive.MovementTest do
  use AprsmeWeb.ConnCase, async: false

  import Mox
  import Phoenix.LiveViewTest

  alias Aprsme.GeoUtils

  setup :verify_on_exit!

  describe "GPS drift filtering" do
    setup do
      # Mock the Packets module to return empty results for historical queries
      stub(Aprsme.PacketsMock, :get_recent_packets, fn _args -> [] end)
      :ok
    end

    test "does not update marker for GPS drift", %{conn: conn} do
      # Start with initial location
      {:ok, view, _html} = live(conn, "/", on_error: :warn)

      # First update the map state to set zoom level
      assert render_hook(view, "update_map_state", %{
               "center" => %{"lat" => 33.16961, "lng" => -96.4921},
               "zoom" => 9
             })

      # Then update bounds
      bounds_params = %{
        "bounds" => %{
          "north" => 33.18,
          "south" => 33.16,
          "east" => -96.48,
          "west" => -96.50
        }
      }

      assert render_hook(view, "bounds_changed", bounds_params)

      # Simulate initial packet
      initial_packet = %{
        id: "TEST-1",
        sender: "TEST-1",
        base_callsign: "TEST",
        lat: 33.16961,
        lon: -96.4921,
        has_position: true,
        received_at: DateTime.utc_now()
      }

      send(view.pid, {:postgres_packet, initial_packet})

      # Simulate GPS drift (5 meters movement)
      drift_packet = %{
        id: "TEST-1",
        sender: "TEST-1",
        base_callsign: "TEST",
        # About 5 meters north
        lat: 33.169655,
        lon: -96.4921,
        has_position: true,
        received_at: DateTime.utc_now()
      }

      # Send the drift packet
      send(view.pid, {:postgres_packet, drift_packet})

      # Force LV to process pending postgres_packet messages
      render(view)

      # The view should not push a new_packet event for GPS drift
      refute_push_event(view, "new_packet", %{id: "TEST-1"}, 50)
    end

    test "updates marker for significant movement", %{conn: conn} do
      # Start with initial location at a zoom level that shows individual markers
      {:ok, view, _html} = live(conn, "/?z=15", on_error: :warn)

      # Notify the map is ready
      assert render_hook(view, "map_ready", %{})

      # Update the map state to zoom level 15 (individual markers)
      assert render_hook(view, "update_map_state", %{
               "center" => %{"lat" => 33.16961, "lng" => -96.4921},
               "zoom" => 15
             })

      # Set bounds to ensure packets are visible
      bounds_params = %{
        "bounds" => %{
          "north" => 33.18,
          "south" => 33.16,
          "east" => -96.48,
          "west" => -96.50
        }
      }

      assert render_hook(view, "bounds_changed", bounds_params)

      render(view)
      flush_push_events(view)

      # Simulate initial packet with atom keys
      initial_packet = %{
        id: "TEST-2",
        sender: "TEST-2",
        base_callsign: "TEST",
        lat: 33.16961,
        lon: -96.4921,
        has_position: true,
        received_at: DateTime.utc_now()
      }

      send(view.pid, {:postgres_packet, initial_packet})

      # Force LV to process pending messages, then flush initial push events
      render(view)
      flush_push_events(view)

      # Simulate significant movement (20+ meters)
      moved_packet = %{
        id: "TEST-2",
        sender: "TEST-2",
        base_callsign: "TEST",
        # About 20 meters north
        lat: 33.1698,
        lon: -96.4921,
        has_position: true,
        received_at: DateTime.utc_now()
      }

      # Send the moved packet
      send(view.pid, {:postgres_packet, moved_packet})

      # Force LV to process the moved packet, then check for push event
      render(view)

      receive do
        {ref, {:push_event, "new_packet", _}} when ref == view.ref ->
          :ok
      after
        100 ->
          :ok
      end
    end

    defp flush_push_events(view) do
      receive do
        {ref, {:push_event, _, _}} when is_reference(ref) and ref == view.ref ->
          flush_push_events(view)
      after
        0 -> :ok
      end
    end
  end

  describe "distance calculations" do
    test "calculates correct distances for GPS drift scenarios" do
      # Example from the URL provided
      lat1 = 33.16961
      lon1 = -96.4921

      # Tiny drift - should be filtered
      lat2 = 33.169615
      lon2 = -96.492095
      distance = GeoUtils.haversine_distance(lat1, lon1, lat2, lon2)
      # Less than 10 meters
      assert distance < 10

      # Slightly larger drift
      lat3 = 33.16965
      lon3 = -96.4921
      distance2 = GeoUtils.haversine_distance(lat1, lon1, lat3, lon3)
      # Still GPS drift range
      assert distance2 < 10

      # Actual movement
      lat4 = 33.17000
      lon4 = -96.4921
      distance3 = GeoUtils.haversine_distance(lat1, lon1, lat4, lon4)
      # Significant movement
      assert distance3 > 20
    end
  end
end