"use strict";

const fs = require("fs");
const path = require("path");
const { BUDGETS } = require("./stage-manifest");

function readAreaConfig(file, options = {}) {
  if (!fs.existsSync(file)) {
    throw new Error(`Config file not found: ${file}`);
  }
  return normalizeAreaConfig(JSON.parse(fs.readFileSync(file, "utf8")), { ...options, configDir: path.dirname(path.resolve(file)) });
}

function normalizeAreaConfig(raw, options = {}) {
  const repoRoot = options.repoRoot || path.resolve(__dirname, "..", "..");
  const id = requireText(raw.id, "id");
  const input = path.resolve(requireText(raw.input, "input"));
  if (!fs.existsSync(input)) {
    throw new Error(`Input OSM XML not found: ${input}`);
  }

  const outputRoot = path.resolve(raw.outputRoot || path.join(repoRoot, "outputs"));
  const outputOverrides = raw.outputs || {};
  const areaDir = path.resolve(outputOverrides.areaDir || path.join(outputRoot, id));
  const fileStem = outputOverrides.fileStem || id;
  const compress = normalizeCompressConfig(raw.compress);
  const budget = normalizeBudgetConfig(raw.budget);
  const pipelineDir = path.resolve(outputOverrides.pipelineDir || path.join(areaDir, "_pipeline"));
  const packageDir = path.resolve(outputOverrides.packageDir || path.join(areaDir, "package"));
  const packageStagingDir = path.resolve(outputOverrides.packageStagingDir || path.join(pipelineDir, "package-staging"));
  const packageRuntimeDir = path.resolve(outputOverrides.packageRuntimeDir || path.join(packageDir, "runtime"));
  const packageStagingRuntimeDir = path.resolve(outputOverrides.packageStagingRuntimeDir || path.join(packageStagingDir, "runtime"));
  const previewDir = path.resolve(outputOverrides.previewDir || path.join(areaDir, "_preview"));
  const geojsonDir = path.resolve(outputOverrides.geojsonDir || path.join(areaDir, "osm2streets_web_out"));
  const nativeRoadDir = path.resolve(outputOverrides.nativeRoadDir || path.join(areaDir, "native-road"));
  const outputs = {
    areaDir,
    geojsonDir,
    nativeRoadDir,
    nativeRoadOverrides: path.resolve(outputOverrides.nativeRoadOverrides || path.join(areaDir, "native-road-overrides.json")),
    nativeTrafficSignals: path.resolve(outputOverrides.nativeTrafficSignals || path.join(areaDir, "native-traffic-signals.json")),
    gpkg: path.resolve(outputOverrides.gpkg || path.join(areaDir, `${fileStem}.gpkg`)),
    qgisProject: path.resolve(outputOverrides.qgisProject || path.join(areaDir, `${fileStem}.qgz`)),
    qgisPreview: path.resolve(outputOverrides.qgisPreview || path.join(areaDir, `${fileStem}-preview.png`)),
    blend: path.resolve(outputOverrides.blend || path.join(areaDir, `${fileStem}.blend`)),
    render: path.resolve(outputOverrides.render || path.join(areaDir, `${fileStem}.png`)),
    // Published static assets are staged first and promoted by the package stage.
    packageDir,
    packageStagingDir,
    packageManifest: path.resolve(outputOverrides.packageManifest || path.join(packageDir, "manifest.json")),
    packageStagingManifest: path.resolve(outputOverrides.packageStagingManifest || path.join(packageStagingDir, "manifest.json")),
    packageModelDir: path.resolve(outputOverrides.packageModelDir || path.join(packageDir, "models")),
    packageStagingModelDir: path.resolve(outputOverrides.packageStagingModelDir || path.join(packageStagingDir, "models")),
    packagePrimaryGlb: path.resolve(outputOverrides.packagePrimaryGlb || path.join(packageDir, "models", `${fileStem}.glb`)),
    glb: path.resolve(outputOverrides.glb || path.join(packageStagingDir, "models", `${fileStem}.glb`)),
    packageRuntimeDir,
    packageStagingRuntimeDir,
    trafficSignalsDynamicGlb: path.resolve(outputOverrides.trafficSignalsDynamicGlb || path.join(packageStagingRuntimeDir, "traffic-signals-dynamic.glb")),
    trafficSignalsCountdown0Glb: path.resolve(outputOverrides.trafficSignalsCountdown0Glb || path.join(packageStagingRuntimeDir, "traffic-signals-countdown-0.glb")),
    trafficSignalsCountdown1Glb: path.resolve(outputOverrides.trafficSignalsCountdown1Glb || path.join(packageStagingRuntimeDir, "traffic-signals-countdown-1.glb")),
    packageTrafficSignals: path.resolve(outputOverrides.packageTrafficSignals || path.join(packageRuntimeDir, "traffic-signals.json")),
    packageStagingTrafficSignals: path.resolve(outputOverrides.packageStagingTrafficSignals || path.join(packageStagingRuntimeDir, "traffic-signals.json")),
    metadata: path.resolve(outputOverrides.metadata || path.join(packageStagingDir, "manifest.json")),
    cesiumPreview: path.resolve(
      outputOverrides.cesiumPreview || path.join(areaDir, `${fileStem}-cesium-preview.html`),
    ),
    previewDir,
    previewDescriptor: path.resolve(outputOverrides.previewDescriptor || path.join(previewDir, "descriptor.json")),
    trafficSimulation: path.resolve(outputOverrides.trafficSimulation || path.join(previewDir, `${fileStem}-traffic-simulation.json`)),
    vehicleRoute: path.resolve(outputOverrides.vehicleRoute || path.join(previewDir, `${fileStem}-vehicle-route.json`)),
    vehicleModel: path.resolve(outputOverrides.vehicleModel || path.join(previewDir, `${fileStem}-vehicle-car.gltf`)),
    trafficSignalAssemblies: path.resolve(
      outputOverrides.trafficSignalAssemblies || path.join(geojsonDir, "traffic_signal_assemblies.geojson"),
    ),
    // Runtime poses are derived from the editable assembly layer and shared by
    // Blender and the browser preview.
    trafficSignals: path.resolve(outputOverrides.trafficSignals || path.join(geojsonDir, "traffic_signals.json")),
    pipelineDir,
    stageManifestDir: path.resolve(outputOverrides.stageManifestDir || path.join(pipelineDir, "stages")),
  };

  return {
    id,
    input,
    outputRoot,
    qgisApp: raw.qgisApp || (process.platform === "darwin" ? "/Applications/QGIS.app" : "/usr"),
    blenderApp: raw.blenderApp || (process.platform === "darwin" ? "/Applications/Blender.app" : "/usr/bin/blender"),
    stages: {
      // Native road compilation is the default. Legacy QGIS/osm2streets
      // intermediates remain explicitly selectable for reference/debug work.
      intermediates: raw.stages?.intermediates ?? raw.stages?.qgis ?? false,
      blender: raw.stages?.blender ?? true,
      cesium: raw.stages?.cesium ?? true,
      reimport: false,
      preview: true,
      compress: true,
      package: true,
    },
    qgis: {
      arrowScale: raw.qgis?.arrowScale ?? raw.arrowScale ?? 0.8,
      arrowMergeTriangles: raw.qgis?.arrowMergeTriangles ?? raw.arrowMergeTriangles ?? true,
      arrowOutlineSimplifyMeters: raw.qgis?.arrowOutlineSimplifyMeters ?? raw.arrowOutlineSimplifyMeters ?? 0.05,
      intersectionCornerSourceMaxDimensionMeters: raw.qgis?.intersectionCornerSourceMaxDimensionMeters ?? raw.intersectionCornerSourceMaxDimensionMeters ?? 2.6,
      clipPad: raw.qgis?.clipPad ?? raw.clipPad ?? 0.002,
      canvasPad: raw.qgis?.canvasPad ?? raw.canvasPad ?? 0.001,
      previewPad: raw.qgis?.previewPad ?? raw.previewPad ?? 0.0007,
      canvasExtent: raw.qgis?.canvasExtent ?? raw.canvasExtent ?? null,
      previewExtent: raw.qgis?.previewExtent ?? raw.previewExtent ?? null,
      layerPrefix: raw.qgis?.layerPrefix ?? raw.layerPrefix ?? "osm2streets",
    },
    turnLaneArrows: {
      enabled: booleanOption(raw.turnLaneArrows?.enabled, false, "turnLaneArrows.enabled"),
    },
    nativeRoad: {
      edgeLines: booleanOption(raw.nativeRoad?.edgeLines, false, "nativeRoad.edgeLines"),
      junctionTemplates: normalizeJunctionTemplates(raw.nativeRoad?.junctionTemplates, repoRoot, options.configDir || repoRoot),
    },
    osm2streets: raw.osm2streets || {
      debug_each_step: false,
      dual_carriageway_experiment: false,
      sidepath_zipping_experiment: false,
      inferred_sidewalks: true,
      osm2lanes: true,
    },
    blender: {
      treeStyle: raw.blender?.treeStyle || "natural",
      officeOverrides: raw.blender?.officeOverrides || raw.blender?.office_overrides || "",
      roadProvider: roadProviderOption(raw.blender?.roadProvider ?? "native"),
    },
    v2xPreview: normalizeV2xPreviewConfig(raw.v2xPreview),
    compress,
    budget,
    outputs,
  };
}

