using System.Collections.Concurrent;
using System.Globalization;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using LeafletForBlazor;
using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
using RutasDBUS.Modelos.Geocodificacion;
using RutasDBUS.Modelos.Planificacion;
using RutasDBUS.Modelos.RedBus;
using RutasDBUS.Servicios;
using RutasDBUS.Servicios.Caminata;
using RutasDBUS.Servicios.Elevacion;
using RutasDBUS.Servicios.Horarios;
using RutasDBUS.Servicios.Planificacion;
using RutasDBUS.Servicios.RedBus;

namespace RutasDBUS.Components.Pages;

public partial class PlanificadorRutas : ComponentBase
{

        private IReadOnlyList<int> ObtenerLineasPermitidasSeleccionadas()
            => _lineasPermitidas
                .Where(linea => linea > 0)
                .Distinct()
                .OrderBy(linea => linea)
                .ToList();

        private IReadOnlyList<int> LineasFiltroDisponibles()
        {
            var lineas = _infoVariantes
                .Select(CodigoLineaAsInt)
                .Concat(RedBusServicio.Lineas.Select(CodigoLineaAsInt))
                .Where(linea => linea != int.MaxValue && linea > 0)
                .Distinct()
                .OrderBy(linea => linea)
                .ToList();

            if (lineas.Count > 0)
                return lineas;

            return _lineasPermitidas
                .Where(linea => linea > 0)
                .Distinct()
                .OrderBy(linea => linea)
                .ToList();
        }

        private bool LineaFiltroSeleccionada(int linea)
            => _lineasPermitidas.Contains(linea);

        private bool TodasLineasFiltroSeleccionadas()
        {
            var disponibles = LineasFiltroDisponibles();
            return disponibles.Count > 0 && disponibles.All(_lineasPermitidas.Contains);
        }

        private string TextoBotonTodasLineasPermitidas()
            => TodasLineasFiltroSeleccionadas() ? "Ninguna" : "Todas";

        private string TextoResumenLineasPermitidas()
        {
            var seleccionadas = ObtenerLineasPermitidasSeleccionadas();
            var disponibles = LineasFiltroDisponibles();
            if (seleccionadas.Count == 0)
                return "Ninguna linea seleccionada";

            if (disponibles.Count > 0 && seleccionadas.Count >= disponibles.Count)
                return $"Todas las lineas ({disponibles.Count})";

            return seleccionadas.Count <= 12
                ? string.Join(", ", seleccionadas)
                : $"{seleccionadas.Count} lineas seleccionadas";
        }

        private async Task ToggleLineaFiltroAsync(int linea, ChangeEventArgs args)
        {
            var seleccionada = args.Value is bool valor && valor;
            if (seleccionada)
                _lineasPermitidas.Add(linea);
            else
                _lineasPermitidas.Remove(linea);

            _busFilteredCache.Clear();
            await PersistirConfiguracionAsync();
        }

        private async Task ToggleTodasLineasPermitidasAsync()
        {
            var disponibles = LineasFiltroDisponibles();
            if (disponibles.Count > 0 && disponibles.All(_lineasPermitidas.Contains))
            {
                _lineasPermitidas.Clear();
            }
            else
            {
                foreach (var linea in disponibles)
                    _lineasPermitidas.Add(linea);
            }

            _busFilteredCache.Clear();
            await PersistirConfiguracionAsync();
        }

        /// <summary>
        /// Actualiza las alturas de origen y destino con la fuente seleccionada para el calculo.
        /// </summary>
        private async Task ActualizarAlturasResumenRutaAsync(CancellationToken ct)
        {
            if (_coordenadasOrigen is null || _coordenadasDestino is null)
            {
                _altitudOrigenResumenRuta = null;
                _altitudDestinoResumenRuta = null;
                return;
            }

            var origen = (_coordenadasOrigen[0], _coordenadasOrigen[1]);
            var destino = (_coordenadasDestino[0], _coordenadasDestino[1]);

            try
            {
                var puntos = new List<(double lat, double lon)> { origen, destino };
                await AsegurarElevacionesFuenteCalculoAsync(puntos, ct);

                _altitudOrigenResumenRuta = ObtenerElevacionFuenteCalculo(origen.Item1, origen.Item2);
                _altitudDestinoResumenRuta = ObtenerElevacionFuenteCalculo(destino.Item1, destino.Item2);
            }
            catch
            {
                _altitudOrigenResumenRuta = null;
                _altitudDestinoResumenRuta = null;
            }
        }

        private async Task ActualizarCallejeroResumenRutaAsync(CancellationToken ct)
        {
            if (_coordenadasOrigen is null || _coordenadasDestino is null)
            {
                _callejeroOrigenResumenRuta = null;
                _callejeroDestinoResumenRuta = null;
                return;
            }

            try
            {
                var origen = await GeocodificadorLocal.BuscarMasCercanoAsync(
                    _coordenadasOrigen[0],
                    _coordenadasOrigen[1],
                    ct);

                var destino = await GeocodificadorLocal.BuscarMasCercanoAsync(
                    _coordenadasDestino[0],
                    _coordenadasDestino[1],
                    ct);

                _callejeroOrigenResumenRuta = FormatearLugarCallejeroResumen(origen);
                _callejeroDestinoResumenRuta = FormatearLugarCallejeroResumen(destino);
            }
            catch
            {
                _callejeroOrigenResumenRuta = null;
                _callejeroDestinoResumenRuta = null;
            }
        }

        private async Task ActualizarResumenTecnicoRutaAsync(CancellationToken ct)
        {
            await ActualizarAlturasResumenRutaAsync(ct);
            await ActualizarCallejeroResumenRutaAsync(ct);
        }
    
    
        private static readonly ConcurrentDictionary<string, double> _elevIdeeCache =
            new(StringComparer.OrdinalIgnoreCase);
        private static readonly ConcurrentDictionary<string, double> _elevLocal5Cache =
            new(StringComparer.OrdinalIgnoreCase);
        private static readonly ConcurrentDictionary<string, double> _elevLocal2Cache =
            new(StringComparer.OrdinalIgnoreCase);
        private static readonly ConcurrentDictionary<string, double> _elevLocal1Cache =
            new(StringComparer.OrdinalIgnoreCase);
        private static readonly SemaphoreSlim _semaforoElevacionIdee = new(1, 1);
        private static long _ideeReintentarDespuesTicksUtc;

        private const string FuenteElevacionLocal5 = "local5";
        private const string FuenteElevacionLocal2 = "local2";
        private const string FuenteElevacionLocal1 = "local1";
        private const string FuenteElevacionIdee = "idee";
        private const int TiempoMaximoIdeeSegundos = 10;
        private string _fuenteElevacionCalculo = FuenteElevacionLocal5;
    
        // IDEE: en el correo indican que 6 decimales es suficiente
        private const int ELEV_IDEE_DECIMALES_CACHE = 6;
    
        /// <summary>
        /// Gestiona idee clave.
        /// </summary>
        private static string ClaveElevacionIdee(double lat, double lon)
        {
            double rLat = Math.Round(lat, ELEV_IDEE_DECIMALES_CACHE);
            double rLon = Math.Round(lon, ELEV_IDEE_DECIMALES_CACHE);
            return $"{rLat.ToString("0.000000", CultureInfo.InvariantCulture)},{rLon.ToString("0.000000", CultureInfo.InvariantCulture)}";
        }

        private static string NormalizarFuenteElevacion(string? fuente)
        {
            if (string.Equals(fuente, FuenteElevacionIdee, StringComparison.OrdinalIgnoreCase))
                return FuenteElevacionIdee;
            if (string.Equals(fuente, FuenteElevacionLocal1, StringComparison.OrdinalIgnoreCase))
                return FuenteElevacionLocal1;
            if (string.Equals(fuente, FuenteElevacionLocal2, StringComparison.OrdinalIgnoreCase))
                return FuenteElevacionLocal2;
            if (string.Equals(fuente, FuenteElevacionLocal5, StringComparison.OrdinalIgnoreCase) ||
                string.Equals(fuente, "local", StringComparison.OrdinalIgnoreCase))
            {
                return FuenteElevacionLocal5;
            }

            return FuenteElevacionLocal5;
        }

        private bool ElevacionLocal5Disponible
            => ElevacionLocal.EstaDisponible(ModeloElevacionLocal.Local5);

        private bool ElevacionLocal2Disponible
            => ElevacionLocal.EstaDisponible(ModeloElevacionLocal.Local2);

        private bool ElevacionLocal1Disponible
            => ElevacionLocal.EstaDisponible(ModeloElevacionLocal.Local1);

        private bool UsarElevacionLocal5ParaCalculo
            => string.Equals(_fuenteElevacionCalculo, FuenteElevacionLocal5, StringComparison.OrdinalIgnoreCase)
               && ElevacionLocal5Disponible;

        private bool UsarElevacionLocal2ParaCalculo
            => string.Equals(_fuenteElevacionCalculo, FuenteElevacionLocal2, StringComparison.OrdinalIgnoreCase)
               && ElevacionLocal2Disponible;

        private bool UsarElevacionLocal1ParaCalculo
            => string.Equals(_fuenteElevacionCalculo, FuenteElevacionLocal1, StringComparison.OrdinalIgnoreCase)
               && ElevacionLocal1Disponible;

        private string EtiquetaFuenteElevacionCalculo
            => UsarElevacionLocal1ParaCalculo
                ? "Altura (L1)"
                : UsarElevacionLocal2ParaCalculo
                    ? "Altura (L2)"
                : UsarElevacionLocal5ParaCalculo
                        ? "Altura (L5)"
                        : "Altura (G)";

