import fs from "fs";
import path from "path";

const dataDir = path.join(process.cwd(), "src", "dal", "data");

function readJSON(name) {
  try {
    const p = path.join(dataDir, name);

    if (!fs.existsSync(p)) return null;
    return JSON.parse(fs.readFileSync(p, "utf8"));
  } catch {
    return null;
  }
}

function toNumber(v) {
  const n = Number(v);
  return Number.isFinite(n) ? n : undefined;
}

export function getVehicles() {
  const raw = readJSON("vehicles.json");

  if (!Array.isArray(raw)) return [];
  return raw.map(v => {
    const loc = v.location || {};

    return {
      vehicleId: v.vehicleId,
      routeNum: v.routeNum,
      routeName: v.routeName,
      destination: v.destination,
      bearing: v.bearing == null ? undefined : toNumber(v.bearing),
      speed: v.speed == null ? undefined : toNumber(v.speed),
      location: {
        latitude: toNumber(loc.latitude),
        longitude: toNumber(loc.longitude)
      }
    };

  });

}

export function getVehicleById(id) {
  if (id == null) return null;
  const vehicles = getVehicles();

  return vehicles.find(v => String(v.vehicleId) === String(id)) || null;
}

export function getRoutes() {
  const raw = readJSON("routes.json");

  if (!Array.isArray(raw)) return [];
  return raw;
}

export function getRouteById(routeId) {
  if (routeId == null) return null;
  const routes = getRoutes();

  return routes.find(r => String(r.route_id) === String(routeId)) || null;
}

function readRoutepathsRaw() {
  const raw = readJSON("routePath.json");

  if (!Array.isArray(raw)) return [];
  return raw;
}

export function getRoutePathsMap() {
  const raw = readRoutepathsRaw();
  const map = {};

  for (const item of raw) {
    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
    const keys = Object.keys(item);

    if (keys.length !== 1) continue;
    const k = String(keys[0]);

    if (Array.isArray(item[k])) map[k] = item[k];
  }

  return map;
}

export function getRoutePath(routeId) {
  if (routeId == null) return null;
  const map = getRoutePathsMap();
  const key = String(routeId);

  return Object.prototype.hasOwnProperty.call(map, key) ? map[key] : null;
}

export function getStationsRaw() {
  return readJSON("stations.json") || null;
}

export function getStations() {
  const raw = getStationsRaw(); 

  if (raw == null) return [];
  if (Array.isArray(raw)) {
    const isArrayOfMaps = raw.every(item => typeof item === "object" && !Array.isArray(item) && Object.values(item).every(v => Array.isArray(v)));
    if (isArrayOfMaps) return raw.flatMap(item => Object.values(item).flat());
    return raw;
  }
  if (typeof raw === "object") {
    return Object.values(raw).flat();
  }
  return [];

}

function transformationStation(s) {
  return {
    stop_id: s.stop_id,
    stop_code: s.stop_code,
    stop_name: s.stop_name,
    stop_desc: s.stop_desc,
    location: { latitude: toNumber(s.stop_lat), longitude: toNumber(s.stop_lon) },
    stop_url: s.stop_url,
    location_type: s.location_type,
    parent_station: s.parent_station,
    lines: s.lines
  };
}

export function getStopsByRoute(routeId) {
  if (routeId == null) return [];
  const raw = getStationsRaw();
  
  if (raw == null) return [];
  if (typeof raw === "object" && !Array.isArray(raw)) {
    const arr = raw[routeId];
    if (!Array.isArray(arr)) return [];
    return arr.map(transformationStation);
  }

  if (Array.isArray(raw)) {
    const matchesFromArrayMaps = [];
    for (const item of raw) {
      if (typeof item === "object" && !Array.isArray(item) && Object.prototype.hasOwnProperty.call(item, routeId)) {
        const arr = item[routeId];
        if (Array.isArray(arr)) matchesFromArrayMaps.push(...arr.map(transformationStation));
      }
    }
    if (matchesFromArrayMaps.length) return matchesFromArrayMaps;

    return raw.filter(s => Array.isArray(s.lines) && s.lines.map(String).includes(String(routeId))).map(transformationStation);
  }

  return [];
}

export function getStationById(id) {
  if (id == null) return null;
  const raw = getStationsRaw();
  if (raw == null) return null;

  if (typeof raw === "object" && !Array.isArray(raw)) {
    for (const key of Object.keys(raw)) {
      const arr = raw[key];
      if (!Array.isArray(arr)) continue;
      const found = arr.find(s => String(s.stop_id) === String(id) || String(s.stationId) === String(id));
      if (found) return transformationStation(found);
    }
    return null;
  }

  if (Array.isArray(raw)) {
    const isArrayOfMaps = raw.every(item => typeof item === "object" && !Array.isArray(item) && Object.values(item).every(v => Array.isArray(v)));
    if (isArrayOfMaps) {
      for (const item of raw) {
        for (const key of Object.keys(item)) {
          const arr = item[key];
          const found = arr.find(s => String(s.stop_id) === String(id));
          if (found) return transformationStation(found);
        }
      }
      return null;
    }
    const found = raw.find(s => String(s.stop_id) === String(id) || String(s.stationId) === String(id));
    return found ? transformationStation(found) : null;
  }

  return null;
}