using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using TMPro;
using System.Text;

public class Measure : MonoBehaviour
{
   //public Slider DoorColorSlider;
   // public void startpnl(){
   //    if (GameObject.Find("ROOM").transform.childCount != 0) {
   //        DOIT.DELETEAllChild("ROOM");
   //        ResetObjects();
   //        }
   //    //DOIT.CloseALLPNL();
   //    GameObject.Find("Canvas").transform.Find("START").gameObject.SetActive(true);
   //  }
   public void ResetObjects()
   {
      DOIT.DELETEAllChild("SCENE"); 
      _G.OBJnum = 0;
      _G.OBJs = new string[300][];
   }
   public void goFull()
   {
      //Screen.SetResolution(Display.main.systemWidth, Display.main.systemHeight, true, 30);
      Screen.SetResolution(960, 480, true, 60);
   }
   //--------------------------GO PNL----------------------------------------
   public void goSTART()
    {
      ShowPNL("START");
      ResetObjects();
      CabinetCollectionSelected();// le bouton de depart reste cache tant que rien n'est choisi
    }
   // A brancher sur le OnValueChanged des toggles de START/Cabinet Collection (Universal, IKEA).
   // Le bouton START n'apparait qu'une fois une collection cochee.
   public void CabinetCollectionSelected()
    {
      GameObject Container = Get.o2("Canvas/START", "Cabinet Collection");
      // Conteneur masque (bannieres autres que kitchengo) : il n'y a rien a choisir,
      // le bouton de depart doit rester accessible.
      bool Any = Container == null || !Container.activeSelf || Get.TogSelected(Container) != null;

      GameObject Btn = Get.o2("Canvas/START", "START");
      if (Btn != null) Btn.SetActive(Any);
    }
   public void goFORM()
    {
      ShowPNL("FORM");
    }  
   public void goINSPIRATION()
    {
      ShowPNL("INSPIRATION");
      Selected("INSPIRATION");
    }  
   public void goDOORSTYLE()
    {
      string fromPNL = _G.PNL;//avant que ShowPNL ne l'ecrase
      ShowPNL("DOORSTYLE");
      Get.o2("Canvas/DOORSTYLE","COLORS DOOR").SetActive(false);
      Selected("DOORSTYLE");
      GameObject SELECTION = Get.o2("DOORSTYLE","SELECTION");
      DOIT.AllChildOff(SELECTION);

      if (_G.PATH == "hampton_bay")
      {
         SetDoorByLabel(SELECTION,"1",Color.white);
         SetDoorByLabel(SELECTION,"2",Color.white);
         SetDoorByLabel(SELECTION,"3",Color.white);
      }
      if (_G.PATH == "baindepot")
      {
         SetDoorByLabel(SELECTION,"2",Color.white);
      }
      if (_G.PATH == "bmr")
      {
         SetDoorByLabel(SELECTION,"2",Color.white);
         SetDoorByLabel(SELECTION,"2B",DOIT.CSc("C6C5C5",255));
         SetDoorByLabel(SELECTION,"4",DOIT.CSc("FFE8BD",255));
      }
      if (_G.PATH == "armoiredepot")
      {
         SetDoorByLabel(SELECTION,"2",Color.white);
         SetDoorByLabel(SELECTION,"2B",DOIT.CSc("C6C5C5",255));
         SetDoorByLabel(SELECTION,"4",DOIT.CSc("FFE8BD",255));
      }
      if (_G.PATH == "homehardware")
      {
         SetDoorByLabel(SELECTION,"2",Color.white);
         SetDoorByLabel(SELECTION,"2B",DOIT.CSc("C6C5C5",255));
         SetDoorByLabel(SELECTION,"4",DOIT.CSc("FFE8BD",255));
      }
      if (_G.PATH == "kent")
      {
         SetDoorByLabel(SELECTION,"2",DOIT.CSc("919FAB",255));
         SetDoorByLabel(SELECTION,"2B",DOIT.CSc("8CA496",255));
         SetDoorByLabel(SELECTION,"2C",Color.white);
         SetDoorByLabel(SELECTION,"4",DOIT.CSc("FFE8BD",255));
         SetDoorByLabel(SELECTION,"2D",Color.grey);
         SetDoorByLabel(SELECTION,"2E",DOIT.CSc("C6C5C5",255));
      }
      if (_G.PATH == "collection_elite")
      {
         SetDoorByLabel(SELECTION,"2",Color.white);
         SetDoorByLabel(SELECTION,"2B",DOIT.CSc("C6C5C5",255));
      }
      if (_G.PATH is "kwizine" or "kitchensdepot" or "free" or "gabinetstogo" or "kitchengo")
      {
         SetDoorByLabel(SELECTION,"1",Color.white);
         SetDoorByLabel(SELECTION,"2",Color.white);
         SetDoorByLabel(SELECTION,"3",Color.white);
         SetDoorByLabel(SELECTION,"1",Color.white);
         SetDoorByLabel(SELECTION,"4",Color.white);
         SetDoorByLabel(SELECTION,"5",Color.white);
         SetDoorByLabel(SELECTION,"6",Color.white);
         SetDoorByLabel(SELECTION,"7",Color.white);
         SetDoorByLabel(SELECTION,"8",Color.white);
         SetDoorByLabel(SELECTION,"9",Color.white);
      }

      // Une seule porte proposee pour cette banniere : rien a choisir, on la prend et on passe au comptoir.
      // On ne saute pas quand on revient de COUNTERTOPSTYLE, sinon son bouton GoBack ne menerait nulle part.
      if (fromPNL != "COUNTERTOPSTYLE")
      {
         GameObject OnlyDoor = OnlyActiveChild(SELECTION);
         Toggle Tog = OnlyDoor != null ? OnlyDoor.GetComponent<Toggle>() : null;
         if (Tog != null)
         {
            Tog.isOn = true;
            // Meme enchainement que le bouton FINISH de DOORSTYLE.
            Preference Pref = FindAnyObjectByType<Preference>();
            if (Pref != null) Pref.DoorModel();
            goCOUNTERTOPSTYLE();
         }
      }
    }
   // Retourne l'unique enfant actif de O, ou null s'il y en a zero ou plusieurs.
   private static GameObject OnlyActiveChild(GameObject O)
   {
      GameObject Found = null;
      for (int i = 0; i < O.transform.childCount; i++)
      {
         GameObject Child = O.transform.GetChild(i).gameObject;
         if (!Child.activeSelf) continue;
         if (Found != null) return null;
         Found = Child;
      }
      return Found;
    }
   public void goCOUNTERTOPSTYLE()
    {
      ShowPNL("COUNTERTOPSTYLE");
      Get.o2("Canvas/COUNTERTOPSTYLE","COLORS COUNTERTOP").SetActive(false);
      Selected("COUNTERTOPSTYLE");
    }
   