        private double? ObtenerElevacionFuenteCalculo(double lat, double lon)
        {
            var clave = ClaveElevacionIdee(lat, lon);
            if (UsarElevacionLocal1ParaCalculo)
                return _elevLocal1Cache.TryGetValue(clave, out var local1) ? local1 : null;
            if (UsarElevacionLocal2ParaCalculo)
                return _elevLocal2Cache.TryGetValue(clave, out var local2) ? local2 : null;
            if (UsarElevacionLocal5ParaCalculo)
                return _elevLocal5Cache.TryGetValue(clave, out var local5) ? local5 : null;

            return _elevIdeeCache.TryGetValue(clave, out var idee) ? idee : null;
        }

        private double? ObtenerElevacionFuenteCalculo(MuestraElevacion muestra)
            => UsarElevacionLocal1ParaCalculo
                ? muestra.ElevacionLocal1
                : UsarElevacionLocal2ParaCalculo
                    ? muestra.ElevacionLocal2
                : UsarElevacionLocal5ParaCalculo
                        ? muestra.ElevacionLocal5
                        : muestra.ElevacionIdee;

        private void ObtenerElevacionesLocalesPorLote(
            ModeloElevacionLocal modelo,
            ConcurrentDictionary<string, double> cache,
            IReadOnlyList<(double lat, double lon)> puntos)
        {
            if (!ElevacionLocal.EstaDisponible(modelo) || puntos.Count == 0)
                return;

            var pendientes = puntos
                .Where(punto => !cache.ContainsKey(ClaveElevacionIdee(punto.lat, punto.lon)))
                .Distinct()
                .ToList();
            if (pendientes.Count == 0)
                return;

            var elevaciones = ElevacionLocal.ObtenerElevaciones(modelo, pendientes);
            for (var i = 0; i < pendientes.Count && i < elevaciones.Count; i++)
            {
                if (elevaciones[i] is { } elevacion && double.IsFinite(elevacion))
                    cache[ClaveElevacionIdee(pendientes[i].lat, pendientes[i].lon)] = elevacion;
            }
        }

        private void ObtenerElevacionesLocal5PorLote(IReadOnlyList<(double lat, double lon)> puntos)
            => ObtenerElevacionesLocalesPorLote(
                ModeloElevacionLocal.Local5,
                _elevLocal5Cache,
                puntos);

        private void ObtenerElevacionesLocal2PorLote(IReadOnlyList<(double lat, double lon)> puntos)
            => ObtenerElevacionesLocalesPorLote(
                ModeloElevacionLocal.Local2,
                _elevLocal2Cache,
                puntos);

        private void ObtenerElevacionesLocal1PorLote(IReadOnlyList<(double lat, double lon)> puntos)
            => ObtenerElevacionesLocalesPorLote(
                ModeloElevacionLocal.Local1,
                _elevLocal1Cache,
                puntos);

        private void ObtenerElevacionesLocalesComparativasPorLote(
            IReadOnlyList<(double lat, double lon)> puntos)
        {
            ObtenerElevacionesLocal5PorLote(puntos);
            ObtenerElevacionesLocal2PorLote(puntos);
            ObtenerElevacionesLocal1PorLote(puntos);
        }

        private async Task AsegurarElevacionesFuenteCalculoAsync(
            IReadOnlyList<(double lat, double lon)> puntos,
            CancellationToken ct)
        {
            if (UsarElevacionLocal1ParaCalculo)
            {
                ObtenerElevacionesLocal1PorLote(puntos);
                return;
            }
            if (UsarElevacionLocal2ParaCalculo)
            {
                ObtenerElevacionesLocal2PorLote(puntos);
                return;
            }
            if (UsarElevacionLocal5ParaCalculo)
            {
                ObtenerElevacionesLocal5PorLote(puntos);
                return;
            }

            var faltan = puntos
                .Where(punto => !_elevIdeeCache.ContainsKey(ClaveElevacionIdee(punto.lat, punto.lon)))
                .Distinct()
                .ToList();
            for (var i = 0; i < faltan.Count; i += ELEV_BATCH_MAX_PUNTOS)
            {
                ct.ThrowIfCancellationRequested();
                await ObtenerElevacionesIdeePorLoteAsync(
                    faltan.Skip(i).Take(ELEV_BATCH_MAX_PUNTOS).ToList(),
                    ct);
            }
        }

        private sealed class RespuestaElevacionIdee
        {
            public string? id { get; set; }
            public List<double>? values { get; set; }
        }
    
        /// <summary>
        /// Recupera elevations idee el lote.
        /// </summary>
        private async Task ObtenerElevacionesIdeePorLoteAsync(List<(double lat, double lon)> points, CancellationToken ct)
        {
            if (points.Count == 0 || DateTime.UtcNow.Ticks < Interlocked.Read(ref _ideeReintentarDespuesTicksUtc))
                return;

            await _semaforoElevacionIdee.WaitAsync(ct);
            try
            {
                if (DateTime.UtcNow.Ticks < Interlocked.Read(ref _ideeReintentarDespuesTicksUtc))
                    return;

                points = points
                    .Where(punto => !_elevIdeeCache.ContainsKey(ClaveElevacionIdee(punto.lat, punto.lon)))
                    .Distinct()
                    .ToList();
                if (points.Count == 0)
                    return;
    
            // Construir FeatureCollection GeoJSON, OJO: coordinates = [lon, lat]
            var features = new List<object>(points.Count);
            foreach (var (lat, lon) in points)
            {
                ct.ThrowIfCancellationRequested();
    
                double rLat = Math.Round(lat, ELEV_IDEE_DECIMALES_CACHE);
                double rLon = Math.Round(lon, ELEV_IDEE_DECIMALES_CACHE);
    
                features.Add(new
                {
                    type = "Feature",
                    geometry = new
                    {
                        type = "Point",
                        coordinates = new[] { rLon, rLat }
                    }
                });
            }
    
            var geomObj = new
            {
                type = "FeatureCollection",
                features
            };
    
            // En la API, "geom" va como STRING con el JSON dentro
            string geomJson = JsonSerializer.Serialize(geomObj);
    
            var body = new
            {
                inputs = new
                {
                    crs = 4326,
                    formato = "geojson",
                    geom = geomJson,
                    outputFormat = "array",
                    withCoord = false
                }
            };
    
            const string url = "https://api-processes.idee.es/processes/getElevation/execution";
    
            try
            {
                using var limite = CancellationTokenSource.CreateLinkedTokenSource(ct);
                limite.CancelAfter(TimeSpan.FromSeconds(TiempoMaximoIdeeSegundos));
                using var req = new HttpRequestMessage(HttpMethod.Post, url);
                req.Headers.Accept.ParseAdd("application/json");
                req.Content = new StringContent(JsonSerializer.Serialize(body), System.Text.Encoding.UTF8, "application/json");
    
                using var resp = await Http.SendAsync(req, limite.Token);
                if (!resp.IsSuccessStatusCode)
                {
                    PosponerConsultasIdee(TimeSpan.FromSeconds(15));
                    return;
                }
    
                var json = await resp.Content.ReadAsStringAsync(limite.Token);
    
                var data = JsonSerializer.Deserialize<RespuestaElevacionIdee>(json, new JsonSerializerOptions
                {
                    PropertyNameCaseInsensitive = true
                });
    
                if (data?.values is null || data.values.Count == 0) return;
    
                // values viene en el mismo orden que mandas los puntos
                int n = Math.Min(points.Count, data.values.Count);
                for (int i = 0; i < n; i++)
                {
                    var (lat, lon) = points[i];
                    var k = ClaveElevacionIdee(lat, lon);
                    _elevIdeeCache[k] = data.values[i];
                }

                Interlocked.Exchange(ref _ideeReintentarDespuesTicksUtc, 0);
            }
            catch (OperationCanceledException) when (ct.IsCancellationRequested)
            {
                throw;
            }
            catch (OperationCanceledException)
            {
                PosponerConsultasIdee(TimeSpan.FromSeconds(45));
            }
            catch
            {
                PosponerConsultasIdee(TimeSpan.FromSeconds(20));
                // silencioso: elevación es informativa
            }
            }
            finally
            {
                _semaforoElevacionIdee.Release();
            }
        }

        private static void PosponerConsultasIdee(TimeSpan demora)
            => Interlocked.Exchange(
                ref _ideeReintentarDespuesTicksUtc,
                DateTime.UtcNow.Add(demora).Ticks);

        // Ajustes (rendimiento)
        /*     private const int ELEV_MAX_PUNTOS_POR_TRAMO = 24; */
        private int _elevMaxPuntosPorTramo = 999; // configurable
        // muestreo por tramo
        private const int ELEV_BATCH_MAX_PUNTOS = 90;         // por request (prudente)
    
        private static List<(double lat, double lon)> SampleLine(double[,] line, int maxPoints)
        {
            int n = line.GetLength(0);
            if (n <= 0) return new();
    
            if (maxPoints < 2) maxPoints = 2;
    
            if (n <= maxPoints)
            {
                var all = new List<(double, double)>(n);
                for (int i = 0; i < n; i++)
                    all.Add((line[i, 0], line[i, 1]));
                return all;
            }
    
            // muestreo equiespaciado incluyendo extremos
            var res = new List<(double, double)>(maxPoints);
            for (int i = 0; i < maxPoints; i++)
            {
                double t = (maxPoints == 1) ? 0 : (double)i / (maxPoints - 1);
                int idx = (int)Math.Round(t * (n - 1));
                if (idx < 0) idx = 0;
                if (idx >= n) idx = n - 1;
    
                var p = (line[idx, 0], line[idx, 1]);
                if (res.Count == 0 || res[^1].Item1 != p.Item1 || res[^1].Item2 != p.Item2)
                    res.Add(p);
            }
    
            return res;
        }
    
    
    
    
    
