#!/usr/bin/env python3
# geo.py — Test de geolocalización WinRT (Windows) con modo adaptativo opcional.
# Uso rápido:
#   python geo.py
#   python geo.py --help

import sys, os, math, asyncio, datetime, time
import argparse

# ---- Comprobación winsdk ----------------------------------------------
try:
    from winsdk.windows.devices.geolocation import (
        Geolocator,
        PositionAccuracy,
        PositionStatus,
        GeolocationAccessStatus,
    )
except Exception:
    print("Falta el paquete 'winsdk'. Instálalo con: pip install winsdk")
    sys.exit(1)

# ---- Utilidades --------------------------------------------------------
def status_name(s):
    m = {
        PositionStatus.NOT_INITIALIZED: "NOT_INITIALIZED",
        PositionStatus.NO_DATA: "NO_DATA",
        PositionStatus.DISABLED: "DISABLED",
        PositionStatus.NOT_AVAILABLE: "NOT_AVAILABLE",
        PositionStatus.READY: "READY",
        PositionStatus.INITIALIZING: "INITIALIZING",
    }
    return m.get(s, str(s))

def access_name(a):
    m = {
        GeolocationAccessStatus.ALLOWED: "ALLOWED",
        GeolocationAccessStatus.DENIED: "DENIED",
        GeolocationAccessStatus.UNSPECIFIED: "UNSPECIFIED",
    }
    return m.get(a, str(a))

def _nan_to_none(x):
    if x is None:
        return None
    try:
        return None if (isinstance(x, float) and math.isnan(x)) else x
    except Exception:
        return x

def src_name(c):
    src = getattr(c, "position_source", None)
    return getattr(src, "name", src)

async def watch_status(geo, verbose: bool, seconds=20):
    if not verbose:
        return
    last = None
    for _ in range(int(seconds * 2)):
        s = status_name(geo.location_status)
        if s != last:
            print(f"[{datetime.datetime.now().strftime('%H:%M:%S')}] Estado proveedor: {s}")
            last = s
        await asyncio.sleep(0.5)

# ---- Intentos ----------------------------------------------------------
async def _try_default(geo: Geolocator, t: int, max_age_s: int, target_acc_m: float):
    start = time.perf_counter()
    geo.desired_accuracy = PositionAccuracy.DEFAULT
    if hasattr(geo, "desired_accuracy_in_meters"):
        try:
            # “Pista” para que se quede en proveedor de red si vale
            geo.desired_accuracy_in_meters = max(int(target_acc_m), 100)
        except Exception:
            pass
    try:
        if max_age_s > 0:
            from datetime import timedelta
            pos = await asyncio.wait_for(
                geo.get_geoposition_async(timedelta(seconds=max_age_s), timedelta(seconds=t)),
                timeout=t + 1
            )
        else:
            pos = await asyncio.wait_for(geo.get_geoposition_async(), timeout=t)
        return pos, time.perf_counter() - start, None
    except Exception as e:
        return None, time.perf_counter() - start, e

async def _try_high(geo: Geolocator, t: int):
    start = time.perf_counter()
    geo.desired_accuracy = PositionAccuracy.HIGH
    try:
        pos = await asyncio.wait_for(geo.get_geoposition_async(), timeout=t)
        return pos, time.perf_counter() - start, None
    except Exception as e:
        return None, time.perf_counter() - start, e

def pack_result(geo: Geolocator, pos, mode_used: str, attempts: int, elapsed_s: float):
    c = pos.coordinate
    p = c.point.position
    data = {
        "timestamp": getattr(c, "timestamp", None),
        "latitude": p.latitude,
        "longitude": p.longitude,
        "altitude_m": _nan_to_none(getattr(p, "altitude", None)),
        "accuracy_m": getattr(c, "accuracy", None),
        "altitude_accuracy_m": getattr(c, "altitude_accuracy", None),
        "speed_m_s": getattr(c, "speed", None),
        "heading_deg": getattr(c, "heading", None),
        "source": src_name(c),
        "provider_status": status_name(getattr(geo, "location_status", None)),
        "mode_used": mode_used,
        "attempts": attempts,
        "elapsed_s": round(elapsed_s, 3),
    }
    return data