   public void goDOORCOLOR()
    {
      Form.getDoor(); 
      ShowPNL("DOORCOLOR");
      Selected("DOORCOLOR");
      print("_G.Ds==="+_G.Ds);
      Get.o1("ImageDoor").GetComponent<Image>().sprite=Resources.Load<Sprite>("Images/Kitchen/"+_G.Ds);
      //DOIT.DELETEAllChild(Get.o4("SELECT","DoorColor","Viewport","ContentColor").name);
      //Measure.okShow("DOORCOLOR", "FINISH", false);
   
      /*string[] dc=_G.Ds.Split('.');
      float qty=float.Parse(dc[2]);

      print("qty==="+qty);

      List<string> modlist=new List<string>(); 
      for(int i=1; i<qty+1;i++)
      {
         modlist.Add(dc[0]+"."+dc[1]+"."+i.ToString());
      }
      float maxsv=(float)qty*2;
      float minsv=-maxsv;
      int nrow=2;
      float Wide=(qty/2f)*150;
      float Hight=270;
      if(qty<=7){nrow=1;Hight=140;Wide=qty*134;}
      Get.o2("SELECT","DoorColor").transform.GetComponent< RectTransform >().sizeDelta = new Vector2 (Wide, Hight);
      Get.o4("SELECT","DoorColor","Viewport","ContentColor").transform.GetComponent<GridLayoutGroup>().constraintCount=nrow; 

      Slider DoorColorSlider=Get.o1("DoorColorSlider").GetComponent<Slider>();

      DoorColorSlider.maxValue=maxsv;
      DoorColorSlider.minValue=minsv;
      DoorColorSlider.value=0;

      if(maxsv<25){DoorColorSlider.transform.GetComponent< CanvasGroup>().alpha=0;}
      else {DoorColorSlider.transform.GetComponent< CanvasGroup>().alpha=1;}

      for(int i=0; i<qty; i++)
      {
         Get.o2("HIDER","BTNSELECTION").SetActive(true);
         GameObject M = (GameObject)Instantiate(Get.o2("HIDER","BTNSELECTION"));
         M.name=modlist[i];
         string path="DOORCOLOR/"+dc[0]+"/"+modlist[i];
         Sprite T = Resources.Load<Sprite>(path);
         //print(path);
         M.transform.Find("Background").GetComponent<Image>().sprite = T;
         M.SetActive(true);
         M.transform.SetParent(Get.o4("SELECT","DoorColor","Viewport","ContentColor").transform, false);
         Get.o2("HIDER","BTNSELECTION").SetActive(false);
         M.transform.GetComponent<Toggle>().isOn=false;
      }*/
    }   
   public void goCOLORROOM(){
      ShowPNL("COLORROOM");
      Selected("COLORROOM");
    }
   // Panneaux dont les boutons ne sont pas regroupes dans un seul "SELECTION" : Selected() ne s'applique pas.
   static readonly string[] FINISHCOLORSSEL = { "SELECTION APPLIANCES", "SELECTION SINKFAUCET", "SELECTION KNOBS" };
   static readonly string[] ISLANDSEL = { "Selection1", "Selection2" };

   // On branche l'ecoute des boutons par code : pas besoin de les cabler un par un dans l'inspecteur.
   void Listen(string PNL, string[] Containers, UnityAction<bool> Handler)
   {
      foreach (string S in Containers)
      {
         GameObject Container = Get.o2(PNL, S);
         if (Container == null) continue;
         foreach (Transform Select in Container.transform)
         {
            if (!Select.TryGetComponent(out Toggle Tog)) continue;
            Tog.onValueChanged.RemoveListener(Handler);// pas de doublon si on revient sur le panneau
            Tog.onValueChanged.AddListener(Handler);
         }
      }
   }
   public void go_FINISHCOLORS(){
      ShowPNL("FINISHCOLORS");
      Listen("FINISHCOLORS", FINISHCOLORSSEL, FINISHCOLORSSelected);
      FINISHCOLORSSelected(false);
    }
   public void FINISHCOLORSSelected(bool _)
   {
      // FINISH n'apparait que si une couleur est choisie dans les trois series.
      bool ok = true;
      foreach (string S in FINISHCOLORSSEL)
      {
         if (Get.TogSelected(Get.o2("FINISHCOLORS", S)) == null) { ok = false; break; }
      }
      okShow("FINISHCOLORS", "FINISH", ok);
   }