        /// <summary>
        /// Construye elev samples.
        /// </summary>
        private async Task<List<MuestraElevacion>> ConstruirMuestrasElevacionAsync(double[,] line, CancellationToken ct)
        {
            var sampled = SampleLine(line, _elevMaxPuntosPorTramo);
            await AsegurarElevacionesFuenteCalculoAsync(sampled, ct);

            return ConstruirMuestrasElevacionDesdeCache(line);
        }

        private List<MuestraElevacion> ConstruirMuestrasElevacionDesdeCache(double[,] line)
        {
            var sampled = SampleLine(line, _elevMaxPuntosPorTramo);
            var res = new List<MuestraElevacion>(sampled.Count);
            for (int i = 0; i < sampled.Count; i++)
            {
                var (lat, lon) = sampled[i];
                var elevIdee = _elevIdeeCache.TryGetValue(ClaveElevacionIdee(lat, lon), out var e2) ? e2 : (double?)null;
                var elevLocal5 = _elevLocal5Cache.TryGetValue(ClaveElevacionIdee(lat, lon), out var local5)
                    ? local5
                    : (double?)null;
                var elevLocal2 = _elevLocal2Cache.TryGetValue(ClaveElevacionIdee(lat, lon), out var local2)
                    ? local2
                    : (double?)null;
                var elevLocal1 = _elevLocal1Cache.TryGetValue(ClaveElevacionIdee(lat, lon), out var local1)
                    ? local1
                    : (double?)null;

                res.Add(new MuestraElevacion
                {
                    Indice = i,
                    Latitud = lat,
                    Longitud = lon,
                    ElevacionIdee = elevIdee,
                    ElevacionLocal5 = elevLocal5,
                    ElevacionLocal2 = elevLocal2,
                    ElevacionLocal1 = elevLocal1
                });
            }

            return res;
        }

        private async Task CalcularEsfuerzoExtraPendienteAlternativasAsync(
            IReadOnlyList<AlternativaRuta> alternativas,
            CancellationToken ct)
        {
            foreach (var alternativa in alternativas)
                alternativa.EsfuerzoExtraPendienteMetros = 0;

            if (!_mostrarElevacionesRuta || alternativas.Count == 0)
                return;

            var lineasPorAlternativa = alternativas
                .Select(alternativa => new
                {
                    Alternativa = alternativa,
                    Lineas = (alternativa.EsSoloAPie
                        ? alternativa.LineaSoloAPie is { } lineaSolo
                            ? new[] { lineaSolo }
                            : Enumerable.Empty<double[,]>()
                        : alternativa.LineasPieCalculoElevacion)
                        .Where(linea => linea.GetLength(0) >= 2)
                        .ToList()
                })
                .ToList();

            var puntosPendientes = new Dictionary<string, (double lat, double lon)>(StringComparer.OrdinalIgnoreCase);
            foreach (var item in lineasPorAlternativa)
            {
                foreach (var linea in item.Lineas)
                {
                    foreach (var (lat, lon) in SampleLine(linea, _elevMaxPuntosPorTramo))
                    {
                        ct.ThrowIfCancellationRequested();
                        var clave = ClaveElevacionIdee(lat, lon);
                        puntosPendientes.TryAdd(
                            clave,
                            (Math.Round(lat, ELEV_IDEE_DECIMALES_CACHE), Math.Round(lon, ELEV_IDEE_DECIMALES_CACHE)));
                    }
                }
            }

            var puntos = puntosPendientes.Values.ToList();
            await AsegurarElevacionesFuenteCalculoAsync(puntos, ct);

            foreach (var item in lineasPorAlternativa)
            {
                ct.ThrowIfCancellationRequested();
                var esfuerzoExtra = 0.0;
                foreach (var linea in item.Lineas)
                {
                    ct.ThrowIfCancellationRequested();
                    var muestras = ConstruirMuestrasElevacionDesdeCache(linea);
                    esfuerzoExtra += CalcularResumenEsfuerzoElevacion(muestras).EsfuerzoExtraMetros;
                }

                item.Alternativa.EsfuerzoExtraPendienteMetros = double.IsFinite(esfuerzoExtra)
                    ? Math.Max(0, esfuerzoExtra)
                    : 0;
            }
        }
    
    /// <summary>
    /// Gestiona tramo bus es basura.
    /// </summary>
    private bool PrimerTramoBusEsBasura(
        RutaBusAlternativa alternativa,
        double[] coordsOrigen,
        double[] coordsDestino)
    {
        if (alternativa?.Tramos is null || alternativa.Tramos.Count < 2)
            return false; // si solo hay un bus, no aplicamos esta regla
    
        var tramos = alternativa.Tramos;
    
        var primer = tramos[0];
        var segundo = tramos[1];
    
        // Parada real donde subes al primer bus
        string codIniPrimer = primer.Variante.CodigosParadas[primer.IndiceInicio];
    
        // Parada real donde bajas del primer bus
        string codFinPrimer = primer.Variante.CodigosParadas[primer.IndiceFin];
    
        // Parada real donde subes al segundo bus
        string codIniSegundo = segundo.Variante.CodigosParadas[segundo.IndiceInicio];
    
        if (!_paradaByCode.TryGetValue(codIniPrimer, out var pIniPrimer))
            return false;
    
        if (!_paradaByCode.TryGetValue(codFinPrimer, out var pFinPrimer))
            return false;
    
        if (!_paradaByCode.TryGetValue(codIniSegundo, out var pIniSegundo))
            return false;
    
        // Distancia del primer tramo bus
        double distPrimerBus = 0;
        {
            double distTmp;
            var lineas = RedBusServicio.ConstruirLineasBus(new List<TramoBus> { primer }, out distTmp);
            distPrimerBus = Math.Max(0, distTmp);
        }
    
        // Nº de paradas del primer tramo
        int paradasPrimerBus = ContarParadasRecorridas(primer);
    
        // Caminata del transbordo tras ese primer tramo
        double distWalkTransfer = CalcularDistanciaMetros(
            pFinPrimer.Latitud, pFinPrimer.Longitud,
            pIniSegundo.Latitud, pIniSegundo.Longitud);
    
        // Distancia desde origen hasta la parada de subida
        double distPieInicio = CalcularDistanciaMetros(
            coordsOrigen[0], coordsOrigen[1],
            pIniPrimer.Latitud, pIniPrimer.Longitud);
    
        // Distancia desde donde te deja ese primer bus hasta destino
        double distDesdeBajada1ADestino = CalcularDistanciaMetros(
            pFinPrimer.Latitud, pFinPrimer.Longitud,
            coordsDestino[0], coordsDestino[1]);
    
        // Distancia desde donde subes al primer bus hasta destino
        double distDesdeSubida1ADestino = CalcularDistanciaMetros(
            pIniPrimer.Latitud, pIniPrimer.Longitud,
            coordsDestino[0], coordsDestino[1]);
    
        double avanceUtil = distDesdeSubida1ADestino - distDesdeBajada1ADestino;
    
        // =====================================================
        // Reglas SOLO para detectar "primer bus absurdo"
        // =====================================================
    
        // 1) Bus muy corto + transbordo andando largo
        if (distPrimerBus <= 350 && distWalkTransfer >= 250)
            return true;
    
        // 2) Apenas 1 parada + luego caminata importante
        if (paradasPrimerBus <= 1 && distWalkTransfer >= 180)
            return true;
    
        // 3) El primer bus aporta poco avance real hacia destino
        if (avanceUtil <= 180 && distWalkTransfer >= 180)
            return true;
    
        // 4) Subes andando poco, haces mini-bus, y luego una caminata grande
        if (distPieInicio <= 180 && distPrimerBus <= 500 && distWalkTransfer >= 300)
            return true;
    
        // 5) El transbordo andando es casi tan grande como el propio tramo bus
        if (distPrimerBus > 0 && distWalkTransfer >= distPrimerBus * 0.9 && distWalkTransfer >= 200)
            return true;
    
        return false;
    }
    
        string FmtDist(double? d)
        {
            if (d is null) return "-";
            if (d.Value < 50) return $"{d.Value:0.0} m";
            return $"{Math.Round(d.Value):0} m";
        }
    
        string FmtPend(double? pend, double? distPrev)
        {
            if (pend is null || distPrev is null) return "-";
            if (distPrev.Value < 15) return "-";
            return $"{pend.Value:+0.0;-0.0;0.0} %";
        }
    
    
    
    
    
    
    
    
    
        /// <summary>
        /// Gestiona geometria completa variante.
        /// </summary>
        private double[,]? ConstruirGeometriaCompletaVariante(InfoVariante v)
        {
            if (v?.CodigosParadas is null || v.CodigosParadas.Count < 2) return null;
    
            // tramo completo: desde la primera parada a la última
            var tramo = new TramoBus
            {
                Variante = v,
                IndiceInicio = 0,
                IndiceFin = v.CodigosParadas.Count - 1
            };
    
            double dist;
            var lineas = RedBusServicio.ConstruirLineasBus(new List<TramoBus> { tramo }, out dist);
    
            // ConstruirLineasBus devuelve lista de lineas por tramo (aquí solo 1)
            if (lineas is null || lineas.Count == 0) return null;
    
            return lineas[0];
        }
    
    
        // =========================================================
        // Rutado BUS filtrado (BFS + filtroVariante)
        // =========================================================
    
