Overlay selected parcels on WMS preview

Components/Pages/Home.razor

@@ -2,6 +2,9 @@
 @inject IJSRuntime JS
 @inject PreciseLocationService LocationService
 @inject CadastralCatalogService CatalogService
+@inject OfficialCadastreService OfficialCadastreService
+@inject LocationSearchService LocationSearchService
+@inject AzureMapsService AzureMapsService
 @implements IAsyncDisposable
 
 <PageTitle>LME Mappe Catastali</PageTitle>
@@ -15,7 +18,16 @@
                 <strong>LME Catasto</strong>
                 <span>@Status</span>
             </div>
-            <button class="toolbar-button" @onclick='() => SelectTab(ActiveTab == "search" ? "map" : "search")'>Cerca</button>
+            <div class="toolbar-actions">
+                <button class="toolbar-button layer-button @(LayerPanelOpen ? "is-active" : null)"
+                        title="Layer catastali"
+                        aria-expanded="@LayerPanelOpen"
+                        @onclick="ToggleLayerPanel">
+                    <span class="layer-symbol" aria-hidden="true"></span>
+                    <span>Layer</span>
+                </button>
+                <button class="toolbar-button" @onclick='() => SelectTab(ActiveTab == "search" ? "map" : "search")'>Cerca</button>
+            </div>
         </header>
 
         <div class="map-search @(ActiveTab == "search" ? "is-open" : null)">
@@ -23,6 +35,33 @@
             <button @onclick="SearchLocation">Vai</button>
         </div>
 
+        @if (LayerPanelOpen)
+        {
+            <section class="map-layer-panel" aria-label="Layer catastali">
+                <header>
+                    <strong>Layer catastali</strong>
+                    <button class="layer-panel-close" aria-label="Chiudi layer" @onclick="ToggleLayerPanel">×</button>
+                </header>
+                @foreach (var layer in CadastralLayers)
+                {
+                    <label class="map-layer-option">
+                        <input type="checkbox" checked="@layer.Enabled" @onchange="(args) => ToggleCadastreLayer(layer, args)" />
+                        <span>
+                            <strong>@layer.Name</strong>
+                            @if (!string.IsNullOrWhiteSpace(layer.Detail))
+                            {
+                                <small>@layer.Detail</small>
+                            }
+                        </span>
+                    </label>
+                }
+                <div class="layer-panel-actions">
+                    <button class="secondary-command" @onclick="ClearSelectedParcels">Rimuovi particelle selezionate</button>
+                    <button class="danger-command" @onclick="ClearMapElements">Pulisci elementi mappa</button>
+                </div>
+            </section>
+        }
+
         <div class="gps-overlay @(ActiveTab == "search" ? "search-open" : null)">
             <div class="gps-state">
                 <span id="gpsState">GPS non attivo</span>
@@ -128,8 +167,10 @@
                             <input @bind="ProjectName" @bind:event="oninput" placeholder="Nome progetto o POI" />
                         </label>
                         <button class="primary-command" @onclick="AddProjectMarker">Aggiungi POI al centro mappa</button>
+                        <button class="secondary-command" aria-pressed="@DrawToolsVisible" @onclick="ToggleDrawTools">
+                            @(DrawToolsVisible ? "Nascondi strumenti di disegno" : "Mostra strumenti di disegno")
+                        </button>
                         <div class="button-row">
-                            <button @onclick="EnableDrawTools">Disegna</button>
                             <button @onclick="SaveWorkspace">Salva</button>
                             <button @onclick="LoadWorkspace">Carica</button>
                         </div>
@@ -142,28 +183,40 @@
                         <h2>Visualizzazione</h2>
                         <label>
                             Sfondo
-                            <select @onchange="ChangeBaseLayer">
+                            <select value="@SelectedBaseLayer" @onchange="ChangeBaseLayer">
-                                <option value="satellite">Satellite</option>
+                                <option value="satellite">Satellite - Esri World Imagery</option>
-                                <option value="osm">Strade</option>
+                                <option value="osm">Strade - OpenStreetMap</option>
+                                <option value="streets-esri">Strade dettagliate - Esri World Street Map</option>
+                                <option value="topographic">Topografica - Esri World Topographic</option>
+                                <option value="terrain">Terreno - OpenTopoMap</option>
+                                <option value="carto">Strade chiare - CARTO Voyager</option>
+                                <option value="azure-road">Strade - Azure Maps</option>
+                                <option value="azure-satellite">Satellite - Azure Maps</option>
+                                <option value="google-satellite">Satellite - Google Maps</option>
+                                <option value="google-roadmap">Strade - Google Maps</option>
                             </select>
                         </label>
+                        <label>
+                            Chiave Google Maps Platform
+                            <input type="password" @bind="GoogleMapsApiKey" placeholder="API key" autocomplete="off" />
+                        </label>
+                        <button class="secondary-command" @onclick="SaveGoogleMapsApiKey">Salva chiave Google</button>
+                        <label>
+                            Chiave sottoscrizione Azure Maps Gen2
+                            <input type="password" @bind="AzureMapsSubscriptionKey" placeholder="Subscription key" autocomplete="off" />
+                        </label>
+                        <button class="secondary-command" @onclick="SaveAzureMapsKey">Salva chiave Azure Maps</button>
+                        <div class="service-note">
+                            <strong>Quota gratuita Azure Maps Gen2</strong>
+                            <p>Include ogni mese 5.000 transazioni per le mappe stradali e 1.000 per le immagini satellitari. Ogni transazione comprende fino a 15 tessere.</p>
+                        </div>
                         <label>
                             Trasparenza catasto
                             <input type="range" min="0" max="1" step="0.05" value="0.75" @onchange="ChangeCadastreOpacity" />
                         </label>
-                        <div class="layer-toggles">
-                            @foreach (var layer in CadastralLayers)
-                            {
-                                <label>
-                                    <input type="checkbox" checked="@layer.Enabled" @onchange="(args) => ToggleCadastreLayer(layer.Key, args)" />
-                                    @layer.Name
-                                </label>
-                            }
-                        </div>
-
                         <h2>GPS e percorso</h2>
                         <label class="toggle-line">
-                            <input type="checkbox" checked @onchange="ToggleTrail" />
+                            <input type="checkbox" checked="@TrailEnabled" @onchange="ToggleTrail" />
                             Registra la traccia mentre cammini
                         </label>
 
@@ -175,7 +228,7 @@
                             <button class="secondary-command" @onclick="OpenOfficialReservedArea">Apri Area riservata per download</button>
                         </div>
 
-                        <button class="secondary-command" @onclick="ExportCadastralImage">Apri vista WMS corrente</button>
+                        <button class="secondary-command" @onclick="ExportCadastralImage">Mostra vista WMS corrente</button>
                         <footer>Dati catastali: Agenzia delle Entrate, licenza CC BY 4.0. App indipendente.</footer>
                     </section>
                 }
@@ -184,6 +237,25 @@
 
         <div id="mapInfo" class="map-info">Pronto</div>
 
+        <div id="wmsPreview" class="wms-preview" hidden>
+            <section class="wms-preview-dialog" role="dialog" aria-modal="true" aria-labelledby="wmsPreviewTitle">
+                <header>
+                    <div>
+                        <strong id="wmsPreviewTitle">Vista WMS catastale</strong>
+                        <small>Immagine ufficiale AdE con le particelle evidenziate dall'app</small>
+                    </div>
+                    <button id="closeWmsPreview" class="close-button" aria-label="Chiudi vista WMS">×</button>
+                </header>
+                <div class="wms-preview-body">
+                    <span id="wmsPreviewLoading">Caricamento...</span>
+                    <div id="wmsPreviewMap" class="wms-preview-map" hidden>
+                        <img id="wmsPreviewImage" alt="Vista WMS catastale dell'area corrente" />
+                        <svg id="wmsPreviewOverlay" aria-hidden="true" preserveAspectRatio="none"></svg>
+                    </div>
+                </div>
+            </section>
+        </div>
+
         <nav class="bottom-tabs" aria-label="Sezioni principali">
             <button class="@(ActiveTab == "map" || ActiveTab == "search" ? "active" : null)" @onclick='() => SelectTab("map")'>Mappa</button>
             <button class="@(ActiveTab == "cadastre" ? "active" : null)" @onclick='() => SelectTab("cadastre")'>Catasto</button>
@@ -198,6 +270,9 @@
     private string SearchText { get; set; } = string.Empty;
     private string ProjectName { get; set; } = string.Empty;
     private string Status { get; set; } = "online";
+    private string SelectedBaseLayer { get; set; } = "satellite";
+    private string GoogleMapsApiKey { get; set; } = string.Empty;
+    private string AzureMapsSubscriptionKey { get; set; } = string.Empty;
     private string SelectedRegionFile { get; set; } = string.Empty;
     private string SelectedMunicipalityCode { get; set; } = string.Empty;
     private string SelectedSheet { get; set; } = string.Empty;
@@ -206,7 +281,13 @@
     private double? CatalogFraction { get; set; }
     private bool CatalogBusy { get; set; }
     private bool GpsActive { get; set; }
+    private bool DrawToolsVisible { get; set; }
+    private bool TrailEnabled { get; set; }
+    private bool LayerPanelOpen { get; set; }
     private CancellationTokenSource? CatalogCancellation { get; set; }
+    private CancellationTokenSource? GpsLookupCancellation { get; set; }
+    private long LastGpsLookupAt;
+    private int GpsLookupInProgress;
 
     private IReadOnlyList<RegionOption> Regions { get; set; } = [];
     private IReadOnlyList<MunicipalityOption> Municipalities { get; set; } = [];