   public void goFLOORROOM(){
      ShowPNL("FLOORROOM");
      Get.o2("Canvas/FLOORROOM","COLORS FLOOR").SetActive(false);
      Selected("FLOORROOM");
   }
   public void goISLAND()
   {
      ShowPNL("ISLAND");
      Listen("ISLAND", ISLANDSEL, ISLANDSelected);
      ISLANDSelected(false);
   }
   public void ISLANDSelected(bool _)
   {
      // Selection1 (None/Island/Peninsula/Peninsula L) + Selection2 (STOOL/SINK/COOKTOP) donnent
      // le nom de l'image : "Island-Sink", "Return-Stool-Cooktop"... "None" n'affiche rien.
      string Key = Preference.IslandKey();
      okShow("ISLAND", "FINISH", Key != null);// il faut au moins un choix dans Selection1

      // "None" : les options n'ont plus de sens. On decoche STOOL/SINK/COOKTOP et on masque
      // le conteneur. Get.o2 le retrouve quand meme une fois inactif : GameObject.Find porte
      // sur ISLAND, qui reste actif, et Transform.Find voit les enfants desactives.
      GameObject Options = Get.o2("ISLAND", "Selection2");
      if (Key == "None") ClearToggles(Options);
      if (Options != null) Options.SetActive(Key != "None");

      GameObject ShowO = Get.o2("ISLAND", "Show");
      if (ShowO == null) return;

      Sprite Img = null;
      if (Key != null && Key != "None")
      {
         Img = Resources.Load<Sprite>("Images/Icons/Island/" + Key);
         if (Img == null) print("Image d'ilot introuvable : Images/Icons/Island/" + Key);
      }
      if (Img != null) ShowO.GetComponent<Image>().sprite = Img;
      ShowO.SetActive(Img != null);
   }
   // Decoche tous les boutons d'un conteneur. SetIsOnWithoutNotify : pas de rappel des listeners,
   // donc pas de reentrance dans ISLANDSelected.
   static void ClearToggles(GameObject Container)
   {
      if (Container == null) return;
      foreach (Transform Select in Container.transform)
      {
         if (Select.TryGetComponent(out Toggle Tog)) Tog.SetIsOnWithoutNotify(false);
      }
   }

   public void goBUDGET()
   {
      ShowPNL("BUDGET");
      okShow("BUDGET", "FINISH", true);
      //Selected("BUDGET");
   }
   public void goSYS()
   {
      ShowPNL("SYS");
      Selected("SYS");
      //DOIT.AllTogchildfalse(GameObject.Find("SELECTION").gameObject);
      
   }

   public void goPLAN2D() {
      if(_G.PNL=="SYS")system();
      ShowPNL("PLAN2D");
      Selected("PLAN2D");
      DOIT.AllTogchildfalse(GameObject.Find("SELECTION"));
      roomplan();
    }  
   public void goSETDIM(){
      if(_Me.roomplan == "" && _G.ROOM != "R7" && _G.ROOM != "R11" && _G.ROOM != "RDRAW"){
         ShowPNL("AR");
      }
      else{
         ShowPNL("SETDIM");
         if (Draw2DNavigation._instance != null) Draw2DNavigation._instance.FitToViewDelayed();
         //SetPlan.newRooms();
         Get.o2("Canvas","OBSTACLELIST").SetActive(true);
         DOIT.DELETEAllChild("OBSTACLELIST");
         Get.o2("Canvas","OBSTACLELIST").SetActive(false);
         ResetObjects();
      }
    }
   public void goCEIL(){
      GameObject WallLineContainer=Get.o2("SETDIM/Panel_DRAWPlan_NEW/Plan2D_UI","WallLineContainer");
      _G.WallPoints.Clear();
      foreach(Transform p in WallLineContainer.transform)
      {
         _G.WallPoints.Add(p.gameObject.GetComponent<WallLine>()._pointStart.transform.localPosition);
         print("V3===="+p.transform.position);
      }
      _G.NW=_G.WallPoints.Count;
      ShowPNL("CEILING");
      Get.o3("CEILING","MCe","mCe").GetComponent<TMP_Text>().text = DOIT.CNs(_G.HEIGHT);
      print("_G.ROOM==="+_G.ROOM);
    }
   public void goOBSTACLES() {
      print("_G.WIDE===="+_G.WIDE);
      print("_G.DEPTH===="+_G.DEPTH);
      print("_G.NW==O=="+_G.NW);
      //print("wP1===="+_G.wP1);
      //print("wP2===="+_G.wP2);

      ShowPNL("OBSTACLES");
      SetPlan.Rooms();
      Get.o2("Canvas","OBSTACLELIST").SetActive(true);
      Positioning.AddWallsCollider("OBSTACLES");
      SetPlan.FitPlan("OBSTACLES");// ajuste le plan a la zone visible
      //DOIT.DELETEAllChild("OBSTACLELIST");

      // La suppression se fait maintenant depuis la corbeille posee sur l'objet selectionne.
      GameObject del = Get.o2("OBSTACLES","Delete");
      if (del != null) del.SetActive(false);
      DELETE.Refresh();
    }
   public void goPOSITIONING()
   {
      ShowPNL("POSITIONING");
      SetPlan.Rooms();
      GameObject ol = Get.o2("Canvas","OBSTACLELIST");
      ol.SetActive(true);
      foreach (Transform go in ol.transform)
      {
         Transform circleT = go.Find("Circle");
         if (circleT != null) circleT.GetComponent<Image>().color = Color.red;
      }
      Positioning.Start();
      SetPlan.FitPlan("POSITIONING");// ajuste le plan a la zone visible
   }
   public void goWALLCAB(){
      bool gowall=true;
      Get.o2("Canvas","OBSTACLELIST").SetActive(true);
      GameObject OL=Get.o1("OBSTACLELIST");

      for(int i=0; i<OL.transform.childCount; i++){
         if(OL.transform.GetChild(i).transform.Find("Circle").GetComponent<Image>().color==Color.red)gowall=false;
      }
      if(gowall==true){
         ShowPNL("WALLCAB");
         okShow("WALLCAB", "FINISH", false);
         SetPlan.Rooms();
         PlaceObjectsOnPlan(OL);
         SetPlan.FitPlan("WALLCAB");// ajuste le plan a la zone visible
      }
      else _M.PH(17, 0, "898787", 1, 1);

    }
   public void goOPTIONS()
   {
      ShowPNL("OPTIONS");
      IslandDoubleShow();
      //Selected("OPTIONS");
   }

   // L'option "ilot double" n'a de sens que si un ilot a ete choisi dans ISLAND.
   static void IslandDoubleShow()
   {
      GameObject SELECTION = Get.o2("OPTIONS","SELECTION");
      if (SELECTION == null) return;
      Transform B = SELECTION.transform.Find("IslandDouble");
      if (B == null) return;

      bool show = _G.Island != "none";
      if (!show)
      {
         Toggle tog = B.GetComponent<Toggle>();
         if (tog != null) tog.isOn = false;// sinon l'option resterait cochee dans _G.Options
      }
      B.gameObject.SetActive(show);
   }

   public static void RebuildWALLCABPlan()
   {
      Transform ol = GameObject.Find("Canvas").transform.Find("OBSTACLELIST");
      if (ol != null) PlaceObjectsOnPlan(ol.gameObject);
   }

