# -*- coding: utf-8 -*-
from __future__ import annotations

import json
import os
import shutil
import tempfile
import zipfile
from datetime import datetime
from pathlib import Path
from typing import Optional

from qgis.PyQt.QtCore import QSize
from qgis.PyQt.QtGui import QColor
from qgis.core import (
    QgsCoordinateTransformContext,
    QgsMapRendererParallelJob,
    QgsMapSettings,
    QgsProject,
    QgsRasterFileWriter,
    QgsRasterPipe,
    QgsVectorFileWriter,
)


MODE_VECTOR = "vector"
MODE_RASTER_TEXTURE = "raster_texture"
VECTOR_REQUIRED_INPUTS = ("dem", "roi", "roads", "buildings", "blocks", "parcels")
RASTER_TEXTURE_REQUIRED_INPUTS = ("dem", "roi", "plan_texture", "roads", "buildings")
REQUIRED_INPUTS = VECTOR_REQUIRED_INPUTS
OPTIONAL_INPUTS = ("trees", "hardscape", "sidewalks", "lights", "benches", "trashbins", "busstops")
ASSET_THEME_DEFAULT = "Modern Urban"
ASSET_CATEGORIES = ("pedestrians", "cars", "trees", "lights", "benches", "bins", "busstops", "facades", "roofs", "paving")
ASSET_THEME_PRESETS = {
    "Modern Urban": {
        "pedestrians": ["Commuter", "Urban Casual", "Office", "Student", "Evening"],
        "cars": ["Graphite", "Slate", "Teal", "White", "Navy", "Silver"],
        "trees": ["Street Linden", "Plane", "Compact Maple", "Columnar"],
        "lights": ["Modern Arc", "Dual Head", "Slim Post", "Bollard Path", "Classic Post"],
        "benches": ["Wood Plank", "Concrete Slab", "Curved Metal", "Slim Urban", "Stone Seat"],
        "bins": ["Square Box", "Dual Recycle", "Cylinder", "Compact", "Solar Compactor"],
        "busstops": ["Glass Shelter", "Minimal Canopy", "Steel Canopy", "Wood Cabin", "Compact Marker"],
        "facades": ["UrbanA", "UrbanB", "UrbanC", "UrbanD", "UrbanE"],
        "roofs": ["RoofA", "RoofB", "GermanTile", "USShingle", "StandingSeam"],
        "paving": ["Asphalt", "StoneA", "Cobble", "Concrete", "PlazaGranite"],
    },
    "Mediterranean": {
        "pedestrians": ["Casual Linen", "Warm Neutral", "Student", "Visitor"],
        "cars": ["Ivory", "Terracotta", "Olive", "Slate", "Sand"],
        "trees": ["Olive", "Cypress", "Plane", "Palm", "Jacaranda"],
        "lights": ["Classic Post", "Slim Post", "Heritage Lantern", "Modern Arc"],
        "benches": ["Wood Plank", "Curved Metal", "Stone Seat", "Classic Iron"],
        "bins": ["Cylinder", "Square Box", "Dual Recycle", "Compact"],
        "busstops": ["Minimal Canopy", "Wood Cabin", "Glass Shelter", "Compact Marker"],
        "facades": ["MediterraneanStucco", "UrbanB", "UrbanD", "CoastalWhite"],
        "roofs": ["TurkishTile", "CeramicLight", "GermanTile", "RoofA"],
        "paving": ["StoneA", "WarmStone", "Cobble", "Concrete"],
    },
    "Campus": {
        "pedestrians": ["Student", "Academic", "Sport", "Visitor"],
        "cars": ["Slate", "Navy", "White", "Graphite", "Silver"],
        "trees": ["Plane", "Pine", "Compact Maple", "Street Linden", "Broadleaf"],
        "lights": ["Slim Post", "Campus Twin", "Modern Arc", "Dual Head"],
        "benches": ["Wood Plank", "Concrete Slab", "Slim Urban", "Eco Timber"],
        "bins": ["Dual Recycle", "Square Box", "Compact", "Solar Compactor"],
        "busstops": ["Glass Shelter", "Minimal Canopy", "Steel Canopy"],
        "facades": ["CampusGlass", "UrbanC", "UrbanA", "UrbanB"],
        "roofs": ["RoofA", "RoofC", "USShingle", "SolarRoof"],
        "paving": ["Concrete", "CampusPaver", "StoneA", "Asphalt"],
    },
    "Eco": {
        "pedestrians": ["Outdoor", "Casual Green", "Student", "Visitor"],
        "cars": ["Teal", "Olive", "White", "Slate", "Moss"],
        "trees": ["Broadleaf", "Pine", "Street Linden", "Compact Maple", "Olive"],
        "lights": ["Slim Post", "Bollard Path", "Modern Arc", "Classic Post"],
        "benches": ["Eco Timber", "Wood Plank", "Stone Seat", "Concrete Slab"],
        "bins": ["Dual Recycle", "Compact", "Cylinder", "Solar Compactor"],
        "busstops": ["Wood Cabin", "Minimal Canopy", "Glass Shelter"],
        "facades": ["EcoTimber", "UrbanD", "UrbanB", "UrbanA"],
        "roofs": ["GreenRoof", "SolarRoof", "RoofA", "TurkishTile"],
        "paving": ["Permeable", "Cobble", "StoneA", "Concrete"],
    },
    "Dense Urban": {
        "pedestrians": ["Commuter", "Office", "Evening", "Urban Casual", "Visitor"],
        "cars": ["Graphite", "Black", "Navy", "White", "Slate", "Burgundy"],
        "trees": ["Columnar", "Compact Maple", "Street Linden"],
        "lights": ["Dual Head", "Modern Arc", "Slim Post", "Bollard Path"],
        "benches": ["Concrete Slab", "Curved Metal", "Slim Urban", "Stone Seat"],
        "bins": ["Square Box", "Compact", "Dual Recycle", "Solar Compactor"],
        "busstops": ["Glass Shelter", "Steel Canopy", "Minimal Canopy", "Compact Marker"],
        "facades": ["DenseBrick", "UrbanA", "UrbanC", "UrbanD"],
        "roofs": ["StandingSeam", "RoofA", "RoofB", "USShingle"],
        "paving": ["Asphalt", "Concrete", "Grid", "PlazaGranite"],
    },
    "Civic Heritage": {
        "pedestrians": ["Visitor", "Academic", "Warm Neutral", "Commuter"],
        "cars": ["Graphite", "Ivory", "Slate", "Burgundy", "Black"],
        "trees": ["Plane", "Cypress", "Street Linden", "Columnar"],
        "lights": ["Heritage Lantern", "Classic Post", "Slim Post", "Bollard Path"],
        "benches": ["Classic Iron", "Stone Seat", "Wood Plank", "Concrete Slab"],
        "bins": ["Cylinder", "Square Box", "Dual Recycle", "Compact"],
        "busstops": ["Steel Canopy", "Glass Shelter", "Minimal Canopy"],
        "facades": ["CivicStone", "MediterraneanStucco", "UrbanB", "UrbanC"],
        "roofs": ["GermanTile", "CeramicLight", "TurkishTile", "StandingSeam"],
        "paving": ["WarmStone", "StoneA", "Cobble", "PlazaGranite"],
    },
    "Coastal Light": {
        "pedestrians": ["Casual Linen", "Visitor", "Student", "Outdoor"],
        "cars": ["White", "Ivory", "Teal", "Sand", "Slate"],
        "trees": ["Palm", "Plane", "Olive", "Broadleaf"],
        "lights": ["Slim Post", "Modern Arc", "Bollard Path", "Classic Post"],
        "benches": ["Wood Plank", "Eco Timber", "Stone Seat", "Slim Urban"],
        "bins": ["Cylinder", "Dual Recycle", "Compact", "Square Box"],
        "busstops": ["Minimal Canopy", "Glass Shelter", "Wood Cabin"],
        "facades": ["CoastalWhite", "MediterraneanStucco", "UrbanD", "CampusGlass"],
        "roofs": ["CeramicLight", "RoofA", "SolarRoof", "TurkishTile"],
        "paving": ["WarmStone", "Permeable", "StoneA", "Concrete"],
    },
}