@@ -237,16 +318,34 @@
 
     private readonly List<CadastralLayer> CadastralLayers =
     [
-        new("CP.CadastralParcel", "Particelle", true),
+        new("CP.CadastralParcel", "Confini particelle", true),
-        new("codice_plla", "Numeri particelle", true),
+        new("codice_plla", "Numeri particelle", true, "Visibili circa da zoom 17"),
-        new("CP.CadastralZoning", "Fogli", true),
+        new("CP.CadastralZoning", "Fogli catastali", true),
         new("fabbricati", "Fabbricati", true),
-        new("strade", "Strade", false),
+        new("strade", "Strade catastali", false),
         new("acque", "Acque", false)
     ];
 
     protected override async Task OnInitializedAsync()
     {
+        try
+        {
+            GoogleMapsApiKey = await SecureStorage.Default.GetAsync("google_maps_api_key") ?? string.Empty;
+        }
+        catch
+        {
+            GoogleMapsApiKey = string.Empty;
+        }
+
+        try
+        {
+            AzureMapsSubscriptionKey = await SecureStorage.Default.GetAsync("azure_maps_subscription_key") ?? string.Empty;
+        }
+        catch
+        {
+            AzureMapsSubscriptionKey = string.Empty;
+        }
+
         try
         {
             Regions = await CatalogService.GetRegionsAsync();
@@ -268,16 +367,48 @@
     private async Task SelectTab(string tab)
     {
         ActiveTab = tab;
+        if (tab != "map")
+        {
+            LayerPanelOpen = false;
+        }
+        await Task.Delay(30);
+        await JS.InvokeVoidAsync("lmeMap.resize");
+    }
+
+    private async Task ToggleLayerPanel()
+    {
+        LayerPanelOpen = !LayerPanelOpen;
+        if (LayerPanelOpen)
+        {
+            ActiveTab = "map";
+        }
+
         await Task.Delay(30);
         await JS.InvokeVoidAsync("lmeMap.resize");
     }
 
     private async Task SearchLocation()
     {
+        if (string.IsNullOrWhiteSpace(SearchText))
+        {
+            await JS.InvokeVoidAsync("lmeMap.showInfo", "Inserisci una localita, un indirizzo o due coordinate.");
+            return;
+        }
+
         try
         {
-            await JS.InvokeVoidAsync("lmeMap.search", SearchText);
+            Status = "ricerca...";
+            var result = await LocationSearchService.SearchAsync(SearchText);
+            if (result is null)
+            {
+                Status = "online";
+                await JS.InvokeVoidAsync("lmeMap.showInfo", "Localita non trovata. Prova ad aggiungere Comune e Provincia.");
+                return;
+            }
+
+            await JS.InvokeVoidAsync("lmeMap.showSearchResult", result.Latitude, result.Longitude, result.Label);
             ActiveTab = "map";
+            Status = "online";
         }
         catch (Exception error)
         {
@@ -322,7 +453,11 @@
         {
             Sheets = await CatalogService.GetSheetsAsync(municipality, CreateProgress(), token);
             CatalogMessage = $"Seleziona uno dei {Sheets.Count} fogli disponibili.";
-            await JS.InvokeVoidAsync("lmeMap.search", $"{municipality.Name}, Italia");
+            var mapLocation = await LocationSearchService.SearchAsync($"{municipality.Name}, Italia", token);
+            if (mapLocation is not null)
+            {
+                await JS.InvokeVoidAsync("lmeMap.showSearchResult", mapLocation.Latitude, mapLocation.Longitude, mapLocation.Label);
+            }
         }
         catch (OperationCanceledException)
         {
@@ -392,7 +527,10 @@
         try
         {
             var label = $"{municipality.Name} - foglio {DisplaySheet(SelectedSheet)}, particella {parcel.Number}";
-            await JS.InvokeVoidAsync("lmeMap.locateParcelByPoint", parcel.Latitude, parcel.Longitude, parcel.Number, label);
+            CatalogBusy = true;
+            CatalogMessage = "Scarico il confine dal servizio ufficiale AdE...";
+            var xml = await OfficialCadastreService.GetParcelsNearAsync(parcel.Latitude, parcel.Longitude, 8);
+            await JS.InvokeVoidAsync("lmeMap.displayOfficialParcel", xml, parcel.Latitude, parcel.Longitude, parcel.Number, label, true);
             ActiveTab = "map";
             await Task.Delay(30);
             await JS.InvokeVoidAsync("lmeMap.resize");
@@ -402,6 +540,10 @@
             CatalogMessage = $"Particella non visualizzata: {error.Message}";
             await JS.InvokeVoidAsync("lmeMap.showInfo", CatalogMessage);
         }
+        finally
+        {
+            CatalogBusy = false;
+        }
     }
 
     private async Task ToggleGps()
@@ -419,11 +561,16 @@
     private async Task StartGps()
     {
         GpsActive = true;
+        GpsLookupCancellation?.Cancel();
+        GpsLookupCancellation?.Dispose();
+        GpsLookupCancellation = new CancellationTokenSource();
+        var lookupToken = GpsLookupCancellation.Token;
         try
         {
             await LocationService.StartTrackingAsync(
-                async location => await InvokeAsync(() => JS.InvokeVoidAsync("lmeMap.setNativeGpsPosition", location)),
+                location => HandleGpsLocationAsync(location, lookupToken),
                 async error => await InvokeAsync(() => JS.InvokeVoidAsync("lmeMap.setGpsError", error)));
+            GpsActive = LocationService.IsTracking;
         }
         catch (Exception error)
         {
@@ -435,10 +582,57 @@
     private async Task StopGps()
     {
         LocationService.StopTracking();
+        GpsLookupCancellation?.Cancel();
+        GpsLookupCancellation?.Dispose();
+        GpsLookupCancellation = null;
         GpsActive = false;
         await JS.InvokeVoidAsync("lmeMap.stopGps");
     }
 
+    private async Task HandleGpsLocationAsync(LocationSnapshot location, CancellationToken cancellationToken)
+    {
+        await InvokeAsync(() => JS.InvokeVoidAsync("lmeMap.setNativeGpsPosition", location));
+
+        var now = Environment.TickCount64;
+        if (now - Interlocked.Read(ref LastGpsLookupAt) < 3_500
+            || Interlocked.CompareExchange(ref GpsLookupInProgress, 1, 0) != 0)
+        {
+            return;
+        }
+
+        Interlocked.Exchange(ref LastGpsLookupAt, now);
+        try
+        {
+            var radius = Math.Clamp(location.Accuracy ?? 5, 2, 25);
+            var xml = await OfficialCadastreService.GetParcelsNearAsync(
+                location.Latitude,
+                location.Longitude,
+                radius,
+                cancellationToken);
+            await InvokeAsync(() => JS.InvokeVoidAsync(
+                "lmeMap.displayOfficialParcel",
+                xml,
+                location.Latitude,
+                location.Longitude,
+                null,
+                "Posizione GPS",
+                false));
+        }
+        catch (OperationCanceledException)
+        {
+        }
+        catch (Exception error)
+        {
+            await InvokeAsync(() => JS.InvokeVoidAsync(
+                "lmeMap.showInfo",
+                $"Aggiornamento particella GPS non disponibile: {error.GetBaseException().Message}"));
+        }
+        finally
+        {
+            Interlocked.Exchange(ref GpsLookupInProgress, 0);
+        }
+    }
+
     private IProgress<CatalogProgress> CreateProgress() => new Progress<CatalogProgress>(progress =>
     {
         _ = InvokeAsync(() =>
@@ -472,21 +666,132 @@
     private Task FitImportedLayers() => JS.InvokeVoidAsync("lmeMap.fitImported").AsTask();
     private Task ClearImportedLayers() => JS.InvokeVoidAsync("lmeMap.clearImported").AsTask();
     private Task AddProjectMarker() => JS.InvokeVoidAsync("lmeMap.addProjectMarker", ProjectName).AsTask();
-    private async Task EnableDrawTools()
+    private async Task ToggleDrawTools()
     {
-        await JS.InvokeVoidAsync("lmeMap.enableDrawTools");
+        DrawToolsVisible = !DrawToolsVisible;
-        await SelectTab("map");
+        await JS.InvokeVoidAsync("lmeMap.setDrawToolsVisible", DrawToolsVisible);
+
+        if (DrawToolsVisible)
+        {
+            await SelectTab("map");
+        }
     }
 
     private Task ClearDrawings() => JS.InvokeVoidAsync("lmeMap.clearDrawings").AsTask();
     private Task SaveWorkspace() => JS.InvokeVoidAsync("lmeMap.saveWorkspace").AsTask();
     private Task LoadWorkspace() => JS.InvokeVoidAsync("lmeMap.loadWorkspace").AsTask();
     private Task CenterOnGps() => JS.InvokeVoidAsync("lmeMap.centerOnGps").AsTask();
-    private Task ToggleTrail(ChangeEventArgs args) => JS.InvokeVoidAsync("lmeMap.toggleTrail", (bool?)args.Value == true).AsTask();
+    private async Task ToggleTrail(ChangeEventArgs args)
-    private Task ChangeBaseLayer(ChangeEventArgs args) => JS.InvokeVoidAsync("lmeMap.setBaseLayer", args.Value?.ToString()).AsTask();
+    {
+        TrailEnabled = (bool?)args.Value == true;
+        await JS.InvokeVoidAsync("lmeMap.toggleTrail", TrailEnabled);
+    }
+    private async Task ChangeBaseLayer(ChangeEventArgs args)
+    {
+        var requestedLayer = args.Value?.ToString() ?? "satellite";
+        try
+        {
+            if (requestedLayer.StartsWith("google-", StringComparison.Ordinal))
+            {
+                if (string.IsNullOrWhiteSpace(GoogleMapsApiKey))
+                {
+                    await JS.InvokeVoidAsync("lmeMap.showInfo", "Inserisci e salva una chiave Google Maps Platform per usare questo sfondo.");
+                    return;
+                }
+
+                await JS.InvokeVoidAsync("lmeMap.configureGoogleMaps", GoogleMapsApiKey.Trim());
+            }
+
+            if (requestedLayer.StartsWith("azure-", StringComparison.Ordinal))
+            {
+                if (string.IsNullOrWhiteSpace(AzureMapsSubscriptionKey))
+                {
+                    await JS.InvokeVoidAsync("lmeMap.showInfo", "Inserisci e salva la chiave della sottoscrizione Azure Maps.");
+                    return;
+                }
+
+                await AzureMapsService.ValidateKeyAsync(AzureMapsSubscriptionKey);
+                await JS.InvokeVoidAsync("lmeMap.configureAzureMaps", AzureMapsSubscriptionKey.Trim());
+            }
+
+            await JS.InvokeVoidAsync("lmeMap.setBaseLayer", requestedLayer);
+            SelectedBaseLayer = requestedLayer;
+        }
+        catch (Exception error)
+        {
+            await JS.InvokeVoidAsync("lmeMap.showInfo", $"Sfondo non disponibile: {error.GetBaseException().Message}");
+        }
+    }
+
+    private async Task SaveGoogleMapsApiKey()
+    {
+        try
+        {
+            if (string.IsNullOrWhiteSpace(GoogleMapsApiKey))
+            {
+                SecureStorage.Default.Remove("google_maps_api_key");
+                await JS.InvokeVoidAsync("lmeMap.showInfo", "Chiave Google rimossa.");
+                return;
+            }
+
+            GoogleMapsApiKey = GoogleMapsApiKey.Trim();
+            await SecureStorage.Default.SetAsync("google_maps_api_key", GoogleMapsApiKey);
+            await JS.InvokeVoidAsync("lmeMap.configureGoogleMaps", GoogleMapsApiKey);
+            await JS.InvokeVoidAsync("lmeMap.showInfo", "Chiave Google salvata sul dispositivo.");
+        }
+        catch (Exception error)
+        {
+            await JS.InvokeVoidAsync("lmeMap.showInfo", $"Chiave Google non salvata: {error.Message}");
+        }
+    }
+
+    private async Task SaveAzureMapsKey()
+    {
+        try
+        {
+            if (string.IsNullOrWhiteSpace(AzureMapsSubscriptionKey))
+            {
+                SecureStorage.Default.Remove("azure_maps_subscription_key");
+                await JS.InvokeVoidAsync("lmeMap.clearAzureMaps");
+                if (SelectedBaseLayer.StartsWith("azure-", StringComparison.Ordinal))
+                {
+                    SelectedBaseLayer = "satellite";
+                }
+                await JS.InvokeVoidAsync("lmeMap.showInfo", "Chiave Azure Maps rimossa.");
+                return;
+            }
+
+            AzureMapsSubscriptionKey = AzureMapsSubscriptionKey.Trim();
+            await AzureMapsService.ValidateKeyAsync(AzureMapsSubscriptionKey);
+            await SecureStorage.Default.SetAsync("azure_maps_subscription_key", AzureMapsSubscriptionKey);
+            await JS.InvokeVoidAsync("lmeMap.configureAzureMaps", AzureMapsSubscriptionKey);
+            await JS.InvokeVoidAsync("lmeMap.showInfo", "Chiave Azure Maps valida e salvata sul dispositivo.");
+        }
+        catch (Exception error)
+        {
+            await JS.InvokeVoidAsync("lmeMap.showInfo", $"Chiave Azure Maps non salvata: {error.GetBaseException().Message}");
+        }
+    }
     private Task ChangeCadastreOpacity(ChangeEventArgs args) => JS.InvokeVoidAsync("lmeMap.setCadastreOpacity", args.Value?.ToString()).AsTask();
-    private Task ToggleCadastreLayer(string layer, ChangeEventArgs args) => JS.InvokeVoidAsync("lmeMap.toggleCadastreLayer", layer, (bool?)args.Value == true).AsTask();
+
-    private Task ExportCadastralImage() => JS.InvokeVoidAsync("lmeMap.exportCadastreView").AsTask();
+    private async Task ToggleCadastreLayer(CadastralLayer layer, ChangeEventArgs args)
+    {
+        layer.Enabled = args.Value is true;
+        await JS.InvokeVoidAsync("lmeMap.toggleCadastreLayer", layer.Key, layer.Enabled);
+    }
+
+    private async Task ExportCadastralImage()
+    {
+        ActiveTab = "map";
+        LayerPanelOpen = false;
+        await Task.Delay(30);
+        await JS.InvokeVoidAsync("lmeMap.resize");
+        await JS.InvokeVoidAsync("lmeMap.exportCadastreView");
+    }
+
+    private Task ClearSelectedParcels() => JS.InvokeVoidAsync("lmeMap.clearSelectedParcels").AsTask();
+
+    private Task ClearMapElements() => JS.InvokeVoidAsync("lmeMap.clearMapElements").AsTask();
 
     private Task OpenOfficialGeoportal() => Microsoft.Maui.ApplicationModel.Launcher.Default.OpenAsync(
         new Uri("https://geoportale.cartografia.agenziaentrate.gov.it/"));
@@ -494,12 +799,20 @@
     private Task OpenOfficialReservedArea() => Microsoft.Maui.ApplicationModel.Launcher.Default.OpenAsync(
         new Uri("https://www.agenziaentrate.gov.it/portale/area-riservata"));
 
-    private sealed record CadastralLayer(string Key, string Name, bool Enabled);
+    private sealed class CadastralLayer(string key, string name, bool enabled, string detail = "")
+    {
+        public string Key { get; } = key;
+        public string Name { get; } = name;
+        public bool Enabled { get; set; } = enabled;
+        public string Detail { get; } = detail;
+    }
 
     public ValueTask DisposeAsync()
     {
         CancelCatalogWork();
         LocationService.StopTracking();
+        GpsLookupCancellation?.Cancel();
+        GpsLookupCancellation?.Dispose();
         return ValueTask.CompletedTask;
     }
 }

LMEMappeCatastaliApp.csproj

@@ -28,8 +28,8 @@
         <ApplicationId>com.companyname.lmemappecatastaliapp</ApplicationId>
 
         <!-- Versions -->
-        <ApplicationDisplayVersion>0.2.1</ApplicationDisplayVersion>
+        <ApplicationDisplayVersion>0.2.5</ApplicationDisplayVersion>
-        <ApplicationVersion>5</ApplicationVersion>
+        <ApplicationVersion>9</ApplicationVersion>
 
         <!-- To develop, package, and publish an app to the Microsoft Store, see: https://aka.ms/MauiTemplateUnpackaged -->
         <WindowsPackageType>None</WindowsPackageType>

MauiProgram.cs

@@ -18,6 +18,9 @@ public static class MauiProgram
         builder.Services.AddMauiBlazorWebView();
         builder.Services.AddSingleton<PreciseLocationService>();
         builder.Services.AddSingleton<CadastralCatalogService>();
+        builder.Services.AddSingleton<OfficialCadastreService>();
+        builder.Services.AddSingleton<LocationSearchService>();
+        builder.Services.AddSingleton<AzureMapsService>();
 
 #if DEBUG
         builder.Services.AddBlazorWebViewDeveloperTools();

README.md

@@ -4,7 +4,7 @@ App .NET MAUI Blazor Hybrid per Android, iOS, Mac Catalyst e Windows, pensata pe
 
 ## Funzioni gia implementate
 
-- Mappa interattiva Leaflet con sfondo satellitare Esri e sfondo stradale OpenStreetMap.
+- Mappa interattiva Leaflet con sfondi Esri, OpenStreetMap, OpenTopoMap, CARTO Voyager, Google Maps e Azure Maps configurabili tramite chiave.
 - Layer WMS ufficiale Agenzia delle Entrate: particelle, numeri particella, fogli, fabbricati, strade e acque.
 - Trasparenza configurabile del layer catastale.
 - Interrogazione WMS con click/tap sulla mappa.
@@ -20,8 +20,15 @@ App .NET MAUI Blazor Hybrid per Android, iOS, Mac Catalyst e Windows, pensata pe
 - Mappa a tutto schermo con tab Catasto, Progetti e Impostazioni, adattabile agli schermi pieghevoli.
 - Ingrandimento oltre lo zoom satellitare nativo senza tessere "Map data not yet available".
 - Tendine concatenate Regione, Comune, Foglio e Particella.
+- Ricerca di localita e indirizzi eseguita nativamente con fallback Esri e OpenStreetMap, senza richieste CORS dalla WebView.
 - Catalogo dei Comuni incluso nell'APK e cataloghi regionali OnData scaricati in cache solo quando servono.
 - Ricerca catastale eseguita dal codice .NET nativo, senza DuckDB WebAssembly nella WebView Android.
+- La registrazione della traccia GPS e' disattivata all'avvio; la toolbar di disegno puo' essere mostrata o nascosta dal tab Progetti.
+- Pannello `Layer` accessibile direttamente dalla mappa, con checkbox sincronizzati per confini, numeri particella, fogli, fabbricati, strade e acque.
+- Le particelle cercate possono essere aggiunte una dopo l'altra, mantenendo contemporaneamente sulla mappa tutti i confini selezionati.
+- Comandi separati per rimuovere le particelle selezionate o pulire importazioni, disegni, POI e traccia GPS.
+- Anteprima WMS ufficiale mostrata dentro l'app senza aprire una nuova finestra Android.
+- Confini delle particelle selezionate e della particella GPS sovrapposti anche all'anteprima WMS corrente.
 - Collegamenti separati al Geoportale pubblico e all'Area riservata AdE per CAPTCHA, SPID/CIE e download ufficiali.
 
 ## Limite ufficiale AdE da considerare
@@ -36,6 +43,21 @@ Questo passaggio e' implementato nel tab `Catasto`. Regione e Comune sono dispon
 
 I layer cartografici pubblici WMS/WFS sono open data e non richiedono CAPTCHA. Il CAPTCHA o l'autenticazione SPID/CIE appartengono ai servizi web di consultazione e download documentale: l'app li apre nel sito ufficiale dell'Agenzia e non tenta di aggirarli.
 
+## Azure Maps Gen2
+
+Nel tab `Impostazioni` sono disponibili gli sfondi `Strade - Azure Maps` e `Satellite - Azure Maps`. Per usarli:
+
+1. crea una risorsa Azure Maps con piano Gen2 nel portale Azure;
+2. copia una delle chiavi di sottoscrizione della risorsa;
+3. inseriscila in `Chiave sottoscrizione Azure Maps Gen2` e premi `Salva chiave Azure Maps`.
+
+La chiave viene validata prima del salvataggio e rimane nel `SecureStorage` del dispositivo; non e' inclusa nel codice o nell'APK. Lasciando vuoto il campo e premendo il pulsante, la chiave viene rimossa.
+
+La quota gratuita mensile Gen2 indicata da Microsoft comprende 5.000 transazioni per le mappe di base e 1.000 per le immagini satellitari. Una transazione raggruppa fino a 15 richieste di tessere. Oltre la quota si applicano le condizioni economiche della sottoscrizione Azure, quindi e' opportuno configurare budget e avvisi nel portale.
+
+- Creazione account e autenticazione: https://learn.microsoft.com/azure/azure-maps/how-to-manage-account-keys
+- Prezzi e quota gratuita: https://azure.microsoft.com/pricing/details/azure-maps/
+
 ## Aprire in Visual Studio
 
 Apri `LMEMappeCatastaliApp.csproj` con Visual Studio 2022/2026 e seleziona:

Services/AzureMapsService.cs

@@ -0,0 +1,53 @@
+using System.Text.Json;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class AzureMapsService
+{
+    private const string TilesetEndpoint = "https://atlas.microsoft.com/map/tileset";
+    private readonly HttpClient _httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(20)
+    };
+    private string? _validatedKey;
+
+    public AzureMapsService()
+    {
+        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2.5");
+        _httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/json");
+    }
+
+    public async Task ValidateKeyAsync(string subscriptionKey, CancellationToken cancellationToken = default)
+    {
+        var key = subscriptionKey.Trim();
+        if (string.IsNullOrWhiteSpace(key))
+        {
+            throw new ArgumentException("Chiave Azure Maps mancante.", nameof(subscriptionKey));
+        }
+
+        if (string.Equals(_validatedKey, key, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        var url = $"{TilesetEndpoint}?api-version=2024-04-01&tilesetId=microsoft.base.road";
+        using var request = new HttpRequestMessage(HttpMethod.Get, url);
+        request.Headers.Add("subscription-key", key);
+        using var response = await _httpClient.SendAsync(request, cancellationToken);
+        if (!response.IsSuccessStatusCode)
+        {
+            throw new InvalidOperationException(response.StatusCode is System.Net.HttpStatusCode.Unauthorized or System.Net.HttpStatusCode.Forbidden
+                ? "Chiave Azure Maps non valida o priva dei permessi Render."
+                : $"Azure Maps ha risposto {((int)response.StatusCode)}.");
+        }
+
+        await using var content = await response.Content.ReadAsStreamAsync(cancellationToken);
+        using var payload = await JsonDocument.ParseAsync(content, cancellationToken: cancellationToken);
+        if (!payload.RootElement.TryGetProperty("tiles", out _))
+        {
+            throw new InvalidDataException("Azure Maps ha restituito una configurazione non valida.");
+        }
+
+        _validatedKey = key;
+    }
+}

Services/LocationSearchService.cs

@@ -0,0 +1,185 @@
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Maui.Devices.Sensors;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class LocationSearchService
+{
+    private const string NominatimEndpoint = "https://nominatim.openstreetmap.org/search";
+    private const string ArcGisEndpoint = "https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates";
+    private readonly HttpClient _httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(20)
+    };
+    private readonly SemaphoreSlim _requestLock = new(1, 1);
+    private readonly Dictionary<string, LocationSearchResult?> _cache = new(StringComparer.OrdinalIgnoreCase);
+    private DateTimeOffset _lastRemoteRequest = DateTimeOffset.MinValue;
+
+    public LocationSearchService()
+    {
+        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2.2");
+        _httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/json");
+        _httpClient.DefaultRequestHeaders.AcceptLanguage.ParseAdd("it-IT");
+    }
+
+    public async Task<LocationSearchResult?> SearchAsync(string text, CancellationToken cancellationToken = default)
+    {
+        var query = text.Trim();
+        if (string.IsNullOrWhiteSpace(query))
+        {
+            return null;
+        }
+
+        if (TryParseCoordinates(query, out var coordinates))
+        {
+            return coordinates;
+        }
+
+        if (_cache.TryGetValue(query, out var cached))
+        {
+            return cached;
+        }
+
+        var nativeResult = await TryNativeGeocodingAsync(query);
+        if (nativeResult is not null)
+        {
+            _cache[query] = nativeResult;
+            return nativeResult;
+        }
+
+        var arcGisResult = await SearchArcGisAsync(query, cancellationToken);
+        if (arcGisResult is not null)
+        {
+            return arcGisResult;
+        }
+
+        var remoteResult = await SearchNominatimAsync(query, cancellationToken);
+        _cache[query] = remoteResult;
+        return remoteResult;
+    }
+
+    private async Task<LocationSearchResult?> SearchArcGisAsync(string query, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var url = $"{ArcGisEndpoint}?f=json&forStorage=false&sourceCountry=ITA&maxLocations=1&outFields=Match_addr,Addr_type,Score&SingleLine={Uri.EscapeDataString(query)}";
+            using var response = await _httpClient.GetAsync(url, cancellationToken);
+            if (!response.IsSuccessStatusCode)
+            {
+                return null;
+            }
+
+            await using var content = await response.Content.ReadAsStreamAsync(cancellationToken);
+            var payload = await JsonSerializer.DeserializeAsync<ArcGisResponse>(content, cancellationToken: cancellationToken);
+            var candidate = payload?.Candidates?.FirstOrDefault();
+            if (candidate?.Location is null || candidate.Score < 60)
+            {
+                return null;
+            }
+
+            return new LocationSearchResult(candidate.Location.Y, candidate.Location.X, candidate.Address ?? query);
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+
+    private static async Task<LocationSearchResult?> TryNativeGeocodingAsync(string query)
+    {
+        try
+        {
+            var locations = await Geocoding.Default.GetLocationsAsync(query);
+            var location = locations?.FirstOrDefault();
+            return location is null
+                ? null
+                : new LocationSearchResult(location.Latitude, location.Longitude, query);
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+
+    private async Task<LocationSearchResult?> SearchNominatimAsync(string query, CancellationToken cancellationToken)
+    {
+        await _requestLock.WaitAsync(cancellationToken);
+        try
+        {
+            var wait = TimeSpan.FromSeconds(1) - (DateTimeOffset.UtcNow - _lastRemoteRequest);
+            if (wait > TimeSpan.Zero)
+            {
+                await Task.Delay(wait, cancellationToken);
+            }
+
+            var url = $"{NominatimEndpoint}?format=jsonv2&limit=1&accept-language=it&q={Uri.EscapeDataString(query)}";
+            _lastRemoteRequest = DateTimeOffset.UtcNow;
+            using var response = await _httpClient.GetAsync(url, cancellationToken);
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new HttpRequestException($"Il servizio di ricerca ha risposto {((int)response.StatusCode)}.");
+            }
+
+            await using var content = await response.Content.ReadAsStreamAsync(cancellationToken);
+            var results = await JsonSerializer.DeserializeAsync<List<NominatimResult>>(content, cancellationToken: cancellationToken);
+            var result = results?.FirstOrDefault();
+            if (result is null
+                || !double.TryParse(result.Latitude, NumberStyles.Float, CultureInfo.InvariantCulture, out var latitude)
+                || !double.TryParse(result.Longitude, NumberStyles.Float, CultureInfo.InvariantCulture, out var longitude))
+            {
+                return null;
+            }
+
+            return new LocationSearchResult(latitude, longitude, result.DisplayName ?? query);
+        }
+        finally
+        {
+            _requestLock.Release();
+        }
+    }
+
+    private static bool TryParseCoordinates(string query, out LocationSearchResult? result)
+    {
+        result = null;
+        var parts = query.Split([' ', ',', ';'], StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+        if (parts.Length != 2
+            || !double.TryParse(parts[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var latitude)
+            || !double.TryParse(parts[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var longitude)
+            || Math.Abs(latitude) > 90
+            || Math.Abs(longitude) > 180)
+        {
+            return false;
+        }
+
+        result = new LocationSearchResult(
+            latitude,
+            longitude,
+            $"Coordinate: {latitude:F6}, {longitude:F6}");
+        return true;
+    }
+
+    private sealed record NominatimResult(
+        [property: JsonPropertyName("lat")] string? Latitude,
+        [property: JsonPropertyName("lon")] string? Longitude,
+        [property: JsonPropertyName("display_name")] string? DisplayName);
+
+    private sealed record ArcGisResponse(
+        [property: JsonPropertyName("candidates")] List<ArcGisCandidate>? Candidates);
+
+    private sealed record ArcGisCandidate(
+        [property: JsonPropertyName("address")] string? Address,
+        [property: JsonPropertyName("score")] double Score,
+        [property: JsonPropertyName("location")] ArcGisLocation? Location);
+
+    private sealed record ArcGisLocation(
+        [property: JsonPropertyName("x")] double X,
+        [property: JsonPropertyName("y")] double Y);
+}
+
+public sealed record LocationSearchResult(double Latitude, double Longitude, string Label);

Services/OfficialCadastreService.cs

@@ -0,0 +1,85 @@
+using System.Globalization;
+using System.Xml.Linq;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class OfficialCadastreService
+{
+    private const string WfsEndpoint = "https://wfs.cartografia.agenziaentrate.gov.it/inspire/wfs/owfs01.php";
+    private readonly HttpClient _httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(30)
+    };
+
+    public OfficialCadastreService()
+    {
+        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2");
+        _httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/gml+xml");
+    }
+
+    public async Task<string> GetParcelsNearAsync(
+        double latitude,
+        double longitude,
+        double radiusMeters,
+        CancellationToken cancellationToken = default)
+    {
+        var meters = Math.Clamp(radiusMeters, 2, 30);
+        var deltaLatitude = meters / 111_320d;
+        var longitudeScale = Math.Cos(latitude * Math.PI / 180d);
+        var deltaLongitude = meters / (111_320d * Math.Max(0.1, longitudeScale));
+        var bbox = string.Join(",",
+        [
+            Format(latitude - deltaLatitude),
+            Format(longitude - deltaLongitude),
+            Format(latitude + deltaLatitude),
+            Format(longitude + deltaLongitude)
+        ]);
+
+        var query = new Dictionary<string, string>
+        {
+            ["language"] = "ita",
+            ["SERVICE"] = "WFS",
+            ["VERSION"] = "2.0.0",
+            ["TYPENAMES"] = "CP:CadastralParcel",
+            ["SRSNAME"] = "urn:ogc:def:crs:EPSG::6706",
+            ["BBOX"] = bbox,
+            ["REQUEST"] = "GetFeature",
+            ["COUNT"] = "20"
+        };
+
+        var url = WfsEndpoint + "?" + string.Join("&", query.Select(item =>
+            $"{Uri.EscapeDataString(item.Key)}={Uri.EscapeDataString(item.Value)}"));
+
+        using var response = await _httpClient.GetAsync(url, HttpCompletionOption.ResponseContentRead, cancellationToken);
+        if (!response.IsSuccessStatusCode)
+        {
+            throw new HttpRequestException($"Il servizio WFS AdE ha risposto {((int)response.StatusCode)}.");
+        }
+
+        var xml = await response.Content.ReadAsStringAsync(cancellationToken);
+        ThrowIfExceptionReport(xml);
+        return xml;
+    }
+
+    private static string Format(double value) => value.ToString("R", CultureInfo.InvariantCulture);
+
+    private static void ThrowIfExceptionReport(string xml)
+    {
+        try
+        {
+            var document = XDocument.Parse(xml);
+            var exceptionText = document.Descendants()
+                .FirstOrDefault(element => element.Name.LocalName == "ExceptionText")
+                ?.Value
+                .Trim();
+            if (!string.IsNullOrWhiteSpace(exceptionText))
+            {
+                throw new InvalidOperationException($"Servizio WFS AdE: {exceptionText}");
+            }
+        }
+        catch (System.Xml.XmlException error)
+        {
+            throw new InvalidDataException("Il servizio WFS AdE ha restituito una risposta non valida.", error);
+        }
+    }
+}

wwwroot/css/app.css

@@ -124,6 +124,28 @@ input[type="checkbox"] {
     color: var(--ink);
 }
 
+.toolbar-actions,
+.layer-button {
+    display: flex;
+    align-items: center;
+    gap: 7px;
+}
+
+.toolbar-actions {
+    flex: 0 0 auto;
+}
+
+.layer-button.is-active {
+    background: #ccebe3;
+    color: var(--accent-strong);
+}
+
+.layer-symbol {
+    width: 20px;
+    height: 20px;
+    background: url("../lib/leaflet/images/layers.png") center / contain no-repeat;
+}
+
 .map-search {
     position: absolute;
     top: 72px;
@@ -150,6 +172,73 @@ input[type="checkbox"] {
     transform: translateY(0);
 }
 
+.map-layer-panel {
+    position: absolute;
+    top: 72px;
+    right: 12px;
+    z-index: 940;
+    display: grid;
+    width: min(320px, calc(100% - 24px));
+    max-height: calc(100% - 152px);
+    overflow-y: auto;
+    border: 1px solid var(--line);
+    border-radius: 8px;
+    padding: 9px;
+    background: rgba(255, 255, 255, 0.98);
+    box-shadow: 0 3px 14px rgba(0, 0, 0, 0.22);
+}
+
+.map-layer-panel > header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+    padding: 0 0 7px 4px;
+    border-bottom: 1px solid var(--line);
+}
+
+.layer-panel-close {
+    width: 36px;
+    min-width: 36px;
+    min-height: 34px;
+    padding: 0;
+    background: #e9eef0;
+    color: var(--ink);
+    font-size: 23px;
+}
+
+.map-layer-option {
+    display: flex;
+    align-items: center;
+    gap: 9px;
+    min-height: 45px;
+    padding: 6px 4px;
+    border-bottom: 1px solid #e5eaed;
+}
+
+.map-layer-option input {
+    flex: 0 0 auto;
+    width: 19px;
+    height: 19px;
+}
+
+.map-layer-option span {
+    display: grid;
+    gap: 2px;
+}
+
+.map-layer-option small {
+    color: var(--muted);
+    font-size: 10px;
+    font-weight: 600;
+}
+
+.layer-panel-actions {
+    display: grid;
+    gap: 7px;
+    padding-top: 9px;
+}
+
 .gps-overlay {
     position: absolute;
     top: 72px;
@@ -384,6 +473,100 @@ label {
     pointer-events: none;
 }
 
+.wms-preview[hidden] {
+    display: none;
+}
+
+.wms-preview {
+    position: absolute;
+    inset: 0;
+    z-index: 1400;
+    display: grid;
+    place-items: center;
+    padding: 16px;
+    background: rgba(15, 22, 27, 0.72);
+}
+
+.wms-preview-dialog {
+    display: grid;
+    grid-template-rows: auto minmax(0, 1fr);
+    width: min(980px, 100%);
+    height: min(820px, 100%);
+    overflow: hidden;
+    border-radius: 8px;
+    background: #fff;
+    box-shadow: 0 10px 34px rgba(0, 0, 0, 0.34);
+}
+
+.wms-preview-dialog > header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    padding: 11px 12px;
+    border-bottom: 1px solid var(--line);
+}
+
+.wms-preview-dialog > header div {
+    display: grid;
+    gap: 2px;
+}
+
+.wms-preview-dialog > header small {
+    color: var(--muted);
+    font-size: 10px;
+}
+
+.wms-preview-body {
+    display: grid;
+    min-height: 0;
+    place-items: center;
+    overflow: auto;
+    padding: 12px;
+    background: #eef2f3;
+    color: var(--muted);
+}
+
+.wms-preview-map {
+    position: relative;
+    flex: 0 0 auto;
+    overflow: hidden;
+    background: #fff;
+}
+
+.wms-preview-map[hidden] {
+    display: none;
+}
+
+.wms-preview-map img,
+.wms-preview-map svg {
+    display: block;
+    width: 100%;
+    height: 100%;
+}
+
+.wms-preview-map svg {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+}
+
+.wms-preview-parcel {
+    fill: rgba(251, 191, 36, 0.28);
+    fill-rule: evenodd;
+    stroke: #ef4444;
+    stroke-width: 4px;
+    vector-effect: non-scaling-stroke;
+}
+
+.wms-preview-gps-parcel {
+    fill: rgba(56, 189, 248, 0.24);
+    fill-rule: evenodd;
+    stroke: #1d4ed8;
+    stroke-width: 4px;
+    vector-effect: non-scaling-stroke;
+}
+
 .bottom-tabs {
     position: absolute;
     right: 0;
@@ -462,6 +645,13 @@ footer {
         right: 8px;
     }
 
+    .map-layer-panel {
+        top: 68px;
+        right: 8px;
+        width: min(320px, calc(100% - 16px));
+        max-height: calc(100% - 144px);
+    }
+
     .tool-sheet {
         top: 10%;
         bottom: var(--nav-height);
@@ -504,6 +694,10 @@ footer {
     .bottom-tabs button {
         font-size: 11px;
     }
+
+    .wms-preview {
+        padding: 8px;
+    }
 }
 
 @media (max-width: 380px) {

wwwroot/index.html

@@ -28,6 +28,7 @@
     <script src="_framework/blazor.webview.js" autostart="false"></script>
     <script src="lib/leaflet/leaflet.js"></script>
     <script src="lib/leaflet-draw/leaflet.draw.js"></script>
+    <script src="lib/googlemutant/Leaflet.GoogleMutant.js"></script>
     <script src="lib/jszip/jszip.min.js"></script>
     <script src="lib/togeojson/togeojson.umd.js"></script>
     <script src="js/lme-map.js"></script>

wwwroot/js/lme-map.js

@@ -2,39 +2,49 @@ const lmeState = {
     map: null,
     baseLayers: {},
     currentBase: null,
+    currentBaseName: "satellite",
     cadastre: null,
     cadastreLayers: ["CP.CadastralParcel", "codice_plla", "CP.CadastralZoning", "fabbricati"],
     cadastreOpacity: 0.75,
     imported: null,
     drawings: null,
     drawControl: null,
+    drawEventsBound: false,
     gpsMarker: null,
     gpsAccuracy: null,
     gpsTrail: null,
-    currentParcelLayer: null,
+    selectedParcelsLayer: null,
-    gpsTrailEnabled: true,
+    gpsParcelLayer: null,
+    gpsTrailEnabled: false,
     gpsTrailPoints: [],
     gpsWatchId: null,
     lastPosition: null,
-    lastWfsLookupAt: 0,
-    wfsLookupInFlight: false,
     fileImportBound: false,
-    resizeBound: false
+    resizeBound: false,
+    googleMapsLoading: null,
+    azureMapsKey: null,
+    azureAttribution: null
 };
 
 window.lmeMap = {
     init,
-    search,
+    showSearchResult,
-    locateParcelByPoint,
+    displayOfficialParcel,
     exportCadastreView,
+    closeCadastrePreview,
+    clearSelectedParcels,
+    clearMapElements,
     fitImported,
     clearImported,
     addProjectMarker,
-    enableDrawTools,
+    setDrawToolsVisible,
     clearDrawings,
     saveWorkspace,
     loadWorkspace,
     setBaseLayer,
+    configureGoogleMaps,
+    configureAzureMaps,
+    clearAzureMaps,
     setCadastreOpacity,
     toggleCadastreLayer,
     startGps,
@@ -70,10 +80,36 @@ function init() {
         attribution: "Tiles © Esri"
     });
 
+    lmeState.baseLayers.topographic = L.tileLayer("https://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}", {
+        maxNativeZoom: 19,
+        maxZoom: 22,
+        attribution: "Tiles © Esri"
+    });
+
+    lmeState.baseLayers["streets-esri"] = L.tileLayer("https://server.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}", {
+        maxNativeZoom: 19,
+        maxZoom: 22,
+        attribution: "Tiles © Esri"
+    });
+
+    lmeState.baseLayers.terrain = L.tileLayer("https://{s}.tile.opentopomap.org/{z}/{x}/{y}.png", {
+        maxNativeZoom: 17,
+        maxZoom: 22,
+        attribution: "Map data © OpenStreetMap contributors, SRTM | Map style © OpenTopoMap"
+    });
+
+    lmeState.baseLayers.carto = L.tileLayer("https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png", {
+        subdomains: "abcd",
+        maxNativeZoom: 20,
+        maxZoom: 22,
+        attribution: "© OpenStreetMap contributors © CARTO"
+    });
+
     lmeState.currentBase = lmeState.baseLayers.satellite.addTo(lmeState.map);
     lmeState.imported = L.featureGroup().addTo(lmeState.map);
     lmeState.drawings = L.featureGroup().addTo(lmeState.map);
-    lmeState.currentParcelLayer = L.featureGroup().addTo(lmeState.map);
+    lmeState.selectedParcelsLayer = L.featureGroup().addTo(lmeState.map);
+    lmeState.gpsParcelLayer = L.featureGroup().addTo(lmeState.map);
     lmeState.gpsTrail = L.polyline([], { color: "#f97316", weight: 4, opacity: 0.85 }).addTo(lmeState.map);
 
     refreshCadastreLayer();
@@ -91,39 +127,36 @@ function init() {
             L.popup().setLatLng(event.latlng).setContent(info).openOn(lmeState.map);
         }
     });
+    lmeState.map.on("moveend", () => void updateAzureAttribution());
+
+    document.getElementById("closeWmsPreview")?.addEventListener("click", closeCadastrePreview);
+    document.getElementById("wmsPreview")?.addEventListener("click", event => {
+        if (event.target?.id === "wmsPreview") {
+            closeCadastrePreview();
+        }
+    });
+    document.addEventListener("keydown", event => {
+        if (event.key === "Escape") {
+            closeCadastrePreview();
+        }
+    });
 
     setInfo("Mappa pronta: satellite + catasto AdE");
 }
 
-async function search(text) {
+function showSearchResult(latitude, longitude, label) {
-    const query = (text || "").trim();
+    const lat = Number(latitude);
-    if (!query) {
+    const lon = Number(longitude);
-        setInfo("Inserisci una localita o coordinate.");
+    if (!Number.isFinite(lat) || !Number.isFinite(lon)) {
+        setInfo("La ricerca ha restituito coordinate non valide.");
         return;
     }
 
-    const coordinate = parseCoordinates(query);
+    lmeState.map.setView([lat, lon], 18);
-    if (coordinate) {
+    setInfo(label || `${lat.toFixed(6)}, ${lon.toFixed(6)}`);
-        lmeState.map.setView(coordinate, 19);
-        setInfo(`Coordinate: ${coordinate[0].toFixed(6)}, ${coordinate[1].toFixed(6)}`);
-        return;
-    }
-
-    const response = await fetch(`https://nominatim.openstreetmap.org/search?format=json&limit=1&q=${encodeURIComponent(query)}`, {
-        headers: { "Accept": "application/json" }
-    });
-    const results = await response.json();
-    if (!results.length) {
-        setInfo("Localita non trovata.");
-        return;
-    }
-
-    const place = results[0];
-    lmeState.map.setView([Number(place.lat), Number(place.lon)], 18);
-    setInfo(place.display_name);
 }
 
-async function locateParcelByPoint(latitude, longitude, parcel, label) {
+function displayOfficialParcel(xmlText, latitude, longitude, parcel, label, shouldFit) {
     const lat = Number(latitude);
     const lon = Number(longitude);
     if (!Number.isFinite(lat) || !Number.isFinite(lon)) {
@@ -131,36 +164,66 @@ async function locateParcelByPoint(latitude, longitude, parcel, label) {
         return;
     }
 
-    setInfo(`Recupero il confine ufficiale: ${label}`);
     try {
-        const meters = 8;
+        const geojson = gmlParcelsToGeoJson(xmlText);
-        const deltaLat = meters / 111320;
-        const deltaLon = meters / (111320 * Math.cos(lat * Math.PI / 180));
-        const geojson = await fetchOfficialParcelsByBbox(lat - deltaLat, lon - deltaLon, lat + deltaLat, lon + deltaLon);
         const normalizedParcel = normalizeParcel(parcel);
-        const feature = (geojson.features || []).find(item => {
+        const featureByNumber = normalizedParcel
-            const props = item.properties || {};
+            ? (geojson.features || []).find(item => {
-            return String(props.LABEL || "").trim().toUpperCase() === normalizedParcel.toUpperCase()
+                const props = item.properties || {};
-                || String(props.NATIONALCADASTRALREFERENCE || "").toUpperCase().endsWith(`.${normalizedParcel.toUpperCase()}`);
+                return String(props.LABEL || "").trim().toUpperCase() === normalizedParcel
-        }) || (geojson.features || []).find(item => geometryContainsPoint(item.geometry, [lon, lat])) || geojson.features?.[0];
+                    || String(props.NATIONALCADASTRALREFERENCE || "").toUpperCase().endsWith(`.${normalizedParcel}`);
+            })
+            : null;
+        const feature = featureByNumber
+            || (geojson.features || []).find(item => geometryContainsPoint(item.geometry, [lon, lat]))
+            || geojson.features?.[0];
 
         if (!feature) {
-            lmeState.map.setView([lat, lon], 20);
+            if (shouldFit) {
+                lmeState.map.setView([lat, lon], 20);
+            }
             setInfo("Posizione trovata, ma il servizio WFS dell'Agenzia non ha restituito il confine. Riprova tra poco.");
             return;
         }
 
-        lmeState.currentParcelLayer.clearLayers();
-        const layer = L.geoJSON(feature, {
-            style: { color: "#ef4444", weight: 4, opacity: 1, fillColor: "#fbbf24", fillOpacity: 0.26 }
-        }).addTo(lmeState.currentParcelLayer);
-        fitLayer(layer);
-
         const ref = feature.properties?.NATIONALCADASTRALREFERENCE || feature.properties?.INSPIREID_LOCALID || label;
-        setText("parcelState", `Particella selezionata: ${ref}`);
+        const targetGroup = normalizedParcel ? lmeState.selectedParcelsLayer : lmeState.gpsParcelLayer;
-        setInfo(`Trovata ${ref}. Ora puoi attivare il GPS e camminare dentro il confine evidenziato.`);
+        if (!normalizedParcel) {
+            targetGroup.clearLayers();
+        }
+
+        const existingLayer = normalizedParcel
+            ? targetGroup.getLayers().find(item => item.lmeParcelReference === ref)
+            : null;
+        if (existingLayer) {
+            if (shouldFit) {
+                fitLayer(existingLayer);
+            }
+            setText("parcelState", `Particella selezionata: ${ref}`);
+            setInfo(`La particella ${ref} e' gia evidenziata sulla mappa.`);
+            return;
+        }
+
+        const layer = L.geoJSON(feature, {
+            style: normalizedParcel
+                ? { color: "#ef4444", weight: 4, opacity: 1, fillColor: "#fbbf24", fillOpacity: 0.26 }
+                : { color: "#1d4ed8", weight: 4, opacity: 1, fillColor: "#38bdf8", fillOpacity: 0.2 }
+        }).addTo(targetGroup);
+        layer.lmeParcelReference = ref;
+        layer.bindPopup(`<strong>${escapeHtml(ref)}</strong>`);
+        if (shouldFit) {
+            fitLayer(layer);
+        }
+
+        if (normalizedParcel) {
+            setText("parcelState", `Particella selezionata: ${ref}`);
+            const count = lmeState.selectedParcelsLayer.getLayers().length;
+            setInfo(`Aggiunta ${ref}. Particelle evidenziate: ${count}.`);
+        } else {
+            setText("parcelState", `Dentro particella AdE: ${ref}`);
+        }
     } catch (error) {
-        setInfo(`Servizio catastale temporaneamente non disponibile: ${error.message}`);
+        setInfo(`Geometria catastale non leggibile: ${error.message}`);
     }
 }
 
@@ -176,12 +239,140 @@ function resize() {
 }
 
 function exportCadastreView() {
-    const center = lmeState.map.getCenter();
+    const layers = activeCadastreLayers();
-    const zoom = lmeState.map.getZoom();
+    if (!layers.length) {
-    const layers = lmeState.cadastreLayers.join(",");
+        setInfo("Attiva almeno un layer catastale prima di aprire la vista WMS.");
-    const url = `${cadastreUrl()}service=WMS&version=1.3.0&request=GetMap&layers=${encodeURIComponent(layers)}&styles=&format=image/png&transparent=true&width=1200&height=1200&crs=EPSG:4258&bbox=${center.lat - 0.01},${center.lng - 0.01},${center.lat + 0.01},${center.lng + 0.01}`;
+        return;
-    window.open(url, "_blank");
+    }
-    setInfo(`Vista catastale aperta per download. Zoom corrente: ${zoom}.`);
+
+    const bounds = lmeState.map.getBounds();
+    const size = lmeState.map.getSize();
+    const scale = Math.min(1, 1200 / size.x, 1200 / size.y);
+    const width = Math.max(256, Math.round(size.x * scale));
+    const height = Math.max(256, Math.round(size.y * scale));
+    const bbox = [bounds.getSouth(), bounds.getWest(), bounds.getNorth(), bounds.getEast()].join(",");
+    const params = new URLSearchParams({
+        service: "WMS",
+        version: "1.3.0",
+        request: "GetMap",
+        layers: layers.join(","),
+        styles: "",
+        format: "image/png",
+        transparent: "true",
+        width: String(width),
+        height: String(height),
+        crs: "EPSG:4258",
+        bbox
+    });
+    const preview = document.getElementById("wmsPreview");
+    const previewBody = preview?.querySelector(".wms-preview-body");
+    const previewMap = document.getElementById("wmsPreviewMap");
+    const image = document.getElementById("wmsPreviewImage");
+    const overlay = document.getElementById("wmsPreviewOverlay");
+    const loading = document.getElementById("wmsPreviewLoading");
+    if (!preview || !previewBody || !previewMap || !image || !overlay || !loading) {
+        setInfo("Vista WMS interna non disponibile.");
+        return;
+    }
+
+    preview.hidden = false;
+    const availableWidth = Math.max(1, previewBody.clientWidth - 24);
+    const availableHeight = Math.max(1, previewBody.clientHeight - 24);
+    const displayScale = Math.min(1, availableWidth / width, availableHeight / height);
+    previewMap.style.width = `${Math.max(1, Math.round(width * displayScale))}px`;
+    previewMap.style.height = `${Math.max(1, Math.round(height * displayScale))}px`;
+    previewMap.hidden = true;
+    renderPreviewParcelOverlay(overlay, bounds, width, height);
+
+    loading.textContent = "Caricamento...";
+    loading.hidden = false;
+    image.onload = () => {
+        loading.hidden = true;
+        previewMap.hidden = false;
+        const highlightedCount = lmeState.selectedParcelsLayer.getLayers().length
+            + lmeState.gpsParcelLayer.getLayers().length;
+        setInfo(`Vista WMS caricata con ${layers.length} layer e ${highlightedCount} particelle evidenziate.`);
+    };
+    image.onerror = () => {
+        previewMap.hidden = true;
+        loading.textContent = "Il servizio WMS non ha restituito l'immagine. Riprova tra poco.";
+        setInfo("Vista WMS non disponibile.");
+    };
+    image.src = `${cadastreUrl()}${params}`;
+}
+
+function closeCadastrePreview() {
+    const preview = document.getElementById("wmsPreview");
+    const previewMap = document.getElementById("wmsPreviewMap");
+    const image = document.getElementById("wmsPreviewImage");
+    const overlay = document.getElementById("wmsPreviewOverlay");
+    if (preview) {
+        preview.hidden = true;
+    }
+    if (previewMap) {
+        previewMap.hidden = true;
+    }
+    if (image) {
+        image.onload = null;
+        image.onerror = null;
+        image.removeAttribute("src");
+    }
+    overlay?.replaceChildren();
+}
+
+function renderPreviewParcelOverlay(svg, bounds, width, height) {
+    svg.replaceChildren();
+    svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+    appendPreviewGeometry(svg, lmeState.selectedParcelsLayer.toGeoJSON(), "wms-preview-parcel", bounds, width, height);
+    appendPreviewGeometry(svg, lmeState.gpsParcelLayer.toGeoJSON(), "wms-preview-gps-parcel", bounds, width, height);
+}
+
+function appendPreviewGeometry(svg, featureCollection, className, bounds, width, height) {
+    const namespace = "http://www.w3.org/2000/svg";
+    for (const feature of featureCollection?.features || []) {
+        for (const polygon of geometryPolygons(feature.geometry)) {
+            const pathData = polygon
+                .map(ring => ring
+                    .map((coordinate, index) => {
+                        const point = previewPixel(coordinate, bounds, width, height);
+                        return `${index ? "L" : "M"}${point.x.toFixed(2)} ${point.y.toFixed(2)}`;
+                    })
+                    .join(" ") + " Z")
+                .join(" ");
+            if (!pathData.trim()) {
+                continue;
+            }
+            const path = document.createElementNS(namespace, "path");
+            path.setAttribute("d", pathData);
+            path.setAttribute("class", className);
+            svg.appendChild(path);
+        }
+    }
+}
+
+function geometryPolygons(geometry) {
+    if (!geometry) {
+        return [];
+    }
+    if (geometry.type === "Polygon") {
+        return [geometry.coordinates || []];
+    }
+    if (geometry.type === "MultiPolygon") {
+        return geometry.coordinates || [];
+    }
+    if (geometry.type === "GeometryCollection") {
+        return (geometry.geometries || []).flatMap(geometryPolygons);
+    }
+    return [];
+}
+
+function previewPixel(coordinate, bounds, width, height) {
+    const longitude = Number(coordinate?.[0]);
+    const latitude = Number(coordinate?.[1]);
+    return {
+        x: ((longitude - bounds.getWest()) / (bounds.getEast() - bounds.getWest())) * width,
+        y: ((bounds.getNorth() - latitude) / (bounds.getNorth() - bounds.getSouth())) * height
+    };
 }
 
 function bindFileImport() {
@@ -284,13 +475,36 @@ function enableDrawTools() {
         }
     });
     lmeState.map.addControl(lmeState.drawControl);
-    lmeState.map.on(L.Draw.Event.CREATED, event => {
+    if (!lmeState.drawEventsBound) {
-        lmeState.drawings.addLayer(event.layer);
+        lmeState.map.on(L.Draw.Event.CREATED, event => {
-        updateGpsInsideState();
+            lmeState.drawings.addLayer(event.layer);
-    });
+            updateGpsInsideState();
+        });
+        lmeState.drawEventsBound = true;
+    }
     setInfo("Disegno attivo: crea POI, linee e aree sulla mappa.");
 }
 
+function setDrawToolsVisible(visible) {
+    if (visible) {
+        enableDrawTools();
+        return;
+    }
+
+    if (!lmeState.drawControl) {
+        return;
+    }
+
+    Object.values(lmeState.drawControl._toolbars || {}).forEach(toolbar => {
+        if (typeof toolbar.disable === "function") {
+            toolbar.disable();
+        }
+    });
+    lmeState.map.removeControl(lmeState.drawControl);
+    lmeState.drawControl = null;
+    setInfo("Strumenti di disegno nascosti.");
+}
+
 function clearDrawings() {
     const count = lmeState.drawings.getLayers().length;
     if (!count) {
@@ -342,7 +556,188 @@ function setBaseLayer(name) {
         lmeState.map.removeLayer(lmeState.currentBase);
     }
     lmeState.currentBase = selected.addTo(lmeState.map);
+    lmeState.currentBaseName = selected === lmeState.baseLayers[name] ? name : "satellite";
     lmeState.currentBase.bringToBack();
+    const labels = {
+        satellite: "Satellite Esri",
+        osm: "OpenStreetMap",
+        "streets-esri": "Strade dettagliate Esri",
+        topographic: "Topografica Esri",
+        terrain: "OpenTopoMap",
+        carto: "CARTO Voyager",
+        "azure-road": "Strade Azure Maps",
+        "azure-satellite": "Satellite Azure Maps",
+        "google-satellite": "Satellite Google Maps",
+        "google-roadmap": "Strade Google Maps"
+    };
+    setInfo(`Sfondo attivo: ${labels[name] || labels.satellite}. Il catasto AdE resta sovrapposto.`);
+    if (lmeState.currentBaseName.startsWith("azure-")) {
+        void updateAzureAttribution();
+    } else {
+        clearAzureAttribution();
+    }
+}
+
+function configureGoogleMaps(apiKey) {
+    const key = (apiKey || "").trim();
+    if (!key) {
+        return Promise.reject(new Error("Chiave Google Maps mancante."));
+    }
+
+    if (window.google?.maps && L.gridLayer.googleMutant) {
+        createGoogleLayers();
+        return Promise.resolve();
+    }
+
+    if (lmeState.googleMapsLoading) {
+        return lmeState.googleMapsLoading;
+    }
+
+    lmeState.googleMapsLoading = new Promise((resolve, reject) => {
+        const callbackName = `lmeGoogleMapsReady${Date.now()}`;
+        const script = document.createElement("script");
+        window[callbackName] = () => {
+            delete window[callbackName];
+            createGoogleLayers();
+            resolve();
+        };
+        script.src = `https://maps.googleapis.com/maps/api/js?key=${encodeURIComponent(key)}&loading=async&callback=${callbackName}`;
+        script.async = true;
+        script.onerror = () => {
+            delete window[callbackName];
+            lmeState.googleMapsLoading = null;
+            reject(new Error("Impossibile caricare Google Maps. Controlla chiave, API e connessione."));
+        };
+        document.head.appendChild(script);
+    });
+
+    return lmeState.googleMapsLoading;
+}
+
+function createGoogleLayers() {
+    if (!L.gridLayer.googleMutant) {
+        throw new Error("Modulo Google Maps non disponibile.");
+    }
+
+    lmeState.baseLayers["google-satellite"] ||= L.gridLayer.googleMutant({ type: "hybrid", maxZoom: 22 });
+    lmeState.baseLayers["google-roadmap"] ||= L.gridLayer.googleMutant({ type: "roadmap", maxZoom: 22 });
+}
+
+function configureAzureMaps(subscriptionKey) {
+    const key = (subscriptionKey || "").trim();
+    if (!key) {
+        throw new Error("Chiave Azure Maps mancante.");
+    }
+    if (lmeState.azureMapsKey === key
+        && lmeState.baseLayers["azure-road"]
+        && lmeState.baseLayers["azure-satellite"]) {
+        return;
+    }
+
+    const activeAzureLayer = lmeState.currentBaseName.startsWith("azure-")
+        ? lmeState.currentBaseName
+        : null;
+    if (activeAzureLayer && lmeState.currentBase) {
+        lmeState.map.removeLayer(lmeState.currentBase);
+    }
+
+    lmeState.azureMapsKey = key;
+    lmeState.baseLayers["azure-road"] = createAzureLayer(key, "microsoft.base.road", 22);
+    lmeState.baseLayers["azure-satellite"] = createAzureLayer(key, "microsoft.imagery", 19);
+
+    if (activeAzureLayer) {
+        lmeState.currentBase = lmeState.baseLayers[activeAzureLayer].addTo(lmeState.map);
+        lmeState.currentBase.bringToBack();
+        void updateAzureAttribution();
+    }
+}
+
+function clearAzureMaps() {
+    if (lmeState.currentBaseName.startsWith("azure-") && lmeState.currentBase) {
+        lmeState.map.removeLayer(lmeState.currentBase);
+        lmeState.currentBase = lmeState.baseLayers.satellite.addTo(lmeState.map);
+        lmeState.currentBase.bringToBack();
+        lmeState.currentBaseName = "satellite";
+    }
+
+    delete lmeState.baseLayers["azure-road"];
+    delete lmeState.baseLayers["azure-satellite"];
+    lmeState.azureMapsKey = null;
+    clearAzureAttribution();
+}
+
+function createAzureLayer(key, tilesetId, maxNativeZoom) {
+    const url = `https://atlas.microsoft.com/map/tile?api-version=2024-04-01&tilesetId=${tilesetId}&zoom={z}&x={x}&y={y}&tileSize=256&language=it-IT&view=Auto&subscription-key=${encodeURIComponent(key)}`;
+    const layer = L.tileLayer(url, {
+        minZoom: tilesetId === "microsoft.imagery" ? 1 : 0,
+        maxNativeZoom,
+        maxZoom: 22,
+        attribution: "Microsoft Azure Maps"
+    });
+    let errorShown = false;
+    layer.on("tileerror", () => {
+        if (!errorShown) {
+            errorShown = true;
+            setInfo("Azure Maps non ha restituito le tessere. Controlla quota e permessi Render della chiave.");
+        }
+    });
+    return layer;
+}
+
+async function updateAzureAttribution() {
+    if (!lmeState.azureMapsKey || !lmeState.currentBaseName.startsWith("azure-")) {
+        return;
+    }
+
+    const requestedLayer = lmeState.currentBaseName;
+    const tilesetId = requestedLayer === "azure-satellite" ? "microsoft.imagery" : "microsoft.base.road";
+    const bounds = lmeState.map.getBounds();
+    const zoom = Math.min(lmeState.map.getZoom(), tilesetId === "microsoft.imagery" ? 19 : 22);
+    const bbox = [bounds.getWest(), bounds.getSouth(), bounds.getEast(), bounds.getNorth()].join(",");
+    const url = `https://atlas.microsoft.com/map/attribution?api-version=2024-04-01&tilesetId=${tilesetId}&zoom=${zoom}&bounds=${bbox}`;
+
+    try {
+        const response = await fetch(url, {
+            headers: {
+                Accept: "application/json",
+                "subscription-key": lmeState.azureMapsKey
+            }
+        });
+        if (!response.ok) {
+            return;
+        }
+        const payload = await response.json();
+        if (lmeState.currentBaseName !== requestedLayer) {
+            return;
+        }
+
+        const attribution = [...new Set((payload.copyrights || []).map(htmlToText).filter(Boolean))].join(" | ");
+        setAzureAttribution(attribution);
+    } catch {
+        clearAzureAttribution();
+    }
+}
+
+function setAzureAttribution(text) {
+    clearAzureAttribution();
+    if (!text) {
+        return;
+    }
+    lmeState.azureAttribution = escapeHtml(text);
+    lmeState.map.attributionControl.addAttribution(lmeState.azureAttribution);
+}
+
+function clearAzureAttribution() {
+    if (lmeState.azureAttribution) {
+        lmeState.map.attributionControl.removeAttribution(lmeState.azureAttribution);
+        lmeState.azureAttribution = null;
+    }
+}
+
+function htmlToText(value) {
+    const element = document.createElement("div");
+    element.innerHTML = String(value || "");
+    return element.textContent?.trim() || "";
 }
 
 function setCadastreOpacity(value) {
@@ -361,6 +756,19 @@ function toggleCadastreLayer(layer, enabled) {
         lmeState.cadastreLayers = lmeState.cadastreLayers.filter(item => item !== layer);
     }
     refreshCadastreLayer();
+    const layerNames = {
+        "CP.CadastralParcel": "Confini particelle",
+        codice_plla: "Numeri particelle",
+        "CP.CadastralZoning": "Fogli catastali",
+        fabbricati: "Fabbricati",
+        strade: "Strade catastali",
+        acque: "Acque"
+    };
+    if (enabled && layer === "codice_plla" && lmeState.map.getZoom() < 17) {
+        setInfo("Numeri particelle attivati. Ingrandisci la mappa almeno fino a zoom 17 per renderli visibili.");
+        return;
+    }
+    setInfo(`${layerNames[layer] || layer}: ${enabled ? "attivo" : "nascosto"}.`);
 }
 
 function refreshCadastreLayer() {
@@ -368,12 +776,14 @@ function refreshCadastreLayer() {
         lmeState.map.removeLayer(lmeState.cadastre);
     }
 
-    if (!lmeState.cadastreLayers.length) {
+    const layers = activeCadastreLayers();
+    lmeState.cadastre = null;
+    if (!layers.length) {
         return;
     }
 
     lmeState.cadastre = L.tileLayer.wms(cadastreUrl(), {
-        layers: lmeState.cadastreLayers.join(","),
+        layers: layers.join(","),
         format: "image/png",
         transparent: true,
         version: "1.3.0",
@@ -384,6 +794,49 @@ function refreshCadastreLayer() {
     }).addTo(lmeState.map);
 }
 
+function activeCadastreLayers() {
+    const drawOrder = [
+        "CP.CadastralZoning",
+        "strade",
+        "acque",
+        "fabbricati",
+        "CP.CadastralParcel",
+        "codice_plla"
+    ];
+    return drawOrder.filter(layer => lmeState.cadastreLayers.includes(layer));
+}
+
+function clearSelectedParcels() {
+    const count = lmeState.selectedParcelsLayer.getLayers().length;
+    lmeState.selectedParcelsLayer.clearLayers();
+    updateGpsInsideState();
+    setInfo(count ? `${count} particelle selezionate rimosse.` : "Non ci sono particelle selezionate da rimuovere.");
+}
+
+function clearMapElements() {
+    const count = lmeState.selectedParcelsLayer.getLayers().length
+        + lmeState.gpsParcelLayer.getLayers().length
+        + lmeState.imported.getLayers().length
+        + lmeState.drawings.getLayers().length
+        + lmeState.gpsTrailPoints.length;
+    if (!count) {
+        setInfo("La mappa non contiene elementi da pulire.");
+        return;
+    }
+    if (!window.confirm("Rimuovere particelle evidenziate, file importati, disegni, POI e traccia GPS dalla mappa?")) {
+        return;
+    }
+
+    lmeState.selectedParcelsLayer.clearLayers();
+    lmeState.gpsParcelLayer.clearLayers();
+    lmeState.imported.clearLayers();
+    lmeState.drawings.clearLayers();
+    lmeState.gpsTrailPoints = [];
+    lmeState.gpsTrail.setLatLngs([]);
+    updateGpsInsideState();
+    setInfo("Elementi della mappa rimossi. Sfondo e layer catastali restano attivi.");
+}
+
 function startGps() {
     if (!navigator.geolocation) {
         setInfo("Geolocalizzazione non disponibile sul dispositivo.");
@@ -469,7 +922,6 @@ function onGpsPosition(position) {
 
     setText("gpsState", `${latitude.toFixed(6)}, ${longitude.toFixed(6)} - precisione ${Math.round(accuracy)} m`);
     updateGpsInsideState();
-    updateOfficialParcelFromPoint(latitude, longitude, accuracy);
 }
 
 function onGpsError(error) {
@@ -483,6 +935,17 @@ function updateGpsInsideState() {
     }
 
     const point = [lmeState.lastPosition[1], lmeState.lastPosition[0]];
+    const officialMatch = findContainingPolygon(point, lmeState.selectedParcelsLayer.toGeoJSON())
+        || findContainingPolygon(point, lmeState.gpsParcelLayer.toGeoJSON());
+    if (officialMatch) {
+        const reference = officialMatch.properties?.NATIONALCADASTRALREFERENCE
+            || officialMatch.properties?.INSPIREID_LOCALID
+            || officialMatch.properties?.LABEL
+            || "particella AdE";
+        setText("parcelState", `Dentro particella AdE: ${reference}`);
+        return;
+    }
+
     const match = findContainingPolygon(point, lmeState.imported.toGeoJSON()) || findContainingPolygon(point, lmeState.drawings.toGeoJSON());
 
     if (match) {
@@ -491,51 +954,11 @@ function updateGpsInsideState() {
         return;
     }
 
-    setText("parcelState", "Fuori dai poligoni caricati");
+    setText(
-}
+        "parcelState",
-
+        lmeState.selectedParcelsLayer.getLayers().length || lmeState.gpsParcelLayer.getLayers().length
-async function updateOfficialParcelFromPoint(latitude, longitude, accuracy) {
+            ? "Fuori dalla particella catastale evidenziata"
-    const now = Date.now();
+            : "Fuori dai poligoni caricati");
-    if (lmeState.wfsLookupInFlight || now - lmeState.lastWfsLookupAt < 2500) {
-        return;
-    }
-
-    lmeState.wfsLookupInFlight = true;
-    lmeState.lastWfsLookupAt = now;
-
-    const meters = Math.max(2, Math.min(Number(accuracy || 5), 25));
-    const deltaLat = meters / 111320;
-    const deltaLon = meters / (111320 * Math.cos(latitude * Math.PI / 180));
-    try {
-        const geojson = await fetchOfficialParcelsByBbox(latitude - deltaLat, longitude - deltaLon, latitude + deltaLat, longitude + deltaLon);
-        const feature = (geojson.features || []).find(item => geometryContainsPoint(item.geometry, [longitude, latitude])) || geojson.features?.[0];
-
-        if (!feature) {
-            return;
-        }
-
-        lmeState.currentParcelLayer.clearLayers();
-        L.geoJSON(feature, {
-            style: { color: "#ef4444", weight: 4, opacity: 1, fillColor: "#fbbf24", fillOpacity: 0.24 }
-        }).addTo(lmeState.currentParcelLayer);
-
-        const ref = feature.properties?.NATIONALCADASTRALREFERENCE || feature.properties?.INSPIREID_LOCALID || feature.properties?.LABEL || "particella AdE";
-        setText("parcelState", `Dentro particella AdE: ${ref}`);
-    } catch (error) {
-        setInfo(`Aggiornamento particella GPS non disponibile: ${error.message}`);
-    } finally {
-        lmeState.wfsLookupInFlight = false;
-    }
-}
-
-async function fetchOfficialParcelsByBbox(south, west, north, east) {
-    const url = `${wfsUrl()}language=ita&SERVICE=WFS&VERSION=2.0.0&TYPENAMES=CP:CadastralParcel&SRSNAME=urn:ogc:def:crs:EPSG::6706&BBOX=${south},${west},${north},${east}&REQUEST=GetFeature&COUNT=20`;
-    const response = await fetch(url);
-    if (!response.ok) {
-        return { type: "FeatureCollection", features: [] };
-    }
-    const xmlText = await response.text();
-    return gmlParcelsToGeoJson(xmlText);
 }
 
 function gmlParcelsToGeoJson(xmlText) {
@@ -634,18 +1057,6 @@ async function queryFeatureInfo(latlng) {
     }
 }
 
-function parseCoordinates(text) {
-    const parts = text.split(/[,\s;]+/).map(Number).filter(value => !Number.isNaN(value));
-    if (parts.length < 2) {
-        return null;
-    }
-    const [lat, lng] = parts;
-    if (Math.abs(lat) <= 90 && Math.abs(lng) <= 180) {
-        return [lat, lng];
-    }
-    return null;
-}
-
 function fitLayer(layer) {
     try {
         const bounds = layer.getBounds();
@@ -661,10 +1072,6 @@ function cadastreUrl() {
     return "https://wms.cartografia.agenziaentrate.gov.it/inspire/wms/ows01.php?language=ita&";
 }
 
-function wfsUrl() {
-    return "https://wfs.cartografia.agenziaentrate.gov.it/inspire/wfs/owfs01.php?";
-}
-
 function setInfo(text) {
     setText("mapInfo", text);
 }

wwwroot/lib/googlemutant/Leaflet.GoogleMutant.js

@@ -0,0 +1,787 @@
+this.L = this.L || {};
+this.L.GridLayer = this.L.GridLayer || {};
+this.L.GridLayer.GoogleMutant = (function (leaflet) {
+	"use strict";
+
+	/**
+	 * GoogleMutant by Iván Sánchez Ortega <ivan@sanchezortega.es> https://ivan.sanchezortega.es
+	 * Source and issue tracking: https://gitlab.com/IvanSanchez/Leaflet.GridLayer.GoogleMutant/
+	 *
+	 * Based on techniques from https://github.com/shramov/leaflet-plugins
+	 * and https://avinmathew.com/leaflet-and-google-maps/ , but relying on MutationObserver.
+	 *
+	 * "THE BEER-WARE LICENSE":
+	 * <ivan@sanchezortega.es> wrote this file. As long as you retain this notice you
+	 * can do whatever you want with this stuff. If we meet some day, and you think
+	 * this stuff is worth it, you can buy me a beer in return.
+	 *
+	 * Uses MIT-licensed code from https://github.com/rsms/js-lru/
+	 */
+
+	// This implementation of LRUMap is a copy of https://github.com/rsms/js-lru/ ,
+	// trivially adapted for ES6 exports.
+
+	/*
+	The MIT License
+
+	Copyright (c) 2010-2020 Rasmus Andersson <https://rsms.me/>
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy
+	of this software and associated documentation files (the "Software"), to deal
+	in the Software without restriction, including without limitation the rights
+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	copies of the Software, and to permit persons to whom the Software is
+	furnished to do so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in
+	all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+	THE SOFTWARE.
+	*/
+
+	/**
+	 * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most
+	 * recently used items while discarding least recently used items when its limit
+	 * is reached.
+	 *
+	 * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>
+	 * See README.md for details.
+	 *
+	 * Illustration of the design:
+	 *
+	 *       entry             entry             entry             entry
+	 *       ______            ______            ______            ______
+	 *      | head |.newer => |      |.newer => |      |.newer => | tail |
+	 *      |  A   |          |  B   |          |  C   |          |  D   |
+	 *      |______| <= older.|______| <= older.|______| <= older.|______|
+	 *
+	 *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
+	 */
+
+	const NEWER = Symbol("newer");
+	const OLDER = Symbol("older");
+
+	class LRUMap {
+		constructor(limit, entries) {
+			if (typeof limit !== "number") {
+				// called as (entries)
+				entries = limit;
+				limit = 0;
+			}
+
+			this.size = 0;
+			this.limit = limit;
+			this.oldest = this.newest = undefined;
+			this._keymap = new Map();
+
+			if (entries) {
+				this.assign(entries);
+				if (limit < 1) {
+					this.limit = this.size;
+				}
+			}
+		}
+
+		_markEntryAsUsed(entry) {
+			if (entry === this.newest) {
+				// Already the most recenlty used entry, so no need to update the list
+				return;
+			}
+			// HEAD--------------TAIL
+			//   <.older   .newer>
+			//  <--- add direction --
+			//   A  B  C  <D>  E
+			if (entry[NEWER]) {
+				if (entry === this.oldest) {
+					this.oldest = entry[NEWER];
+				}
+				entry[NEWER][OLDER] = entry[OLDER]; // C <-- E.
+			}
+			if (entry[OLDER]) {
+				entry[OLDER][NEWER] = entry[NEWER]; // C. --> E
+			}
+			entry[NEWER] = undefined; // D --x
+			entry[OLDER] = this.newest; // D. --> E
+			if (this.newest) {
+				this.newest[NEWER] = entry; // E. <-- D
+			}
+			this.newest = entry;
+		}
+
+		assign(entries) {
+			let entry,
+				limit = this.limit || Number.MAX_VALUE;
+			this._keymap.clear();
+			let it = entries[Symbol.iterator]();
+			for (let itv = it.next(); !itv.done; itv = it.next()) {
+				let e = new Entry(itv.value[0], itv.value[1]);
+				this._keymap.set(e.key, e);
+				if (!entry) {
+					this.oldest = e;
+				} else {
+					entry[NEWER] = e;
+					e[OLDER] = entry;
+				}
+				entry = e;
+				if (limit-- == 0) {
+					throw new Error("overflow");
+				}
+			}
+			this.newest = entry;
+			this.size = this._keymap.size;
+		}
+
+		get(key) {
+			// First, find our cache entry
+			var entry = this._keymap.get(key);
+			if (!entry) return; // Not cached. Sorry.
+			// As <key> was found in the cache, register it as being requested recently
+			this._markEntryAsUsed(entry);
+			return entry.value;
+		}
+
+		set(key, value) {
+			var entry = this._keymap.get(key);
+
+			if (entry) {
+				// update existing
+				entry.value = value;
+				this._markEntryAsUsed(entry);
+				return this;
+			}
+
+			// new entry
+			this._keymap.set(key, (entry = new Entry(key, value)));
+
+			if (this.newest) {
+				// link previous tail to the new tail (entry)
+				this.newest[NEWER] = entry;
+				entry[OLDER] = this.newest;
+			} else {
+				// we're first in -- yay
+				this.oldest = entry;
+			}
+
+			// add new entry to the end of the linked list -- it's now the freshest entry.
+			this.newest = entry;
+			++this.size;
+			if (this.size > this.limit) {
+				// we hit the limit -- remove the head
+				this.shift();
+			}
+
+			return this;
+		}
+
+		shift() {
+			// todo: handle special case when limit == 1
+			var entry = this.oldest;
+			if (entry) {
+				if (this.oldest[NEWER]) {
+					// advance the list
+					this.oldest = this.oldest[NEWER];
+					this.oldest[OLDER] = undefined;
+				} else {
+					// the cache is exhausted
+					this.oldest = undefined;
+					this.newest = undefined;
+				}
+				// Remove last strong reference to <entry> and remove links from the purged
+				// entry being returned:
+				entry[NEWER] = entry[OLDER] = undefined;
+				this._keymap.delete(entry.key);
+				--this.size;
+				return [entry.key, entry.value];
+			}
+		}
+
+		// -------------------------------------------------------------------------------------
+		// Following code (until end of class definition) is optional and can be removed without
+		// breaking the core functionality.
+
+		find(key) {
+			let e = this._keymap.get(key);
+			return e ? e.value : undefined;
+		}
+
+		has(key) {
+			return this._keymap.has(key);
+		}
+
+		delete(key) {
+			var entry = this._keymap.get(key);
+			if (!entry) return;
+			this._keymap.delete(entry.key);
+			if (entry[NEWER] && entry[OLDER]) {
+				// relink the older entry with the newer entry
+				entry[OLDER][NEWER] = entry[NEWER];
+				entry[NEWER][OLDER] = entry[OLDER];
+			} else if (entry[NEWER]) {
+				// remove the link to us
+				entry[NEWER][OLDER] = undefined;
+				// link the newer entry to head
+				this.oldest = entry[NEWER];
+			} else if (entry[OLDER]) {
+				// remove the link to us
+				entry[OLDER][NEWER] = undefined;
+				// link the newer entry to head
+				this.newest = entry[OLDER];
+			} else {
+				// if(entry[OLDER] === undefined && entry.newer === undefined) {
+				this.oldest = this.newest = undefined;
+			}
+
+			this.size--;
+			return entry.value;
+		}
+
+		clear() {
+			// Not clearing links should be safe, as we don't expose live links to user
+			this.oldest = this.newest = undefined;
+			this.size = 0;
+			this._keymap.clear();
+		}
+
+		keys() {
+			return new KeyIterator(this.oldest);
+		}
+
+		values() {
+			return new ValueIterator(this.oldest);
+		}
+
+		entries() {
+			return this;
+		}
+
+		[Symbol.iterator]() {
+			return new EntryIterator(this.oldest);
+		}
+
+		forEach(fun, thisObj) {
+			if (typeof thisObj !== "object") {
+				thisObj = this;
+			}
+			let entry = this.oldest;
+			while (entry) {
+				fun.call(thisObj, entry.value, entry.key, this);
+				entry = entry[NEWER];
+			}
+		}
+
+		/** Returns a JSON (array) representation */
+		toJSON() {
+			var s = new Array(this.size),
+				i = 0,
+				entry = this.oldest;
+			while (entry) {
+				s[i++] = { key: entry.key, value: entry.value };
+				entry = entry[NEWER];
+			}
+			return s;
+		}
+
+		/** Returns a String representation */
+		toString() {
+			var s = "",
+				entry = this.oldest;
+			while (entry) {
+				s += String(entry.key) + ":" + entry.value;
+				entry = entry[NEWER];
+				if (entry) {
+					s += " < ";
+				}
+			}
+			return s;
+		}
+	}
+
+	function Entry(key, value) {
+		this.key = key;
+		this.value = value;
+		this[NEWER] = undefined;
+		this[OLDER] = undefined;
+	}
+
+	function EntryIterator(oldestEntry) {
+		this.entry = oldestEntry;
+	}
+	EntryIterator.prototype[Symbol.iterator] = function () {
+		return this;
+	};
+	EntryIterator.prototype.next = function () {
+		let ent = this.entry;
+		if (ent) {
+			this.entry = ent[NEWER];
+			return { done: false, value: [ent.key, ent.value] };
+		} else {
+			return { done: true, value: undefined };
+		}
+	};
+
+	function KeyIterator(oldestEntry) {
+		this.entry = oldestEntry;
+	}
+	KeyIterator.prototype[Symbol.iterator] = function () {
+		return this;
+	};
+	KeyIterator.prototype.next = function () {
+		let ent = this.entry;
+		if (ent) {
+			this.entry = ent[NEWER];
+			return { done: false, value: ent.key };
+		} else {
+			return { done: true, value: undefined };
+		}
+	};
+
+	function ValueIterator(oldestEntry) {
+		this.entry = oldestEntry;
+	}
+	ValueIterator.prototype[Symbol.iterator] = function () {
+		return this;
+	};
+	ValueIterator.prototype.next = function () {
+		let ent = this.entry;
+		if (ent) {
+			this.entry = ent[NEWER];
+			return { done: false, value: ent.value };
+		} else {
+			return { done: true, value: undefined };
+		}
+	};
+
+	// GoogleMutant by Iván Sánchez Ortega <ivan@sanchezortega.es>
+
+	function waitForAPI(callback, context) {
+		let checkCounter = 0,
+			intervalId = null;
+
+		intervalId = setInterval(function () {
+			if (checkCounter >= 20) {
+				clearInterval(intervalId);
+				throw new Error("window.google not found after 10 seconds");
+			}
+			if (!!window.google && !!window.google.maps && !!window.google.maps.Map) {
+				clearInterval(intervalId);
+				callback.call(context);
+			}
+			++checkCounter;
+		}, 500);
+	}
+
+	// 🍂class GridLayer.GoogleMutant
+	// 🍂extends GridLayer
+	class GoogleMutant extends leaflet.GridLayer {
+		static {
+			// Try to set default option values the Leaflet 2 way
+			if (this.setDefaultOptions) {
+				this.setDefaultOptions({
+					maxZoom: 21, // can be 23, but ugly if more than maxNativeZoom
+					// 🍂option type: String = 'roadmap'
+					// Google's map type. Valid values are 'roadmap', 'satellite', 'terrain' or 'hybrid'.
+					type: "roadmap",
+					maxNativeZoom: 21,
+				});
+			} else {
+				// If Leaflet v2 is not available, fall back.
+				this.options ??= {};
+				this.options.maxZoom ??= 21;
+				this.options.type ??= "roadmap";
+				this.options.maxNativeZoom ??= 21;
+			}
+		}
+
+		constructor(options) {
+			super(options);
+
+			// Couple data structures indexed by tile key
+			this._tileCallbacks = {}; // Callbacks for promises for tiles that are expected
+			this._lru = new LRUMap(100); // Tile LRU cache
+
+			// Before 2024(ish), Google used two tiles for hybrid mode, reusing
+			// the aerial tiles. This seems to be no longer the case.
+			// this._imagesPerTile = this.options.type === "hybrid" ? 2 : 1;
+			this._imagesPerTile = 1;
+
+			this._boundOnMutatedImage = this._onMutatedImage.bind(this);
+		}
+
+		onAdd(map) {
+			super.onAdd(map);
+			this._initMutantContainer();
+
+			// Attribution and logo nodes are not mutated a second time if the
+			// mutant is removed and re-added to the map, hence they are
+			// not cleaned up on layer removal, so they can be added here.
+			if (this._logoContainer) {
+				map._controlCorners.bottomleft.appendChild(this._logoContainer);
+			}
+			if (this._attributionContainer) {
+				map._controlCorners.bottomright.appendChild(this._attributionContainer);
+			}
+
+			waitForAPI(() => {
+				if (!this._map) {
+					return;
+				}
+				this._initMutant();
+
+				//handle layer being added to a map for which there are no Google tiles at the given zoom
+				google.maps.event.addListenerOnce(this._mutant, "idle", () => {
+					if (!this._map) {
+						return;
+					}
+					this._checkZoomLevels();
+					this._mutantIsReady = true;
+				});
+			});
+		}
+
+		onRemove(map) {
+			super.onRemove(map);
+			this._observer.disconnect();
+			map._container.removeChild(this._mutantContainer);
+			this._logoContainer?.remove();
+			this._attributionContainer?.remove();
+			if (this._mutant) {
+				google.maps.event.clearListeners(this._mutant, "idle");
+			}
+		}
+
+		// 🍂method addGoogleLayer(name: String, options?: Object): this
+		// Adds layer with the given name and options to the google Map instance.
+		// `name`: one of the google maps API layers, with it's constructor available in `google.maps` object.
+		// currently following values supported: 'TrafficLayer', 'TransitLayer', 'BicyclingLayer'.
+		// `options`: see https://developers.google.com/maps/documentation/javascript/reference/map
+		addGoogleLayer(googleLayerName, options) {
+			if (!this._subLayers) this._subLayers = {};
+			this.whenReady(() => {
+				var Constructor = google.maps[googleLayerName];
+				var googleLayer = new Constructor(options);
+				googleLayer.setMap(this._mutant);
+				this._subLayers[googleLayerName] = googleLayer;
+			});
+			return this;
+		}
+
+		// 🍂method removeGoogleLayer(name: String): this
+		// Removes layer with the given name from the google Map instance.
+		removeGoogleLayer(googleLayerName) {
+			this.whenReady(() => {
+				var googleLayer = this._subLayers && this._subLayers[googleLayerName];
+				if (googleLayer) {
+					googleLayer.setMap(null);
+					delete this._subLayers[googleLayerName];
+				}
+			});
+			return this;
+		}
+
+		_initMutantContainer() {
+			if (!this._mutantContainer) {
+				this._mutantContainer = leaflet.DomUtil.create(
+					"div",
+					"leaflet-google-mutant leaflet-top leaflet-left"
+				);
+				this._mutantContainer.id =
+					"_MutantContainer_" + leaflet.Util.stamp(this._mutantContainer);
+				this._mutantContainer.style.pointerEvents = "none";
+				this._mutantContainer.style.visibility = "hidden";
+
+				leaflet.DomEvent.off(this._mutantContainer);
+			}
+			this._map.getContainer().appendChild(this._mutantContainer);
+
+			this.setOpacity(this.options.opacity);
+			const style = this._mutantContainer.style;
+			if (this._map.options.zoomSnap < 1) {
+				// Fractional zoom needs a bigger mutant container in order to load more (smaller) tiles
+				style.width = "180%";
+				style.height = "180%";
+			} else {
+				style.width = "100%";
+				style.height = "100%";
+			}
+			style.zIndex = -1;
+
+			this._attachObserver(this._mutantContainer);
+		}
+
+		_initMutant() {
+			if (this._mutant) {
+				return;
+			}
+
+			var options = {
+				center: { lat: 0, lng: 0 },
+				zoom: 0,
+				tilt: 0,
+				mapTypeId: this.options.type,
+				disableDefaultUI: true,
+				keyboardShortcuts: false,
+				draggable: false,
+				disableDoubleClickZoom: true,
+				scrollwheel: false,
+				styles: this.options.styles || [],
+				backgroundColor: "transparent",
+			};
+			if (this.options.mapId != null) {
+				options.mapId = this.options.mapId;
+			}
+			var map = new google.maps.Map(this._mutantContainer, options);
+
+			this._mutant = map;
+
+			this._update();
+
+			// 🍂event spawned
+			// Fired when the mutant has been created.
+			this.fire("spawned", { mapObject: map });
+
+			this._waitControls();
+			this.once("controls_ready", this._setupAttribution);
+		}
+
+		_attachObserver(node) {
+			if (!this._observer)
+				this._observer = new MutationObserver(this._onMutations.bind(this));
+
+			// pass in the target node, as well as the observer options
+			this._observer.observe(node, { childList: true, subtree: true });
+
+			// if we are reusing an old _mutantContainer, we must manually detect
+			// all existing tiles in it
+			Array.prototype.forEach.call(node.querySelectorAll("img"), this._boundOnMutatedImage);
+		}
+
+		_waitControls() {
+			const id = setInterval(() => {
+				const layoutManager = this._mutant.__gm.layoutManager;
+				if (!layoutManager) {
+					return;
+				}
+				clearInterval(id);
+				let positions;
+				// iterate through obfuscated key names to find positions set (atm: layoutManager.o)
+				Object.keys(layoutManager).forEach(function (key) {
+					const el = layoutManager[key];
+					if (el.get) {
+						if (el.get(1) instanceof Node) {
+							positions = el;
+						}
+					}
+				});
+				// 🍂event controls_ready
+				// Fired when controls positions get available (passed in `positions` property).
+				this.fire("controls_ready", { positions });
+			}, 50);
+		}
+
+		_setupAttribution(ev) {
+			if (!this._map) {
+				return;
+			}
+			// https://developers.google.com/maps/documentation/javascript/reference/control#ControlPosition
+			const pos = google.maps.ControlPosition;
+			const ctr = (this._attributionContainer = ev.positions.get(pos.BOTTOM_RIGHT));
+			ctr.classList.add("leaflet-control", "leaflet-control-attribution");
+			leaflet.DomEvent.disableClickPropagation(ctr);
+			ctr.style.height = "14px";
+			this._map._controlCorners.bottomright.appendChild(ctr);
+
+			this._logoContainer = ev.positions.get(pos.BOTTOM_LEFT);
+			this._logoContainer.style.pointerEvents = "auto";
+			this._map._controlCorners.bottomleft.appendChild(this._logoContainer);
+		}
+
+		_onMutations(mutations) {
+			for (var i = 0; i < mutations.length; ++i) {
+				var mutation = mutations[i];
+				for (var j = 0; j < mutation.addedNodes.length; ++j) {
+					var node = mutation.addedNodes[j];
+
+					if (node instanceof HTMLImageElement) {
+						this._onMutatedImage(node);
+					} else if (node instanceof HTMLElement) {
+						Array.prototype.forEach.call(
+							node.querySelectorAll("img"),
+							this._boundOnMutatedImage
+						);
+					}
+				}
+			}
+		}
+
+		// Only images which 'src' attrib match this will be considered for moving around.
+		// Looks like some kind of string-based protobuf, maybe??
+		// Only the roads (and terrain, and vector-based stuff) match this pattern
+		_roadRegexp = /!1i(\d+)!2i(\d+)!3i(\d+|VinaFnapurmBegrtn)!/;
+
+		// On the other hand, raster imagery matches this other pattern
+		_satRegexp = /x=(\d+)&y=(\d+)&z=(\d+|VinaFnapurmBegrtn)/;
+
+		_onMutatedImage(imgNode) {
+			let coords;
+			let match = imgNode.src.match(this._roadRegexp);
+			let sublayer = 0;
+
+			if (match) {
+				coords = {
+					z: match[1],
+					x: match[2],
+					y: match[3],
+				};
+				if (this._imagesPerTile > 1) {
+					imgNode.style.zIndex = 1;
+					sublayer = 1;
+				}
+			} else {
+				match = imgNode.src.match(this._satRegexp);
+				if (match) {
+					coords = {
+						x: match[1],
+						y: match[2],
+						z: match[3],
+					};
+				}
+				// imgNode.style.zIndex = 0;
+				sublayer = 0;
+			}
+
+			if (coords) {
+				var tileKey = this._tileCoordsToKey(coords);
+				imgNode.style.position = "absolute";
+
+				var key = tileKey + "/" + sublayer;
+				// Cache img so it can also be used in subsequent tile requests
+				this._lru.set(key, imgNode);
+
+				if (key in this._tileCallbacks && this._tileCallbacks[key]) {
+					// Use the tile for *all* pending callbacks. They'll be cloned anyway.
+					this._tileCallbacks[key].forEach((callback) => callback(imgNode));
+					delete this._tileCallbacks[key];
+				}
+			}
+		}
+
+		createTile(coords, done) {
+			const key = this._tileCoordsToKey(coords),
+				tileContainer = leaflet.DomUtil.create("div");
+
+			tileContainer.style.textAlign = "left";
+			tileContainer.dataset.pending = this._imagesPerTile;
+			done = done.bind(this, null, tileContainer);
+
+			for (var i = 0; i < this._imagesPerTile; ++i) {
+				const key2 = key + "/" + i,
+					imgNode = this._lru.get(key2);
+				if (imgNode) {
+					tileContainer.appendChild(this._clone(imgNode));
+					--tileContainer.dataset.pending;
+				} else {
+					this._tileCallbacks[key2] = this._tileCallbacks[key2] || [];
+					this._tileCallbacks[key2].push(
+						function (c /*, k2*/) {
+							return function (imgNode) {
+								c.appendChild(this._clone(imgNode));
+								--c.dataset.pending;
+								if (!parseInt(c.dataset.pending)) {
+									done();
+								}
+							}.bind(this);
+						}.bind(this)(tileContainer /*, key2*/)
+					);
+				}
+			}
+
+			if (!parseInt(tileContainer.dataset.pending)) {
+				leaflet.Util.requestAnimFrame(done);
+			}
+			return tileContainer;
+		}
+
+		_clone(imgNode) {
+			const clonedImgNode = imgNode.cloneNode(true);
+			clonedImgNode.style.visibility = "visible";
+			return clonedImgNode;
+		}
+
+		_checkZoomLevels() {
+			//setting the zoom level on the Google map may result in a different zoom level than the one requested
+			//(it won't go beyond the level for which they have data).
+			const zoomLevel = this._map.getZoom(),
+				gMapZoomLevel = this._mutant.getZoom();
+
+			if (!zoomLevel || !gMapZoomLevel) return;
+
+			if (
+				gMapZoomLevel !== zoomLevel || //zoom levels are out of sync, Google doesn't have data
+				gMapZoomLevel > this.options.maxNativeZoom
+			) {
+				//at current location, Google does have data (contrary to maxNativeZoom)
+				//Update maxNativeZoom
+				this._setMaxNativeZoom(gMapZoomLevel);
+			}
+		}
+
+		_setMaxNativeZoom(zoomLevel) {
+			if (zoomLevel !== this.options.maxNativeZoom) {
+				this.options.maxNativeZoom = zoomLevel;
+				this._resetView();
+			}
+		}
+
+		_update(center) {
+			// zoom level check needs to happen before super's implementation (tile addition/creation)
+			// otherwise tiles may be missed if maxNativeZoom is not yet correctly determined
+			if (this._mutant) {
+				center = center || this._map.getCenter();
+				const _center = new google.maps.LatLng(center.lat, center.lng),
+					zoom = Math.round(this._map.getZoom()),
+					mutantZoom = this._mutant.getZoom();
+
+				this._mutant.setCenter(_center);
+
+				//ignore fractional zoom levels
+				if (zoom !== mutantZoom) {
+					this._mutant.setZoom(zoom);
+
+					if (this._mutantIsReady) this._checkZoomLevels();
+					//else zoom level check will be done later by 'idle' handler
+				}
+			}
+
+			super._update(center);
+		}
+
+		// @method whenReady(fn: Function, context?: Object): this
+		// Runs the given function `fn` when the mutant gets initialized, or immediately
+		// if it's already initialized, optionally passing a function context.
+		whenReady(callback, context) {
+			if (this._mutant) {
+				callback.call(context || this, { target: this });
+			} else {
+				this.on("spawned", callback, context);
+			}
+			return this;
+		}
+	}
+
+	// 🍂factory gridLayer.googleMutant(options)
+	// Returns a new `GridLayer.GoogleMutant` given its options
+	if (L && L.gridLayer) {
+		L.gridLayer.googleMutant = function (options) {
+			return new L.GridLayer.GoogleMutant(options);
+		};
+	}
+
+	return GoogleMutant;
+})(L);
+//# sourceMappingURL=Leaflet.GoogleMutant.js.map