   public static void OpenFromWALLCAB(string objName)
   {
      string[] parts = objName.Split('_');
      if (parts.Length < 2 || !int.TryParse(parts[1], out int n)) return;
      if (_G.OBJs[n] == null) return;
      _G.WallSELECTED = _G.OBJs[n][22];
      RepositionPNL.StartPNL(objName, null);
   }

   static void PlaceObjectsOnPlan(GameObject OL)
   {
      Transform plan = Get.o2("WALLCAB", "Plan").transform;

      var toRemove = new List<Transform>();
      foreach (Transform child in plan)
         if (child.name.StartsWith("OBJ_")) toRemove.Add(child);
      foreach (Transform t in toRemove) UnityEngine.Object.Destroy(t.gameObject);

      for (int i = 0; i < OL.transform.childCount; i++)
      {
         string objName = OL.transform.GetChild(i).name;
         string[] parts = objName.Split('_');
         if (parts.Length < 2 || !int.TryParse(parts[1], out int n)) continue;
         string baseName = parts[0];
         if (_G.OBJs[n] == null || _G.OBJs[n][0] == "null") continue;

         float dx    = DOIT.CSn(_G.OBJs[n][15]);
         float dz    = DOIT.CSn(_G.OBJs[n][17]);
         float w     = DOIT.CSn(_G.OBJs[n][6]);
         float depth = DOIT.CSn(_G.OBJs[n][8]);

         bool isAppliance   = baseName=="DISH"||baseName=="FRIDGE"||baseName=="STOVE"||baseName=="HOOD"||baseName=="WASHER";
         bool isWallElement = baseName=="WINDOW"||baseName=="PATIO"||baseName=="DOOR"||baseName=="OPENING";
         if (!isAppliance && !isWallElement) continue;

         float wallAngle = WallAngleAt(dx * 2f, dz * 2f);
         Vector2 planPos  = isWallElement
            ? ProjectOntoWall(new Vector2(dx * 2f, dz * 2f))
            : new Vector2(dx * 2f, dz * 2f);
         float thickness = isWallElement ? 14f : depth * 2f;

         GameObject marker = new GameObject("OBJ_" + objName);
         marker.transform.SetParent(plan, false);
         RectTransform rt = marker.AddComponent<RectTransform>();
         rt.anchoredPosition = planPos;
         rt.pivot = new Vector2(0.5f, 0.5f);
         rt.localEulerAngles = new Vector3(0, 0, wallAngle);
         rt.sizeDelta = new Vector2(w * 2f, thickness);

         Image bg = marker.AddComponent<Image>();
         bg.color = isAppliance
            ? new Color32(60, 120, 200, 160)
            : new Color32(230, 150, 30, 220);

         Button btn = marker.AddComponent<Button>();
         string capturedName = objName;
         btn.onClick.AddListener(() => OpenFromWALLCAB(capturedName));

         GameObject labelGO = new GameObject("Lbl");
         labelGO.transform.SetParent(marker.transform, false);
         RectTransform lrt = labelGO.AddComponent<RectTransform>();
         lrt.anchorMin = Vector2.zero;
         lrt.anchorMax = Vector2.one;
         lrt.offsetMin = Vector2.zero;
         lrt.offsetMax = Vector2.zero;
         TextMeshProUGUI txt = labelGO.AddComponent<TextMeshProUGUI>();
         txt.text = baseName;
         txt.enableAutoSizing = true;
         txt.fontSizeMin = 2;
         txt.fontSizeMax = 8;
         txt.alignment = TextAlignmentOptions.Center;
         txt.color = Color.white;
      }
   }

   static float WallAngleAt(float px, float pz)
   {
      int count = _G.WallPoints2D.Count;
      if (count < 2) return 0f;
      int n = (_G.WallPoints2D[count - 1] == _G.WallPoints2D[0]) ? count - 1 : count;
      Vector2 pos = new(px, pz);
      float minDist = float.MaxValue;
      float angle = 0f;
      for (int i = 0; i < n; i++)
      {
         Vector2 A = _G.WallPoints2D[i];
         Vector2 B = _G.WallPoints2D[(i + 1) % n];
         float dist = PointToSegDist(pos, A, B);
         if (dist < minDist) { minDist = dist; angle = Mathf.Atan2(B.y - A.y, B.x - A.x) * Mathf.Rad2Deg; }
      }
      return angle;
   }

   static Vector2 ProjectOntoWall(Vector2 pos)
   {
      int count = _G.WallPoints2D.Count;
      if (count < 2) return pos;
      int n = (_G.WallPoints2D[count - 1] == _G.WallPoints2D[0]) ? count - 1 : count;
      float minDist = float.MaxValue;
      Vector2 best = pos;
      for (int i = 0; i < n; i++)
      {
         Vector2 A = _G.WallPoints2D[i];
         Vector2 B = _G.WallPoints2D[(i + 1) % n];
         Vector2 ab = B - A;
         float t = Mathf.Clamp01(Vector2.Dot(pos - A, ab) / ab.sqrMagnitude);
         Vector2 proj = A + t * ab;
         float dist = Vector2.Distance(pos, proj);
         if (dist < minDist) { minDist = dist; best = proj; }
      }
      return best;
   }

   static float PointToSegDist(Vector2 p, Vector2 a, Vector2 b)
   {
      Vector2 ab = b - a;
      float t = Mathf.Clamp01(Vector2.Dot(p - a, ab) / ab.sqrMagnitude);
      return Vector2.Distance(p, a + t * ab);
   }
   
   public void goSENDING()
   {
      ShowPNL("SENDING");
      GameObject pnl = GameObject.Find("Canvas");
      pnl.transform.Find("SENDING").gameObject.SetActive(true);
      //SaveXML.buildXMLData();

      byte[] bytes = SaveXML.BuildXmlBytes();
      string xmls = Encoding.UTF8.GetString(bytes);

      ShowSendingButtons();

      // Le champ vit sous SENDING/BUTTONS et kitchengo le masque : Transform.Find traverse
      // les enfants inactifs, contrairement a GameObject.Find utilise avant.
      Transform DesignerEmail = pnl.transform.Find("SENDING/BUTTONS/Input Designer Email");
      if (DesignerEmail != null && DesignerEmail.TryGetComponent(out InputField DesignerField))
         DesignerField.text = _G.designerEmail;

      //Prefill for demo
      MonoBehaviour host = GameObject.Find("Canvas").GetComponent<MonoBehaviour>();
      host.StartCoroutine(FillInput(host));
   }