    /// <summary>
    /// Busca ruta bus con filtro.
    /// </summary>
    private List<TramoBus>? BuscarRutaBusConFiltro(
        string codigoParadaOrigen,
        string codigoParadaDestino,
        Func<InfoVariante, bool> filtroVariante,
        out List<string> codigosParadasTransbordo,
        int? maxTransbordos = null)
    {
        codigosParadasTransbordo = new();
    
        if (!_indiceParadas.TryGetValue(codigoParadaOrigen, out var aparicionesOrigen))
            return null;
        if (!_indiceParadas.TryGetValue(codigoParadaDestino, out var aparicionesDestino))
            return null;
    
        // Estado = (variante, índice)
        // Coste = nº de transbordos (cambios de variante) desde que subes al primer bus
        var dq = new ColaDoble<(InfoVariante Variante, int IndiceParada)>();
    
        var dist = new Dictionary<(InfoVariante Variante, int IndiceParada), int>();
        var padre = new Dictionary<(InfoVariante Variante, int IndiceParada),
                                   (InfoVariante Variante, int IndiceParada)?>();
    
        // Inicial: subir al primer bus NO cuenta como transbordo => 0
        foreach (var ap in aparicionesOrigen)
        {
            if (!filtroVariante(ap.Variante))
                continue;
    
            var nodo = (ap.Variante, ap.IndiceParada);
            if (dist.ContainsKey(nodo)) continue;
    
            dist[nodo] = 0;
            padre[nodo] = null;
            dq.PushFront(nodo);
        }
    
        (InfoVariante Variante, int IndiceParada)? objetivo = null;
    
        while (dq.Count > 0)
        {
            var actual = dq.PopFront();
            var (variante, indice) = actual;
    
            int transUsados = dist[actual];
            if (maxTransbordos is not null && transUsados > maxTransbordos.Value)
                continue;
    
            string codigoParadaActual = variante.CodigosParadas[indice];
    
            if (codigoParadaActual == codigoParadaDestino)
            {
                objetivo = actual;
                break; // ✅ 0-1 BFS => primer objetivo es mínimo en transbordos
            }
    
            // -----------------------
            // 1) AVANZAR (coste 0)
            // -----------------------
            if (indice + 1 < variante.CodigosParadas.Count)
            {
                var sig = (variante, indice + 1);
                int nuevo = transUsados; // coste 0
    
                if (!dist.TryGetValue(sig, out var best) || nuevo < best)
                {
                    dist[sig] = nuevo;
                    padre[sig] = actual;
                    dq.PushFront(sig); // coste 0 => delante
                }
            }
    
            // -----------------------
            // 2) TRANSBORDO MISMA PARADA (coste 1 si cambia variante)
            // -----------------------
            if (_indiceParadas.TryGetValue(codigoParadaActual, out var aparicionesParada))
            {
                foreach (var ap in aparicionesParada)
                {
                    if (!filtroVariante(ap.Variante))
                        continue;
    
                    // si es exactamente el mismo estado, nada
                    if (ReferenceEquals(ap.Variante, variante) && ap.IndiceParada == indice)
                        continue;
    
                    int nuevo = transUsados + 1; // cambio de bus = +1
                    if (maxTransbordos is not null && nuevo > maxTransbordos.Value)
                        continue;
    
                    var sig = (ap.Variante, ap.IndiceParada);
    
                    if (!dist.TryGetValue(sig, out var best) || nuevo < best)
                    {
                        dist[sig] = nuevo;
                        padre[sig] = actual;
                        dq.PushBack(sig); // coste 1 => detrás
                    }
                }
            }
    
            // -----------------------
            // 3) TRANSBORDO ANDANDO A PARADAS CERCANAS (coste 1 si cambia variante)
            // -----------------------
            if (_paradasCercanas.TryGetValue(codigoParadaActual, out var vecinas))
            {
                foreach (var codVecino in vecinas)
                {
                    if (!_indiceParadas.TryGetValue(codVecino, out var aparicionesVecino))
                        continue;
    
                    foreach (var ap in aparicionesVecino)
                    {  
                        if (!filtroVariante(ap.Variante))
                            continue;
    
                        int nuevo = transUsados + 1;
                        if (maxTransbordos is not null && nuevo > maxTransbordos.Value)
                            continue;
    
                        var sig = (ap.Variante, ap.IndiceParada);
    
                        if (!dist.TryGetValue(sig, out var best) || nuevo < best)
                        {
                            dist[sig] = nuevo;
                            padre[sig] = actual;
                            dq.PushBack(sig);
                        }
                    }
                }
            }
        }
    
        if (objetivo is null)
            return null;
    
        // reconstrucción camino
        var nodosCamino = new List<(InfoVariante Variante, int IndiceParada)>();
        var nodoActual = objetivo.Value;
    
        while (true)
        {
            nodosCamino.Add(nodoActual);
            if (!padre.TryGetValue(nodoActual, out var anterior) || anterior is null)
                break;
            nodoActual = anterior.Value;
        }
    
        nodosCamino.Reverse();
    
        int numeroTransbordos;
        var tramos = ConstruirTramosYTransbordosDesdeCamino(
            nodosCamino,
            codigoParadaOrigen,
            codigoParadaDestino,
            out codigosParadasTransbordo,
            out numeroTransbordos);
    
        // ✅ númeroTransbordos aquí será coherente con el 0-1 BFS (mínimo transbordos)
        return tramos;
    }
    
    
        /// <summary>
        /// Gestiona tramos y transbordos desde camino.
        /// </summary>
        private List<TramoBus> ConstruirTramosYTransbordosDesdeCamino(
            List<(InfoVariante Variante, int IndiceParada)> nodosCamino,
            string codigoParadaOrigen,
            string codigoParadaDestino,
            out List<string> codigosParadasTransbordo,
            out int numeroTransbordos)
        {
            codigosParadasTransbordo = new List<string>();
    
            for (int i = 1; i < nodosCamino.Count; i++)
            {
                var previo = nodosCamino[i - 1];
                var ahora = nodosCamino[i];
    
                if (!ReferenceEquals(previo.Variante, ahora.Variante))
                {
                    string codigoParada = ahora.Variante.CodigosParadas[ahora.IndiceParada];
                    if (!codigosParadasTransbordo.Contains(codigoParada) &&
                        codigoParada != codigoParadaOrigen &&
                        codigoParada != codigoParadaDestino)
                    {
                        codigosParadasTransbordo.Add(codigoParada);
                    }
                }
            }
    
            var tramos = new List<TramoBus>();
            if (nodosCamino.Count <= 1)
            {
                numeroTransbordos = 0;
                return tramos;
            }
    
            var varianteActual = nodosCamino[0].Variante;
            int indiceInicio = nodosCamino[0].IndiceParada;
            int ultimoIndice = nodosCamino[0].IndiceParada;
    
            for (int i = 1; i < nodosCamino.Count; i++)
            {
                var (variante, indice) = nodosCamino[i];
    
                if (ReferenceEquals(variante, varianteActual) && indice == ultimoIndice + 1)
                {
                    ultimoIndice = indice;
                    continue;
                }
    
                if (ultimoIndice > indiceInicio)
                {
                    tramos.Add(new TramoBus
                    {
                        Variante = varianteActual,
                        IndiceInicio = indiceInicio,
                        IndiceFin = ultimoIndice
                    });
                }
    
                varianteActual = variante;
                indiceInicio = indice;
                ultimoIndice = indice;
            }
    
            if (ultimoIndice > indiceInicio)
            {
                tramos.Add(new TramoBus
                {
                    Variante = varianteActual,
                    IndiceInicio = indiceInicio,
                    IndiceFin = ultimoIndice
                });
            }

            codigosParadasTransbordo = new List<string>();
            for (var i = 1; i < tramos.Count; i++)
            {
                if (!UtilidadesTransitoDbus.EsTransbordoReal(tramos[i - 1], tramos[i]))
                    continue;

                var codigoParada = tramos[i].CodigoParadaInicio;
                if (!codigosParadasTransbordo.Contains(codigoParada, StringComparer.OrdinalIgnoreCase) &&
                    codigoParada != codigoParadaOrigen &&
                    codigoParada != codigoParadaDestino)
                {
                    codigosParadasTransbordo.Add(codigoParada);
                }
            }

            numeroTransbordos = UtilidadesTransitoDbus.ContarTransbordosReales(tramos);
            return tramos;
        }
    
        /// <summary>
        /// Normaliza sentido codigo.
        /// </summary>
        private static string NormalizarSentidoCodigo(string? codigo)
        {
            if (string.IsNullOrWhiteSpace(codigo)) return "?";
    
            var s = codigo.Trim();
    
            // aceptar códigos ya normalizados
            if (s.Equals("V", StringComparison.OrdinalIgnoreCase)) return "V";
            if (s.Equals("I", StringComparison.OrdinalIgnoreCase)) return "I";
    
            // aceptar textos
            if (s.Equals("Vuelta", StringComparison.OrdinalIgnoreCase)) return "V";
            if (s.Equals("Ida", StringComparison.OrdinalIgnoreCase)) return "I";
    
            // fallback razonable
            var c = char.ToUpperInvariant(s[0]);
            if (c == 'V') return "V";
            if (c == 'I') return "I";
            return "?";
        }
    