# ---- Lógica principal adaptativa ---------------------------------------
async def get_position(mode: str, timeout_total: int, t_default: int, t_high: int,
                       target_acc_m: float, max_age_s: int, warmup: float,
                       verbose: bool, no_escalate: bool):
    # Acceso
    access = await Geolocator.request_access_async()
    print(f"Acceso del sistema: {access_name(access)}")
    if access != GeolocationAccessStatus.ALLOWED:
        return None, 2, "Acceso denegado por Windows (habilita Ubicación para apps de escritorio)."

    geo = Geolocator()
    print(f"Estado inicial del proveedor: {status_name(geo.location_status)}")

    if warmup > 0:
        # Pequeño warm-up (especialmente útil si hay WWAN/GNSS)
        status_task = asyncio.create_task(watch_status(geo, verbose, seconds=max(warmup, 3)))
        await asyncio.sleep(min(max(warmup, 0.5), 10.0))
        status_task.cancel()

    # Modo forzado
    if mode == "high":
        pos, dt, err = await _try_high(geo, max(1, timeout_total))
        if pos:
            return pack_result(geo, pos, "HIGH", 1, dt), 0, None
        return None, 3, f"Timeout/err en HIGH ({timeout_total}s): {repr(err)}"

    if mode == "default":
        pos, dt, err = await _try_default(geo, max(1, timeout_total), max_age_s, target_acc_m)
        if pos:
            return pack_result(geo, pos, "DEFAULT", 1, dt), 0, None
        return None, 3, f"Timeout/err en DEFAULT ({timeout_total}s): {repr(err)}"

    # Modo adaptativo
    attempts = 0
    t_remain = max(1, timeout_total)

    # Reparto de tiempos si no se especificaron
    if t_default <= 0 and t_high <= 0:
        t_default = max(1, min(t_remain - 1, int(t_remain * 0.6)))
        t_high = max(0, t_remain - t_default)

    # 1) DEFAULT
    td = min(t_default if t_default > 0 else t_remain, t_remain)
    attempts += 1
    if verbose:
        print(f"[ADAPT] DEFAULT (t={td}s, max_age={max_age_s}s, target_acc={target_acc_m}m)")
    pos, dt1, err1 = await _try_default(geo, td, max_age_s, target_acc_m)
    t_remain -= td
    if pos:
        c = pos.coordinate
        acc = getattr(c, "accuracy", 9999) or 9999
        src = src_name(c)
        if verbose:
            print(f"[ADAPT] DEFAULT → src={src}, acc={acc}m")
        if no_escalate or acc <= target_acc_m or src in ("WIFI", "GNSS") or t_remain <= 0:
            return pack_result(geo, pos, "DEFAULT", attempts, dt1), 0, None

    # 2) HIGH (si queda presupuesto)
    if t_remain > 0 and not no_escalate:
        th = min(t_high if t_high > 0 else t_remain, t_remain)
        attempts += 1
        if verbose:
            print(f"[ADAPT] HIGH (t={th}s)")
        pos2, dt2, err2 = await _try_high(geo, th)
        if pos2:
            return pack_result(geo, pos2, "HIGH", attempts, dt1 + dt2), 0, None
        return None, 3, f"Timeout/err: DEFAULT({td}s) y HIGH({th}s). " \
                        f"err_default={repr(err1)} err_high={repr(err2)}"

    # Sin presupuesto tras DEFAULT
    return None, 3, f"Timeout/err en DEFAULT ({td}s): {repr(err1)}"