   // Page "Your design" de kitchengo, atteinte par SENDING/BUTTONS/Button KitchenGo.
   public void goVIEWER()
   {
      ShowPNL("VIEWER");
      ShowViewerModify(false);// on entre toujours par la liste de boutons
      ViewerImages.Load();// rendus telecharges dans le Scroll View
   }

   // Page d'achat du PDF, atteinte par VIEWER/BUTTONS/Button Buy PDF.
   public void goPDFBUY()
   {
      ShowPNL("PDFBuy");
   }
   // Bouton PDFBuy/GoBackFromBuyPDF : retour a VIEWER. On ne rappelle pas ViewerImages.Load(),
   // sinon un simple retour relancerait le sablier et le telechargement des rendus deja affiches.
   public void goBackVIEWER()
   {
      ShowPNL("VIEWER");
      ShowViewerModify(false);
   }

   // Page des fournisseurs, atteinte par VIEWER/BUTTONS/Button Find suplier.
   public void goSUPPLIERS()
   {
      ShowPNL("SUPPLIERS");
      Suppliers.Clear();// on repart d'une liste vide a chaque ouverture
      SuppliersTabs();
      Listen("SUPPLIERS", SUPPLIERSSEL, SUPPLIERSSelected);
      Listen("SUPPLIERS", SUPPLIERSLISTS, SuppliersSendShow);
      SuppliersListenInput();
      SUPPLIERSSelected(false);// ouvre un onglet et recalcule le bouton d'envoi
   }
   // Les trois boutons de SUPPLIERS/Select ouvrent chacun un bloc de SUPPLIERS/Selected.
   // Meme ordre dans les deux tableaux.
   static readonly string[] SUPPLIERSSEL = { "Select" };
   static readonly string[] SUPPLIERSBTN = { "Designer service", "Ai Quote", "Your supplier" };
   static readonly string[] SUPPLIERSPNL = { "DesignerList", "AiList", "InputSuplier" };
   // Les listes de choix vivent sous Selected. Transform.Find accepte un chemin, donc Get.o2 aussi.
   static readonly string[] SUPPLIERSLISTS = { "Selected/DesignerList/Selections", "Selected/AiList/Selections (1)" };
   const string SUPPLIERSINPUT = "Selected/InputSuplier/InputField (TMP)";

   // Exclusivite des trois onglets. Le ToggleGroup est pose par code : pas besoin de renseigner
   // le champ Group de chaque Toggle dans l'inspecteur, et un bouton ajoute plus tard suivra.
   static void SuppliersTabs()
   {
      GameObject Select = Get.o2("SUPPLIERS", "Select");
      if (Select == null) return;
      if (!Select.TryGetComponent(out ToggleGroup Grp)) Grp = Select.AddComponent<ToggleGroup>();
      Grp.allowSwitchOff = true;// aucun onglet impose : SUPPLIERS ouvre sur Selected vide

      bool Any = false;
      foreach (Transform Btn in Select.transform)
      {
         if (!Btn.TryGetComponent(out Toggle Tog)) continue;
         Tog.group = Grp;
         if (!Tog.isOn) continue;
         if (Any) Tog.SetIsOnWithoutNotify(false);// deux boutons coches : on ne garde que le premier
         else Any = true;
      }
   }
   // Affiche dans Selected le bloc du bouton coche et masque les deux autres.
   public void SUPPLIERSSelected(bool _)
   {
      string Sel = Get.TogSelectedName(Get.o2("SUPPLIERS", "Select"));
      GameObject Selected = Get.o2("SUPPLIERS", "Selected");
      if (Selected == null) return;
      for (int i = 0; i < SUPPLIERSPNL.Length; i++)
      {
         Transform PNL = Selected.transform.Find(SUPPLIERSPNL[i]);
         if (PNL != null) PNL.gameObject.SetActive(Sel == SUPPLIERSBTN[i]);
      }
      SuppliersSendShow(false);// changer d'onglet change ce qui compte comme selection
   }
   // Le courriel saisi dans InputSuplier tient lieu de selection pour cet onglet : on suit sa frappe.
   void SuppliersListenInput()
   {
      GameObject In = Get.o2("SUPPLIERS", SUPPLIERSINPUT);
      if (In == null || !In.TryGetComponent(out TMP_InputField Field)) return;
      Field.onValueChanged.RemoveListener(SuppliersInputChanged);// pas de doublon si on revient
      Field.onValueChanged.AddListener(SuppliersInputChanged);
   }
   public void SuppliersInputChanged(string _)
   {
      SuppliersSendShow(false);
   }
   // "Button Send to supplier" reste cache tant que rien n'est choisi dans l'onglet ouvert.
   // Une selection faite dans un onglet ferme ne compte pas : d'ou le test activeInHierarchy.
   public void SuppliersSendShow(bool _)
   {
      bool Ok = false;
      foreach (string Path in SUPPLIERSLISTS)
      {
         GameObject List = Get.o2("SUPPLIERS", Path);
         if (List == null || !List.activeInHierarchy) continue;
         if (Get.TogSelected(List) != null) { Ok = true; break; }
      }
      if (!Ok)
      {
         GameObject In = Get.o2("SUPPLIERS", SUPPLIERSINPUT);
         if (In != null && In.activeInHierarchy && In.TryGetComponent(out TMP_InputField Field))
            Ok = !string.IsNullOrWhiteSpace(Field.text);
      }
      GameObject Btn = Get.o2("SUPPLIERS", "Button Send to supplier");
      if (Btn != null) Btn.SetActive(Ok);
   }
   // Recherche par code postal.
   public void SearchSuppliers()
   {
      Suppliers.Search();
   }
   // Bouton "Button Geolocalisation" de SUPPLIERS.
   public void GeolocateSuppliers()
   {
      Suppliers.SearchHere();
   }
   // A brancher sur le OnValueChanged (string) de SUPPLIERS/Input Postal Code.
   public void PostalCodeChanged(string Value)
   {
      Suppliers.PostalCodeChanged(Value);
   }

