server.js

/**
 * server.js — Express HTTP server (entry point)
 *
 * Responsibilities:
 *   - Serve the static frontend from /public.
 *   - POST /api/graph      → fetch + build road graph for a city (legacy).
 *   - POST /api/graph-bbox  → fetch + merge road graph for a bounding box.
 *   - POST /api/route       → find shortest path between two GPS points.
 *   - Single merged in-memory graph that grows as the user explores.
 */

const express = require("express");
const path = require("path");
const axios = require("axios");

const { fetchRoadGraph, fetchRoadGraphByBBox, fetchCorridorRoads } = require("./src/overpass");
const { buildGraph, haversineDistance, buildGridIndex } = require("./src/graph");
const { dijkstra } = require("./src/dijkstra");
const { astar } = require("./src/astar");
const { bfs } = require("./src/bfs");
const { dfs } = require("./src/dfs");
const { bidirectionalDijkstra } = require("./src/bidirectional");

const app = express();
const PORT = process.env.PORT || 3000;

// ── Middleware ───────────────────────────────────────────────────────
app.use(express.json());
app.use(express.static(path.join(__dirname, "public")));

// ── Single merged graph ─────────────────────────────────────────────
// Instead of per-city caching, we keep ONE global graph that merges
// new data as the user pans around.
let globalNodes = {};        // id → {lat, lon}
let globalGraph = new Map(); // adjacency list
let globalGrid  = new Map(); // spatial index

// Track which bbox tiles have been loaded (0.05° grid)
const loadedTiles = new Set();
// Track which long-distance corridors have been loaded (quantized start-end key)
const loadedCorridors = new Set();

/**
 * Quantize a bbox into 0.05° tile keys and return which ones are new.
 */
function getNewTiles(south, west, north, east) {
  const TILE_SIZE = 0.05;
  const newTiles = [];
  for (let lat = Math.floor(south / TILE_SIZE) * TILE_SIZE; lat < north; lat += TILE_SIZE) {
    for (let lon = Math.floor(west / TILE_SIZE) * TILE_SIZE; lon < east; lon += TILE_SIZE) {
      const key = `${lat.toFixed(3)},${lon.toFixed(3)}`;
      if (!loadedTiles.has(key)) {
        newTiles.push(key);
      }
    }
  }
  return newTiles;
}

/**
 * Merge new OSM data into the global graph.
 */
function mergeIntoGlobal(osmData) {
  // Merge nodes
  Object.assign(globalNodes, osmData.nodes);

  // Build a temporary graph from the new data
  const newGraph = buildGraph(osmData);

  // Merge edges into globalGraph
  for (const [nodeId, neighbors] of newGraph.entries()) {
    if (!globalGraph.has(nodeId)) {
      globalGraph.set(nodeId, []);
    }
    const existing = globalGraph.get(nodeId);
    const existingSet = new Set(existing.map(e => e.neighborId));

    for (const edge of neighbors) {
      if (!existingSet.has(edge.neighborId)) {
        existing.push(edge);
      }
    }
  }

  // Rebuild grid index (fast — it's just a hash map scan)
  globalGrid = buildGridIndex(globalNodes, globalGraph);
}

// ── Helpers ─────────────────────────────────────────────────────────

function findNearestNode(lat, lon) {
  const latBucket = Math.floor(lat * 100);
  const lonBucket = Math.floor(lon * 100);

  const candidates = [];
  for (let i = -3; i <= 3; i++) {
    for (let j = -3; j <= 3; j++) {
      const key = `${latBucket + i},${lonBucket + j}`;
      if (globalGrid.has(key)) {
        candidates.push(...globalGrid.get(key));
      }
    }
  }

  if (candidates.length === 0) {
    // Fallback: search all nodes
    for (const ids of globalGrid.values()) candidates.push(...ids);
  }

  let bestId = null;
  let bestDist = Infinity;

  for (const id of candidates) {
    const coord = globalNodes[id] ?? globalNodes[Number(id)];
    if (!coord) continue;
    const d = haversineDistance(lat, lon, coord.lat, coord.lon);
    if (d < bestDist) {
      bestDist = d;
      bestId = String(id);
    }
  }

  return bestId;
}

function countEdges(graph) {
  let total = 0;
  for (const neighbors of graph.values()) {
    total += neighbors.length;
  }
  return total;
}

// Mutex to prevent concurrent Overpass requests
let fetchInProgress = false;

// ── Routes ──────────────────────────────────────────────────────────

/**
 * POST /api/graph-bbox
 * Body: { south, west, north, east }
 * Fetches road data for the visible map area and merges into the global graph.
 */
