// geo-re.jsx — Adresse unique (Google Places), Street View et irradiance automatique (NASA POWER via worker).
// Clé Google : app_settings « google_maps » → { key } (clé navigateur restreinte au domaine raycast.raycomelectrique.com,
// APIs : Maps JavaScript, Places, Street View Static). Sans clé : le champ reste une saisie libre, sans suggestion.
// Exposé : window.GeoRE = { chargerGoogle, AdresseInput, VueAdresse, streetViewUrl, staticMapUrl, irradiance, decomposer, geocoder, resoudreAdresse }
(function () {
  const { useState, useEffect, useRef } = React;
  const WORKER_URL = window.RAYCAST_WORKER_URL || "https://raycom-ghl-qbo-worker.proud-leaf-b313.workers.dev";
  let keyPromise = null, gPromise = null;

  async function cleGoogle() {
    if (!keyPromise) keyPromise = (async () => {
      try { const v = await window.RaycastDB.getAppSetting("google_maps"); return (v && v.key) || ""; } catch (e) { return ""; }
    })();
    const k = await keyPromise;
    if (!k) keyPromise = null; // pas de clé (ou session pas encore prête) : on réessaiera au prochain appel
    return k;
  }
  /** Charge l'API Maps JS (Places) une seule fois. Résout `google` ou null si pas de clé. */
  async function chargerGoogle() {
    if (window.google && window.google.maps && window.google.maps.places) return window.google;
    if (gPromise) return gPromise;
    gPromise = (async () => {
      const key = await cleGoogle();
      if (!key) return null;
      await new Promise((res, rej) => {
        const s = document.createElement("script");
        s.src = `https://maps.googleapis.com/maps/api/js?key=${encodeURIComponent(key)}&libraries=places&language=fr-CA&region=CA&loading=async`;
        s.async = true; s.onload = res; s.onerror = () => rej(new Error("Google Maps non chargé"));
        document.head.appendChild(s);
      });
      // loading=async : attendre que la librairie Places soit prête
      if (window.google && window.google.maps && window.google.maps.importLibrary) await window.google.maps.importLibrary("places");
      return window.google || null;
    })().catch(() => null);
    const g = await gPromise;
    if (!g) gPromise = null; // échec ou clé absente : nouvel essai possible au prochain montage
    return g;
  }
  const pret = () => !!(window.google && window.google.maps && window.google.maps.places && window.google.maps.places.Autocomplete);
  /** Attend que Places soit réellement utilisable (jusqu'à 12 s), en relançant le chargement si la clé arrive plus tard. */
  async function attendrePlaces() {
    for (let i = 0; i < 30; i++) {
      if (pret()) return window.google;
      await chargerGoogle();
      if (pret()) return window.google;
      await new Promise(r => setTimeout(r, 400));
    }
    return null;
  }
  async function streetViewUrl(lat, lng, size) {
    const key = await cleGoogle();
    if (!key || !isFinite(lat) || !isFinite(lng)) return null;
    return `https://maps.googleapis.com/maps/api/streetview?size=${size || "640x360"}&location=${lat},${lng}&fov=80&pitch=5&key=${encodeURIComponent(key)}`;
  }
  async function staticMapUrl(lat, lng, size) {
    const key = await cleGoogle();
    if (!key || !isFinite(lat) || !isFinite(lng)) return null;
    return `https://maps.googleapis.com/maps/api/staticmap?center=${lat},${lng}&zoom=19&maptype=satellite&size=${size || "640x360"}&markers=color:red%7C${lat},${lng}&key=${encodeURIComponent(key)}`;
  }
  /** Irradiance annuelle (kWh/m²/an) par coordonnées, via le worker (cache serveur). */
  async function irradiance(lat, lng) {
    const { data } = await window.RAYCAST_SUPABASE.auth.getSession();
    const t = data && data.session ? data.session.access_token : null;
    if (!t) throw new Error("session");
    const r = await fetch(`${WORKER_URL}/raycast/irradiance?lat=${lat}&lon=${lng}`, { headers: { Authorization: "Bearer " + t } });
    if (!r.ok) throw new Error("HTTP " + r.status);
    return r.json();
  }
  /** Géocodage par le worker (clé serveur) : repli quand l'adresse a été tapée sans choisir une suggestion. */
  async function geocoder(texte) {
    const { data } = await window.RAYCAST_SUPABASE.auth.getSession();
    const t = data && data.session ? data.session.access_token : null;
    if (!t) throw new Error("session");
    const r = await fetch(`${WORKER_URL}/raycast/geocode?q=${encodeURIComponent(texte)}`, { headers: { Authorization: "Bearer " + t } });
    const j = await r.json().catch(() => ({}));
    if (!r.ok) throw new Error(j.error || `HTTP ${r.status}`);
    const parts = String(j.adresse || "").split(",").map(x => x.trim());
    const m = (parts[0] || "").match(/^(\d+[A-Za-z]?)\s+(.*)$/);
    return { address_full: j.adresse || texte, address_civic: m ? m[1] : "", address_street: m ? m[2] : (parts[0] || ""), address_city: j.ville || "", address_postal: j.code_postal || "", address_province: j.province || "QC", lat: j.lat, lng: j.lng, place_id: j.place_id || null, precision: j.precision };
  }
  /** Biais géographique des recherches : Mascouche, 200 km (Rive-Nord, Montréal, Laurentides, Lanaudière d'abord). */
  const BIAIS = { center: { lat: 45.7236, lng: -73.6248 }, radius: 200000 };
  /** Un résultat est vague quand le texte porte un numéro civique mais que Google renvoie une ville, une province ou un pays. */
  const vague = (texte, r) => /^\s*\d/.test(String(texte || "")) && !(r && r.address_civic);
  /** Même chemin que le menu déroulant Google : première prédiction Places pour le texte, puis détails du lieu. */
  async function parPlaces(texte) {
    const g0 = await chargerGoogle(); // sans clé : réponse immédiate, on passe au worker
    const google = g0 ? (pret() ? window.google : await attendrePlaces()) : null;
    const pl = google && google.maps && google.maps.places;
    if (!pl) return null;
    if (pl.AutocompleteService && pl.PlacesService) {
      const preds = await new Promise(res => { try { new pl.AutocompleteService().getPlacePredictions({ input: texte, componentRestrictions: { country: "ca" }, types: ["address"], locationBias: BIAIS, region: "ca" }, (p, st) => res(st === "OK" && p && p.length ? p : null)); } catch (e) { res(null); } });
      if (!preds) return null;
      const place = await new Promise(res => { try { new pl.PlacesService(document.createElement("div")).getDetails({ placeId: preds[0].place_id, fields: ["address_components", "formatted_address", "geometry", "place_id"] }, (d, st) => res(st === "OK" ? d : null)); } catch (e) { res(null); } });
      return place && place.address_components ? decomposer(place) : null;
    }
    if (pl.AutocompleteSuggestion && pl.AutocompleteSuggestion.fetchAutocompleteSuggestions) {
      try {
        const { suggestions } = await pl.AutocompleteSuggestion.fetchAutocompleteSuggestions({ input: texte, includedRegionCodes: ["ca"], locationBias: BIAIS, language: "fr-CA", region: "ca" });
        const s0 = suggestions && suggestions[0] && suggestions[0].placePrediction;
        if (!s0) return null;
        const place = s0.toPlace();
        await place.fetchFields({ fields: ["addressComponents", "formattedAddress", "location", "id"] });
        return decomposer({ address_components: (place.addressComponents || []).map(a => ({ long_name: a.longText, short_name: a.shortText, types: a.types })), formatted_address: place.formattedAddress, geometry: { location: place.location }, place_id: place.id });
      } catch (e) { return null; }
    }
    return null;
  }
  /** Résout une adresse écrite sans suggestion choisie (fiche ouverte, client importé, champ quitté) :
   *  1) comme le menu Google (Places), 2) géocodage par le worker (clé serveur) ; en ajoutant la ville connue si le texte ne la porte pas.
   *  Rejette les résultats vagues (ville, province, pays) : mieux vaut « introuvable » qu'une mauvaise maison. */
  async function resoudreAdresse(texte, ctx) {
    const t = String(texte || "").replace(/\s+/g, " ").trim();
    if (t.length < 5) throw new Error("Adresse trop courte");
    const c = ctx || {};
    const essais = [t];
    if (c.ville && !t.toLowerCase().includes(String(c.ville).toLowerCase())) essais.push(`${t}, ${c.ville}`);
    for (const e of essais) { try { const r = await parPlaces(e); if (r && r.lat && !vague(t, r)) return r; } catch (_) { /* Places indisponible : worker */ } }
    for (const e of essais) { try { const r = await geocoder(e); if (r && r.lat && !vague(t, r)) return r; } catch (_) { /* essai suivant */ } }
    throw new Error("Adresse introuvable");
  }
  /** Décompose un lieu Google en champs Raycast. */
  function decomposer(place) {
    const g = (type, short) => { const c = (place.address_components || []).find(x => (x.types || []).includes(type)); return c ? (short ? c.short_name : c.long_name) : ""; };
    const loc = place.geometry && place.geometry.location;
    return {
      address_full: place.formatted_address || "",
      address_civic: g("street_number"), address_street: g("route"),
      address_city: g("locality") || g("sublocality") || g("administrative_area_level_3") || g("administrative_area_level_2"),
      address_postal: g("postal_code").toUpperCase(), address_province: g("administrative_area_level_1", true) || "QC",
      lat: loc ? (typeof loc.lat === "function" ? loc.lat() : loc.lat) : null,
      lng: loc ? (typeof loc.lng === "function" ? loc.lng() : loc.lng) : null,
      place_id: place.place_id || null,
    };
  }

  /** Champ d'adresse unique avec suggestions Google ; onPick(champs) reçoit l'adresse décomposée + lat/lng. */
  function AdresseInput({ value, onChange, onPick, onBlur, placeholder }) {
    const ref = useRef(null);
    const [pret, setPret] = useState(false);
    useEffect(() => {
      let alive = true, ac = null;
      attendrePlaces().then(google => {
        if (!alive || !google || !ref.current) return;
        ac = new google.maps.places.Autocomplete(ref.current, { componentRestrictions: { country: "ca" }, fields: ["address_components", "formatted_address", "geometry", "place_id"], types: ["address"] });
        ac.addListener("place_changed", () => { const p = ac.getPlace(); if (p && p.address_components) onPick(decomposer(p)); });
        setPret(true);
      });
      return () => { alive = false; if (ac && window.google) window.google.maps.event.clearInstanceListeners(ac); };
    }, []); // eslint-disable-line
    return (
      <div className="re-adresse">
        <input ref={ref} value={value || ""} onChange={e => onChange(e.target.value)} onBlur={() => { if (onBlur) setTimeout(onBlur, 350); }} placeholder={placeholder || "Tape l'adresse complète du client"} autoComplete="off" />
        <span className={"re-adresse-etat " + (pret ? "ok" : "")} title={pret ? "Suggestions Google Maps actives" : "Clé Google Maps absente : saisie libre (Paramètres → Intégrations)"}>{pret ? "Google Maps" : "saisie libre"}</span>
      </div>
    );
  }

  /** Vignette Street View + satellite pour une fiche ou une soumission. */
  function VueAdresse({ lat, lng, compact }) {
    const [urls, setUrls] = useState(null);
    useEffect(() => { let a = true; (async () => { const [sv, sat] = await Promise.all([streetViewUrl(lat, lng, compact ? "400x220" : "640x360"), staticMapUrl(lat, lng, compact ? "400x220" : "640x360")]); if (a) setUrls(sv ? { sv, sat } : null); })(); return () => { a = false; }; }, [lat, lng, compact]);
    if (!urls) return null;
    return (
      <div className={"re-vue-adresse" + (compact ? " compact" : "")}>
        <img src={urls.sv} alt="Street View" loading="lazy" />
        <img src={urls.sat} alt="Vue satellite" loading="lazy" />
      </div>
    );
  }

  window.GeoRE = { chargerGoogle, AdresseInput, VueAdresse, streetViewUrl, staticMapUrl, irradiance, decomposer, geocoder, resoudreAdresse };
})();