   // VIEWER a deux etats : la liste de boutons (BUTTONS) ou le panneau de modification.
   // Enfants de VIEWER visibles en mode modification.
   static readonly string[] VIEWER_MODIFY = { "MODIFYER", "GoBackFromModify", "Resent" };

   // Bouton "Modify" de VIEWER/BUTTONS.
   public void goMODIFY()
   {
      ShowViewerModify(true);
   }
   // Bouton "GoBackFromModify" : retour a la liste de boutons.
   public void goBackMODIFY()
   {
      ShowViewerModify(false);
   }
   // Bouton "Resent" : on referme le panneau de modification, puis on vide les images
   // et on relance l'animation suivie du chargement.
   public void goRESENT()
   {
      ShowViewerModify(false);
      ViewerImages.Load();
   }
   // Panneau MODIFPNL, ouvert par les boutons de VIEWER/MODIFYER, referme par son btnX.
   // A brancher sur chaque bouton de MODIFYER.
   public void goMODIFPNL()
   {
      // La categorie est le bouton coche dans MODIFYER. Recliquer le meme bouton le decoche
      // (AllowSwitchOff) : plus rien de selectionne, on referme.
      Transform Sel = Get.TogSelected(Get.o2("Canvas/VIEWER", "MODIFYER"));
      if (Sel == null) { ShowModifPnl(false); return; }

      ModifPanel.Fill(Sel.name, ModifPanel.LabelOf(Sel));
      ShowModifPnl(true);
   }
   // A brancher sur le OnValueChanged des toggles de MODIFPNL/ListBTNS : met le Prompt a jour.
   public void ModifOptionChanged()
   {
      ModifPanel.OptionChanged();
   }
   // Bouton "Save" de MODIFPNL : retient les cases cochees et referme.
   public void SaveMODIFPNL()
   {
      Transform Sel = Get.TogSelected(Get.o2("Canvas/VIEWER", "MODIFYER"));
      if (Sel != null) ModifPanel.Save(Sel.name);
      ShowModifPnl(false);
   }
   // A brancher sur MODIFPNL/btnX.
   public void CloseMODIFPNL()
   {
      ShowModifPnl(false);
   }
   // Variante pour un Toggle : ouvre quand il est coche, ferme quand il est decoche.
   public void ShowMODIFPNL(bool On)
   {
      ShowModifPnl(On);
   }
   static void ShowModifPnl(bool On)
   {
      GameObject Pnl = Get.o2("Canvas", "MODIFPNL");
      if (Pnl != null) Pnl.SetActive(On);
   }

   static void ShowViewerModify(bool On)
   {
      ShowModifPnl(false);// le panneau de modification repart toujours ferme
      ModifPanel.LabelCategories();// libelles des categories, poses depuis _T

      GameObject Viewer = Get.o2("Canvas", "VIEWER");
      if (Viewer == null) return;

      Transform Buttons = Viewer.transform.Find("BUTTONS");
      if (Buttons != null) Buttons.gameObject.SetActive(!On);

      foreach (string Name in VIEWER_MODIFY)
      {
         Transform Child = Viewer.transform.Find(Name);
         if (Child != null) Child.gameObject.SetActive(On);
      }
   }
   // Version appelable depuis un autre script (Send) : les go* sont des methodes d'instance
   // parce que les boutons les branchent via UnityEvent.
   public static void ShowVIEWER()
   {
      Measure M = FindAnyObjectByType<Measure>();
      if (M != null) M.goVIEWER();
   }

   // Enfants de SENDING/BUTTONS a laisser visibles : kitchengo n'a que son bouton,
   // les autres bannieres gardent le trio message ai / courriel designer / envoi designer.
   static readonly string[] SENDINGBTN_KITCHENGO = { "Button KitchenGo" };
   static readonly string[] SENDINGBTN_DEFAUT = { "Button message ai", "Input Designer Email", "Button send to designer" };

   static void ShowSendingButtons()
   {
      GameObject Buttons = Get.o2("Canvas/SENDING", "BUTTONS");
      if (Buttons == null) return;

      string[] Shown = _G.PATH == "kitchengo" ? SENDINGBTN_KITCHENGO : SENDINGBTN_DEFAUT;
      foreach (Transform Child in Buttons.transform)
         Child.gameObject.SetActive(System.Array.IndexOf(Shown, Child.name) >= 0);
   }

IEnumerator FillInput(MonoBehaviour host)
{
    GameObject pnl = GameObject.Find("Canvas");
    yield return host.StartCoroutine(TypeText(host, pnl, "SENDING/Inputs/InputName",    "Your name"));
    yield return host.StartCoroutine(TypeText(host, pnl, "SENDING/Inputs/InputAddress", "Your addresss"));
    yield return host.StartCoroutine(TypeText(host, pnl, "SENDING/Inputs/InputEmail",   "hb3d63@gmail.com"));    
    yield return host.StartCoroutine(TypeText(host, pnl, "SENDING/Inputs/InputPhone",   "123-456-7890")); 
    yield return host.StartCoroutine(TypeText(host, pnl, "SENDING/Inputs/InputNote",   "Demo U-Kitchen-IT "+_G.PATH));
}
IEnumerator TypeText(MonoBehaviour host, GameObject pnl, string path, string fullText, float delay = 0.04f, float pauseAfter = 0.3f)
{
    Transform t = pnl.transform.Find(path);
    if (t == null) { Debug.LogError($"[TypeText] Introuvable : '{path}'"); yield break; }

    InputField field = t.GetComponent<InputField>(); // ✅ Legacy InputField
    if (field == null) { Debug.LogError($"[TypeText] Pas d'InputField sur : '{path}'"); yield break; }

    field.text = "";
    foreach (char c in fullText)
    {
        field.text += c;
        yield return new WaitForSeconds(delay);
    }

    yield return new WaitForSeconds(pauseAfter);
}