app.post("/api/graph-bbox", async (req, res) => {
  try {
    const { south, west, north, east } = req.body;

    if ([south, west, north, east].some(v => typeof v !== "number")) {
      return res.status(400).json({ error: "south, west, north, east must be numbers" });
    }

    // Check which tiles are new
    const newTiles = getNewTiles(south, west, north, east);

    if (newTiles.length === 0) {
      return res.json({
        cached: true,
        nodeCount: globalGraph.size,
        edgeCount: countEdges(globalGraph),
        newNodes: 0
      });
    }

    if (fetchInProgress) {
      return res.json({
        cached: true,
        nodeCount: globalGraph.size,
        edgeCount: countEdges(globalGraph),
        newNodes: 0,
        busy: true
      });
    }

    fetchInProgress = true;

    try {
      const nodesBefore = globalGraph.size;
      const osmData = await fetchRoadGraphByBBox(south, west, north, east);

      mergeIntoGlobal(osmData);

      // Mark all tiles in this bbox as loaded
      for (const tile of newTiles) {
        loadedTiles.add(tile);
      }

      const newNodes = globalGraph.size - nodesBefore;
      console.log(`[server] Merged bbox → total ${globalGraph.size} nodes, ${countEdges(globalGraph)} edges (+${newNodes} new nodes)`);

      return res.json({
        cached: false,
        nodeCount: globalGraph.size,
        edgeCount: countEdges(globalGraph),
        newNodes
      });
    } finally {
      fetchInProgress = false;
    }
  } catch (err) {
    fetchInProgress = false;
    console.error("[server] /api/graph-bbox error:", err.message);
    return res.status(500).json({ error: err.message });
  }
});

/**
 * POST /api/graph (legacy — still works for city-name loading)
 */
app.post("/api/graph", async (req, res) => {
  try {
    const { city } = req.body;
    if (!city || typeof city !== "string") {
      return res.status(400).json({ error: "Missing or invalid 'city' field" });
    }

    const osmData = await fetchRoadGraph(city);
    mergeIntoGlobal(osmData);

    return res.json({
      cached: false,
      nodeCount: globalGraph.size,
      edgeCount: countEdges(globalGraph)
    });
  } catch (err) {
    console.error("[server] /api/graph error:", err.message);
    return res.status(500).json({ error: err.message });
  }
});

/**
 * POST /api/route
 * Body: { startLat, startLon, endLat, endLon, algorithm }
 * No more "city" field needed — uses the global merged graph.
 */
app.post("/api/route", async (req, res) => {
  try {
    const { startLat, startLon, endLat, endLon, algorithm } = req.body;

    if ([startLat, startLon, endLat, endLon].some(v => typeof v !== "number")) {
      return res.status(400).json({ error: "startLat, startLon, endLat, endLon must be numbers" });
    }

    // Auto-fetch corridor if needed (for inter-city / long distance routes)
    const clickDist = haversineDistance(startLat, startLon, endLat, endLon);
    console.log(`[route] Click distance: ${(clickDist/1000).toFixed(1)} km`);

    if (clickDist > 2000000) {
      // Distance > 2000km — Overpass will crash Node's memory limit if we try to fetch it
      return res.status(400).json({ error: "Distance too large. Maximum supported routing distance is 2,000km." });
    }

    if (clickDist > 5000) {
      // Create a unique key for this corridor (quantized to ~10km precision to handle slight marker drags)
      const corridorKey = `${(startLat).toFixed(1)},${(startLon).toFixed(1)}|${(endLat).toFixed(1)},${(endLon).toFixed(1)}`;
      
      if (loadedCorridors.has(corridorKey)) {
        console.log(`[route] Corridor for ${corridorKey} already loaded. Skipping fetch.`);
      } else {
        console.log(`[route] Long distance detected. Auto-fetching corridor...`);
        try {
          const corridorData = await fetchCorridorRoads(startLat, startLon, endLat, endLon);
          if (corridorData.ways.length > 0) {
            mergeIntoGlobal(corridorData);
            loadedCorridors.add(corridorKey);
            console.log(`[route] Corridor merged → ${globalGraph.size} total nodes`);
          }
        } catch (err) {
          console.warn(`[route] Corridor fetch failed: ${err.message}`);
        }
      }
    }

    if (globalGraph.size === 0) {
      return res.status(400).json({ error: "No graph data loaded. Pan the map to load roads first." });
    }

    const startId = findNearestNode(startLat, startLon);
    const endId   = findNearestNode(endLat, endLon);

    if (startId) {
      const sc = globalNodes[startId] ?? globalNodes[Number(startId)];
      if (sc) console.log(`[route] Start: (${startLat.toFixed(4)},${startLon.toFixed(4)}) → node ${startId}, dist=${haversineDistance(startLat, startLon, sc.lat, sc.lon).toFixed(0)}m`);
    }
    if (endId) {
      const ec = globalNodes[endId] ?? globalNodes[Number(endId)];
      if (ec) console.log(`[route] End: (${endLat.toFixed(4)},${endLon.toFixed(4)}) → node ${endId}, dist=${haversineDistance(endLat, endLon, ec.lat, ec.lon).toFixed(0)}m`);
    }

    if (!startId || !endId) {
      return res.status(400).json({ error: "Could not find graph nodes near the given coordinates." });
    }

    if (!algorithm) {
      return res.status(400).json({ error: "Missing 'algorithm' field" });
    }

    const result = runAlgorithm(algorithm, startId, endId);
    if (result.error) return res.status(400).json({ error: result.error });

    return res.json({
      path: toCoords(result.path),
      exploredNodes: toCoordsExplored(result.exploredNodes),
      totalDistance: result.totalDistance,
      nodesExplored: result.exploredNodes.length,
    });
  } catch (err) {
    console.error("[server] /api/route error:", err.message);
    return res.status(500).json({ error: err.message });
  }
});

