RutasDBUS/RutasDBUS/Components/Pages/PlanificadorRutas.InspectorZ.cs

using System.Globalization;
using Microsoft.JSInterop;

namespace RutasDBUS.Components.Pages;

public partial class PlanificadorRutas
{
    private PuntoInspectorAnterior? _inspectorPuntoAnterior;
    private double[,]? _caminoInspectorAnterior;
    private bool _caminoInspectorVisible;

    private async Task OcultarCaminoInspectorAsync()
    {
        _caminoInspectorAnterior = null;
        _caminoInspectorVisible = false;
        try { await JS.InvokeVoidAsync("rt.setInspectorWalk", Array.Empty<double[]>(), false); } catch { }
    }

    private async Task AlternarCaminoInspectorAsync()
    {
        if (_caminoInspectorAnterior is null) return;
        _caminoInspectorVisible = !_caminoInspectorVisible;
        var puntos = Enumerable.Range(0, _caminoInspectorAnterior.GetLength(0))
            .Select(i => new[] { _caminoInspectorAnterior[i, 0], _caminoInspectorAnterior[i, 1] }).ToArray();
        await JS.InvokeVoidAsync("rt.setInspectorWalk", puntos, _caminoInspectorVisible);
    }

    private sealed record PuntoInspectorAnterior(
        double Latitud,
        double Longitud,
        double? ElevacionIdee,
        double? ElevacionLocal5,
        double? ElevacionLocal2,
        double? ElevacionLocal1,
        string Direccion,
        double? DistanciaAndandoMetros,
        bool CalculandoDatosAdicionales);

    private double? ObtenerElevacionPuntoInspectorAnterior(PuntoInspectorAnterior punto)
        => UsarElevacionLocal1ParaCalculo
            ? punto.ElevacionLocal1
            : UsarElevacionLocal2ParaCalculo
                ? punto.ElevacionLocal2
                : UsarElevacionLocal5ParaCalculo
                    ? punto.ElevacionLocal5
                    : punto.ElevacionIdee;

    private double? ObtenerElevacionPuntoInspectorActual()
        => UsarElevacionLocal1ParaCalculo
            ? _inspectorElevLocal1
            : UsarElevacionLocal2ParaCalculo
                ? _inspectorElevLocal2
                : UsarElevacionLocal5ParaCalculo
                    ? _inspectorElevLocal5
                    : _inspectorElevIdee;

    private static string FormatearDistanciaPuntoInspector(double distanciaMetros)
        => distanciaMetros < 1000
            ? distanciaMetros.ToString("0.0", CultureInfo.InvariantCulture) + " m"
            : (distanciaMetros / 1000.0).ToString("0.000", CultureInfo.InvariantCulture) + " km";

    private static string FormatearAlturaPuntoInspector(double? altura)
        => altura is { } valor
            ? valor.ToString("0.00", CultureInfo.InvariantCulture) + " m"
            : "-";

    private static string FormatearDiferenciaAlturaPuntoInspector(
        double? alturaActual,
        double? alturaAnterior)
        => alturaActual is { } actual && alturaAnterior is { } anterior
            ? (actual - anterior).ToString("+0.00;-0.00;0.00", CultureInfo.InvariantCulture) + " m"
            : "-";

    private string ObtenerDireccionPuntoInspectorActual()
        => FormatearLugarCallejeroResumen(_inspectorLugaresCercanos.FirstOrDefault());

    private async Task<string> ResolverDireccionPuntoInspectorAnteriorAsync(PuntoInspectorAnterior punto)
    {
        if (!string.IsNullOrWhiteSpace(punto.Direccion))
            return punto.Direccion;

        try
        {
            var cercano = await GeocodificadorLocal.BuscarMasCercanoAsync(
                punto.Latitud,
                punto.Longitud,
                CancellationToken.None);
            return FormatearLugarCallejeroResumen(cercano);
        }
        catch
        {
            return string.Empty;
        }
    }

    private async Task CompletarDatosPuntoInspectorAnteriorAsync(
        PuntoInspectorAnterior punto,
        int versionInspector)
    {
        try
        {
            var tareaDireccion = ResolverDireccionPuntoInspectorAnteriorAsync(punto);
            var tareaCaminata = ClienteValhalla.ObtenerRutaAsync(
                punto.Latitud,
                punto.Longitud,
                _inspectorLat,
                _inspectorLon);

            await Task.WhenAll(tareaDireccion, tareaCaminata);

            if (versionInspector != _versionInspector || _inspectorPuntoAnterior is not { } puntoVigente ||
                puntoVigente.Latitud != punto.Latitud || puntoVigente.Longitud != punto.Longitud)
            {
                return;
            }

            var caminata = await tareaCaminata;
            _caminoInspectorAnterior = caminata.Linea;
            _inspectorPuntoAnterior = puntoVigente with
            {
                Direccion = await tareaDireccion,
                DistanciaAndandoMetros = caminata.Linea is not null && double.IsFinite(caminata.DistanciaMetros) && caminata.DistanciaMetros >= 0
                    ? caminata.DistanciaMetros
                    : null,
                CalculandoDatosAdicionales = false
            };

            await InvokeAsync(StateHasChanged);
        }
        catch
        {
            if (versionInspector != _versionInspector || _inspectorPuntoAnterior is not { } puntoVigente ||
                puntoVigente.Latitud != punto.Latitud || puntoVigente.Longitud != punto.Longitud)
            {
                return;
            }

            _inspectorPuntoAnterior = puntoVigente with { CalculandoDatosAdicionales = false };
            await InvokeAsync(StateHasChanged);
        }
    }
}