    /// <summary>
    /// Gestiona linea itinerario sentido.
    /// </summary>
    private static string CodigoLineaItinerarioSentido(TramoBus tramo)
    {
        var v = tramo.Variante;
    
        var linea = v.Linea.Codigo?.ToString() ?? "?";
        var itin = v.CodigoItinerario;
    
        // ✅ sentido real del JSON
        var sentido = NormalizarSentidoCodigo(v.Sentido?.Codigo);
    
        return $"{linea}.{itin}-{sentido}";
    }
    
    
        /// <summary>
        /// Gestiona ruta bus.
        /// </summary>
        private static string FirmaRutaBus(RutaBusAlternativa alt)
        {
            return string.Join(">",
                alt.Tramos.Select(t => $"{CodigoLineaItinerarioSentido(t)}:{t.IndiceInicio}->{t.IndiceFin}")
            );
        }
    
        /// <summary>
        /// Calcula transbordos reales.
        /// </summary>
        private static int CalcularTransbordosReales(RutaBusAlternativa alternativa)
        {
            return UtilidadesTransitoDbus.ContarTransbordosReales(alternativa?.Tramos);
        }
    
        // =========================================================
        // Acciones UI
        // =========================================================
    
        /// <summary>
        /// Resuelve parada desde texto.
        /// </summary>
        private Parada? ResolverParadaDesdeTexto(string texto)
        {
            if (string.IsNullOrWhiteSpace(texto))
                return null;
    
            texto = texto.Trim();
    
            int idx = texto.LastIndexOf('(');
            if (idx >= 0 && texto.EndsWith(")"))
            {
                var codigoRaw = texto.Substring(idx + 1, texto.Length - idx - 2).Trim();
                var codNorm = NormalizarCodigoParada(codigoRaw);
    
                var paradaPorCodigo = RedBusServicio.Paradas.FirstOrDefault(p =>
                    NormalizarCodigoParada(p.Codigo).Equals(codNorm, StringComparison.OrdinalIgnoreCase));
    
                if (paradaPorCodigo is not null)
                    return paradaPorCodigo;
            }
    
            var codNorm2 = NormalizarCodigoParada(texto);
    
            var porCodigo = RedBusServicio.Paradas.FirstOrDefault(p =>
                NormalizarCodigoParada(p.Codigo).Equals(codNorm2, StringComparison.OrdinalIgnoreCase));
    
            if (porCodigo is not null)
                return porCodigo;
    
            var porNombre = RedBusServicio.Paradas
                .FirstOrDefault(p =>
                    p.Nombre.Contains(texto, StringComparison.OrdinalIgnoreCase) ||
                    p.NombreCorto.Contains(texto, StringComparison.OrdinalIgnoreCase) ||
                    p.Abreviatura.Contains(texto, StringComparison.OrdinalIgnoreCase));
    
            return porNombre;
        }
    
        /// <summary>
        /// Cambia alternativa absoluta.
        /// </summary>
        private async Task CambiarAlternativaAbsoluta(int indice)
        {
            await CerrarTodasLasPreviewsAsync();
            if (indice < 0 || indice >= _opcionesRuta.Count) return;
    
            _indiceAlternativaSeleccionada = indice;
            _proveedorSoloAPieRecalculo = _opcionesRuta[indice].EsSoloAPie ? _opcionesRuta[indice].ProveedorRuta : null;
            await CerrarPopupsAsync();

            ResetEstadoRuta(limpiarOpciones: false, limpiarMensaje: false);
            _mensajeRuta = "Representando ruta seleccionada...";
            StateHasChanged();
            await Task.Yield();
            await PintarOpcionRutaCompleta(_opcionesRuta[indice]);
            await RegistrarEscenarioActualEnHistorialLocalAsync();
        }