// ── Shared Helpers for Route Endpoints ──────────────────────────────

function runAlgorithm(name, startId, endId) {
  switch (name.toLowerCase()) {
    case "dijkstra":
      return dijkstra(globalGraph, startId, endId);
    case "astar":
      return astar(globalGraph, startId, endId, globalNodes);
    case "bfs":
      return bfs(globalGraph, startId, endId);
    case "dfs":
      return dfs(globalGraph, startId, endId);
    case "bidirectional":
      return bidirectionalDijkstra(globalGraph, startId, endId);
    default:
      return { error: `Unknown algorithm: ${name}` };
  }
}

function toCoords(ids) {
  return ids.map(id => {
    const n = globalNodes[id] ?? globalNodes[Number(id)];
    return n ? { lat: n.lat, lon: n.lon } : null;
  }).filter(Boolean);
}

function toCoordsExplored(items) {
  return items.map(item => {
    const isObj = typeof item === "object" && item !== null;
    const id = isObj ? item.id : item;
    const n = globalNodes[id] ?? globalNodes[Number(id)];
    if (!n) return null;
    if (isObj && item.direction) {
      return { lat: n.lat, lon: n.lon, direction: item.direction };
    }
    return { lat: n.lat, lon: n.lon };
  }).filter(Boolean);
}

/**
 * POST /api/route-compare
 * Body: { startLat, startLon, endLat, endLon, algorithmA, algorithmB }
 * Runs two algorithms and returns both results for side-by-side comparison.
 */
app.post("/api/route-compare", async (req, res) => {
  try {
    const { startLat, startLon, endLat, endLon, algorithmA, algorithmB } = req.body;

    if ([startLat, startLon, endLat, endLon].some(v => typeof v !== "number")) {
      return res.status(400).json({ error: "startLat, startLon, endLat, endLon must be numbers" });
    }

    // Auto-fetch corridor for long distances
    const clickDist = haversineDistance(startLat, startLon, endLat, endLon);
    if (clickDist > 5000) {
      try {
        const corridorData = await fetchCorridorRoads(startLat, startLon, endLat, endLon);
        if (corridorData.ways.length > 0) mergeIntoGlobal(corridorData);
      } catch (err) {
        console.warn(`[compare] Corridor fetch failed: ${err.message}`);
      }
    }

    if (globalGraph.size === 0) {
      return res.status(400).json({ error: "No graph data loaded." });
    }

    const startId = findNearestNode(startLat, startLon);
    const endId   = findNearestNode(endLat, endLon);

    if (!startId || !endId) {
      return res.status(400).json({ error: "Could not find graph nodes near the given coordinates." });
    }

    const resultA = runAlgorithm(algorithmA, startId, endId);
    const resultB = runAlgorithm(algorithmB, startId, endId);

    if (resultA.error) return res.status(400).json({ error: resultA.error });
    if (resultB.error) return res.status(400).json({ error: resultB.error });

    console.log(`[compare] ${algorithmA}: ${resultA.exploredNodes.length} explored, ${resultA.path.length} path | ${algorithmB}: ${resultB.exploredNodes.length} explored, ${resultB.path.length} path`);

    return res.json({
      a: {
        path: toCoords(resultA.path),
        exploredNodes: toCoordsExplored(resultA.exploredNodes),
        totalDistance: resultA.totalDistance,
        nodesExplored: resultA.exploredNodes.length,
      },
      b: {
        path: toCoords(resultB.path),
        exploredNodes: toCoordsExplored(resultB.exploredNodes),
        totalDistance: resultB.totalDistance,
        nodesExplored: resultB.exploredNodes.length,
      }
    });
  } catch (err) {
    console.error("[server] /api/route-compare error:", err.message);
    return res.status(500).json({ error: err.message });
  }
});

/**
 * GET /api/geocode?q=search&viewbox=west,north,east,south
 * Proxies to Nominatim with viewport bias to resolve place names.
 */
app.get("/api/geocode", async (req, res) => {
  try {
    const { q, viewbox } = req.query;
    if (!q) return res.status(400).json({ error: "Missing 'q' parameter" });

    const params = {
      q,
      format: "json",
      limit: 5,
      "accept-language": "en",
    };

    // Bias results to the current map viewport
    if (viewbox) {
      params.viewbox = viewbox;
      params.bounded = 0; // prefer but don't restrict to viewbox
    }

    const response = await axios.get("https://nominatim.openstreetmap.org/search", {
      params,
      headers: { "User-Agent": "PathFinderApp/1.0" },
      timeout: 10000,
    });

    return res.json(response.data);
  } catch (err) {
    console.error("[geocode] Error:", err.message);
    return res.status(500).json({ error: err.message });
  }
});

// ── Start ───────────────────────────────────────────────────────────
app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
});