# ---- CLI ----------------------------------------------------------------
def parse_args():
    p = argparse.ArgumentParser(
        description="Prueba de geolocalización Windows (WinRT) con modo adaptativo."
    )
    p.add_argument("--mode", choices=["adaptive", "default", "high"], default="adaptive",
                   help="Estrategia de obtención. Por defecto: adaptive.")
    p.add_argument("--timeout", type=int, default=20,
                   help="Presupuesto total de tiempo en segundos (por defecto 20).")
    p.add_argument("--t-default", type=int, default=0,
                   help="Tiempo (s) para DEFAULT dentro del modo adaptativo. Si 0, se reparte automáticamente.")
    p.add_argument("--t-high", type=int, default=0,
                   help="Tiempo (s) para HIGH dentro del modo adaptativo. Si 0, se reparte automáticamente.")
    p.add_argument("--target-acc", type=float, default=150.0,
                   help="Precisión objetivo en metros para considerar suficiente DEFAULT (por defecto 150).")
    p.add_argument("--max-age", type=int, default=0,
                   help="Aceptar caché de hasta X segundos en DEFAULT (por defecto 0 = solo posiciones frescas).")
    p.add_argument("--warmup", type=float, default=0.0,
                   help="Warm-up en segundos antes de pedir posición (p.ej. 3–6s si hay WWAN).")
    p.add_argument("--no-escalate", action="store_true",
                   help="No escalar a HIGH nunca (solo DEFAULT).")
    p.add_argument("--json", action="store_true",
                   help="Salida en JSON (una línea).")
    p.add_argument("--verbose", "-v", action="store_true",
                   help="Más trazas (estados de proveedor, etapas adaptativas).")
    # Nuevo: solo <3.14, por si quieres forzar selector legacy
    p.add_argument("--force-selector", action="store_true",
                   help="(Solo <3.14) Forzar WindowsSelectorEventLoopPolicy. No usar salvo necesidad.")
    return p.parse_args()

def _maybe_force_selector(force_flag: bool):
    """Evita deprecations en 3.14+: solo fuerza selector en <3.14 si el usuario lo pide
       (flag --force-selector o env GEO_FORCE_SELECTOR=1)."""
    try:
        if not sys.platform.startswith("win"):
            return
        if sys.version_info >= (3, 14):
            return  # nada que hacer en 3.14+
        want = force_flag or os.getenv("GEO_FORCE_SELECTOR") in ("1","true","TRUE")
        if want and hasattr(asyncio, "WindowsSelectorEventLoopPolicy"):
            asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())  # ok en <3.14
    except Exception:
        pass

def main():
    if not sys.platform.startswith("win"):
        print("Este test solo está soportado en Windows.")
        sys.exit(1)

    args = parse_args()
    # En 3.13.x funcionará sin tocar la policy; solo si lo pides explícitamente:
    _maybe_force_selector(args.force_selector)

    if not args.json:
        print("=== Prueba de geolocalización Windows (WinRT) ===")
        print(f"Modo: {args.mode} | Presupuesto total: {args.timeout}s\nSolicitando una posición...\n")

    data, code, err = asyncio.run(get_position(
        mode=args.mode,
        timeout_total=args.timeout,
        t_default=args.t_default,
        t_high=args.t_high,
        target_acc_m=args.target_acc,
        max_age_s=args.max_age,
        warmup=args.warmup,
        verbose=args.verbose,
        no_escalate=args.no_escalate
    ))

    if err:
        if args.json:
            import json
            print(json.dumps({"ok": False, "error": err, "code": code}, default=str))
        else:
            print("No se pudo obtener posición.")
            print("Motivo:", err)
            print("""
Pistas para habilitarlo:
  1) Configuración → Privacidad y seguridad → Ubicación:
     • Activar "Servicios de ubicación".
     • Activar "Permitir que las aplicaciones de escritorio accedan a tu ubicación".
  2) Servicio de Windows "Geolocalización" (lfsvc) en ejecución.
  3) En Windows Server: comprobar directivas en gpedit.msc
     (Equipo → Plantillas administrativas → Componentes de Windows → 'Ubicación y sensores').
  4) Si el equipo tiene SIM/WWAN y no hay GNSS, prueba con --mode adaptive o --no-escalate,
     o añade --warmup 4 y acepta caché con --max-age 300.
""")
        sys.exit(code or 2)

    # Éxito
    if args.json:
        import json
        print(json.dumps({"ok": True, "data": data}, default=str))
    else:
        print("✔ Posición obtenida:")
        ts = data["timestamp"]
        if isinstance(ts, datetime.datetime):
            ts_str = ts.strftime("%Y-%m-%d %H:%M:%S")
        else:
            ts_str = str(ts)
        print(f"  Timestamp:       {ts_str}")
        print(f"  Lat, Lon:        {data['latitude']:.6f}, {data['longitude']:.6f}")
        print(f"  Precisión (m):   {data['accuracy_m']}")
        print(f"  Altitud (m):     {data['altitude_m']}")
        print(f"  Fuente:          {data['source']}")
        print(f"  Estado proveedor:{data['provider_status']}")
        print(f"  Modo usado:      {data['mode_used']} (intentos={data['attempts']}, {data['elapsed_s']}s)")

if __name__ == "__main__":
    main()
​
​