function normalizeV2xPreviewConfig(raw) {
  if (raw !== undefined && (raw === null || typeof raw !== "object" || Array.isArray(raw))) {
    throw new Error("v2xPreview must be an object");
  }
  const value = raw || {};
  const text = (name, fallback) => {
    const item = value[name] ?? fallback;
    if (typeof item !== "string") throw new Error(`v2xPreview.${name} must be a string`);
    return item.trim();
  };
  return {
    enabled: booleanOption(value.enabled, false, "v2xPreview.enabled"),
    // Relative defaults keep credentials and private service origins out of the
    // generated preview. Production should reverse-proxy these prefixes.
    apiBaseUrl: text("apiBaseUrl", "/api"),
    wsBaseUrl: text("wsBaseUrl", "/websocket"),
    crossCode: text("crossCode", ""),
  };
}

function normalizeJunctionTemplates(raw, repoRoot, configDir) {
  if (raw === undefined || raw === null) return { enabled: false, references: [] };
  if (typeof raw !== "object" || Array.isArray(raw)) throw new Error("nativeRoad.junctionTemplates must be an object");
  const enabled = booleanOption(raw.enabled, false, "nativeRoad.junctionTemplates.enabled");
  if (raw.references !== undefined && !Array.isArray(raw.references)) throw new Error("nativeRoad.junctionTemplates.references must be an array");
  const references = (raw.references || []).map((item, index) => {
    if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error(`nativeRoad.junctionTemplates.references[${index}] must be an object`);
    const nodeId = requireText(item.nodeId, `nativeRoad.junctionTemplates.references[${index}].nodeId`);
    const template = item.template ?? "cross-v1";
    if (template !== "cross-v1") throw new Error(`nativeRoad.junctionTemplates.references[${index}].template must be \"cross-v1\"`);
    const referenceFile = item.referenceFile ? path.resolve(configDir, item.referenceFile) : null;
    const coordinateSystem = item.coordinateSystem ?? "GCJ-02";
    if (coordinateSystem !== "GCJ-02") throw new Error(`nativeRoad.junctionTemplates.references[${index}].coordinateSystem must be \"GCJ-02\"`);
    const cornerRadiusMultiplier = numberOption(item.cornerRadiusMultiplier, 1, `nativeRoad.junctionTemplates.references[${index}].cornerRadiusMultiplier`, 0.75, 1.25);
    const cutbackMultiplier = numberOption(item.cutbackMultiplier, 1, `nativeRoad.junctionTemplates.references[${index}].cutbackMultiplier`, 1, 1.35);
    const approachWidthMultiplier = numberOption(item.approachWidthMultiplier, 1, `nativeRoad.junctionTemplates.references[${index}].approachWidthMultiplier`, 1, 1.8);
    const approachLengthMeters = numberOption(item.approachLengthMeters, 24, `nativeRoad.junctionTemplates.references[${index}].approachLengthMeters`, 10, 50);
    return { nodeId, template, referenceFile, coordinateSystem, cornerRadiusMultiplier, cutbackMultiplier, approachWidthMultiplier, approachLengthMeters };
  });
  if (raw.clusters !== undefined && !Array.isArray(raw.clusters)) throw new Error("nativeRoad.junctionTemplates.clusters must be an array");
  const clusters = (raw.clusters || []).map((item, index) => {
    if (!item || typeof item !== "object" || Array.isArray(item)) throw new Error(`nativeRoad.junctionTemplates.clusters[${index}] must be an object`);
    const id = requireText(item.id, `nativeRoad.junctionTemplates.clusters[${index}].id`);
    const nodeIds = item.nodeIds;
    if (!Array.isArray(nodeIds) || nodeIds.length < 2 || nodeIds.some((value) => typeof value !== "string" && typeof value !== "number")) throw new Error(`nativeRoad.junctionTemplates.clusters[${index}].nodeIds must contain at least two node ids`);
    const template = item.template ?? "complex-junction-v1";
    if (template !== "cross-cluster-v1" && template !== "complex-junction-v1") throw new Error(`nativeRoad.junctionTemplates.clusters[${index}].template must be \"cross-cluster-v1\" or \"complex-junction-v1\"`);
    const referenceFile = item.referenceFile ? path.resolve(configDir, item.referenceFile) : null;
    const approachWidthMultiplier = numberOption(item.approachWidthMultiplier, 1.45, `nativeRoad.junctionTemplates.clusters[${index}].approachWidthMultiplier`, 1, 1.8);
    const approachLengthMeters = numberOption(item.approachLengthMeters, 32, `nativeRoad.junctionTemplates.clusters[${index}].approachLengthMeters`, 10, 50);
    const coreRadiusMeters = numberOption(item.coreRadiusMeters, 28, `nativeRoad.junctionTemplates.clusters[${index}].coreRadiusMeters`, 12, 80);
    const cornerRadiusMeters = numberOption(item.cornerRadiusMeters, 12, `nativeRoad.junctionTemplates.clusters[${index}].cornerRadiusMeters`, 4, 25);
    const outerRadiusExtraMeters = numberOption(item.outerRadiusExtraMeters, 18, `nativeRoad.junctionTemplates.clusters[${index}].outerRadiusExtraMeters`, 18, 35);
    return { id, nodeIds: nodeIds.map(String), template, referenceFile, approachWidthMultiplier, approachLengthMeters, coreRadiusMeters, cornerRadiusMeters, outerRadiusExtraMeters };
  });
  return { enabled, references, clusters };
}