   public void goAR()
   {
      if (_G.ROOM == "R7" || _G.ROOM == "R11" || _G.ROOM == "RDRAW")
      {
         goSETDIM();
         return;
      }
      ShowPNL("AR");
      GameObject pnl = GameObject.Find("Canvas");
      pnl.transform.Find("AR").gameObject.SetActive(true);
      //SaveXML.buildXMLData();
      //print("_G.DesignerEmail===="+_G.designer_path);
      //Get.o1("SENDING/InputDesigner").GetComponent<InputField>().text=_G.designer_path;
   }

   // Variante kitchengo : page THANKSGO, et on referme SUPPLIERS d'ou l'on vient.
   public static void goTHANKSGO(string yourname,string youremail,string SendEmail,string btn)
   {
      GameObject Suppliers = Get.o2("Canvas","SUPPLIERS");
      if (Suppliers != null) Suppliers.SetActive(false);

      goTHANKS(yourname, youremail, SendEmail, btn, "THANKSGO");
   }
   public static void goTHANKS(string yourname,string youremail,string SendEmail,string btn)
   {
      goTHANKS(yourname, youremail, SendEmail, btn, "THANKS");
   }
   static void goTHANKS(string yourname,string youremail,string SendEmail,string btn,string PanelName)
   {
      //DOIT.CloseALLPNLONLY();
      GameObject pnl = Get.o2("Canvas",PanelName);
      if (pnl == null) { Debug.LogError("[goTHANKS] panneau introuvable : " + PanelName); return; }
      pnl.SetActive(true);
      pnl.transform.Find("Nametext").transform.GetComponent<Text>().text=yourname;//yourname.text;
      pnl.transform.Find("YourEmail").transform.GetComponent<Text>().text=youremail;//youremail.text;
      pnl.transform.Find("DesignerEmail").transform.GetComponent<Text>().text=SendEmail;//SendEmail.text;

      // "DEMO PNL" est desactive : GameObject.Find ne voit que les objets actifs et renvoyait null,
      // donc cette ligne lancait une NullReferenceException et coupait goTHANKS a chaque appel.
      // Transform.Find, lui, traverse les enfants inactifs.
      Transform DesignerInput = pnl.transform.Find("DEMO PNL/Input Designer Email");
      if (DesignerInput != null && DesignerInput.TryGetComponent(out TMP_InputField DesignerField))
         DesignerField.text = _G.designerEmail;

      //logo
      pnl.transform.Find("Logo").GetComponent<Image>().sprite =_G.Logo;//Resources.Load<Sprite>("LOGOS/"+_G.PATH);

      GameObject Logo2=pnl.transform.Find("Logo2").gameObject;
      if(_G.PATH is "collection_elite" or "homehardware" or "bmr" or "kent") {
         Logo2.SetActive(true);
         Logo2.GetComponent<Image>().sprite =_G.Logo2;
         }

// #if UNITY_WEBGL
//       bool isPCOrEditor = !WebGLBrowserCheck.IsMobileBrowser();
// #else
//       bool isPCOrEditor = Application.isEditor || SystemInfo.deviceType == DeviceType.Desktop;
// #endif
//       pnl.transform.Find("OPEN EMPTY").gameObject.SetActive(isPCOrEditor);


      // if(btn=="software"){
      //    Get.o1("T_THANKS2").transform.GetComponent<Text>().text=TRANS.This("T_THANKS3");
      //    Get.o2("THANKS","T_SENDPHOTOS").SetActive(false);
      // }
      //else {
         //Get.o1("T_THANKS2").transform.GetComponent<Text>().text=TRANS.This("T_THANKS2");
         //Get.o2("THANKS","T_SENDPHOTOS").SetActive(true);
      //}
   }
   
   //--------------------------OLD PNL----------------------------------------
   public void goOPENING(){
      _Me.ToIns = "open";
      _Me.sH = 82;
      _Me.sW = 48;
      goWALLSEL();
    }
   public void goPLUMBING(){
      _Me.ToIns = "cabi";
      _Me.sH = 36;
      _Me.sW = 32;
      _Me.sD = 32;
      goWALLSEL();
    }
   public void goBLOC(){
      _Me.ToIns = "bloc";
      _Me.sH = 36;
      _Me.sW = 32;
      _Me.sD = 32;
      goWALLSEL();
    }

   public void goAlert()
   {
      _M.PH(15, 0, "898787", 1, 1);
   }  
   public void goWALLSEL(){

      /*if (GameObject.Find("ROOM").transform.childCount != 0) { }
      else{Create3D.createRoom();}
      
      if (this.name == "OPENING") { _Me.ToIns = "open"; }
      if (this.name == "PLUMBING") { _Me.ToIns = "cabi"; }
      DOIT.CloseALLPNLONLY();
      ShowPNL("WALLSEL");

      _G.SM = "selected";

      DASH.CamTop();
      
      Install.ResetTop();
      DOIT.ResetRoomSelect();
      DOIT.AllSelOff();
      _Me.WS = "";
      wallSel();
      MoveObject.DeleteMesures();*/

    }

   public void goWINDSEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("WINDSEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("WIND",13);
    }
   public void goSTOVESEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("STOVSEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("STOV", 22);
    }
   public void goDOWASEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("DOWASEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
    }
   public void goDOOSSEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("DOOSSEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("DOOS", 19);
    }
   public void goDOODSEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("DOODSEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("DOOD", 19);
    }
   public void goPATISEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("PATISEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("PATI", 19);
    }
   public void goSLIDSEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("SLIDSEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("SLID", 19);
    }
   public void goHOOWSEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("HOOWSEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("HOOW", 13);
    }
   public void goDISWSEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("DISWSEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("DISW", 13);
    }
   public void goFRIDSEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("FRIDSEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("FRID", 25);
    }
   public void goBLOCSEL(){
      DOIT.CloseALLPNLONLY();
      ShowPNL("BLOCSEL");
      DOIT.AllTogchildfalse(GameObject.Find("SELECT").gameObject);
      Sel("BLOC",3);
    }
   
