move json to api, change tile loading api

lib/mound_hunters/repo.ex

@@ -9,15 +9,52 @@ defmodule MoundHunters.Repo do
   @type tile_status :: :processing | :ready | :error
 
   @doc """
-  Get a tile by ID from Mnesia.
+  Get a tile by its ID.
+  Returns {:ok, tile} or {:error, :not_found}
   """
-  def get_tile(tile_id) do
+  def get_tile(id) do
     case :mnesia.transaction(fn ->
-           :mnesia.read(:tiles, tile_id)
+           :mnesia.read(:tiles, id)
          end) do
-      {:atomic, [tile]} -> {:ok, tile_to_map(tile)}
-      {:atomic, []} -> {:error, :not_found}
-      {:aborted, reason} -> {:error, reason}
+      {:atomic, [tile]} ->
+        {:ok, tile_to_map(tile)}
+
+      {:atomic, []} ->
+        {:error, :not_found}
+
+      {:aborted, reason} ->
+        Logger.error("Failed to read tile #{id}: #{inspect(reason)}")
+        {:error, :database_error}
+    end
+  end
+
+  @doc """
+  Get a tile that contains the given lat/lng coordinates.
+  Returns {:ok, tile} or {:error, :not_found}
+
+  If multiple tiles contain the point, returns the first match.
+  """
+  def get_tile_at_coords(lat, lng) do
+    match_spec = [
+      {{:tiles, :"$1", :"$2", :"$3", :"$4", :"$5", :"$6", :"$7", :"$8", :"$9", :"$10", :"$11"},
+       [
+         {:andalso, {:"=<", :"$2", lat}, {:"=<", lat, :"$3"}},
+         {:andalso, {:"=<", :"$4", lng}, {:"=<", lng, :"$5"}}
+       ], [:"$_"]}
+    ]
+
+    case :mnesia.transaction(fn ->
+           :mnesia.select(:tiles, match_spec)
+         end) do
+      {:atomic, [tile | _]} ->
+        {:ok, tile_to_map(tile)}
+
+      {:atomic, []} ->
+        {:error, :not_found}
+
+      {:aborted, reason} ->
+        Logger.error("Failed to query tiles at #{lat}, #{lng}: #{inspect(reason)}")
+        {:error, :database_error}
     end
   end
 
@@ -31,7 +68,8 @@ defmodule MoundHunters.Repo do
     tile_record =
       {:tiles, tile_id, Map.get(attrs, :min_lat), Map.get(attrs, :max_lat),
        Map.get(attrs, :min_lng), Map.get(attrs, :max_lng), Map.get(attrs, :status),
-       Map.get(attrs, :error_message), Map.get(attrs, :created_at, now), now}
+       Map.get(attrs, :error_message), Map.get(attrs, :jpg_available, false),
+       Map.get(attrs, :png_available, false), Map.get(attrs, :created_at, now), now}
 
     case :mnesia.transaction(fn ->
            :mnesia.write(tile_record)
@@ -73,8 +111,8 @@ defmodule MoundHunters.Repo do
 
   # Convert Mnesia tile record to map
   defp tile_to_map(
-         {:tiles, id, min_lat, max_lat, min_lng, max_lng, status, error_message, created_at,
-          updated_at}
+         {:tiles, id, min_lat, max_lat, min_lng, max_lng, status, error_message, jpg_available,
+          png_available, created_at, updated_at}
        ) do
     %{
       id: id,
@@ -84,6 +122,8 @@ defmodule MoundHunters.Repo do
       max_lng: max_lng,
       status: status,
       error_message: error_message,
+      jpg_available: jpg_available,
+      png_available: png_available,
       created_at: created_at,
       updated_at: updated_at
     }
@@ -98,6 +138,175 @@ defmodule MoundHunters.Repo do
     }
   end
 