function normalizeBudgetConfig(raw) {
  if (raw !== undefined && raw !== null && (typeof raw !== "object" || Array.isArray(raw))) {
    throw new Error("budget must be an object");
  }
  const value = raw || {};
  const budget = {
    glbBytes: megabytesOption(value.glbSizeMb, BUDGETS.glbBytes, "budget.glbSizeMb"),
    glbNodes: integerOption(value.nodes, BUDGETS.glbNodes, "budget.nodes"),
    glbImages: integerOption(value.images, BUDGETS.glbImages, "budget.images"),
    glbTriangles: integerOption(value.triangles, BUDGETS.glbTriangles, "budget.triangles"),
    glbImageBytes: megabytesOption(value.embeddedImageBytesMb, BUDGETS.glbImageBytes, "budget.embeddedImageBytesMb"),
    reason: value.reason ?? "",
  };
  if (typeof budget.reason !== "string") {
    throw new Error("budget.reason must be a string");
  }
  const loosened = Object.keys(BUDGETS).some((key) => budget[key] > BUDGETS[key]);
  if (loosened && budget.reason.trim() === "") {
    throw new Error("budget.reason is required when a budget exceeds the default");
  }
  return budget;
}

function requireText(value, key) {
  if (typeof value !== "string" || value.trim() === "") {
    throw new Error(`Missing config key: ${key}`);
  }
  return value;
}