   //--------------------------SELECTIONS----------------------------------------
   public void system()
   {
      //_Me.sys = "";_G.WIDE = 192;
      _G.DEPTH = 168f;
      _G.HEIGHT = 96;
      _G.WIDE = 192;
      okShow("SYS", "FINISH", false); 
      if (okOn("cm")) {
         _G.WIDE = 192.126f;
         _G.DEPTH = 168.111f;
         _G.HEIGHT = 96.063f;
         _G.System=2;_G.Sys = "cm"; 
         okShow("SYS", "FINISH",true);
         }
      if (okOn("inch")) {
         _G.WIDE = 192;
         _G.DEPTH = 168f;
         _G.HEIGHT = 96f;
         _G.System=1; _G.Sys = " ''"; 
         okShow("SYS", "FINISH", true);
         }

   }
   public void ShowPNL(string S){
      DOIT.CloseALLPNLONLY();
      Get.o2("Canvas","PanelPosition").SetActive(false);
      Get.o2("Canvas","OBSTACLELIST").SetActive(false);
      GameObject.Find("Canvas").transform.Find(S).gameObject.SetActive(true);
      _G.PNL=S;
      DELETE.Refresh();// la corbeille des vignettes n'existe que dans OBSTACLES
      //Steps.Update();
     }
   public bool okOn(string S)
      {
       return GameObject.Find("SELECTION").transform.Find(S).transform.GetComponent<Toggle>().isOn;
      }
   public static void okShow(string S1, string S2,bool tf)
    {
      GameObject.Find(S1).transform.Find(S2).gameObject.SetActive(tf);
    }
   public void roomplan()
   {
      _Me.roomplan = "";
      okShow("PLAN2D", "FINISH", false);
      _G.ROOM=Get.TogOn("PLAN2D/SELECTION");
      if(_G.ROOM!=null){
         _Me.roomplan=_G.ROOM;
         okShow("PLAN2D", "FINISH", true); 
         }
    }
   public void AR()
   {
      _Me.roomplan = "";
      okShow("PLAN2D", "FINISH", true); 
    }
   public void Sel(string sel,int n) 
   {
      print("sel==" + sel);
      sel = sel.Substring(0, 4);
      _Me.ToIns = "";
      okShow(sel+"SEL", "FINISH", false);
      for (int i = 1; i < n; i++)
      {
         if (okOn(sel + (100 + i).ToString()))
         {
               _Me.ToIns = sel + (100 + i).ToString();
               okShow(sel + "SEL", "FINISH", true);
         }
      }
   }
   public void Selthis(string n)
   {
      string sel = this.name;
      Sel(sel, int.Parse(n));
   }
   public void doorSel()
   {
      _Me.ToIns = "";
      okShow("DOORSEL", "FINISH", false);
      for (int i = 1; i < 22; i++)
      {
         if (okOn("DOOR" + (100 + i).ToString()))
         {
               _Me.ToIns = "DOOR" + (100 + i).ToString();
               okShow("DOORSEL", "FINISH", true);
         }
      }
   } 
   public void Selected(string PNL)
   {
      print("PNL==="+PNL);
      okShow(PNL, "FINISH", false);
      string path = PNL+"/SELECTION";
      //if(PNL=="INSPIRATION")path = PNL+"/SELECTION/Viewport/Content";

      // ISLAND n'a plus de "SELECTION" actif (Selection1/Selection2) : c'est ISLANDSelected qui s'en charge.
      GameObject Container=Get.o1(path);
      if(Container==null)return;

      int QTY=Container.transform.childCount;
      for (int i = 0; i < QTY; i++){
         if(Get.TogOn(path)!=null){
            okShow(PNL, "FINISH", true);
            if(PNL=="COUNTERTOPSTYLE"){Get.o2("Canvas/COUNTERTOPSTYLE","COLORS COUNTERTOP").SetActive(true);}
            if(PNL=="FLOORROOM" ){Get.o2("Canvas/FLOORROOM","COLORS FLOOR").SetActive(true);}
            if(PNL=="DOORSTYLE" && _G.PATH is "free" or "kwizine" or "kitchensdepot" or "kitchengo"){Get.o2("Canvas/DOORSTYLE","COLORS DOOR").SetActive(true);}
         }
      }
   }
   public void Close()
      {
         this.transform.parent.gameObject.SetActive(false);
      }
   public static void wallSel(){
      for (int i = 0; i < _G.NW; i++){
         Get.o2("HIDER","BTNwn").SetActive(true);
         GameObject WN=Instantiate(Get.o2("HIDER","BTNwn"));
         WN.transform.Find("NW").GetComponent<TMP_Text>().text = (i+1).ToString();
         WN.name="w"+(i+1).ToString();
         WN.transform.SetParent(Get.o2("WALLCAB","Plan").transform, false);
         //float scale=1;
         WN.transform.localPosition=new Vector3(_G.WallsPointCenter[i].x,_G.WallsPointCenter[i].y,0);
         Get.o2("HIDER","BTNwn").SetActive(false);
      }
    }

   //--------------------------SETTING----------------------------------------
   public static void setRoom(){
      _G.ceilx = 0;
      _G.ceily = _G.HEIGHT / 2;
      _G.ceilz = 0;
      _G.ceilw = _G.WIDE;
      _G.ceild = _G.DEPTH;
    }
   public static void setMesureNew(float M, string m)
   {
      //print("m===="+m);
      string Vs = DOIT.CNs(M);
      GameObject.Find(m).GetComponent<UnityEngine.UI.Text>().text = Vs;
   }
   public void Deleting()
     {
        print("_G.SELECTED)===="+ _G.SELECTED);
        int nO = DOIT.getint(_G.SELECTED);
        string nW = _G.OBJs[nO][22];
        _G.OBJs[nO][0] = "null";
        DestroyImmediate(GameObject.Find(_G.SELECTED).gameObject);
        //if (nW.Substring(0, 1) == "w") HOLE.wall(nW);
        //goOBSTACLES();
     }
   public void SetDoorByLabel(GameObject SELECTION, string name,Color Color)
   {
      GameObject Door = SELECTION.transform.Find("T_Door"+name).gameObject;
      Door.SetActive(true);
      Door.transform.Find("Background").GetComponent<Image>().color=Color;
   }
}