        /// <summary>
        /// Cambia el criterio prioritario de rutas sugeridas.
        /// </summary>
        private async Task CambiarCriterioPrioritarioRutasAsync(string criterio)
        {
            var criterioNormalizado = NormalizarCriterioRuta(criterio);
            if (string.Equals(_criterioPrioritarioRuta, criterioNormalizado, StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            _criterioPrioritarioRuta = criterioNormalizado;
            SincronizarPreferenciaDesdeCriterioRuta();
            await PersistirConfiguracionAsync();

            if (_mapa is not null && _coordenadasOrigen is not null && _coordenadasDestino is not null)
            {
                _omitirRegistroHistorialEnSiguienteCalculo = true;
                await CalcularRutaCompletaAsync();
                return;
            }

            if (_opcionesRuta.Count == 0)
            {
                StateHasChanged();
                return;
            }

            OrdenarOpcionesRutaSegunCriterio();
            var indicePreferido = BuscarIndicePreferidoPorCriterio(criterioNormalizado);
            if (indicePreferido < 0 || indicePreferido >= _opcionesRuta.Count)
            {
                StateHasChanged();
                return;
            }

            await CerrarTodasLasPreviewsAsync();
            _indiceAlternativaSeleccionada = indicePreferido;
            await CerrarPopupsAsync();
            ResetEstadoRuta(limpiarOpciones: false, limpiarMensaje: false);
            _mensajeRuta = "Representando ruta seleccionada...";
            StateHasChanged();
            await Task.Yield();
            await PintarOpcionRutaCompleta(_opcionesRuta[indicePreferido]);
            StateHasChanged();
        }

        private int BuscarIndicePreferidoPorCriterio(string criterio)
        {
            if (string.Equals(criterio, CriterioRutaEquilibrado, StringComparison.OrdinalIgnoreCase))
                return BuscarIndiceEquilibrado();

            if (string.Equals(criterio, CriterioRutaAndar, StringComparison.OrdinalIgnoreCase))
            {
                return BuscarPrimerIndiceOrdenadoPor(
                    opcion => CalcularCosteAndarEquilibradoSegundos(opcion),
                    opcion => DuracionOrdenacion(opcion));
            }

            return BuscarPrimerIndiceOrdenadoPor(
                opcion => DuracionOrdenacion(opcion),
                opcion => TiempoPieOrdenacion(opcion));
        }

        private int BuscarIndiceEquilibrado()
        {
            var candidatas = _opcionesRuta
                .Select((opcion, indice) => new { opcion, indice })
                .ToList();

            if (candidatas.Count == 0)
                return _opcionesRuta.Count > 0 ? 0 : -1;

            return candidatas
                .OrderBy(x => CalcularScoreEquilibradoFactor(x.opcion))
                .ThenBy(x => x.opcion.NumeroTransbordosReales)
                .ThenBy(x => x.opcion.TiempoEsperaTotalSegundos)
                .ThenBy(x => x.opcion.PuntuacionCoste)
                .Select(x => x.indice)
                .FirstOrDefault();
        }

        private void OrdenarOpcionesRutaSegunCriterio()
        {
            if (_opcionesRuta.Count <= 1)
                return;

            IEnumerable<AlternativaRuta> ordenadas = _opcionesRuta;
            if (CriterioPrioritarioAndarActivo)
            {
                ordenadas = ordenadas
                    .OrderBy(CalcularCosteAndarEquilibradoSegundos)
                    .ThenBy(DuracionOrdenacion)
                    .ThenBy(opcion => opcion.PuntuacionCoste);
            }
            else if (CriterioPrioritarioTiempoActivo)
            {
                ordenadas = ordenadas
                    .OrderBy(DuracionOrdenacion)
                    .ThenBy(TiempoPieOrdenacion)
                    .ThenBy(opcion => opcion.PuntuacionCoste);
            }
            else if (CriterioPrioritarioEquilibradoActivo)
            {
                ordenadas = ordenadas
                    .OrderBy(CalcularScoreEquilibradoFactor)
                    .ThenBy(opcion => opcion.NumeroTransbordosReales)
                    .ThenBy(opcion => opcion.TiempoEsperaTotalSegundos)
                    .ThenBy(opcion => opcion.PuntuacionCoste);
            }

            var listaOrdenada = ordenadas.ToList();
            _opcionesRuta.Clear();
            _opcionesRuta.AddRange(listaOrdenada);
            FiltrarAlternativasBusRedundantes();
            RenumerarEtiquetasGenericasOpcionesRuta();
        }

        /// <summary>
        /// Conserva la mejor alternativa de cada direccion de acceso a una misma linea
        /// y descarta rutas en bus que no ahorran ninguna distancia andando.
        /// </summary>
        private void FiltrarAlternativasBusRedundantes()
        {
            if (_opcionesRuta.Count <= 1)
                return;

            var distanciaSoloPie = _opcionesRuta
                .Where(opcion => opcion.EsSoloAPie &&
                                 double.IsFinite(opcion.DistanciaSoloAPie) &&
                                 opcion.DistanciaSoloAPie > 0)
                .Select(opcion => opcion.DistanciaSoloAPie)
                .DefaultIfEmpty(double.PositiveInfinity)
                .Min();

            var conservadas = new List<AlternativaRuta>(_opcionesRuta.Count);
            foreach (var candidata in _opcionesRuta)
            {
                if (candidata.EsSoloAPie)
                {
                    conservadas.Add(candidata);
                    continue;
                }

                if (double.IsFinite(distanciaSoloPie) &&
                    double.IsFinite(candidata.DistanciaPieTotalAprox) &&
                    candidata.DistanciaPieTotalAprox >= distanciaSoloPie)
                {
                    continue;
                }

                var repiteDireccionAcceso = conservadas.Any(referencia =>
                    !referencia.EsSoloAPie &&
                    EsMismaLineaInicial(referencia, candidata) &&
                    CaminanEnLaMismaDireccionDesdeOrigen(referencia, candidata));

                if (!repiteDireccionAcceso)
                    conservadas.Add(candidata);
            }

            if (conservadas.Count == _opcionesRuta.Count)
                return;

            _opcionesRuta.Clear();
            _opcionesRuta.AddRange(conservadas);
        }

        private static bool EsMismaLineaInicial(
            AlternativaRuta referencia,
            AlternativaRuta candidata)
        {
            var tramoReferencia = referencia.AlternativaBus?.Tramos.FirstOrDefault();
            var tramoCandidata = candidata.AlternativaBus?.Tramos.FirstOrDefault();
            if (tramoReferencia is null || tramoCandidata is null)
                return false;

            return string.Equals(
                   UtilidadesTransitoDbus.LineaCodigoStr(tramoReferencia.Variante),
                   UtilidadesTransitoDbus.LineaCodigoStr(tramoCandidata.Variante),
                   StringComparison.OrdinalIgnoreCase) &&
               tramoReferencia.Variante.CodigoItinerario == tramoCandidata.Variante.CodigoItinerario;
        }

        private bool CaminanEnLaMismaDireccionDesdeOrigen(
            AlternativaRuta referencia,
            AlternativaRuta candidata)
        {
            if (_coordenadasOrigen is null ||
                _coordenadasOrigen.Length < 2 ||
                referencia.OrigenParada is null ||
                candidata.OrigenParada is null)
            {
                return false;
            }

            var latitudOrigen = _coordenadasOrigen[0];
            var longitudOrigen = _coordenadasOrigen[1];
            if (!double.IsFinite(latitudOrigen) || !double.IsFinite(longitudOrigen))
                return false;

            var metrosPorGradoLatitud = 111_320d;
            var metrosPorGradoLongitud =
                metrosPorGradoLatitud * Math.Cos(latitudOrigen * Math.PI / 180d);

            var referenciaX =
                (referencia.OrigenParada.Longitud - longitudOrigen) * metrosPorGradoLongitud;
            var referenciaY =
                (referencia.OrigenParada.Latitud - latitudOrigen) * metrosPorGradoLatitud;
            var candidataX =
                (candidata.OrigenParada.Longitud - longitudOrigen) * metrosPorGradoLongitud;
            var candidataY =
                (candidata.OrigenParada.Latitud - latitudOrigen) * metrosPorGradoLatitud;

            var moduloReferencia = Math.Sqrt(
                referenciaX * referenciaX + referenciaY * referenciaY);
            var moduloCandidata = Math.Sqrt(
                candidataX * candidataX + candidataY * candidataY);
            if (!double.IsFinite(moduloReferencia) ||
                !double.IsFinite(moduloCandidata) ||
                moduloReferencia < 1d ||
                moduloCandidata < 1d)
            {
                return false;
            }

            var cosenoDireccion =
                (referenciaX * candidataX + referenciaY * candidataY) /
                (moduloReferencia * moduloCandidata);
            return double.IsFinite(cosenoDireccion) && cosenoDireccion >= 0d;
        }

        private void RenumerarEtiquetasGenericasOpcionesRuta()
        {
            for (var i = 0; i < _opcionesRuta.Count; i++)
            {
                var etiqueta = _opcionesRuta[i].Etiqueta;
                if (!EsEtiquetaOpcionGenerica(etiqueta))
                    continue;

                _opcionesRuta[i].Etiqueta = $"Opcion {i + 1}";
            }
        }

        private static bool EsEtiquetaOpcionGenerica(string? etiqueta)
        {
            if (string.IsNullOrWhiteSpace(etiqueta))
                return false;

            return Regex.IsMatch(
                etiqueta.Trim(),
                @"^Opci(?:o|ó|ó)n\s+\d+$",
                RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
        }

        private int BuscarPrimerIndiceOrdenadoPor(
            Func<AlternativaRuta, double> criterioPrincipal,
            Func<AlternativaRuta, double> criterioSecundario)
        {
            return _opcionesRuta
                .Select((opcion, indice) => new { opcion, indice })
                .OrderBy(x => criterioPrincipal(x.opcion))
                .ThenBy(x => criterioSecundario(x.opcion))
                .ThenBy(x => x.opcion.PuntuacionCoste)
                .Select(x => x.indice)
                .FirstOrDefault(-1);
        }

        private double DuracionOrdenacion(AlternativaRuta alternativa)
            => double.IsFinite(alternativa.DuracionTotalAproxSegundos)
                ? alternativa.DuracionTotalAproxSegundos
                : double.PositiveInfinity;

        private double TiempoPieOrdenacion(AlternativaRuta alternativa)
        {
            if (alternativa.EsSoloAPie)
                return DuracionOrdenacion(alternativa);

            var tiempoTransbordosPie = EstimarDuracionPieSegundos(alternativa.DistanciaPieTransbordosAprox);
            return Math.Max(0, alternativa.TiempoPieInicio) +
                   Math.Max(0, tiempoTransbordosPie) +
                   Math.Max(0, alternativa.TiempoPieFin);
        }
    
        /// <summary>
        /// Intercambia origen destino.
        /// </summary>
        private async Task IntercambiarOrigenDestino()
        {
            (_coordenadasOrigen, _coordenadasDestino) = (_coordenadasDestino, _coordenadasOrigen);
            (_textoBusquedaOrigen, _textoBusquedaDestino) = (_textoBusquedaDestino, _textoBusquedaOrigen);
            (_ubicacionOrigenSeleccionada, _ubicacionDestinoSeleccionada) = (_ubicacionDestinoSeleccionada, _ubicacionOrigenSeleccionada);
            _sugerenciasBusquedaOrigen.Clear();
            _sugerenciasBusquedaDestino.Clear();
            _campoBusquedaActivo = null;

            await ClearRoutesJsAsync();
            await CerrarTodasLasPreviewsAsync();
            await SincronizarMarcadoresOrigenDestinoJsAsync();

            if (_mapa is not null)
            {
                try { await _mapa.Geometric.DisplayPolylinesFromArray.deleteConnectors(); } catch { }
            }
    
            if (_coordenadasOrigen is not null && _coordenadasDestino is not null)
                await CalcularRutaCompletaAsync(conservarSeleccionSoloAPie: true);
    
            StateHasChanged();
        }
    
    /// <summary>
    /// Busca ruta desde buscador.
    /// </summary>
    private async Task BuscarRutaDesdeBuscador()
    {
        if (string.IsNullOrWhiteSpace(_textoBusquedaOrigen) ||
            string.IsNullOrWhiteSpace(_textoBusquedaDestino))
        {
            return;
        }
    
        var po = await ResolverUbicacionBusquedaAsync(CampoBusquedaMapa.Origen);
        var pd = await ResolverUbicacionBusquedaAsync(CampoBusquedaMapa.Destino);
    
        if (po is null || pd is null)
        {
            _mensajeRuta = "No he podido interpretar el origen o el destino. Prueba a seleccionar una sugerencia de la lista.";
            _hayRutaValida = false;
            StateHasChanged();
            return;
        }
    
        _coordenadasOrigen = new[] { po.Latitud, po.Longitud };
        _coordenadasDestino = new[] { pd.Latitud, pd.Longitud };
        _textoBusquedaOrigen = po.TextoEntrada;
        _textoBusquedaDestino = pd.TextoEntrada;
        _ubicacionOrigenSeleccionada = po;
        _ubicacionDestinoSeleccionada = pd;
        _sugerenciasBusquedaOrigen.Clear();
        _sugerenciasBusquedaDestino.Clear();
        _campoBusquedaActivo = null;
    
        if (_mapa is not null)
        {
            await ClearRoutesJsAsync();
            try { await _mapa.Geometric.DisplayPolylinesFromArray.deleteConnectors(); } catch { }

            await _mapa.Geometric.DisplayPointsFromArray.deleteAllPoints();
            await SincronizarMarcadoresOrigenDestinoJsAsync();

            if (_mostrarParadas)
                await DibujarParadasAsync();
        }
    
        await CerrarTodasLasPreviewsAsync();
        await CerrarPopupsAsync();
        await CalcularRutaCompletaAsync(conservarSeleccionSoloAPie: true);
    }
        /// <summary>
        /// Muestra inspector.
        /// </summary>
        private async Task MostrarInspectorAsync(double lat, double lon)
        {
            _inspectorPuntoAnterior = _popupInspectorVisible
                ? new PuntoInspectorAnterior(
                    _inspectorLat,
                    _inspectorLon,
                    _inspectorElevIdee,
                    _inspectorElevLocal5,
                    _inspectorElevLocal2,
                    _inspectorElevLocal1,
                    ObtenerDireccionPuntoInspectorActual(),
                    DistanciaAndandoMetros: null,
                    CalculandoDatosAdicionales: true)
                : null;

            var versionInspector = ++_versionInspector;
            _inspectorLat = lat;
            _inspectorLon = lon;
            _inspectorElevIdee = null;
            _inspectorElevLocal5 = null;
            _inspectorElevLocal2 = null;
            _inspectorElevLocal1 = null;
            _inspectorLugaresCercanos = Array.Empty<LugarGeocodificadoCercano>();
            _inspectorSuperficieTexto = null;
            _inspectorSuperficieCargando = true;
            _popupInspectorVisible = true;

            ObtenerElevacionesLocalesComparativasPorLote(new[] { (lat, lon) });
            var claveLocal = ClaveElevacionIdee(lat, lon);
            _inspectorElevLocal5 = _elevLocal5Cache.TryGetValue(claveLocal, out var elevLocal5)
                ? elevLocal5
                : null;
            _inspectorElevLocal2 = _elevLocal2Cache.TryGetValue(claveLocal, out var elevLocal2)
                ? elevLocal2
                : null;
            _inspectorElevLocal1 = _elevLocal1Cache.TryGetValue(claveLocal, out var elevLocal1)
                ? elevLocal1
                : null;

            await ActualizarMarcadoresInspectorJsAsync();
            StateHasChanged();

            _ = CompletarSuperficiePuntoInspectorAsync(lat, lon, versionInspector);

            if (_inspectorPuntoAnterior is { } puntoAnterior)
                _ = CompletarDatosPuntoInspectorAnteriorAsync(puntoAnterior, versionInspector);

            var tareaLugares = GeocodificadorLocal.BuscarCercanosAsync(
                lat,
                lon,
                radioMetros: 20,
                maxResultados: 3,
                cancellationToken: CancellationToken.None);

            double? elevacionIdee = null;
            try
            {
                // -------------------------
                // IDEE (cache primero)
                // -------------------------
                var kIdee = ClaveElevacionIdee(lat, lon);
                if (_elevIdeeCache.TryGetValue(kIdee, out var cachedIdee))
                {
                    elevacionIdee = cachedIdee;
                }
                else
                {
                    await ObtenerElevacionesIdeePorLoteAsync(
                        new List<(double lat, double lon)> { (lat, lon) },
                        CancellationToken.None);

                    elevacionIdee = _elevIdeeCache.TryGetValue(ClaveElevacionIdee(lat, lon), out var elevIdee)
                        ? elevIdee
                        : (double?)null;
                }
            }
            catch
            {
            }

            try
            {
                var lugares = await tareaLugares;
                if (versionInspector != _versionInspector)
                    return;

                _inspectorLugaresCercanos = lugares;
            }
            catch
            {
                if (versionInspector != _versionInspector)
                    return;

                _inspectorLugaresCercanos = Array.Empty<LugarGeocodificadoCercano>();
            }

            if (versionInspector != _versionInspector)
                return;

            _inspectorElevIdee = elevacionIdee;
            await ActualizarMarcadoresInspectorJsAsync();
            StateHasChanged();
        }

        private async Task ActualizarMarcadoresInspectorJsAsync()
        {
            var lugares = _inspectorLugaresCercanos
                .Select(cercano => new
                {
                    latitud = cercano.Lugar.Latitud,
                    longitud = cercano.Lugar.Longitud,
                    texto = FormatearLugarCallejeroResumen(cercano)
                })
                .ToList();

            try
            {
                await JS.InvokeVoidAsync(
                    "rt.setInspectorMarkers",
                    _inspectorLat,
                    _inspectorLon,
                    lugares);
            }
            catch
            {
            }
        }

        private async Task CerrarInspectorAsync()
        {
            _versionInspector++;
            _popupInspectorVisible = false;
            _inspectorPuntoAnterior = null;
            _inspectorLugaresCercanos = Array.Empty<LugarGeocodificadoCercano>();
            _inspectorSuperficieCargando = false;
            _inspectorSuperficieTexto = null;

            try { await JS.InvokeVoidAsync("rt.clearInspectorMarkers"); } catch { }
        }
    
    
        /// <summary>
        /// Gestiona hacer clic en mapa.
        /// </summary>
        private async Task AlHacerClickEnMapa(RealTimeMap.ClicksMapArgs e)
        {
            var lat = e.location.latitude;
            var lon = e.location.longitude;

            if (_modoDibujoExclusionCaminata)
            {
                await OnExclusionPolygonMapClick(lat, lon);
                return;
            }
    
            // Inspector (Z) sigue siendo click simple inmediato
            if (_inspectorActivo)
            {
                await MostrarInspectorAsync(lat, lon);
                return;
            }
    
            // ¿Este click cae SOBRE una parada?
            var paradaHit = await DetectarParadaHitAsync(lat, lon);
            if (paradaHit is null && !_mostrarParadas)
                paradaHit = await DetectarParadaDestacadaHitAsync(lat, lon);
    
            // =====================================================
            // 2º click (si había uno pendiente)
            // =====================================================
            if (_primerClickPendiente is (double lat1, double lon1))
            {
                _ctsDobleClick?.Cancel();
                _ctsDobleClick?.Dispose();
                _ctsDobleClick = null;
    
                _primerClickPendiente = null;
                _paradaPrimerClickPendiente = null; // ✅ si era parada, anulamos popup
    
                // si los dos clicks son cerca => doble click => PONER PUNTO SIEMPRE
                if (Cerca(lat1, lon1, lat, lon, DBLCLICK_MAX_METROS))
                {
                    // Si el segundo click cae en parada, ponemos el punto EXACTO en la parada
                    if (paradaHit is not null)
                        await EjecutarSeleccionOrigenDestinoAsync(paradaHit.Latitud, paradaHit.Longitud);
                    else
                        await EjecutarSeleccionOrigenDestinoAsync(lat, lon);
                }
    
                return;
            }
    
            // =====================================================
            // 1º click (armamos la ventana de doble click)
            // =====================================================
            _primerClickPendiente = (lat, lon);
            _paradaPrimerClickPendiente = paradaHit;
    
            _ctsDobleClick = new CancellationTokenSource();
            var ct = _ctsDobleClick.Token;
    
            _ = Task.Run(async () =>
            {
                try
                {
                    await Task.Delay(DBLCLICK_MS, ct);
    
                    if (ct.IsCancellationRequested) return;
    
                    // Se acabó la ventana: NO hubo doble click
                    var parada = _paradaPrimerClickPendiente;
    
                    _primerClickPendiente = null;
                    _paradaPrimerClickPendiente = null;
    
                    // Si era parada => click simple => mostrar popup
                    if (parada is not null)
                    {
                        await InvokeAsync(async () =>
                        {
                            await MostrarPopupParadaAsync(parada);
                        });
                    }
                    // Si NO era parada: click simple no hace nada (como querías)
                }
                catch { }
                finally
                {
                    if (!ct.IsCancellationRequested)
                    {
                        // por si acaso
                        _primerClickPendiente = null;
                        _paradaPrimerClickPendiente = null;
                    }
                }
            });
        }

        /// <summary>
        /// Selecciona origen o destino mediante pulsacion larga en dispositivos tactiles.
        /// </summary>
        [JSInvokable]
        public async Task OnMobileMapLongPress(double lat, double lon)
        {
            if (_modoDibujoExclusionCaminata) return;
            await InvokeAsync(async () =>
            {
                if (_inspectorActivo)
                    return;

                _ctsDobleClick?.Cancel();
                _ctsDobleClick?.Dispose();
                _ctsDobleClick = null;
                _primerClickPendiente = null;
                _paradaPrimerClickPendiente = null;

                var paradaHit = await DetectarParadaHitAsync(lat, lon);
                if (paradaHit is null && !_mostrarParadas)
                    paradaHit = await DetectarParadaDestacadaHitAsync(lat, lon);

                if (paradaHit is not null)
                    await EjecutarSeleccionOrigenDestinoAsync(paradaHit.Latitud, paradaHit.Longitud);
                else
                    await EjecutarSeleccionOrigenDestinoAsync(lat, lon);
            });
        }
    
        /// <summary>
        /// Gestiona seleccion origen destino.
        /// </summary>
    private async Task EjecutarSeleccionOrigenDestinoAsync(double lat, double lon)
    {
        if (_coordenadasOrigen is null)
        {
            _coordenadasOrigen = new[] { lat, lon };

            await SincronizarMarcadoresOrigenDestinoJsAsync();

            _mensajeRuta = string.Empty;
            _hayRutaValida = false;
            StateHasChanged();
            return;
            }
    
        if (_coordenadasDestino is null)
        {
            _coordenadasDestino = new[] { lat, lon };

            await SincronizarMarcadoresOrigenDestinoJsAsync();

            await CalcularRutaCompletaAsync(conservarSeleccionSoloAPie: true);
            return;
        }
    
            _coordenadasDestino = new[] { lat, lon };
    
            if (_mapa is not null)
            {
                try { await _mapa.Geometric.DisplayPolylinesFromArray.deleteConnectors(); } catch { }
                await ClearRoutesJsAsync();
                await SincronizarMarcadoresOrigenDestinoJsAsync();
            }

            await CalcularRutaCompletaAsync(conservarSeleccionSoloAPie: true);
        }

        /// <summary>
        /// Reacciona al arrastre de origen o destino desde el mapa.
        /// </summary>
        [JSInvokable]
        public async Task OnEndpointDragged(string kind, double lat, double lon)
        {
            await InvokeAsync(async () =>
            {
                if (string.Equals(kind, "origin", StringComparison.OrdinalIgnoreCase))
                {
                    _coordenadasOrigen = new[] { lat, lon };
                    _ubicacionOrigenSeleccionada = null;
                    _sugerenciasBusquedaOrigen.Clear();
                }
                else if (string.Equals(kind, "destination", StringComparison.OrdinalIgnoreCase))
                {
                    _coordenadasDestino = new[] { lat, lon };
                    _ubicacionDestinoSeleccionada = null;
                    _sugerenciasBusquedaDestino.Clear();
                }
                else
                {
                    return;
                }

                await SincronizarMarcadoresOrigenDestinoJsAsync();
                await CerrarTodasLasPreviewsAsync();
                await CerrarPopupsAsync();

                if (_mapa is not null)
                {
                    try { await _mapa.Geometric.DisplayPolylinesFromArray.deleteConnectors(); } catch { }
                    await ClearRoutesJsAsync();
                }

                if (_coordenadasOrigen is not null && _coordenadasDestino is not null)
                {
                    await CalcularRutaCompletaAsync(conservarSeleccionSoloAPie: true);
                }
                else
                {
                    ResetEstadoRuta(limpiarOpciones: true);
                    _mensajeRuta = string.Empty;
                    StateHasChanged();
                }
            });
        }
    
    
    
    
        // =========================================================
        // Cálculo completo (optimizado + estricto real)
        // =========================================================
    
    /// <summary>
    /// Calcula ruta completa.
    /// </summary>
    private string? _proveedorSoloAPieRecalculo;

    private string? ObtenerProveedorSoloAPieParaRecalculo(bool conservarSeleccion)
    {
        if (!conservarSeleccion)
            _proveedorSoloAPieRecalculo = null;
        else if (_indiceAlternativaSeleccionada >= 0 && _indiceAlternativaSeleccionada < _opcionesRuta.Count)
        {
            var seleccionada = _opcionesRuta[_indiceAlternativaSeleccionada];
            _proveedorSoloAPieRecalculo = seleccionada.EsSoloAPie ? seleccionada.ProveedorRuta : null;
        }
        // Durante un calculo las opciones se vacian; otro cambio de punto conserva la preferencia.
        return _proveedorSoloAPieRecalculo;
    }

    private async Task CalcularRutaCompletaAsync(bool conservarSeleccionSoloAPie = false)
    {
        if (_mapa is null || _coordenadasOrigen is null || _coordenadasDestino is null)
            return;

        var proveedorSoloAPiePreferido = ObtenerProveedorSoloAPieParaRecalculo(conservarSeleccionSoloAPie);

        _mostrarElevacionesRuta = _mostrarElevacionesRutaConfiguracion;

        var confirmarDerivacionHistorial = !_aplicandoRegistroHistorial &&
                                           PrepararDerivacionHistorialParaRecalculo();

        var cronometroCalculo = System.Diagnostics.Stopwatch.StartNew();
        _panelRutasMovilContraido = _mostrarBuscadorMapa;
    
        await CerrarTodasLasPreviewsAsync();
    
        _ctsCalculo?.Cancel();
        _ctsCalculo = new CancellationTokenSource();
        var ct = _ctsCalculo.Token;
        var omitirRegistroHistorialEsteCalculo = _omitirRegistroHistorialEnSiguienteCalculo;
        _omitirRegistroHistorialEnSiguienteCalculo = false;
    
        int versionActual = Interlocked.Increment(ref _versionCalculo);
        IniciarNuevaVersionPintadoRuta();
    
        ResetEstadoRuta(limpiarOpciones: true);
    
        _mensajeRuta = "Calculando ruta…";
        StateHasChanged();
    
        await ClearRoutesJsAsync();
        try { await _mapa.Geometric.DisplayPolylinesFromArray.deleteConnectors(); } catch { }
    
        try
        {
            ct.ThrowIfCancellationRequested();
            if (versionActual != _versionCalculo)
                throw new OperationCanceledException();

            var salidaBase = AhoraLocal();
            _ultimaHoraReferenciaRuta = salidaBase;

            var parametros = new ParametrosPlanificadorRuta
            {
                VelocidadPieKmH = _velocidadPieKmH,
                FactorPenalizacionDistanciaPie = _factorPenalizacionDistanciaPie,
                ParametroPenalizacionDistanciaPieMetros = _parametroPenalizacionDistanciaPieMetros,
                PesoTransbordoRankingMinutos = _pesoTransbordoRankingMinutos,
                FactorEquilibradoAndarBus = _factorEquilibradoAndarBus,
                UsarValhallaParaCaminatas = _walkProvider == ProveedorCaminata.Valhalla,
                PoligonosExclusionCaminata = ObtenerPoligonosExclusionCaminata(),
                VelocidadBusKmH = _velocidadBusKmH,
                MinutosPorTransbordo = _minutosTransbordo,
                MargenTransbordoSegundos = Math.Clamp(_margenTransbordoSegundos, 0, 1800),
                SegundosPorParadaBus = _segundosPorParadaBus,
                RadioParadasCandidatasMetros = _radioCandidatasMetros,
                MaxParadasCandidatasPorLado = _maxCandidatasPorLado,
                UsarOsrmParaRanking = _usarOsrmParaRanking,
                ActivarRangoLineas = _activarRangoLineas,
                LineaMin = _lineaMin,
                LineaMax = _lineaMax,
                LineasPermitidas = ObtenerLineasPermitidasSeleccionadas().ToList(),
                ActivarRangoItinerarios = _activarRangoItinerarios,
                ItinerarioMin = _itinerarioMin,
                ItinerarioMax = _itinerarioMax,
                FiltroSentidoItinerario = _filtroSentidoItinerario,
                ActivarRangoTransbordos = _activarRangoTransbordos,
                MinTransbordosPermitidos = _minTransbordosPermitidos,
                MaxTransbordosPermitidos = _maxTransbordosPermitidos,
                MaxParesEvaluados = _activarRangoItinerarios ? 280 : 140,
                MaxAlternativasBusPorPar = (_activarRangoTransbordos && _minTransbordosPermitidos > 0)
                    ? (_activarRangoItinerarios ? 8 : 6)
                    : (_activarRangoItinerarios ? 4 : 3),
                UsarHorariosReales = _usarHorariosTeoricos,
                FechaSalida = DateOnly.FromDateTime(salidaBase),
                HoraSalida = TimeOnly.FromDateTime(salidaBase),
                DescartarAlternativasSinHorario = false,
                MaxEsperaInicialMinutos = 90,
                MaxEsperaTransbordoMinutos = 60,
                MaxEsperaTotalMinutos = 120,
                PreferenciaEtiquetaRuta = _preferenciaEtiquetaRuta
            };
    
            var resultado = await PlanificadorRutasServicio.CalcularAsync(
                _coordenadasOrigen,
                _coordenadasDestino,
                parametros,
                ct);
    
            ct.ThrowIfCancellationRequested();
            if (versionActual != _versionCalculo)
                throw new OperationCanceledException();
    
            var alternativas = resultado.Alternativas;
            var filtradas = alternativas
                .Where(a => a.EsSoloAPie || a.AlternativaBus is null || !PrimerTramoBusEsBasura(a.AlternativaBus, _coordenadasOrigen, _coordenadasDestino))
                .ToList();
    
            if (filtradas.Count == 0 && alternativas.Count > 0)
                filtradas = alternativas;
    
            _opcionesRuta.Clear();
            _opcionesRuta.AddRange(filtradas);
            await CalcularEsfuerzoExtraPendienteAlternativasAsync(_opcionesRuta, ct);
            OrdenarOpcionesRutaSegunCriterio();
    
            if (!resultado.Ok || _opcionesRuta.Count == 0)
            {
                _mensajeRuta = string.IsNullOrWhiteSpace(resultado.Mensaje)
                    ? "No hay rutas disponibles para esta combinacion."
                    : resultado.Mensaje;
                _hayRutaValida = false;
                try
                {
                    await ActualizarResumenTecnicoRutaAsync(CancellationToken.None);
                }
                catch
                {
                }
                _tiempoUltimoCalculoRuta = cronometroCalculo.Elapsed;
                StateHasChanged();
                return;
            }
    
            var idxPreferida = proveedorSoloAPiePreferido is not null
                ? _opcionesRuta.FindIndex(opcion => opcion.EsSoloAPie &&
                    string.Equals(opcion.ProveedorRuta, proveedorSoloAPiePreferido, StringComparison.OrdinalIgnoreCase))
                : BuscarIndicePreferidoPorCriterio(_criterioPrioritarioRuta);
            if (idxPreferida < 0 || idxPreferida >= _opcionesRuta.Count)
            {
                idxPreferida = BuscarIndicePreferidoPorCriterio(_criterioPrioritarioRuta);
                if (idxPreferida < 0 || idxPreferida >= _opcionesRuta.Count)
                    idxPreferida = 0;
            }
    
            _indiceAlternativaSeleccionada = idxPreferida;
            ResetEstadoRuta(limpiarOpciones: false, limpiarMensaje: false);
            _mensajeRuta = "Representando ruta seleccionada...";
            StateHasChanged();
            await Task.Yield();
            await PintarOpcionRutaCompleta(_opcionesRuta[idxPreferida]);
            if (!omitirRegistroHistorialEsteCalculo)
            {
                await RegistrarEscenarioActualEnHistorialLocalAsync();
            }
            if (confirmarDerivacionHistorial)
                ConfirmarDerivacionHistorial();
            await ActualizarResumenTecnicoRutaAsync(CancellationToken.None);
            _tiempoUltimoCalculoRuta = cronometroCalculo.Elapsed;
            StateHasChanged();
        }
        catch (OperationCanceledException)
        {
        }
        catch (Exception ex)
        {
            _mensajeRuta = $"Error calculando ruta: {ex.Message}";
            _hayRutaValida = false;
            try
            {
                await ActualizarResumenTecnicoRutaAsync(CancellationToken.None);
            }
            catch
            {
            }
            _tiempoUltimoCalculoRuta = cronometroCalculo.Elapsed;
            StateHasChanged();
        }
    }
    
    
        // =========================================================
        // Pintado
        // =========================================================
    
}