function normalizeCompressConfig(raw) {
  const value = raw || {};
  return {
    textureSize: numberOption(value.textureSize, 768, "compress.textureSize", 64, 4096),
    quality: numberOption(value.quality, 82, "compress.quality", 1, 100),
    effort: numberOption(value.effort, 80, "compress.effort", 0, 100),
    meshopt: booleanOption(value.meshopt, false, "compress.meshopt"),
  };
}

function numberOption(value, fallback, label, min, max) {
  const number = value === undefined ? fallback : Number(value);
  if (!Number.isFinite(number) || number < min || number > max) {
    throw new Error(`${label} must be a finite number in [${min}, ${max}]`);
  }
  return number;
}

function roadProviderOption(value) {
  const provider = value ?? "osm2streets";
  if (provider !== "osm2streets" && provider !== "native") {
    throw new Error("blender.roadProvider must be \"osm2streets\" or \"native\".");
  }
  return provider;
}

function integerOption(value, fallback, label) {
  const number = value === undefined ? fallback : Number(value);
  if (!Number.isInteger(number) || number < 1) {
    throw new Error(`${label} must be a positive integer`);
  }
  return number;
}

function megabytesOption(value, fallbackBytes, label) {
  const megabytes = value === undefined ? fallbackBytes / 1024 / 1024 : Number(value);
  if (!Number.isFinite(megabytes) || megabytes <= 0) {
    throw new Error(`${label} must be a positive finite number`);
  }
  return Math.round(megabytes * 1024 * 1024);
}

function booleanOption(value, fallback, label) {
  if (value === undefined) return fallback;
  if (typeof value === "boolean") return value;
  if (value === "true") return true;
  if (value === "false") return false;
  throw new Error(`${label} must be boolean`);
}

function toRoadCompilerInput(area) {
  return {
    areaId: area.id,
    osmFile: area.input,
    outDir: area.outputs.nativeRoadDir,
    stagingDir: area.outputs.pipelineDir,
    overridesFile: area.outputs.nativeRoadOverrides,
    trafficSignalsFile: area.outputs.nativeTrafficSignals,
    comparisonDir: area.outputs.geojsonDir,
    options: {
      edgeLines: area.nativeRoad.edgeLines,
      junctionTemplates: area.nativeRoad.junctionTemplates,
    },
  };
}

module.exports = {
  normalizeAreaConfig,
  readAreaConfig,
  toRoadCompilerInput,
};