+  @doc """
+  Repopulate tiles table from .mound files in the configured directory.
+  Skips tiles that already exist in the database.
+  Returns {success_count, skip_count, error_count}.
+  """
+  def repopulate_from_mounds do
+    tile_dir = Application.get_env(:mound_hunters, :tile_output_dir)
+    mound_dir = Path.join(tile_dir, "MOUND")
+
+    Logger.info("Scanning for .mound files in: #{mound_dir}")
+
+    case File.ls(mound_dir) do
+      {:ok, files} ->
+        results =
+          files
+          |> Enum.filter(&String.ends_with?(&1, ".mound"))
+          |> Enum.map(fn filename ->
+            # Extract tile_id from filename (e.g., "BS18921654.mound" -> "BS18921654")
+            tile_id = Path.rootname(filename)
+            full_path = Path.join(mound_dir, filename)
+
+            process_mound_file(tile_id, full_path)
+          end)
+
+        successes = Enum.count(results, &(&1 == :ok))
+        skips = Enum.count(results, &(&1 == :skipped))
+        errors = Enum.count(results, &match?({:error, _}, &1))
+
+        Logger.info(
+          "Repopulation complete: #{successes} inserted, #{skips} skipped, #{errors} errors"
+        )
+
+        {successes, skips, errors}
+
+      {:error, reason} ->
+        Logger.error("Failed to list directory #{mound_dir}: #{inspect(reason)}")
+        {:error, reason}
+    end
+  end
+
+  @doc """
+  Scan tile directories and update jpg_available and png_available flags.
+  Returns {updated_count, not_found_count}.
+  """
+  def update_tile_availability do
+    tile_dir = Application.get_env(:mound_hunters, :tile_output_dir)
+    mound_dir = Path.join(tile_dir, "MOUND")
+
+    Logger.info("Scanning tile availability in: #{mound_dir}")
+
+    # Get all tile IDs from database
+    case :mnesia.transaction(fn ->
+           :mnesia.match_object({:tiles, :_, :_, :_, :_, :_, :_, :_, :_, :_, :_, :_})
+         end) do
+      {:atomic, tiles} ->
+        results =
+          tiles
+          |> Enum.map(fn tile_record ->
+            tile = tile_to_map(tile_record)
+            tile_id = tile.id
+
+            jpg_path = Path.join(mound_dir, "#{tile_id}.jpg")
+            png_path = Path.join(mound_dir, "#{tile_id}.png")
+
+            jpg_available = File.exists?(jpg_path)
+            png_available = File.exists?(png_path)
+
+            # Only update if availability changed
+            if jpg_available != tile.jpg_available or png_available != tile.png_available do
+              attrs = %{
+                id: tile_id,
+                min_lat: tile.min_lat,
+                max_lat: tile.max_lat,
+                min_lng: tile.min_lng,
+                max_lng: tile.max_lng,
+                status: tile.status,
+                error_message: tile.error_message,
+                jpg_available: jpg_available,
+                png_available: png_available,
+                created_at: tile.created_at
+              }
+
+              case upsert_tile(attrs) do
+                {:ok, _} ->
+                  Logger.debug("Updated #{tile_id}: jpg=#{jpg_available}, png=#{png_available}")
+
+                  :updated
+
+                {:error, reason} ->
+                  Logger.error("Failed to update #{tile_id}: #{inspect(reason)}")
+                  {:error, reason}
+              end
+            else
+              :unchanged
+            end
+          end)
+
+        updated = Enum.count(results, &(&1 == :updated))
+        unchanged = Enum.count(results, &(&1 == :unchanged))
+        errors = Enum.count(results, &match?({:error, _}, &1))
+
+        Logger.info(
+          "Availability scan complete: #{updated} updated, #{unchanged} unchanged, #{errors} errors"
+        )
+
+        {updated, unchanged, errors}
+
+      {:aborted, reason} ->
+        Logger.error("Failed to read tiles: #{inspect(reason)}")
+        {:error, reason}
+    end
+  end
+
+  defp process_mound_file(tile_id, file_path) do
+    # Check if tile already exists
+    case get_tile(tile_id) do
+      {:ok, _existing} ->
+        Logger.debug("Skipping existing tile: #{tile_id}")
+        :skipped
+
+      {:error, :not_found} ->
+        # Parse header and insert
+        case MoundHunters.MoundParser.parse_header(file_path) do
+          {:ok, header} ->
+            # Convert Web Mercator coordinates to lat/lng
+            min_lng = header.min_x
+            max_lng = header.max_x
+            min_lat = header.min_y
+            max_lat = header.max_y
+
+            # Check for jpg and png availability
+            tile_dir = Application.get_env(:mound_hunters, :tile_output_dir)
+            mound_dir = Path.join(tile_dir, "MOUND")
+            jpg_available = File.exists?(Path.join(mound_dir, "#{tile_id}.jpg"))
+            png_available = File.exists?(Path.join(mound_dir, "#{tile_id}.png"))
+
+            attrs = %{
+              id: tile_id,
+              min_lat: min_lat,
+              max_lat: max_lat,
+              min_lng: min_lng,
+              max_lng: max_lng,
+              status: :ready,
+              error_message: nil,
+              jpg_available: jpg_available,
+              png_available: png_available
+            }
+
+            case upsert_tile(attrs) do
+              {:ok, _tile} ->
+                Logger.debug("Inserted tile: #{tile_id}")
+                :ok
+
+              {:error, reason} ->
+                Logger.error("Failed to insert tile #{tile_id}: #{inspect(reason)}")
+                {:error, reason}
+            end
+
+          {:error, reason} ->
+            Logger.error("Failed to parse header for #{tile_id}: #{inspect(reason)}")
+            {:error, reason}
+        end
+
+      {:error, reason} ->
+        Logger.error("Failed to check if tile exists #{tile_id}: #{inspect(reason)}")
+        {:error, reason}
+    end
+  end
+
   # Generate random 8-character alphanumeric ID
   defp generate_id do
     :crypto.strong_rand_bytes(6)