VECTOR_TARGETS = {
    "roi": "roi.geojson",
    "roads": "myroads.geojson",
    "buildings": "mybuildings.geojson",
    "blocks": "myblocks.geojson",
    "parcels": "myparcels.geojson",
    "trees": "mytrees.geojson",
    "hardscape": "myhardscape.geojson",
    "sidewalks": "mysidewalks.geojson",
    "lights": "mylights.geojson",
    "benches": "mybenches.geojson",
    "trashbins": "mytrashbins.geojson",
    "busstops": "mybusstops.geojson",
}

LABELS = {
    "dem": "DEM",
    "plan_texture": "Plan texture GeoTIFF",
    "basemap": "QGIS basemap texture",
    "roi": "ROI",
    "roads": "Roads",
    "buildings": "Buildings",
    "blocks": "Blocks",
    "parcels": "Parcels",
    "trees": "Trees",
    "hardscape": "Hardscape",
    "sidewalks": "Sidewalks",
    "lights": "Lights",
    "benches": "Benches",
    "trashbins": "Trash bins",
    "busstops": "Bus stops",
}


class ExportError(RuntimeError):
    pass


def copy_portable_viewer(web_root: str, output_dir: str, tour_json_path: Optional[str] = None) -> list[str]:
    """Copy the self-contained browser viewer payload for classroom handoff."""
    web_path = Path(web_root)
    data_path = web_path / "data"
    if not data_path.exists():
        raise ExportError("No exported web/data folder found. Export project data first, then create a portable viewer.")

    output_path = Path(output_dir)
    if output_path.exists():
        raise ExportError(f"Portable viewer folder already exists: {output_path}")
    output_path.mkdir(parents=True, exist_ok=False)

    copied: list[str] = []

    def copy_dir(source: Path, target: Path) -> None:
        if not source.exists():
            raise ExportError(f"Required viewer folder is missing: {source}")
        ignore = shutil.ignore_patterns("__pycache__", "*.pyc", ".git", ".idea", ".DS_Store")
        shutil.copytree(source, target, ignore=ignore)
        for path in target.rglob("*"):
            if path.is_file():
                copied.append(str(path))

    copy_dir(web_path / "src", output_path / "src")
    copy_dir(web_path / "assets" / "vendor", output_path / "assets" / "vendor")
    copy_dir(data_path, output_path / "data")

    if tour_json_path:
        tour_source = Path(tour_json_path)
        if not tour_source.exists():
            raise ExportError(f"Tour JSON file does not exist: {tour_source}")
        tour_target = output_path / "data" / "planx_tour.json"
        shutil.copy2(tour_source, tour_target)
        copied.append(str(tour_target))

    readme_path = output_path / "README_PORTABLE_VIEWER.txt"
    readme_path.write_text(
        "\n".join(
            [
                "PlanX 3D City Portable Viewer",
                "",
                "This folder contains the exported viewer app, bundled vendor libraries, and the current project data.",
                "",
                "How to open:",
                "Option A: double-click Start-PlanX-Viewer.bat on Windows.",
                "Option B:",
                "1. Open a terminal in this folder.",
                "2. Run: py -3 -m http.server 8080",
                "3. Open: http://127.0.0.1:8080/src/",
                "",
                "Notes:",
                "- Do not open src/index.html directly from the file system; GeoTIFF and GeoJSON loading needs a local HTTP server.",
                "- Narrative Studio JSON files store camera/tour/viewer state only. They do not embed DEM, GeoJSON, imagery, or the viewer app.",
                "- If this package includes data/planx_tour.json, the viewer can auto-load it on another computer.",
                "- If you export a newer project from QGIS, create a fresh portable folder so the copied data stays in sync.",
            ]
        ),
        encoding="utf-8",
    )
    copied.append(str(readme_path))

    bat_path = output_path / "Start-PlanX-Viewer.bat"
    bat_path.write_text(
        "\n".join(
            [
                "@echo off",
                "cd /d \"%~dp0\"",
                "start \"\" \"http://127.0.0.1:8080/src/\"",
                "py -3 -m http.server 8080",
                "pause",
            ]
        ),
        encoding="utf-8",
    )
    copied.append(str(bat_path))

    ps1_path = output_path / "Start-PlanX-Viewer.ps1"
    ps1_path.write_text(
        "\n".join(
            [
                "Set-Location -LiteralPath $PSScriptRoot",
                "Start-Process \"http://127.0.0.1:8080/src/\"",
                "py -3 -m http.server 8080",
            ]
        ),
        encoding="utf-8",
    )
    copied.append(str(ps1_path))
    return copied


