// solaire-design-re.jsx — Design solaire phase 1 : Google Solar API via le worker, carte satellite avec panneaux,
// choix du nombre de panneaux, pans exclus, application à la soumission (pans de toit, panneaux, production).
// Exposé : window.SolaireDesignRE ({ state, setState })
(function () {
  const { useState, useEffect, useRef, useMemo } = React;
  const WORKER_URL = window.RAYCAST_WORKER_URL || "https://raycom-ghl-qbo-worker.proud-leaf-b313.workers.dev";
  const fmtInt = (n) => Math.round(Number(n) || 0).toLocaleString("fr-CA");
  const fmtNum = (n) => (Number(n) || 0).toLocaleString("fr-CA", { maximumFractionDigits: 1 });

  async function analyserToit(lat, lng, qualite) {
    const { data } = await window.RAYCAST_SUPABASE.auth.getSession();
    const t = data && data.session ? data.session.access_token : null;
    if (!t) throw new Error("Session expirée");
    const r = await fetch(`${WORKER_URL}/raycast/solaire/toit?lat=${lat}&lon=${lng}&qualite=${qualite || "MEDIUM"}`, { headers: { Authorization: "Bearer " + t } });
    const j = await r.json().catch(() => ({}));
    if (!r.ok) throw new Error(j.error || `HTTP ${r.status}`);
    return j;
  }
  /** Rectangle d'un panneau (4 coins lat/lng) centré sur (lat,lng) : grand côté le long de la pente (portrait), raccourci par cos(pente)
   *  vu du ciel, tourné selon l'azimut du pan (angle horaire depuis le nord, direction de la descente). */
  function coinsPanneau(p, az, pente, dims) {
    const w = p.orientation === "paysage" ? dims.h : dims.w, h = (p.orientation === "paysage" ? dims.w : dims.h) * Math.cos(((pente || 0) * Math.PI) / 180);
    const rad = (az * Math.PI) / 180, cos = Math.cos(rad), sin = Math.sin(rad);
    const mLat = 1 / 111320, mLng = 1 / (111320 * Math.cos((p.lat * Math.PI) / 180));
    return [[-w / 2, -h / 2], [w / 2, -h / 2], [w / 2, h / 2], [-w / 2, h / 2]].map(([x, y]) => {
      const est = x * cos + y * sin, nord = -x * sin + y * cos; // rotation horaire : y (long de la pente) pointe vers l'azimut
      return { lat: p.lat + nord * mLat, lng: p.lng + est * mLng };
    });
  }
  const azimutsDe = (toit) => Object.fromEntries((toit.segments || []).map(s => [s.index, s.azimut_deg]));
  const pentesDe = (toit) => Object.fromEntries((toit.segments || []).map(s => [s.index, s.pente_deg]));
  const dimsGoogle = (toit) => ({ w: (toit.panneau_google && toit.panneau_google.largeur_m) || 1.045, h: (toit.panneau_google && toit.panneau_google.hauteur_m) || 1.879 });

  function SolaireDesignRE({ state, setState }) {
    const c = state.client || {};
    const s = state.solaire || {};
    const p = state.parcours || {};
    const [toit, setToit] = useState(s.design_google || null);
    const [etat, setEtat] = useState({});
    const [nb, setNb] = useState(s.design_google ? (s.design_google_nb || 0) : 0);
    const [exclus, setExclus] = useState(new Set(s.design_google_exclus || []));
    const mapRef = useRef(null), mapObj = useRef(null), overlays = useRef([]);
    const cat = window.CatalogueRE && window.CatalogueRE._cache && window.CatalogueRE._cache();
    const PR = window.ParcoursRE || {};
    const modele = p.panneau || "longi500";
    const artPan = cat && cat.byId && PR.ID ? cat.byId.get(PR.ID[modele]) : null;
    // Puissance de notre panneau : lue sur l'article du catalogue, sinon table du parcours, sinon 500 W (LONGi par défaut).
    const wattsNotre = (artPan && artPan.watts) || (PR.WATTS && PR.WATTS[modele]) || 500;
    const dims = modele === "longi500" ? { w: 1.134, h: 1.96 } : { w: 1.134, h: 2.382 };

    const lancer = async (qualite) => {
      let lat = c.lat, lng = c.lng;
      setEtat({ loading: true });
      if (!lat || !lng) {
        // Adresse tapée sans suggestion, ou client repris d'une ancienne fiche : on géocode par le worker.
        const texte = c.address_full || [c.address_civic, c.address_street, c.address_city, c.address_postal].filter(Boolean).join(", ");
        if (!texte || texte.length < 5 || !window.GeoRE || !window.GeoRE.geocoder) { setEtat({ err: "Entre d'abord l'adresse du client à l'étape Client (numéro, rue et ville suffisent)." }); return; }
        try {
          const g = await window.GeoRE.geocoder(texte);
          lat = g.lat; lng = g.lng;
          setState(st => ({ ...st, client: { ...(st.client || {}), ...g, address_full: g.address_full } }));
        } catch (e) { setEtat({ err: "Adresse introuvable par Google (" + String(e.message || e) + "). Vérifie l'adresse à l'étape Client." }); return; }
      }
      try {
        const t = await analyserToit(lat, lng, qualite);
        setToit(t); setExclus(new Set());
        const defaut = Math.min(Number(p.nb_panneaux) || 0, t.max_panneaux || 0) || Math.min(12, t.max_panneaux || 0);
        setNb(defaut); setEtat({});
      } catch (e) { setEtat({ err: String(e.message || e) }); }
    };

    // Les panneaux de référence Google (≈ 400 W, 1,88 × 1,05 m) sont plus petits que les nôtres : le nombre qui tient
    // sur chaque pan est réduit au prorata des surfaces, et l'énergie suit (même irradiance par m²).
    const ratioSurface = useMemo(() => { const g = toit && toit.panneau_google; const sg = g && g.hauteur_m && g.largeur_m ? g.hauteur_m * g.largeur_m : 1.96; return Math.min(1, sg / (dims.w * dims.h)); }, [toit, dims.w, dims.h]);
    // Configuration retenue : la plus grande config dont le nombre de panneaux (hors pans exclus, ramené à nos panneaux) ≤ nb demandé
    const choix = useMemo(() => {
      if (!toit || !toit.configs || !toit.configs.length) return null;
      const utiles = toit.configs.map(cf => {
        const parPan = cf.par_pan.filter(r => !exclus.has(r.pan)).map(r => ({ ...r, panneaux_google: r.panneaux, panneaux: Math.max(0, Math.floor(r.panneaux * ratioSurface)), kwh_dc_an: r.kwh_dc_an * ratioSurface }));
        return { cf, panneaux: parPan.reduce((t, r) => t + r.panneaux, 0), kwh: parPan.reduce((t, r) => t + r.kwh_dc_an, 0), parPan };
      }).filter(u => u.panneaux > 0);
      let best = null;
      for (const u of utiles) if (u.panneaux <= nb && (!best || u.panneaux > best.panneaux)) best = u;
      return best || utiles[0];
    }, [toit, nb, exclus]);
    const facteur = toit && toit.panneau_google && toit.panneau_google.watts ? wattsNotre / toit.panneau_google.watts : 1;
    const kwhNotre = choix ? Math.round(choix.kwh * facteur) : 0;
    const panneauxVis = useMemo(() => {
      if (!toit || !choix) return [];
      // Implantation de référence : la grille Google (panneaux de référence, positions et tailles cohérentes) pour la config choisie ;
      // nos panneaux plus grands sont comptés au prorata, l'implantation exacte à la main vient avec l'éditeur.
      const parPanRestant = Object.fromEntries(choix.parPan.map(r => [r.pan, r.panneaux_google != null ? r.panneaux_google : r.panneaux]));
      const out = [];
      for (const pan of toit.panneaux || []) { if (parPanRestant[pan.pan] > 0) { out.push(pan); parPanRestant[pan.pan]--; } }
      return out;
    }, [toit, choix]);

    // Carte Google (satellite) avec les panneaux dessinés
    useEffect(() => {
      if (!toit || !window.GeoRE || !mapRef.current) return;
      let alive = true;
      window.GeoRE.chargerGoogle().then(google => {
        if (!alive || !google || !google.maps) return;
        const centre = toit.centre || { lat: c.lat, lng: c.lng };
        if (!centre.lat) return;
        if (!mapObj.current) mapObj.current = new google.maps.Map(mapRef.current, { center: centre, zoom: 20, mapTypeId: "satellite", tilt: 0, disableDefaultUI: true, zoomControl: true, gestureHandling: "greedy" });
        overlays.current.forEach(o => o.setMap(null)); overlays.current = [];
        const az = azimutsDe(toit), pe = pentesDe(toit), dg = dimsGoogle(toit);
        for (const pan of panneauxVis) {
          const poly = new google.maps.Polygon({ paths: coinsPanneau(pan, az[pan.pan] || 0, pe[pan.pan] || 0, dg), strokeColor: "#0ea5e9", strokeWeight: 1, fillColor: "#0c4a6e", fillOpacity: 0.85, map: mapObj.current });
          overlays.current.push(poly);
        }
        for (const seg of toit.segments || []) {
          if (!seg.centre) continue;
          const m = new google.maps.Marker({ position: seg.centre, map: mapObj.current, label: { text: String(seg.index + 1), color: "#fff", fontWeight: "700", fontSize: "11px" }, icon: { path: google.maps.SymbolPath.CIRCLE, scale: 11, fillColor: exclus.has(seg.index) ? "#64748b" : "#f59e0b", fillOpacity: 0.95, strokeColor: "#fff", strokeWeight: 1.5 }, title: `Pan ${seg.index + 1} : ${seg.orientation}, ${seg.pente}` });
          m.addListener("click", () => setExclus(prev => { const n = new Set(prev); n.has(seg.index) ? n.delete(seg.index) : n.add(seg.index); return n; }));
          overlays.current.push(m);
        }
      });
      return () => { alive = false; };
    }, [toit, panneauxVis, exclus]); // eslint-disable-line

    /** Image fixe (Static Maps) avec les panneaux, convertie en data: pour la proposition et le PDF. */
    const imageDesign = async () => {
      if (!window.GeoRE || !window.GeoRE.staticMapUrl) return null;
      const base = await window.GeoRE.staticMapUrl((toit.centre || c).lat, (toit.centre || c).lng, "640x400");
      if (!base) return null;
      const u = new URL(base); u.searchParams.set("zoom", "20"); u.searchParams.delete("markers");
      const az = azimutsDe(toit), pe = pentesDe(toit), dg = dimsGoogle(toit);
      for (const pan of panneauxVis.slice(0, 60)) { const pts = coinsPanneau(pan, az[pan.pan] || 0, pe[pan.pan] || 0, dg); u.searchParams.append("path", "color:0x0ea5e9ff|weight:1|fillcolor:0x0c4a6edd|" + pts.concat([pts[0]]).map(q => `${q.lat.toFixed(6)},${q.lng.toFixed(6)}`).join("|")); }
      const url = u.toString();
      try {
        const img = await new Promise((res, rej) => { const i = new Image(); i.crossOrigin = "anonymous"; i.onload = () => res(i); i.onerror = rej; i.src = url; });
        const cv = document.createElement("canvas"); cv.width = img.naturalWidth; cv.height = img.naturalHeight; cv.getContext("2d").drawImage(img, 0, 0);
        return cv.toDataURL("image/jpeg", 0.88);
      } catch (e) { return url; }
    };

    const appliquer = async () => {
      if (!toit || !choix) return;
      const segs = (toit.segments || []).filter(sg => !exclus.has(sg.index));
      const parPan = Object.fromEntries(choix.parPan.map(r => [r.pan, r.panneaux]));
      const pans_toit = segs.filter(sg => parPan[sg.index] > 0).sort((a, b) => parPan[b.index] - parPan[a.index]).slice(0, 6).map((sg, i) => ({ nom: i === 0 ? "toit principal" : `pan ${sg.index + 1}`, orientation: sg.orientation, revetement: s.revetement || (s.pans_toit && s.pans_toit[0] && s.pans_toit[0].revetement) || "", pente: sg.pente, nb_panneaux: parPan[sg.index] }));
      const image = await imageDesign();
      const nbTotal = choix.panneaux;
      // Recomposition du devis par le parcours (ou passage du parcours en mode solaire si la soumission vient du catalogue).
      const catNow = window.CatalogueRE && window.CatalogueRE._cache ? window.CatalogueRE._cache() : null;
      const r = catNow && PR.appliquerPanneaux ? PR.appliquerPanneaux(state, catNow, { nb_panneaux: nbTotal }) : { parcours: { ...(PR.DEFAUT || {}), ...p, nb_panneaux: nbTotal }, lignes: state.lignes };
      setState({ ...state, parcours: r.parcours, lignes: r.lignes, solaire: { ...s, pans_toit, pans: pans_toit.map(x => x.nom).join(", "), orientation: pans_toit.map(x => x.orientation).join(", "), pente: pans_toit[0] ? pans_toit[0].pente : s.pente, acces_pct: 100, production_google_kwh: kwhNotre, production_source: "google", design_google: toit, design_google_nb: nbTotal, design_google_exclus: [...exclus], aurora_image: image || s.aurora_image || null } });
      setEtat({ ok: `Design appliqué : ${nbTotal} panneaux de ${wattsNotre} W, ≈ ${fmtInt(kwhNotre * 0.96)} kWh/an AC.` });
    };

    return (
      <div className="re-design span">
        <div className="re-design-head">
          <div><b>Design solaire automatique</b><span className="re-muted"> toit détecté, ombrage et production réels (Google Solar)</span></div>
          <div className="re-inline">
            {toit && toit.qualite_imagerie !== "HIGH" && <button className="re-btn small" onClick={() => lancer("LOW")} title="Imagerie de moindre qualité si rien n'est trouvé">Réessayer (basse qualité)</button>}
            {toit && <span className="re-muted" style={{ fontSize: 12 }}>Implantation de référence Google (panneaux {toit.panneau_google && toit.panneau_google.watts} W) ; placement exact à la main avec l'éditeur, bientôt.</span>}
            <button className="re-btn primary small" disabled={etat.loading} onClick={() => lancer("MEDIUM")}>{etat.loading ? "Analyse…" : toit ? "↻ Analyser à nouveau" : "Analyser le toit"}</button>
          </div>
        </div>
        {etat.err && <div className="re-alert error">{etat.err}</div>}
        {etat.ok && <div className="re-alert ok">{etat.ok}</div>}
        {toit && (
          <div className="re-design-corps">
            <div ref={mapRef} className="re-design-carte" />
            <div className="re-design-panneau">
              <div className="re-design-meta">{(toit.segments || []).length} pans détectés · imagerie {toit.qualite_imagerie ? toit.qualite_imagerie.toLowerCase() : "?"}{toit.date_imagerie ? ` (${toit.date_imagerie})` : ""} · {Math.floor((toit.max_panneaux || 0) * ratioSurface)} panneaux de {wattsNotre} W max</div>
              <label className="re-field"><span className="re-field-label">Nombre de panneaux ({wattsNotre} W)</span>
                <div className="re-inline"><input type="range" min="1" max={Math.max(1, Math.floor((toit.max_panneaux || 1) * ratioSurface))} value={nb} onChange={e => setNb(Number(e.target.value))} /><b style={{ minWidth: 34, textAlign: "right" }}>{choix ? choix.panneaux : 0}</b></div>
              </label>
              <div className="re-design-kpis">
                <div><b>{fmtNum((choix ? choix.panneaux : 0) * wattsNotre / 1000)} kW</b><span>puissance</span></div>
                <div><b>{fmtInt(kwhNotre * 0.96)} kWh</b><span>production AC / an</span></div>
                <div><b>{choix && choix.panneaux ? fmtInt(kwhNotre * 0.96 / (choix.panneaux * wattsNotre / 1000)) : "—"}</b><span>kWh par kW</span></div>
              </div>
              <div className="re-design-pans">
                {(toit.segments || []).map(sg => {
                  const r = choix && choix.parPan.find(x => x.pan === sg.index);
                  return (
                    <label key={sg.index} className={"re-design-pan" + (exclus.has(sg.index) ? " off" : "")}>
                      <input type="checkbox" checked={!exclus.has(sg.index)} onChange={() => setExclus(prev => { const n = new Set(prev); n.has(sg.index) ? n.delete(sg.index) : n.add(sg.index); return n; })} />
                      <span className="re-design-num">{sg.index + 1}</span>
                      <span className="re-design-desc">{sg.orientation} · {sg.pente} · {sg.surface_m2} m²{sg.ensoleillement_h ? ` · ${fmtInt(sg.ensoleillement_h)} h de soleil` : ""}</span>
                      <b>{r ? r.panneaux : 0}</b>
                    </label>
                  );
                })}
              </div>
              <button className="re-btn primary" disabled={!choix} onClick={appliquer}>Appliquer à la soumission</button>
              <div className="re-muted" style={{ fontSize: 12 }}>Applique le nombre de panneaux, les pans de toit, la production réelle et l'image du toit à la proposition. Référence Google : panneaux de {(toit.panneau_google && toit.panneau_google.watts) || "?"} W ; le nombre est ramené à la taille de nos panneaux de {wattsNotre} W et la production suit.</div>
            </div>
          </div>
        )}
        {toit && window.SolaireEditeurRE && <window.SolaireEditeurRE state={state} setState={setState} toit={toit} />}
      </div>
    );
  }
  window.SolaireDesignRE = SolaireDesignRE;
})();