def zip_portable_viewer(web_root: str, zip_path: str, tour_json_path: Optional[str] = None) -> list[str]:
    zip_target = Path(zip_path)
    zip_target.parent.mkdir(parents=True, exist_ok=True)
    if zip_target.exists():
        zip_target.unlink()

    root_name = zip_target.stem or "planx_3d_city_portable"
    with tempfile.TemporaryDirectory(prefix="planx_3d_city_portable_") as tmp:
        portable_root = Path(tmp) / root_name
        copied = copy_portable_viewer(web_root, str(portable_root), tour_json_path=tour_json_path)
        with zipfile.ZipFile(zip_target, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as zf:
            for path in portable_root.rglob("*"):
                if path.is_file():
                    zf.write(path, path.relative_to(portable_root.parent).as_posix())
    return copied + [str(zip_target)]


def empty_feature_collection() -> dict:
    return {"type": "FeatureCollection", "name": "empty", "features": []}


def write_empty_geojson(path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(empty_feature_collection(), ensure_ascii=False, indent=2), encoding="utf-8")


def web_data_paths(web_root: str) -> tuple[Path, Path]:
    data_root = Path(web_root) / "data"
    dem_dir = data_root / "dem"
    vector_dir = data_root / "yerlesim"
    dem_dir.mkdir(parents=True, exist_ok=True)
    vector_dir.mkdir(parents=True, exist_ok=True)
    return dem_dir, vector_dir


def target_files(web_root: str) -> list[Path]:
    dem_dir, vector_dir = web_data_paths(web_root)
    texture_dir = Path(web_root) / "data" / "texture"
    texture_dir.mkdir(parents=True, exist_ok=True)
    files = [dem_dir / "mydem.tif", texture_dir / "siteplan.tif"]
    files.append(texture_dir / "basemap.png")
    files.extend(vector_dir / filename for filename in VECTOR_TARGETS.values())
    files.append(Path(web_root) / "data" / "planx_manifest.json")
    return files


def existing_target_files(web_root: str) -> list[Path]:
    return [path for path in target_files(web_root) if path.exists()]


def export_mode(layer_map: dict) -> str:
    return layer_map.get("mode") or MODE_VECTOR


def required_inputs_for_mode(mode: str) -> tuple[str, ...]:
    return RASTER_TEXTURE_REQUIRED_INPUTS if mode == MODE_RASTER_TEXTURE else VECTOR_REQUIRED_INPUTS


def optional_inputs_for_mode(mode: str) -> tuple[str, ...]:
    if mode == MODE_RASTER_TEXTURE:
        return ("blocks", "parcels") + OPTIONAL_INPUTS
    return OPTIONAL_INPUTS


def validate_inputs(layer_map: dict) -> list[str]:
    required_inputs = required_inputs_for_mode(export_mode(layer_map))
    missing = []
    for key in required_inputs:
        if layer_map.get(key) is None:
            missing.append(LABELS[key])
    return missing


def export_all(layer_map: dict, web_root: str, feedback=None) -> list[str]:
    mode = export_mode(layer_map)
    required_inputs = required_inputs_for_mode(mode)
    optional_inputs = optional_inputs_for_mode(mode)
    missing = validate_inputs(layer_map)
    if missing:
        raise ExportError("Missing required inputs: " + ", ".join(missing))

    dem_dir, vector_dir = web_data_paths(web_root)
    texture_dir = Path(web_root) / "data" / "texture"
    texture_dir.mkdir(parents=True, exist_ok=True)
    written = []
    manifest_inputs = []

    _export_dem(layer_map["dem"], dem_dir / "mydem.tif")
    written.append(str(dem_dir / "mydem.tif"))
    manifest_inputs.append(_layer_manifest("dem", layer_map["dem"], "dem/mydem.tif", False, required_inputs))

    terrain_texture = None
    base_map_texture = None
    if mode == MODE_RASTER_TEXTURE:
        texture_path = texture_dir / "siteplan.tif"
        _export_dem(layer_map["plan_texture"], texture_path)
        terrain_texture = {
            "key": "plan_texture",
            "target": "texture/siteplan.tif",
            "label": LABELS["plan_texture"],
        }
        written.append(str(texture_path))
        manifest_inputs.append(_layer_manifest("plan_texture", layer_map["plan_texture"], "texture/siteplan.tif", False, required_inputs))

    if layer_map.get("basemap") is not None:
        basemap_path = texture_dir / "basemap.png"
        _export_basemap(layer_map, basemap_path)
        base_map_texture = {
            "key": "basemap",
            "target": "texture/basemap.png",
            "label": LABELS["basemap"],
            "sourceLayer": layer_map["basemap"].name(),
            "size": int(layer_map.get("basemap_export_size") or 4096),
        }
        written.append(str(basemap_path))
        manifest_inputs.append(_layer_manifest("basemap", layer_map["basemap"], "texture/basemap.png", False, required_inputs))

    for key, filename in VECTOR_TARGETS.items():
        out_path = vector_dir / filename
        layer = layer_map.get(key)
        empty = layer is None
        if layer is None:
            write_empty_geojson(out_path)
        else:
            _export_vector(layer, out_path)
        written.append(str(out_path))
        manifest_inputs.append(_layer_manifest(key, layer, f"yerlesim/{filename}", empty, required_inputs))
        if feedback:
            feedback(f"{LABELS[key]} -> {out_path.name}")

    road_access = _road_access_manifest(layer_map)
    field_mappings = _field_mappings_manifest(layer_map)
    analysis_defaults = _analysis_defaults_manifest(layer_map)
    viewer_defaults = _viewer_defaults_manifest(layer_map)
    asset_theme, asset_pools, pedestrian_style = _asset_theme_manifest(layer_map)
    manifest_path = write_manifest(
        web_root,
        manifest_inputs,
        mode,
        required_inputs,
        optional_inputs,
        terrain_texture,
        base_map_texture,
        road_access,
        field_mappings,
        analysis_defaults,
        viewer_defaults,
        asset_theme,
        asset_pools,
        pedestrian_style,
    )
    written.append(str(manifest_path))
    return written


def write_manifest(
    web_root: str,
    inputs: list[dict],
    mode: str,
    required_inputs: tuple[str, ...],
    optional_inputs: tuple[str, ...],
    terrain_texture: Optional[dict],
    base_map_texture: Optional[dict],
    road_access: Optional[dict],
    field_mappings: dict,
    analysis_defaults: dict,
    viewer_defaults: dict,
    asset_theme: str,
    asset_pools: dict,
    pedestrian_style: dict,
) -> Path:
    data_root = Path(web_root) / "data"
    data_root.mkdir(parents=True, exist_ok=True)
    project = QgsProject.instance()
    project_title = project.title() or Path(project.fileName()).stem or "PlanX 3D City Project"
    manifest = {
        "schema": "planx-3d-city-manifest/v1",
        "plugin": "planx_3d_city",
        "version": "0.7.3",
        "mode": mode,
        "exportedAt": datetime.now().astimezone().isoformat(timespec="seconds"),
        "project": {
            "title": project_title,
            "fileName": project.fileName() or "",
        },
        "requiredInputs": list(required_inputs),
        "optionalInputs": list(optional_inputs),
        "terrainTexture": terrain_texture,
        "baseMapTexture": base_map_texture,
        "roadAccess": road_access,
        "fieldMappings": field_mappings,
        "analysisDefaults": analysis_defaults,
        "viewerDefaults": viewer_defaults,
        "assetLibraryVersion": "2026.05-procedural-v2",
        "assetTheme": asset_theme,
        "assetPools": asset_pools,
        "pedestrianStyle": pedestrian_style,
        "inputs": inputs,
        "summary": {
            "emptyOptionalInputs": [item["key"] for item in inputs if item.get("optional") and item.get("empty")],
            "crs": sorted({item.get("crs") for item in inputs if item.get("crs")}),
        },
    }
    manifest_path = data_root / "planx_manifest.json"
    manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
    return manifest_path


def _road_access_manifest(layer_map: dict) -> Optional[dict]:
    field = (layer_map.get("road_access_field") or "").strip()
    if not field:
        return None
    no_car_values = layer_map.get("road_no_car_values") or "yaya,pedestrian,foot,walk,path"
    vehicle_values = layer_map.get("road_vehicle_values") or "tasit,taşıt,vehicle,car,arac,araç,motorlu"
    return {
        "field": field,
        "noCarKeywords": [v.strip() for v in no_car_values.split(",") if v.strip()],
        "vehicleKeywords": [v.strip() for v in vehicle_values.split(",") if v.strip()],
    }


def _field_mappings_manifest(layer_map: dict) -> dict:
    keys = (
        "road_hierarchy_field",
        "building_population_field",
        "building_dwelling_field",
        "building_vehicle_field",
        "building_floor_area_field",
        "landuse_function_field",
        "odor_source_field",
        "tree_height_field",
        "light_angle_field",
        "bench_angle_field",
        "trashbin_angle_field",
        "busstop_angle_field",
    )
    return {key: (layer_map.get(key) or "").strip() or None for key in keys}


def _analysis_defaults_manifest(layer_map: dict) -> dict:
    return {
        "roadColorMode": "Default",
        "windDirectionDeg": 315,
        "windPlumeDistance": 180,
        "screeningLabel": "Planning screening / design review",
    }


def _viewer_defaults_manifest(layer_map: dict) -> dict:
    return {
        "showTerrainSides": True,
        "terrainSideDrop": 5.0,
        "terrainSideColor": "#d9fbf5",
        "demMeshQuality": 160,
        "showXyzTiles": bool(layer_map.get("basemap")),
        "assetTheme": (layer_map.get("asset_theme") or ASSET_THEME_DEFAULT),
    }


def _asset_theme_manifest(layer_map: dict) -> tuple[str, dict, dict]:
    theme = (layer_map.get("asset_theme") or ASSET_THEME_DEFAULT).strip() or ASSET_THEME_DEFAULT
    if theme not in ASSET_THEME_PRESETS:
        theme = ASSET_THEME_DEFAULT
    counts = layer_map.get("asset_pool_counts") or {}
    preset = ASSET_THEME_PRESETS[theme]
    pools = {}
    for category in ASSET_CATEGORIES:
        try:
            count = int(counts.get(category, 4))
        except (TypeError, ValueError):
            count = 4
        count = max(3, min(5, count))
        variants = list(preset.get(category) or ASSET_THEME_PRESETS[ASSET_THEME_DEFAULT].get(category) or [])
        pools[category] = {
            "count": count,
            "variants": variants[:count],
        }
    pedestrian_style = {
        "model": "procedural-low-poly",
        "limbs": True,
        "walkCycle": True,
        "palette": pools["pedestrians"]["variants"],
    }
    return theme, pools, pedestrian_style


def _layer_manifest(key: str, layer, target: str, empty: bool, required_inputs: tuple[str, ...]) -> dict:
    item = {
        "key": key,
        "label": LABELS[key],
        "target": target,
        "required": key in required_inputs,
        "optional": key not in required_inputs,
        "empty": bool(empty),
        "sourceLayer": None,
        "crs": None,
    }
    if layer is None:
        return item

    item["sourceLayer"] = layer.name()
    if hasattr(layer, "crs") and layer.crs().isValid():
        item["crs"] = layer.crs().authid()
    if hasattr(layer, "featureCount"):
        item["featureCount"] = int(layer.featureCount())
        if hasattr(layer, "wkbType"):
            item["wkbType"] = int(layer.wkbType())
    else:
        item["width"] = int(layer.width()) if hasattr(layer, "width") else None
        item["height"] = int(layer.height()) if hasattr(layer, "height") else None
        item["source"] = _local_raster_source(layer) or layer.source()
    return item


def _export_vector(layer, out_path: Path) -> None:
    out_path.parent.mkdir(parents=True, exist_ok=True)
    if out_path.exists():
        out_path.unlink()

    options = QgsVectorFileWriter.SaveVectorOptions()
    options.driverName = "GeoJSON"
    options.fileEncoding = "UTF-8"
    options.layerName = out_path.stem
    transform_context = QgsProject.instance().transformContext()
    result = QgsVectorFileWriter.writeAsVectorFormatV3(layer, str(out_path), transform_context, options)

    error_code = result[0] if isinstance(result, tuple) else result
    if error_code != QgsVectorFileWriter.NoError:
        message = result[1] if isinstance(result, tuple) and len(result) > 1 else "unknown writer error"
        raise ExportError(f"Could not export {layer.name()} to {out_path}: {message}")


def _export_dem(layer, out_path: Path) -> None:
    out_path.parent.mkdir(parents=True, exist_ok=True)
    if out_path.exists():
        out_path.unlink()

    source_path = _local_raster_source(layer)
    if source_path and os.path.exists(source_path):
        shutil.copy2(source_path, out_path)
        return

    provider = layer.dataProvider()
    pipe = QgsRasterPipe()
    if not pipe.set(provider.clone()):
        raise ExportError(f"Could not create raster pipe for {layer.name()}")

    writer = QgsRasterFileWriter(str(out_path))
    result = writer.writeRaster(
        pipe,
        layer.width(),
        layer.height(),
        layer.extent(),
        layer.crs(),
        QgsCoordinateTransformContext(),
    )
    if result != QgsRasterFileWriter.NoError:
        raise ExportError(f"Could not export DEM {layer.name()} to {out_path}")


def _export_basemap(layer_map: dict, out_path: Path) -> None:
    out_path.parent.mkdir(parents=True, exist_ok=True)
    if out_path.exists():
        out_path.unlink()

    basemap = layer_map.get("basemap")
    if basemap is None:
        return
    size = int(layer_map.get("basemap_export_size") or 4096)
    size = max(1024, min(8192, size))

    extent_layer = layer_map.get("roi") or layer_map.get("dem") or basemap
    extent = extent_layer.extent()
    destination_crs = extent_layer.crs() if hasattr(extent_layer, "crs") and extent_layer.crs().isValid() else basemap.crs()

    settings = QgsMapSettings()
    settings.setLayers([basemap])
    settings.setExtent(extent)
    settings.setDestinationCrs(destination_crs)
    settings.setTransformContext(QgsProject.instance().transformContext())
    settings.setOutputSize(QSize(size, size))
    settings.setBackgroundColor(QColor(255, 255, 255, 0))

    job = QgsMapRendererParallelJob(settings)
    job.start()
    job.waitForFinished()
    rendered = job.renderedImage()
    if rendered.isNull():
        raise ExportError(f"Could not render basemap layer {basemap.name()}")
    if not rendered.save(str(out_path), "PNG"):
        raise ExportError(f"Could not save rendered basemap to {out_path}")


def _local_raster_source(layer) -> Optional[str]:
    source = layer.source() or ""
    source = source.split("|", 1)[0]
    if source.lower().startswith("file:///"):
        source = source[8:]
    return source if source and os.path.exists(source) else None
