using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using TMPro;
using Unity.VisualScripting;
using System;
using System.Linq;
using AutoTiling;

public class AI : MonoBehaviour
{
    private static WaitForSecondsRealtime _waitForSecondsRealtime1 = new WaitForSecondsRealtime(1);
    private static WaitForSecondsRealtime _waitForSecondsRealtime2 = new WaitForSecondsRealtime(2);
    public static List<List<Vector3>> BASEPBLB = new();//
    public static List<string> WallSelected = new();//w1,w2...
    [SerializeField] GameObject PNL;
    [SerializeField] GameObject SELECTOR;
    static GameObject NextObject;
    static GameObject PreviousObject;
    static float _WideIsland;

    public void StartPnl()
    {
        _G.MesureONOFF = true;
        DOIT.CloseALLPNL();
        PNL.SetActive(true);
        _G.PON = "AIpnl";
        WallSelected = new();
        ShowWallSelected();

        SceneModeManager.Instance.SetSceneMode(SceneModes.Panel);

        GameObject[] tohide = GameObject.FindGameObjectsWithTag("tohide");
        foreach (GameObject see in tohide)
        {
            Set.alpha(see, false);
        }

        SELECTOR.SetActive(false);

        _AI.On = true;

        _AI.FloorLine = -_G.HEIGHT * 0.5f;
        _AI.CeilingLine = _G.HEIGHT * 0.5f;
        _AI.CabinetHeight = 35;


        if (_G.PATH == "kitchensdepot")
        {
            _AI.CB90 = "LS36";//Corner Bse 90
            _AI.CBDEADL = "DLB48-51";//Corner _AI.BASE Dead Left
            _AI.CBDEADR = "DLB48-51";//Corner _AI.BASE Dead Right       
            _AI.CW90 = "WPC2430";//Corner Wall 90
            _AI.CWDEADL = "";//Corner Wall Dead Left
            _AI.CWDEADR = "";//Corner Wall Dead Right
            _AI.BASE = "B24";
            _AI.WALL = "W2430";
            _AI.TALL = "TP302484";
            _AI.DRAWER = "DB24";
            _AI.BASESINK = "SB36";
            _AI.FRIDGE = "W331524";
            _AI.HOOD = "HOOW101";
            _AI.DISHWASHER = "DISH101";
            _AI.MICROWAVE = "BMC30";
            _AI.PANEL_ISLAND = "PLY-1/2";
            _AI.PANEL_FRIDGE = "REP1-1/2"; // 
            _AI.BaseDepth = 23.375f + 0.75f;
            _AI.WallDepth = 11.375f + 0.75f;
            _AI.Door1 = "6?16";
            _AI.Door2 = "5?15";
            _AI.Kick1 = "1?16?90";
            _AI.Kick2 = "1?15?90";

            //Base Cabinet Wider
            _AI.Base9 = "B09";
            _AI.Base12 = "B12";
            _AI.Base15 = "B15";
            _AI.Base18 = "B18";
            _AI.Base21 = "B21";
            _AI.Base24 = "B24";
            _AI.Base27 = "B27";
            _AI.Base30 = "B30";
            _AI.Base33 = "B33";
            _AI.Base36 = "B36";

            _AI.TallUnder = "DB30";

            //Drawer
            _AI.Drawer12 = "DB12";
            _AI.Drawer15 = "DB15";
            _AI.Drawer18 = "DB18";
            _AI.Drawer21 = "DB18";
            _AI.Drawer24 = "DB24";
            _AI.Drawer27 = "";
            _AI.Drawer30 = "DB30";
            _AI.Drawer33 = "";
            _AI.Drawer36 = "DB36";

            //Wall Cabinet Wider
            _AI.Wall9 = "W0930";
            _AI.Wall12 = "W1230";
            _AI.Wall15 = "W1530";
            _AI.Wall18 = "W1830";
            _AI.Wall21 = "W2130";
            _AI.Wall24 = "W2124";
            _AI.Wall27 = "W2730";
            _AI.Wall30 = "W3030";
            _AI.Wall33 = "W3330";
            _AI.Wall36 = "W3630";
            _AI.Wall24OS = "DW2412";
        }
        if (_G.PATH == "collection_elite")
        {
            _AI.CB90 = "RD-BC36";//Corner Bse 90
            _AI.CBDEADL = "RD-BCM36";//Corner _AI.BASE Dead Left
            _AI.CBDEADR = "RD-BCM36";//Corner _AI.BASE Dead Right       
            _AI.CW90 = "RD-HC2424";//Corner Wall 90
            _AI.CWDEADL = "";//Corner Wall Dead Left
            _AI.CWDEADR = "";//Corner Wall Dead Right
            _AI.BASE = "RD-B24";
            _AI.WALL = "RD-HG24";
            _AI.TALL = "RD-GM2449";
            _AI.DRAWER = "RD-B2T24";
            _AI.BASESINK = "RD-B36";
            _AI.FRIDGE = "REP1-1/2";// REP1-1/2  RD-HTPP3312
            _AI.HOOD = "HOOW101";
            _AI.DISHWASHER = "DISH101";
            _AI.MICROWAVE = "RD-BMO24";

            _AI.PANEL_ISLAND = "RD-PANDW";
            _AI.PANEL_FRIDGE = "RD-3085"; // 
            _AI.BaseDepth = 23.625f + 0.75f;
            _AI.WallDepth = 11.625f + 0.75f;
            _AI.Door1 = "1?1";
            _AI.Door2 = "2?2";
            _AI.Kick1 = "1?1?90";
            _AI.Kick2 = "2?2?90";

            //Base Cabinet Wider
            _AI.Base9 = "";
            _AI.Base12 = "RD-B12";
            _AI.Base15 = "RD-B15";
            _AI.Base18 = "RD-B18";
            _AI.Base21 = "";
            _AI.Base24 = "RD-B24";
            _AI.Base27 = "";
            _AI.Base30 = "RD-B30";
            _AI.Base33 = "RD-B33";
            _AI.Base36 = "RD-B36";

            _AI.TallUnder = "RD-B2T24";

            //Drawer
            _AI.Drawer12 = "RD-B3T12";
            _AI.Drawer15 = "RD-B3T15";
            _AI.Drawer18 = "";
            _AI.Drawer21 = "";
            _AI.Drawer24 = "RD-B2T24";
            _AI.Drawer27 = "";
            _AI.Drawer30 = "RD-B2T30";
            _AI.Drawer33 = "";
            _AI.Drawer36 = "";

            //Wall Cabinet Wider
            _AI.Wall9 = "";
            _AI.Wall12 = "RD-HG12";
            _AI.Wall15 = "RD-HG15";
            _AI.Wall18 = "RD-HG18";
            _AI.Wall21 = "";
            _AI.Wall24 = "RD-HG24";
            _AI.Wall27 = "";
            _AI.Wall30 = "RD-HG30";
            _AI.Wall33 = "RD-HG33";
            _AI.Wall36 = "RD-HG36";
            _AI.Wall24OS = "";
        }

        float BaseHeight = UIT.ValueFloat(Library.Cabinet,_AI.BASE,Header.B);
        float WallHeight = UIT.ValueFloat(Library.Cabinet,_AI.WALL,Header.B);
        _AI.BaseHeightPosition = -_G.HEIGHT * 0.5f + BaseHeight * 0.5f + 1.25f * 0.5f;
        _AI.WallHeightPosition = -_G.HEIGHT * 0.5f + 54 + WallHeight * 0.5f;

        AiButton.Instance.GetTitle().text = AiText.Trans("Hi");
        AiButton.Instance.GetButtonGoNext().SetActive(true);
        AiButton.Instance.GetModification().SetActive(false);
        AiButton.Instance.GetSelector().SetActive(false);
        AiButton.Instance.GetPlus().SetActive(false);
        AiButton.Instance.GetGoBackButton().SetActive(false);
        AiButton.Instance.GetDeleteAllCabButton().SetActive(AiStep.CabinetOnScene());
    }

    //------------------------------------Play--------------------------------------------------
    public void ProcessAi()
    {
        if (WallSelected != null && WallSelected.Count > 0)
        {
            StartCoroutine(AiProcess());
        }
        else
        {
            WallSelected = new();
            for (int i = 0; i < _G.OBJnum; i++)
            {
                if (DOIT.exist(i))
                {
                    string[] ADN = _G.OBJs[i];
                    if (ADN[2] == "Cabinet" && ADN[22] != "floor")
                    {
                        string WallNumber = ADN[22].Replace("w", "m");
                        if (!WallSelected.Contains(WallNumber)){WallSelected.Add(ADN[22].Replace("w", "m"));}
                    }
                }
            }
            StartCoroutine(AiProcess());
        }
    }
    IEnumerator AiProcess()
    {
        //UIPathEffect.StartMovement();
        Get.o2("HIDER", "MESSAGE").SetActive(false);
        DeleteAllCab();
        // WallSelected = ReorderWallString(WallSelected);
        yield return _waitForSecondsRealtime1;
        SetGlobals();

        AddSinkCabinet();
        yield return null;

        AddCornerBASECabinet();
        yield return _waitForSecondsRealtime1;

        //SetSinkCabinet();

        AddHood();
        yield return _waitForSecondsRealtime1;

        AddCornerWallCabinet();
        yield return _waitForSecondsRealtime1;

        AddTALLCabinet();
        yield return _waitForSecondsRealtime1;

        AddBASECabinet();
        yield return _waitForSecondsRealtime2;

        AddWallCabinet();
        yield return _waitForSecondsRealtime2;

        //VerifyWallCabinetOverSink();

        AddFridgeCabinet();
        yield return null;

        AddIslandCabinet();
        yield return null;

        AddDrawers();
        yield return null;

        AddDishwasher();
        yield return null;

        AddBackSplash();
        yield return _waitForSecondsRealtime2;

        AddFillers_Cover();
        yield return _waitForSecondsRealtime2;

        AddStools();
        yield return _waitForSecondsRealtime2;

        AddLamps();
        yield return _waitForSecondsRealtime1;

        AddMicrowave();
        yield return null;

        AddFloor();
        yield return null;
        yield return _waitForSecondsRealtime1;

        PaintWalls();
        yield return null;

        AddSpotCeilling();
        yield return null;

        yield return _waitForSecondsRealtime2;

        //
        DOIT.AllSelOff();
        AllMeshDeselect();
        DASH.HDsetBTNcolor(true);
        AiStep.ShowModification();
        UIPathEffect.StopMovement();
        _G.CameraCliping = 2;
        Camera.main.GetComponent<CameraAround>().Hide();

    }

    //-------------------------------SINK CABINET------------------------------------------------------------------  
    public void AddSinkCabinet()
    {
        //Check on all walls if there is a window
        string WallNumber = "No window found";//
        GameObject Window = null;
        Vector3 PositionToInstall;
        Vector3 Forward;
        int IndexSinkWindow = GetWindowSinkIndex();
        if (IndexSinkWindow != 1000)
        {
            WallNumber = _G.OBJs[IndexSinkWindow][22];
            Window = Get.o2("SCENE", _G.OBJs[IndexSinkWindow][0]);
            Forward = -Get.o1(WallNumber).transform.forward.normalized;
            PositionToInstall = Window.transform.position;
            PositionToInstall += _AI.BaseDepth * 0.5f * Forward;
            PositionToInstall.y = _AI.BaseHeightPosition;
            StartCoroutine(AddSinkCabinetToWall(_AI.BASESINK, WallNumber, PositionToInstall,true));
            return;
        }
        else if(WallSelected!=null && WallSelected.Count>0)
        {
            WallNumber = WallSelected[0];
            Forward = -Get.o1(WallNumber).transform.forward.normalized;
            List<GameObject> Obstacles = AiGet.AllObjectsOnWall(WallSelected[0], "All", "All", _AI.FloorLine + _AI.CabinetHeight, _AI.FloorLine);

            if (Obstacles.Count == 0)
            {
                Vector3 StartPoint = AiGet.WallStartPoint(WallNumber);
                Vector3 EndPoint = AiGet.WallEndPoint(WallNumber);
                float Delta1 = Vector3.Distance(StartPoint, EndPoint);
                if (Delta1 > 66)
                {
                    PositionToInstall = (StartPoint + EndPoint) / 2f;
                    PositionToInstall += _AI.BaseDepth * 0.5f * Forward;
                    PositionToInstall.y = _AI.BaseHeightPosition;
                    StartCoroutine(AddSinkCabinetToWall(_AI.BASESINK, WallNumber, PositionToInstall, false));
                    return;
                }
            }
            if (Obstacles.Count == 1)
            {
                Vector3 StartPoint = AiGet.WallStartPoint(WallNumber);
                Vector3 EndPoint = Obstacles[0].transform.Find("PBLB").position;
                float Delta1 = Vector3.Distance(StartPoint, EndPoint);
                if (Delta1 > 66)
                {
                    PositionToInstall = (StartPoint + EndPoint) / 2f;
                    PositionToInstall += 12 * Forward;
                    PositionToInstall.y = _AI.BaseHeightPosition;
                    StartCoroutine(AddSinkCabinetToWall(_AI.BASESINK, WallNumber, PositionToInstall, false));
                    return;
                }
                else
                {
                    StartPoint = Obstacles[0].transform.Find("PBRB").position;
                    EndPoint = AiGet.WallEndPoint(WallNumber);
                    Delta1 = Vector3.Distance(StartPoint, EndPoint);
                    if (Delta1 > 36)
                    {
                        PositionToInstall = (StartPoint + EndPoint) / 2f;
                        PositionToInstall += 12 * Forward;
                        PositionToInstall.y = _AI.BaseHeightPosition;
                        StartCoroutine(AddSinkCabinetToWall(_AI.BASESINK, WallNumber, PositionToInstall, false));
                        return;
                    }
                }

            }
            if (Obstacles.Count > 2)
            {
                for (int i = 0; i < Obstacles.Count; i++)
                {
                    Vector3 StartPoint = Obstacles[i].transform.Find("PBRB").position;
                    Vector3 EndPoint = Obstacles[i+1].transform.Find("PBLB").position;
                    float Delta1 = Vector3.Distance(StartPoint, EndPoint);
                    if (Delta1 > 36)
                    {
                        PositionToInstall = (StartPoint + EndPoint) / 2f;
                        PositionToInstall += _AI.BaseDepth * 0.5f * Forward;
                        PositionToInstall.y = _AI.BaseHeightPosition;
                        StartCoroutine(AddSinkCabinetToWall(_AI.BASESINK, WallNumber, PositionToInstall, false));
                        return;
                    }
                }
            }
        }
    }
    IEnumerator AddSinkCabinetToWall(string Model, string WallNumber, Vector3 PositionToInstall, bool isUnderWindow)
    {
        float Angle = GetAngleByWall(WallNumber);
        Set_TemporySC(_AI.BASESINK, WallNumber, PositionToInstall, Angle, "F");
        _G.SC[67] = "SINK103,26,18,F3F3F3?Glossy?none";
        _G.SC[68] = "FAUC101,10,10,F3F3F3?Glossy?none";
        _G.SC[55] = "0,0,0,0";
        if(!isUnderWindow){_G.SC[55] = "0,48,0,0";}
        _G.SC[61] = _AI.Door1;
        _G.SC[63] = _AI.Kick1;
        CreateCAB.AddCab();
        DOIT.AllSelOff();
        yield return null;
    }

    //-------------------------------CORNER BASE CABINET------------------------------------------------------------------
    public void AddCornerBASECabinet()
    {
        if (WallSelected.Count > 1)
        {
            //GameObject Wall;
            string PreviousWallName;
            Vector3 StartPoint;
            Vector3 EndPoint;

            List<Vector3> Delta;
            foreach (string Wallstring in WallSelected)
            {
                //Wall = Get.o2("ROOM", Wallstring.Replace("m", "w"));
                PreviousWallName =  AiGet.PreviousWallName(Wallstring);
                List<GameObject> WallObstacles = AiGet.AllObjectsOnWall(Wallstring, "All", "All", _AI.FloorLine + _AI.CabinetHeight, _AI.FloorLine);
                List<GameObject> PreviousObstacles =AiGet. AllObjectsOnWall(PreviousWallName, "All", "All", _AI.FloorLine + _AI.CabinetHeight, _AI.FloorLine);

                float AngleBetween = AiGet.AngleBetweenWallAndPrevious(Wallstring, PreviousWallName);
                float SpaceOnWall = AiGet.WallSpaceDeltaOnWallFrom(Wallstring,WallObstacles,"From Start");
                float SpaceOnPrevious = AiGet.WallSpaceDeltaOnWallFrom(PreviousWallName,PreviousObstacles,"From End");

                print("SpaceOnWall==" + SpaceOnWall+"      SpaceOnPreviou===" + SpaceOnPrevious);

                //Obstacle have to be a cabinet sink
                float MinWallSpace = 72;
                float MinPreviousSpace = 36;
                bool isFirstWallSink = false;
                bool isFirstPreviousSink = false;

                if (WallObstacles.Count>0 && GetObjectUniqueName(WallObstacles[0]) == _AI.BASESINK) { MinWallSpace = 36; isFirstWallSink = true;}
                if (PreviousObstacles.Count>0 && GetObjectUniqueName(PreviousObstacles[0])==_AI.BASESINK){ MinPreviousSpace = 36; isFirstPreviousSink = true; }

                //Add Cabinet on Start point
                if (WallSelected.Contains(PreviousWallName.Replace("w", "m")) && AngleBetween < 91 && AngleBetween > 89)
                {
                    if (SpaceOnWall >= MinWallSpace && SpaceOnPrevious >= MinPreviousSpace)
                    {
                        StartPoint = AiGet.WallStartPoint(Wallstring);
                        EndPoint = AiGet.WallEndPoint(Wallstring);
                        Delta = new() { StartPoint, EndPoint };
                        StartCoroutine(AddBASECorners("90", Wallstring, Delta, SpaceOnWall));
                    }
                    if (SpaceOnWall <= MinWallSpace && SpaceOnWall >= 24 && SpaceOnPrevious >= MinPreviousSpace && isFirstPreviousSink)
                    {
                        StartPoint = AiGet.WallEndPoint(PreviousWallName);
                        EndPoint = AiGet.WallStartPoint(PreviousWallName);
                        Delta = new() { StartPoint, EndPoint };
                        StartCoroutine(AddBASECorners("Dead_R", PreviousWallName, Delta, SpaceOnPrevious));
                    }
                    if (SpaceOnWall >= MinWallSpace && SpaceOnPrevious < 36 && SpaceOnPrevious >= 24 && isFirstWallSink)
                    {
                        StartPoint = AiGet.WallStartPoint(Wallstring);
                        EndPoint = AiGet.WallEndPoint(Wallstring);
                        Delta = new() { StartPoint, EndPoint };
                        StartCoroutine(AddBASECorners("Dead_L",Wallstring, Delta, SpaceOnWall));
                    }
                }
            }
        }
        DOIT.AllSelOff();
    }
    IEnumerator AddBASECorners(string Model, string WallNumber, List<Vector3> Delta, float SpaceWall_1)
    {
        print("Wall.name=======" + WallNumber + "   Model====" + Model);
        Vector3 direction = (Delta[1] - Delta[0]).normalized;
        Vector3 PositionToInstall;
        Vector3 Forward = -Get.o1(WallNumber).transform.forward.normalized;
        float angle = GetAngleFromXClockwise(Delta[0], Delta[1]);
        
        if (Model == "90")
        {
            float Depth = DOIT.ConvertStringToNumber(UIT.Value(Library.Cabinet, _AI.CB90, Header.C));
            PositionToInstall = Delta[0] + direction.normalized * Depth * 0.5f;
            PositionToInstall += Forward * Depth * 0.5f;
            PositionToInstall.y = _AI.BaseHeightPosition;
            Set_TemporySC(_AI.CB90, WallNumber, PositionToInstall, angle, "F");
        }
        if (Model == "Dead_R")
        {
            //if (SpaceWall_1 > 51) {SpaceWall_1 = 51;}
            angle = GetAngleFromXClockwise(Delta[1], Delta[0]);
            PositionToInstall = Delta[0] + direction.normalized * 24;
            PositionToInstall += 0.5f * _AI.BaseDepth * Forward;
            PositionToInstall.y = _AI.BaseHeightPosition;

            Set_TemporySC(_AI.CBDEADR, WallNumber, PositionToInstall, angle, "R");
            _G.SC[23] = "R";
            _G.SC[4] = "B10";
        }
        if (Model == "Dead_L")
        {
            //float wide = Vector3.Distance(Delta[0], Delta[1]);
            if (SpaceWall_1 > 51) {SpaceWall_1 = 51;}

            PositionToInstall = Delta[0] + 0.5f * SpaceWall_1 * direction.normalized;
            PositionToInstall += 0.5f * _AI.BaseDepth * Forward;
            PositionToInstall.y = _AI.BaseHeightPosition;
            Set_TemporySC(_AI.CBDEADL, WallNumber, PositionToInstall, angle, "L");
            _G.SC[6]= SpaceWall_1.ToString();
        }

        _G.SC[55] = "0,20,0,0";
        _G.SC[56] = "0,20,0,0";
        
        _G.SC[61] = _AI.Door1;
        _G.SC[63] = _AI.Kick1;

        CreateCAB.AddCab();

        yield return null;
    }

    //-------------------------------SET SINK CABINET------------------------------------------------------------------
    public void SetSinkCabinet()
    {
        //Get side space
        GameObject Target = AiGet.SinkOnWall(WallSelected);
        //if spcae < 9 reduce sink cabinet

        //_AI.BASESINK = "SB33";
        ChangeCabinet(Target, _AI.BASESINK);

    }

    //-------------------------------CORNER WALL CABINET------------------------------------------------------------------
    public void AddCornerWallCabinet()
    {
        if (WallSelected.Count > 1)
        {
            //GameObject Wall;
            string PreviousWallName;
            Vector3 StartPoint;
            Vector3 EndPoint;

            List<Vector3> Delta;
            foreach (string Wallstring in WallSelected)
            {

                //Wall = Get.o2("ROOM", Wallstring.Replace("m", "w"));
                PreviousWallName = AiGet.PreviousWallName(Wallstring);
                List<GameObject> WallObstacles = AiGet.AllObjectsOnWall(Wallstring, "All", "All", _AI.CeilingLine, _AI.CeilingLine);
                List<GameObject> PreviousObstacles = AiGet.AllObjectsOnWall(PreviousWallName, "All", "All", _AI.CeilingLine, _AI.CeilingLine);

                float AngleBetween = AiGet.AngleBetweenWallAndPrevious(Wallstring, PreviousWallName);
                float SpaceOnWall = AiGet.WallSpaceDeltaOnWallFrom(Wallstring, WallObstacles, "From Start");
                float SpaceOnPrevious = AiGet.WallSpaceDeltaOnWallFrom(PreviousWallName, PreviousObstacles, "From End");

                float MinWallSpace = 24;
                float MinPreviousSpace = 24;


                if (WallSelected.Contains(PreviousWallName.Replace("w", "m")) && AngleBetween < 91 && AngleBetween > 89)
                {
                    if (SpaceOnWall >= MinWallSpace && SpaceOnPrevious >= MinPreviousSpace)
                    {
                        StartPoint = AiGet.WallStartPoint(Wallstring);
                        EndPoint = AiGet.WallEndPoint(Wallstring);
                        Delta = new() { StartPoint, EndPoint };
                        StartCoroutine(AddWallCorners("90", Wallstring, Delta, SpaceOnWall));
                    }
                    if (SpaceOnWall <= MinWallSpace && SpaceOnWall >= 24 && SpaceOnPrevious >= MinPreviousSpace)
                    {
                        StartPoint = AiGet.WallEndPoint(PreviousWallName);
                        EndPoint = AiGet.WallStartPoint(PreviousWallName);
                        Delta = new() { StartPoint, EndPoint };
                        StartCoroutine(AddWallCorners("Dead_R", PreviousWallName, Delta, SpaceOnPrevious));
                    }
                    if (SpaceOnWall >= MinWallSpace && SpaceOnPrevious < 36 && SpaceOnPrevious >= 24)
                    {
                        StartPoint = AiGet.WallStartPoint(Wallstring);
                        EndPoint = AiGet.WallEndPoint(Wallstring);
                        Delta = new() { StartPoint, EndPoint };
                        StartCoroutine(AddWallCorners("Dead_L", Wallstring, Delta, SpaceOnWall));
                    }
                }
            }
        }
        DOIT.AllSelOff();

    }
    IEnumerator AddWallCorners(string Model, string WallNumber, List<Vector3> Delta,float SpaceWall_1)
    {

        print("From AddWallCorners  Model=====" + Model);
        Vector3 direction = (Delta[1] - Delta[0]).normalized;
        Vector3 PositionToInstall;
        Vector3 Forward = -Get.o1(WallNumber).transform.forward.normalized;
        float angle = GetAngleFromXClockwise(Delta[0], Delta[1]);

        if (Model == "90")
        {
            PositionToInstall = Delta[0] + direction.normalized * 12;
            PositionToInstall += Forward * 12;
            PositionToInstall.y = _AI.WallHeightPosition;
            Set_TemporySC(_AI.CW90, WallNumber, PositionToInstall, angle, "F");
            }
        if (Model == "Dead_R")
            {
                PositionToInstall = Delta[1] + direction.normalized * 12;
                PositionToInstall += Forward * 6;
                PositionToInstall.y = _AI.WallHeightPosition;
                Set_TemporySC(_AI.CWDEADR, WallNumber, PositionToInstall, angle, "F");
            }
        if (Model == "Dead_L")
            {
                PositionToInstall = Delta[0] - direction.normalized * 12;
                PositionToInstall += Forward * 6;
                PositionToInstall.y = _AI.WallHeightPosition;
                Set_TemporySC(_AI.CBDEADR, WallNumber, PositionToInstall, angle, "F");
            }
        _G.SC[40] = "On_125";
        _G.SC[61] = _AI.Door2;
        _G.SC[60] = "GLOBAL2";
        CreateCAB.AddCab();

        yield return null;
    }

    //------------------------------_TALL CABINET------------------------------------------------------------------
    public void AddTALLCabinet()
    {
        Vector3 StartPoint;
        Vector3 EndPoint;
        Vector3 ObstacleStartPoint;
        Vector3 ObstacleEndPoint;
        float AvailableStart;
        float AvailableEnd;
        List<Vector3> DeltaStart;
        List<Vector3> DeltaEnd;
        float TallWide = UIT.ValueFloat(Library.Cabinet, _AI.TALL, Header.A);        

        if (WallSelected.Count == 1)
        {
            List<GameObject> Obstacles = AiGet.AllObjectsOnWall(WallSelected[0], "All", "All", _AI.CeilingLine, _AI.FloorLine);

            StartPoint = AiGet.WallStartPoint(WallSelected[0]);
            EndPoint = AiGet.WallEndPoint(WallSelected[0]);
            DeltaStart = new() { StartPoint, EndPoint };
            DeltaEnd = new() { EndPoint, StartPoint };

            AvailableStart = Vector3.Distance(StartPoint, EndPoint);
            AvailableEnd = Vector3.Distance(EndPoint, StartPoint);

            if (Obstacles.Count > 0)
            {
                ObstacleStartPoint = PointAlign(Obstacles[0].transform.Find("PBLB").transform.position, -_G.HEIGHT * 0.5f);
                ObstacleEndPoint = PointAlign(Obstacles[^1].transform.Find("PBRB").transform.position, -_G.HEIGHT * 0.5f);
                DeltaStart = new() { StartPoint, ObstacleStartPoint };
                DeltaEnd = new() { EndPoint, ObstacleEndPoint };
                AvailableStart = Vector3.Distance(StartPoint, ObstacleStartPoint);
                AvailableEnd = Vector3.Distance(EndPoint, ObstacleEndPoint);
            }

            if (AvailableStart >= TallWide) StartCoroutine(Add_TallCabinetonWall(WallSelected[0], DeltaStart));
            if (AvailableEnd >= TallWide) StartCoroutine(Add_TallCabinetonWall(WallSelected[0], DeltaEnd));
        }

        if (WallSelected.Count >= 1)
        {
            foreach (string Wallstring in WallSelected)
            {
                StartPoint = AiGet.WallStartPoint(Wallstring);
                EndPoint = AiGet.WallEndPoint(Wallstring);
                List<GameObject> Obstacles = AiGet.AllObjectsOnWall(Wallstring, "All", "All", _AI.CeilingLine, _AI.FloorLine);

                int IndexWall = int.Parse(Wallstring[1..]) - 1;

                Obstacles.Sort((obj1, obj2) =>
                {
                    float sqrDist1 = (obj1.transform.position - StartPoint).sqrMagnitude;
                    float sqrDist2 = (obj2.transform.position - StartPoint).sqrMagnitude;
                    return sqrDist1.CompareTo(sqrDist2);
                });


                DeltaStart = SetDeltaPoint(Wallstring, StartPoint, EndPoint,  "Base",Obstacles);

                AvailableStart = Vector3.Distance(StartPoint, EndPoint);
                AvailableEnd = Vector3.Distance(EndPoint, StartPoint);

                DeltaEnd = new() { EndPoint, StartPoint };
                bool isEndAvailable = false;
                if (EndPoint == DeltaStart[1]) { isEndAvailable = true; }

                if (Obstacles.Count > 0)
                {
                    ObstacleStartPoint = PointAlign(Obstacles[0].transform.Find("PBLB").transform.position, -_G.HEIGHT * 0.5f);
                    ObstacleEndPoint = PointAlign(Obstacles[^1].transform.Find("PBRB").transform.position, -_G.HEIGHT * 0.5f);

                    DeltaStart = new() { StartPoint, ObstacleStartPoint };
                    DeltaEnd = new() { EndPoint, ObstacleEndPoint };

                    AvailableStart = Vector3.Distance(StartPoint, ObstacleStartPoint);
                    AvailableEnd = Vector3.Distance(EndPoint, ObstacleEndPoint);
                }
                //if !previous 
                bool isPreviousSpace = true;
                string WallPreviousName = AiGet.PreviousWallName(Wallstring).Replace("w","m");
                if (WallSelected.Contains(WallPreviousName)) { isPreviousSpace = false; }
                
                bool isNexSpace = true;
                string WallNextName = AiGet.NextWallName(Wallstring).Replace("w","m");
                if (WallSelected.Contains(WallNextName)) { isNexSpace = false; }

                if (AvailableStart >= TallWide  && isPreviousSpace) { StartCoroutine(Add_TallCabinetonWall(Wallstring, DeltaStart)); }
                if (isEndAvailable && AvailableEnd >= TallWide && isNexSpace) {StartCoroutine(Add_TallCabinetonWall(Wallstring, DeltaEnd));}
            }
        }

        // //print("Add Talls Cabinet");
        // //Find Last cab _AI.BASE and last cab wall
        // GameObject LastBASECabinet;
        // GameObject LastWallCabinet;

        foreach (string Wallstring in WallSelected)
        {
            GameObject Fridge = GetObject("frid", Wallstring);

            if (Fridge != null)
            {
                int indexADN = Get.GetObjectIndex(Fridge.name);
                string[] ADN = _G.OBJs[indexADN];
                float AvailableSpace = AiGet.GetSpaceSide(ADN, "Left");

                print("AvailableSpace for tall ====" + AvailableSpace);

                if (AvailableSpace >= TallWide)
                {
                    Vector3 DirectionFridge = Fridge.transform.right.normalized;
                    EndPoint = Fridge.transform.Find("PBLB").position;
                    StartPoint = EndPoint - (TallWide+2.0f)* DirectionFridge;

                    print("StartPoint=====" + StartPoint + "    EndPoint====" + EndPoint);
                    DeltaStart = new() { StartPoint, EndPoint };
                    StartCoroutine(Add_TallCabinetonWall(Wallstring, DeltaStart));
                }
            }

        }
        //DOIT.AllSelOff();
    }
    IEnumerator Add_TallCabinetonWall(string Wallstring, List<Vector3> Delta)
    {
        Vector3 Direction = Delta[1] - Delta[0];
        float TallWide = DOIT.ConvertStringToNumber(UIT.Value(Library.Cabinet,_AI.TALL,Header.A));
        float FromFloor = DOIT.ConvertStringToNumber(UIT.Value(Library.Cabinet, _AI.TALL, Header.FF));
        float CabinetHeight = DOIT.ConvertStringToNumber(UIT.Value(Library.Cabinet, _AI.TALL, Header.B));
        Vector3 PositionToInstall = Delta[0]+TallWide*0.5f*Direction.normalized;
        float angle = GetAngleByWall(Wallstring);
        Vector3 Forward = AiGet.FowardbyWall(Wallstring);
        PositionToInstall.y = -_G.HEIGHT * 0.5f + FromFloor+CabinetHeight*0.5f; //_AI.BaseHeightPosition;
        PositionToInstall += _AI.BaseDepth *0.5f* Forward;
        Set_TemporySC(_AI.TALL, Wallstring, PositionToInstall, angle, "F");
        _G.SC[61] = _AI.Door1;
        _G.SC[63] = _AI.Kick1;
        _G.SC[60] = "GLOBAL2";
        CreateCAB.AddCab();

        if (FromFloor > 24)
        {
            print("Add basecabinet");
            CabinetHeight=DOIT.ConvertStringToNumber(UIT.Value(Library.Cabinet, _AI.TallUnder, Header.B));
            PositionToInstall.y= -_G.HEIGHT * 0.5f + CabinetHeight*0.5f;
            Set_TemporySC(_AI.TallUnder, Wallstring, PositionToInstall, angle, "F");
            _G.SC[14] = "0";
            _G.SC[55] = "0,0,0,0";
            _G.SC[60] = "GLOBAL2";
            CreateCAB.AddCab();
        }

        yield return null;
    }

    //-------------------------------BASE CABINET------------------------------------------------------------------
    public void AddBASECabinet()
    {
        StartCoroutine(CoroutineAdd_BASECabinet());
    }
    IEnumerator CoroutineAdd_BASECabinet()
    {
        foreach (string Wallstring in WallSelected)
        {
            yield return StartCoroutine(Add_BASECabinetonWall(Wallstring));
        }
    }
    IEnumerator Add_BASECabinetonWall(string Wallstring)
    {
        int IndexWall = int.Parse(Wallstring[1..]) - 1;
        List<GameObject> Obstacles = AiGet.AllObjectsOnWall(Wallstring, "All", "All", _AI.FloorLine + 10, _AI.FloorLine);

        //Points
        Vector3 StartPoint = _G.ExteriorWallPoints[IndexWall][0];
        Vector3 EndPoint = _G.ExteriorWallPoints[IndexWall][1];

        Obstacles.Sort((obj1, obj2) =>
        {
            float sqrDist1 = (obj1.transform.position - StartPoint).sqrMagnitude;
            float sqrDist2 = (obj2.transform.position - StartPoint).sqrMagnitude;
            return sqrDist1.CompareTo(sqrDist2);
        });

        foreach (GameObject O in Obstacles)
        {
            print("Obstacle===Base=" + O.name);
        }
        
        List<Vector3> ListDelta = SetDeltaPoint(Wallstring, StartPoint, EndPoint, "Base",Obstacles);

        print("Wall number ==============Base " + Wallstring+"  Start Point====="+ListDelta[0]+"  End Point====="+ListDelta[1]);
        //yield return null;

        //Add Cabinets

        yield return StartCoroutine(AddCabinetBaseToScene(Wallstring,  ListDelta, Obstacles));
        //yield return null;
    }
    IEnumerator AddCabinetBaseToScene(string Wallstring, List<Vector3> Delta,List<GameObject> Obstacles)
    {
        int DeltaQty = Obstacles.Count+1;
        Vector3 StartPoint = Delta[0];
        Vector3 EndPoint;
        Vector3 WallEndPoint = Delta[1];
        List<GameObject> ListObstacles = Obstacles;
        Vector3 Direction = (Delta[1] - Delta[0]).normalized;


        //if (CheckCornerAtEnd(Wallstring, "Base")) { Direction = -Direction; }

        if (DeltaQty == 1)
        {
            yield return AddBASECabinetOnDelta(Wallstring, Delta);
            yield return null;
        }
        if (DeltaQty >= 2)
        {
            //Start
            //if(Wallstring=="m6")print("ListObstacles[0]========on Wall 6   " + ListObstacles[0]);
            float ObjectGap = AiGet.Gap(ListObstacles[0].name);
            EndPoint = ListObstacles[0].transform.Find("PBLB").position - ObjectGap * Direction;

            Delta = new() { StartPoint, EndPoint };

            print("Base Cabinet on Wall 6 " + Wallstring + "StartPoint====" + StartPoint + "      EndPoint====" + EndPoint);
            yield return AddBASECabinetOnDelta(Wallstring, Delta);
            //yield return null;

            //Between 
            for (int i = 3; i < DeltaQty +1; i++)
            {
                ObjectGap = AiGet.Gap(ListObstacles[i - 3].name);
                StartPoint = ListObstacles[i - 3].transform.Find("PBRB").position + ObjectGap * Direction;
                ObjectGap = AiGet.Gap(ListObstacles[i - 2].name);
                EndPoint = ListObstacles[i - 2].transform.Find("PBLB").position - ObjectGap * Direction;
                Delta = new() { StartPoint, EndPoint };
                yield return AddBASECabinetOnDelta(Wallstring, Delta);
            }

            //End
            string ObstacleName = ListObstacles[DeltaQty - 2].name;
            ObjectGap = AiGet.Gap(ObstacleName);
            StartPoint = ListObstacles[DeltaQty - 2].transform.Find("PBRB").position + ObjectGap * Direction;

            EndPoint = WallEndPoint;
            Delta = new() { StartPoint, EndPoint };
            bool isSpaceAvailable = false;
            float DeltaDistance = Vector3.Distance(StartPoint, WallEndPoint);
            if (new List<string> { "cabi", "stov", "frid" }.Contains(ObstacleName[..4])) { isSpaceAvailable = true; }
            else if (DeltaDistance > 36) { isSpaceAvailable = true; }
            if (isSpaceAvailable)
            {
                yield return AddBASECabinetOnDelta(Wallstring, Delta);
            }
        }
        DOIT.AllSelOff();
        yield return null;
    }
    IEnumerator AddBASECabinetOnDelta(string WallNumber, List<Vector3> Delta)
    {
        //print("Base wall ====2====" + WallNumber);
        Vector3 StartPoint = PointAlign(Delta[0], -_G.HEIGHT * 0.5f);
        Vector3 EndPoint = PointAlign(Delta[1], -_G.HEIGHT * 0.5f);
        float Distance = Vector3.Distance(StartPoint, EndPoint);

        print("Add_AI.BASECabinetOnDelta on wall " + WallNumber + " start==" + Delta[0] + " end==" + Delta[1] + "   distance= " + Distance);
        if (Distance > 9)
        {
            Vector3 PositionToInstall = StartPoint;
            var direction = Get.o1(WallNumber).transform.right.normalized;
            float angle = GetAngleFromXClockwise(StartPoint, EndPoint);
            Vector3 Forward = -Get.o1(WallNumber).transform.forward.normalized;

            //Add cabinets
            float Qty = Mathf.Floor(Distance / 24f);
            PositionToInstall += 0.5f * (_AI.BaseDepth) * Forward;
            //List<string> AddOnDelta = new();
            string last = null;

            for (int i = 0; i < Qty; i++)
            {
                if (i == 0) { PositionToInstall += direction.normalized * 12; }
                PositionToInstall.y = _AI.BaseHeightPosition;
                Set_TemporySC(_AI.BASE, WallNumber, PositionToInstall, angle, "F");
                _G.SC[61] = _AI.Door1;
                _G.SC[63] = _AI.Kick1;
                _G.SC[55] = "0,20,0,0";
                CreateCAB.AddCab();
                last = _G.OBJs[_G.OBJnum - 1][0];
                yield return null;
                if (i != Qty - 1) { PositionToInstall += direction * 24; }
                if (i == Qty - 1) { PositionToInstall += direction * 12; }
            }

            //Find Empty Space
            float EmptySpace = Distance - Qty * 24;
            print("EmptySpace=====" + EmptySpace);

            GameObject LastInstall = null;
            if (last != null) { LastInstall = Get.o2("SCENE", last); }

            if (EmptySpace >= 3 && EmptySpace < 9 && LastInstall != null)//Between 9 to 24
            {
                if (EmptySpace >= 3 && EmptySpace < 6 && _AI.Base27 != "") { IncreaseBaseCab(_AI.Base27, LastInstall, 27, direction, angle, WallNumber); }
                else if (EmptySpace >= 6 && EmptySpace < 9 && _AI.Base30 != "") { IncreaseBaseCab(_AI.Base30, LastInstall, 30, direction, angle, WallNumber); }
            }
            else if (EmptySpace >= 9)
            {
                string AddCaB = "";
                float Wide = 0;
                if (EmptySpace >= 9 && EmptySpace < 12 && _AI.Base9 != "") { AddCaB = _AI.Base9; Wide = 9; }//or IncreaseCab("B33")
                else if (EmptySpace >= 12 && EmptySpace < 15 && _AI.Base12 != "") { AddCaB = _AI.Base12; Wide = 12; }//or IncreaseCab("B36")
                else if (EmptySpace >= 15 && EmptySpace < 18 && _AI.Base15 != "") { AddCaB = _AI.Base15; Wide = 15; }
                else if (EmptySpace >= 18 && EmptySpace < 21 && _AI.Base18 != "") { AddCaB = _AI.Base18; Wide = 18; }
                else if (EmptySpace >= 21 && EmptySpace < 24 && _AI.Base21 != "") { AddCaB = _AI.Base21; Wide = 21; }
                else if (EmptySpace >= 21 && EmptySpace < 24 && _AI.Base18 != "") { AddCaB = _AI.Base18; Wide = 18; }
                if (AddCaB != "")
                {
                    AddNewBaseCab(AddCaB, PositionToInstall, Wide, direction, angle, WallNumber);
                }
            }
        }
        DOIT.AllSelOff();
        yield return null;
    }

    static void IncreaseBaseCab(string NewCab, GameObject LastInstall, float Wide, Vector3 direction,float angle,string WallNumber)
    {
        Vector3 PositionToInstall = LastInstall.transform.position;
        int ADN = Get.GetObjectIndex(LastInstall.name);
        _G.OBJs[ADN][0] = "null";
        Destroy(LastInstall);
        PositionToInstall += (Wide - 24) * 0.5f * direction;
        PositionToInstall.y = _AI.BaseHeightPosition;
        Set_TemporySC(NewCab, WallNumber, PositionToInstall, angle, "F");
        _G.SC[61] = _AI.Door1;
        _G.SC[63] = _AI.Kick1;
        _G.SC[55] = "0,20,0,0";
        CreateCAB.AddCab();
    }
    static void AddNewBaseCab(string NewCab,Vector3 PositionToInstall,float Wide,Vector3 direction,float angle,string WallNumber)
    {
        print("Pass AddNewBaseCab " + NewCab);
        PositionToInstall += (0+(Wide*0.5f))*direction;
        PositionToInstall.y = _AI.BaseHeightPosition;
        Set_TemporySC(NewCab, WallNumber, PositionToInstall, angle, "R");
        _G.SC[61] = _AI.Door1;
        _G.SC[63] = _AI.Kick1;
        _G.SC[55] = "0,20,0,0";
        CreateCAB.AddCab();
    }

    //-------------------------------WALL CABINET------------------------------------------------------------------
    public void AddWallCabinet()
    {
        StartCoroutine(CoroutineAddWallCabinet());
    }
    IEnumerator CoroutineAddWallCabinet()
    {
        foreach (string Wallstring in WallSelected)
        {
            yield return StartCoroutine(AddWallCabinetonWall(Wallstring));
        }
    }
    IEnumerator AddWallCabinetonWall(string Wallstring)
    {
        int IndexWall = int.Parse(Wallstring[1..]) - 1;

        //Points
        Vector3 StartPoint = _G.ExteriorWallPoints[IndexWall][0];
        Vector3 EndPoint = _G.ExteriorWallPoints[IndexWall][1];
        List<GameObject> Obstacles = AiGet.AllObjectsOnWall(Wallstring, "All", "All", _AI.CeilingLine, _AI.FloorLine + 64);



        Obstacles.Sort((obj1, obj2) =>
        {
            float sqrDist1 = (obj1.transform.position - StartPoint).sqrMagnitude;
            float sqrDist2 = (obj2.transform.position - StartPoint).sqrMagnitude;
            return sqrDist1.CompareTo(sqrDist2);
        });
        
        foreach (GameObject O in Obstacles)
        {
            print("Obstacle===Wall=" + O.name);
        }
        
        List<Vector3> ListDelta = SetDeltaPoint(Wallstring, StartPoint, EndPoint,"Wall",Obstacles);
        print("Wall number ==============Wall " + Wallstring+"  Start Point====="+ListDelta[0]+"  End Point====="+ListDelta[1]);

        //Add Cabinets
        yield return StartCoroutine(AddCabineWallToScene(Wallstring, ListDelta, Obstacles));
        yield return null;

    }
    IEnumerator AddCabineWallToScene(string Wallstring, List<Vector3> Delta,List<GameObject> Obstacles)
    {
        int DeltaQty = Obstacles.Count+1;
        Vector3 DeltaStartPoint = Delta[0];
        Vector3 StartPoint;
        Vector3 EndPoint;
        Vector3 DeltaEndPoint = Delta[1];
        List<GameObject> ListObstacles = Obstacles;
        Vector3 Direction = (Delta[1] - Delta[0]).normalized;

        Vector3 WallStartPointReal = AiGet.WallStartPoint(Wallstring);
        Vector3 WallEndPointReal = AiGet.WallEndPoint(Wallstring);

        if (DeltaQty == 1)
        {
            yield return AddWallCabinetOnDelta(Wallstring, Delta);
            yield return null;
        }
        if (DeltaQty >= 2)
        {
            //Start
            float ObjectGap = AiGet.Gap(ListObstacles[0].name);
            EndPoint = PointAlign(ListObstacles[0].transform.Find("PBLB").position - ObjectGap * Direction,_AI.FloorLine);
            Delta = new() { DeltaStartPoint, EndPoint };

            //Check if Obstacle is inDelta from start
            // float Distance_RealStart_DeltaStart = Vector3.Distance(WallStartPointReal, Delta[0]);
            // float Distance_RealStart_Obstacle = Vector3.Distance(WallStartPointReal, DeltaStartPoint);
            // if (Distance_RealStart_DeltaStart < Distance_RealStart_Obstacle) { yield return AddWallCabinetOnDelta(Wallstring, Delta); }

            yield return AddWallCabinetOnDelta(Wallstring, Delta); 

            //Between
            for (int i = 3; i < DeltaQty + 1; i++)//3 & 4
            {
                if (Wallstring == "m4") { print("ListObstacles[i - 3].name=====" + ListObstacles[i - 3].name); }
                ObjectGap = AiGet.Gap(ListObstacles[i - 3].name);
                StartPoint = ListObstacles[i - 3].transform.Find("PBRB").position + ObjectGap * Direction;
                ObjectGap = AiGet.Gap(ListObstacles[i - 2].name);
                EndPoint = ListObstacles[i - 2].transform.Find("PBLB").position - ObjectGap * Direction;
                Delta = new() { StartPoint, EndPoint };
                yield return AddWallCabinetOnDelta(Wallstring, Delta);
            }

            //End
            string ObstacleName = ListObstacles[DeltaQty - 2].name;
            ObjectGap = AiGet.Gap(ObstacleName);
            StartPoint = ListObstacles[DeltaQty - 2].transform.Find("PBRB").position + ObjectGap * Direction;
            EndPoint = DeltaEndPoint;

            Delta = new() { StartPoint, EndPoint };

            bool isSpaceAvailable = false;
            float DeltaDistance = Vector3.Distance(StartPoint, EndPoint);

            if (new List<string> { "cabi", "stov", "frid" }.Contains(ObstacleName[..4])) { isSpaceAvailable = true; }
            else if (DeltaDistance > 36) { isSpaceAvailable = true; }
            if (isSpaceAvailable)
            {
                //Check if Obstacle is inDelta from end
                float Distance_RealEnd_DeltaEnd = Vector3.Distance(WallEndPointReal, DeltaEndPoint);
                float Distance_RealEnd_Obstacle = Vector3.Distance(WallEndPointReal, EndPoint);
                if (Distance_RealEnd_DeltaEnd <= Distance_RealEnd_Obstacle)
                {
                    yield return AddWallCabinetOnDelta(Wallstring, Delta);
                }
            }
        }
        DOIT.AllSelOff();
        yield return null;
    }
    static IEnumerator AddWallCabinetOnDelta(string WallNumber, List<Vector3> Delta)
    {
        Vector3 StartPoint = PointAlign(Delta[0], -_G.HEIGHT * 0.5f);
        Vector3 EndPoint = PointAlign(Delta[1], -_G.HEIGHT * 0.5f);
        float Distance = Vector3.Distance(StartPoint, EndPoint);

        if(WallNumber=="m4")print("Distance======" + Distance);
        
        //if(WallNumber=="m3")print("m3 Delta[0]===" + Delta[0] + "Delta[1]===" + Delta[1] +"    distance===="+Distance);

        if (Distance > 9)
        {
            Vector3 PositionToInstall = StartPoint;
            var direction = Get.o1(WallNumber).transform.right.normalized;

            //Rotation
            float angle = GetAngleFromXClockwise(StartPoint, EndPoint);
            Vector3 Forward = -Get.o1(WallNumber).transform.forward.normalized;

            //Add cabinets
            float Qty = Mathf.Floor(Distance / 24f);
            PositionToInstall += Forward * _AI.WallDepth * 0.5f;
            string last =null;

            for (int i = 0; i < Qty; i++)
            {
                if (i == 0) { PositionToInstall += direction.normalized * 12; }
                PositionToInstall.y = _AI.WallHeightPosition;
                Set_TemporySC(_AI.WALL, WallNumber, PositionToInstall, angle, "F");
                _G.SC[40] = "On_25";
                _G.SC[61] = _AI.Door2;
                _G.SC[60] = "GLOBAL2";
                CreateCAB.AddCab();
                last=_G.OBJs[_G.OBJnum - 1][0];
                yield return null;
                if (i != Qty - 1) { PositionToInstall += direction * 24; }
                if (i == Qty - 1) { PositionToInstall += direction * 12; }
            }

            //Find Empty Space
            float EmptySpace = Distance - Qty * 24;

            GameObject LastInstall = null;
            if (last !=null) { LastInstall = Get.o2("SCENE", last); }

            if (EmptySpace >= 3 && EmptySpace < 9 && LastInstall != null)
            {
                if (EmptySpace >= 3 && EmptySpace < 6 && _AI.Wall27 != "") { IncreaseWallCab(_AI.Wall27, LastInstall, 27, direction, angle, WallNumber); }
                else if (EmptySpace >= 6 && EmptySpace < 9 && _AI.Wall30 != "") { IncreaseWallCab(_AI.Wall30, LastInstall, 30, direction, angle, WallNumber); }
            }
            else if (EmptySpace >= 9)
            {
                string AddCaB = "";
                float Wide = 0;
                if (EmptySpace >= 9 && EmptySpace < 12 && _AI.Wall9 != "") { AddNewWallCab(_AI.Wall9, PositionToInstall, 9, direction, angle, WallNumber); }//or IncreaseCab("W3330")
                else if (EmptySpace >= 12 && EmptySpace < 15 && _AI.Wall12 != "") { AddCaB = _AI.Wall12; Wide = 12; }//or IncreaseCab("W3630")
                else if (EmptySpace >= 15 && EmptySpace < 18 && _AI.Wall15 != "") { AddCaB = _AI.Wall15; Wide = 15; }
                else if (EmptySpace >= 18 && EmptySpace < 21 && _AI.Wall18 != "") { AddCaB = _AI.Wall18; Wide = 18; }
                else if (EmptySpace >= 21 && EmptySpace < 24 && _AI.Wall21 != "") { AddCaB = _AI.Wall21; Wide = 21; }
                else if (EmptySpace >= 21 && EmptySpace < 24 && _AI.Wall18 != "") { AddCaB = _AI.Wall18; Wide = 18; }
                if (AddCaB != "")
                {
                    AddNewWallCab(AddCaB, PositionToInstall, Wide, direction, angle, WallNumber);
                }
            }
        }
        DOIT.AllSelOff();
        yield return null;
    }
    static void IncreaseWallCab(string NewCab, GameObject LastInstall, float Wide, Vector3 direction,float angle,string WallNumber)
    {
        Vector3 PositionToInstall = LastInstall.transform.position;
        int ADN = Get.GetObjectIndex(LastInstall.name);
        _G.OBJs[ADN][0] = "null";
        Destroy(LastInstall);        
        PositionToInstall += (Wide - 24) * 0.5f * direction;
        PositionToInstall.y = _AI.WallHeightPosition;
        Set_TemporySC(NewCab, WallNumber, PositionToInstall, angle, "F");
        _G.SC[40] = "On_25";
        _G.SC[61] = _AI.Door2;
        _G.SC[60] = "GLOBAL2";
        CreateCAB.AddCab();
    }
    static void AddNewWallCab(string NewCab,Vector3 PositionToInstall,float Wide,Vector3 direction,float angle,string WallNumber)
    {
        PositionToInstall += Wide*0.5f*direction;
        PositionToInstall.y = _AI.WallHeightPosition;
        Set_TemporySC(NewCab, WallNumber, PositionToInstall, angle, "R");
        _G.SC[40] = "On_25";
        _G.SC[61] = _AI.Door2;
        _G.SC[60] = "GLOBAL2";
        _G.SC[60] = "GLOBAL2";
        CreateCAB.AddCab();
    }

    //-------------------------------ISLAND CABINET------------------------------------------------------------------
    public void AddIslandCabinet()
    {
        StartCoroutine(AddIslandCabinetonFloor());
    }
    IEnumerator AddIslandCabinetonFloor()
    {
        //print("Add Island=====");
        int IndexWall = int.Parse(WallSelected[0][1..]) - 1;
        Vector3 StartPoint = PointAlign(_G.ExteriorWallPoints[IndexWall][0], -_G.HEIGHT * 0.5f);
        Vector3 EndPoint = PointAlign(_G.ExteriorWallPoints[IndexWall][1], -_G.HEIGHT * 0.5f);
        string Wallstring = WallSelected[0].Replace("m", "w");
        Vector3 Direction = Get.o1(Wallstring).transform.right.normalized;
        Vector3 Forward = -Get.o1(Wallstring).transform.forward.normalized;

        StartPoint += 66 * Direction;
        StartPoint += Forward * 78;
        EndPoint -= 66 * Direction;
        EndPoint += Forward * 78;
        List<Vector3> Delta = new() { StartPoint, EndPoint };

        yield return AddIslandCabinetOnDelta(Wallstring, Delta);
        yield return null;
    }
    static IEnumerator AddIslandCabinetOnDelta(string WallNumber, List<Vector3> Delta)
    {
        _WideIsland = 0;
        Vector3 StartPoint = Delta[0];
        Vector3 EndPoint = Delta[1];
        float Distance = Vector3.Distance(StartPoint, EndPoint);
        Vector3 PositionToInstall = StartPoint;
        Vector3 direction = Get.o1(WallNumber).transform.right.normalized;
        Vector3 forward = -Get.o1(WallNumber).transform.forward.normalized;
        float angle = GetAngleFromXClockwise(EndPoint, StartPoint);
        PositionToInstall.y = _AI.BaseHeightPosition;

        //Add Dishwasher
        PositionToInstall += direction.normalized * 12;   
        Set_TemporySC(_AI.BASE, "floor", PositionToInstall, angle, "F");
        _G.SC[42] = "1.25_0_10_0_1.75_0_0_0";
        _G.SC[45] = "OFF";
        _G.SC[47] = "ON";
        _G.SC[55] = "0,20,0,0";
        _WideIsland += 24;
        CreateCAB.AddCab();
        yield return null;

        //Add Drawer
        PositionToInstall += direction.normalized * 24;        
        Set_TemporySC(_AI.BASE, "floor", PositionToInstall, angle, "F");
        _G.SC[42] = "1.25_0_10_0_1.75_0_0_0";
        _G.SC[45] = "OFF";
        _G.SC[47] = "OFF";
        _G.SC[55] = "0,20,0,0";
        _WideIsland += 24;
        CreateCAB.AddCab();
        yield return null;

        //Add Microwave
        float MicrowaveWide = DOIT.ConvertStringToNumber(UIT.Value(Library.Cabinet,_G.SC[0],Header.A));
        PositionToInstall += direction.normalized * MicrowaveWide;  
        Set_TemporySC(_AI.MICROWAVE, "floor", PositionToInstall, angle, "F");
        _G.SC[42] = "1.25_0_10_0_1.75_0_0_0";
        _G.SC[45] = "ON";
        _G.SC[47] = "OFF";
        CreateCAB.AddCab();
        yield return null;
        _WideIsland += MicrowaveWide;

        //Add cabinets
        // if (Distance > 1)
        // {
        //     float Qty = Mathf.Floor(Distance / 24f);
        //     PositionToInstall += direction.normalized * 12;
        //     PositionToInstall.y = _AI.BaseHeightPosition;

        //     for (int i = 0; i < Qty; i++)
        //     {
        //         //print("PositionToInstall====" + PositionToInstall);
        //         Set_TemporySC(_AI.BASE, "floor", PositionToInstall, angle, "F");
        //         _G.SC[42] = "1.25_0_10_0_1.75_0_0_0";
        //         _G.SC[45] = "OFF";
        //         _G.SC[47] = "OFF";
        //         if (i == 0) { _G.SC[47] = "ON"; }
        //         if (i == Qty - 1) { _G.SC[45] = "ON"; }
        //         _G.SC[61] = _AI.Door1;
        //         _G.SC[63] = _AI.Kick1;
        //         CreateCAB.AddCab();
        //         PositionToInstall += direction.normalized * 24;
        //         yield return null;
        //     }
        // }

        //Add panel back island

        Vector3 size = new(0.5f, 35.5f, _WideIsland);
        PositionToInstall = StartPoint;
        PositionToInstall += _WideIsland*0.5f * direction + 14 * forward;
        PositionToInstall.y = -_G.HEIGHT * 0.5f + 35.5f * 0.5f;
        Set_TemporySC_Panel(_AI.PANEL_ISLAND, "floor", size, PositionToInstall, angle, "F");
        _G.SC[60] = "GLOBAL3";;
        _G.SC[61] = UIT.Global(Header.Door,3).Split("?")[1]+"?90";
        CreatePnl.addpnl();
        DOIT.AllSelOff();
        yield return null;
    }

    //----------------------------------HOOD--------------------------------------------------------------------------
    public void AddHood()
    {
        StartCoroutine(CaroutineAddHood());
    }
    IEnumerator CaroutineAddHood()
    {
        print("Add Hood reach");
        GameObject Stove = null;
        string WallNumber = "";
        foreach (string Wall in WallSelected)
        {
            Stove = GetObject("stov", Wall);
            WallNumber = Wall.Replace("m", "w");            
            if (Stove != null) break;
        }
        if (Stove != null)
        {
            print("Add Hood reach and stove exist");
            Vector3 PositionToInstall = Stove.transform.position;
            float StoveWide = AiGet.ObjectWide(Stove);
            float angle = GetAngleByWall(WallNumber);
            float HoodHeight = _G.HEIGHT - 60;
            PositionToInstall.y = -_G.HEIGHT * 0.5f + 60 + HoodHeight * 0.5f;
            Vector3 Size = new(StoveWide, HoodHeight, 24);
            Set_TemporySC_Hood(_AI.HOOD, WallNumber, Size, PositionToInstall, angle);
            _G.SC[40] = "On_200";
            CreateHOOD.AddHood();
            DOIT.AllSelOff();
        }
        yield return null;
    }

    //------------------------------FRIDGE CABINET AND PANELS------------------------------------------------------
    public void AddFridgeCabinet()
    {
        foreach (string Wall in WallSelected)
        {
            StartCoroutine(AddFridgeCab(Wall));
        }
    }
    IEnumerator AddFridgeCab(string Wall) {

        GameObject Fridge = GetObject("frid", Wall);
        if (Fridge != null)
        {
            Vector3 PositionToInstall = Fridge.transform.position;
            Vector3 Forward = Fridge.transform.forward.normalized;
            //Vector3 Up = Fridge.transform.up.normalized;
            Vector3 Right = Fridge.transform.right.normalized;
            float CabinetHeight = UIT.ValueFloat(Library.Cabinet,_AI.FRIDGE,Header.B);
            float FridgeDepth = AiGet.ObjectDepth(Fridge);
            float FridgeWide = AiGet.ObjectWide(Fridge);
            float CabinetFridgeDepth=UIT.ValueFloat(Library.Cabinet,_AI.FRIDGE,Header.C);
            float CabinetFridgeWide=UIT.ValueFloat(Library.Cabinet,_AI.FRIDGE,Header.A);
            PositionToInstall += (FridgeDepth - CabinetFridgeDepth) * 0.5f * Forward;
            PositionToInstall.y = _G.HEIGHT*0.5f-12-CabinetHeight * 0.5f;
            float angle = GetAngleByWall(Wall);
            Set_TemporySC(_AI.FRIDGE, Wall, PositionToInstall, angle, "F");
            _G.SC[40] = "Off";
            _G.SC[60] = "GLOBAL2";
            CreateCAB.AddCab();

            //Panel Right
            Vector3 size = new(0.75f, 84, CabinetFridgeDepth);
            //PositionToInstall = Fridge.transform.position-;
            PositionToInstall += (CabinetFridgeWide* 0.5f + 0.75f*0.5f) * Right;
            PositionToInstall.y = -_G.HEIGHT * 0.5f + 42;
            //print("FridgeWide====" + FridgeWide);
            Set_TemporySC_Panel(_AI.PANEL_FRIDGE, Wall, size, PositionToInstall, angle - 90, "F");
            _G.SC[60] = "GLOBAL1";
            _G.SC[61] = UIT.Global(Header.Door,1).Split("?")[1]+"?0";
            _G.SC[60] = "GLOBAL2";
            CreatePnl.addpnl();

            //Panel Right
            //PositionToInstall = Fridge.transform.position;
            PositionToInstall -= (CabinetFridgeWide + 0.75f) * Right;
            //PositionToInstall.y = -_G.HEIGHT * 0.5f + 42;
            Set_TemporySC_Panel(_AI.PANEL_FRIDGE, Wall, size, PositionToInstall, angle - 90, "F");
            _G.SC[60] = "GLOBAL1";
            _G.SC[61] = UIT.Global(Header.Door,1).Split("?")[1]+"?0";
            _G.SC[60] = "GLOBAL2";
            CreatePnl.addpnl();
        }
        DOIT.AllSelOff();
        yield return null;
    }

    //------------------------------DRAWERS------------------------------------------------------------------
    public void AddDrawers()
    {
        List<GameObject> ListTarget = new();
        GameObject Newtarget;
        
        foreach (string Wall in WallSelected)
        {
            List<GameObject> ListCabinetsOnWall = AiGet.AllObjectsOnWall(Wall, "Cabinet", "B1", _AI.FloorLine + _AI.CabinetHeight, _AI.FloorLine);

            float CenterDistance = 200;
            GameObject TobeAdd = null;

            //Cabinet on Walls
            foreach (GameObject Cabinet in ListCabinetsOnWall)
            {
                string CabinetUniqueName = GetObjectUniqueName(Cabinet);

                int ADN = Get.GetObjectIndex(Cabinet.name);
                int IndexofWall = int.Parse(Wall[1..]);
                Vector3 WallcenterPoint = _G.WallsPointCenter[IndexofWall-1];
                float DistancefromCenterWall = Vector3.Distance(WallcenterPoint, Cabinet.transform.position);
                if (DistancefromCenterWall < CenterDistance)
                    if (CabinetUniqueName != _AI.BASESINK)
                    {
                        CenterDistance = DistancefromCenterWall;
                        TobeAdd = Cabinet;
                    }
            }
            ListTarget.Add(TobeAdd); 
        }

        //Change Cab from list
        foreach (GameObject Target in ListTarget)
        {
            if (Target != null)
            {
                string drawerUniqueName = CabinetDrawerMatchSizeUniqueName(Target);
                if (drawerUniqueName != "")ChangeCabinet(Target, drawerUniqueName);               
            }
        }

        
        //Island
        List<GameObject> ListCabinetsOnIsland = GetAllObjectsOnFloor("floor", "Cabinet", "B1", _AI.FloorLine + _AI.CabinetHeight+10, _AI.FloorLine, "From Start");
        Newtarget = ListCabinetsOnIsland[0];
        if (Newtarget != null)
        {
            string drawerUniqueName = CabinetDrawerMatchSizeUniqueName(Newtarget);
            if (drawerUniqueName != "")
            {
                ChangeCabinet(Newtarget, drawerUniqueName);
            }
        }
        DOIT.AllSelOff();
    }

    //----------------------------DISHWASHER----------------------------------------------------------------
    public void AddDishwasher()
    {
        StartCoroutine(CoroutineAddDishwasher());
    }
    IEnumerator CoroutineAddDishwasher()
    {
        //First Check if place on island
        List<GameObject> ListCabinetsOnIsland = GetAllObjectsOnFloor("floor", "Cabinet", "B1", _AI.FloorLine + _AI.CabinetHeight, _AI.FloorLine, "From Start");
        foreach (GameObject Cabinet in ListCabinetsOnIsland)
        {
            string UniqueName = GetObjectUniqueName(Cabinet);
            if (UniqueName == _AI.Base24)
            {
                //print("Add Dishwasher reach and stove exist");
                Vector3 PositionToInstall = Cabinet.transform.position;
                PositionToInstall += Cabinet.transform.forward*0.3125f;

                float CabinetWide = AiGet.ObjectWide(Cabinet);
                float CabinetDepth = AiGet.ObjectDepth(Cabinet);
                float CabinetHeight = AiGet.ObjectHeight(Cabinet) + _G.caCH;
                float Angle = AiGet.ObjectAngle(Cabinet);
                Vector3 Size = new(CabinetWide, CabinetHeight, CabinetDepth);
                string C42 = GetObjectADN(Cabinet, 42);
                string C45 = GetObjectADN(Cabinet, 45);
                string C47 = GetObjectADN(Cabinet, 47);

                DestroyImmediate(Cabinet);
                Set_TemporySC_Dishwasher(_AI.DISHWASHER, "floor", Size, PositionToInstall, Angle);

                _G.SC[42] = C42;
                _G.SC[45] = C45;
                _G.SC[47] = C47;
                CreateDISHWASHER.AddDishwasher();
                DOIT.AllSelOff();
                yield break;
            }
        }
        yield return null;
    }

    //----------------------------MICROWAVE---------------------------------------------------------------
    public void AddMicrowave()
    {
        StartCoroutine(CoroutineAddMicrowave());
    }
    IEnumerator CoroutineAddMicrowave()
    {
        //Find Microwave cabinet
        for (int i = 0; i < _G.OBJnum; i++)
        {
            if (DOIT.exist(i))
            {
                string[] ADN = _G.OBJs[i];
                if (ADN[1] == _AI.MICROWAVE)
                {
                    GameObject Cabinet = Get.o2("SCENE", ADN[0]);
                    Vector3 PositionToInstall = Cabinet.transform.position;
                    PositionToInstall += 6*Cabinet.transform.up-3*Cabinet.transform.forward;
                    Vector3 Size = new(20, 13, 16);
                    float Angle = AiGet.ObjectAngle(Cabinet);  
                    Set_TemporySC_Deco("MICR101", "floor", Size, PositionToInstall, Angle);
                    CreateMICROWAVE.AddMicrowave();
                }
            }
        }
        yield return null;
    }

    //----------------------------ADD FILLERS & RECOVER----------------------------------------------------------------
    public void AddFillers_Cover()
    {
        StartCoroutine(CoroutineAddFillers());
    }
    IEnumerator CoroutineAddFillers()
    {
        _G.CameraCliping = 1;
        Camera.main.GetComponent<CameraAround>().Hide();
        for (int i = 0; i < _G.OBJnum; i++)
        {
            print("i======" + i);
            if (DOIT.exist(i))
            {

                string[] ADN = _G.OBJs[i];
                print("i=====exist=" + i+"     ADN[2]==="+ADN[2]+"     ADN[22]==="+ADN[22]);                
                if (ADN[2] == "Cabinet" && ADN[22].Contains("w") && ADN[4]!="B2")//B2 is off only for demo
                {

                    float distanceRight = AiGet.GetSpaceSide(ADN, "Right"); yield return null;
                    float distanceLeft = AiGet.GetSpaceSide(ADN, "Left"); yield return null;
                    string IDText = Match_Finish.Exterior_From_Door(ADN[61]).Split("?")[1];

                    print("IDText======" + IDText + "Cabinet " + ADN[0] + "    distanceRight= " + distanceRight + "   distanceLeft= " + distanceLeft);

                    if (distanceRight > 0.25f && distanceRight < 6)
                    {
                        string wide = distanceRight.ToString();
                        ADN[51] = "FLAT?" + IDText + "?90?" + wide;
                        ADN[38] = distanceRight.ToString();
                        ADN[42] = DOIT.ChangeCodeOnPos(ADN[42], 3, wide, "_");
                        ADN[55] = DOIT.ChangeCodeOnPos(ADN[55], 2, wide, ",");
                        ADN[63] = DOIT.ChangeCodeOnPos(ADN[63], 1, IDText, "?");
                        DOIT.REDOCAB(i);
                        yield return new WaitForSecondsRealtime(1);
                    }
                    if (distanceRight == 1000 || distanceLeft == 1000)
                    {
                        print("Add recover On Right to Cabinet ====" + ADN[0]);
                        string Model = "4";
                        if (_G.PATH == "collection_elite")
                        {
                            Model = "3";
                            if (ADN[1] == _AI.TALL)
                            {
                                Model = "2";
                            }
                        }
                        string PanelRecipe = Model + "?" + IDText + "?0";//Model+ColorIF+Sens

                        if (distanceRight == 1000)
                        {
                            if (new List<string> { "B1", "W1", "T1" }.Contains(ADN[4]))
                            {
                                ADN[81] = "0_0_" + PanelRecipe + "_0_0_0_0";
                                if(ADN[4]=="B1"){Set.NewValueCode(ADN[42], "1", 3, "_");}
                            }
                            else { ADN[81] = "0_0_0_" + PanelRecipe + "_0_0_0"; }
                        }
                        if (distanceLeft == 1000)
                        {
                            if (new List<string> { "B1", "W1", "T1" }.Contains(ADN[4]))
                            {
                                ADN[81] = Set.NewValueCode(ADN[81], PanelRecipe, 0, "_");
                                if(ADN[4]=="B1"){Set.NewValueCode(ADN[42], "1", 1, "_");}
                            }
                        }
                        DOIT.REDOCAB(i);
                    }
                }
            }
        }
        yield return null;
    }

    //----------------------------STOOLS---------------------------------------------------------------
    public void AddStools()
    {
        StartCoroutine(CoroutineAddStools());
    }
    IEnumerator CoroutineAddStools()
    {
        //List Objects
        List<GameObject> ListObjectsOnIsland = GetAllObjectsOnFloor("floor", "All", "Base_Dish", _AI.FloorLine + _AI.CabinetHeight, _AI.FloorLine, "From Start");

        //Find center point of Island
        Vector3 PositionToInstall = GetIslandCenterPoint(ListObjectsOnIsland);

        //Find Lenght of Island
        float LengthAvailable = GetIslandWide(ListObjectsOnIsland);

        //Get Directions
        Vector3 Forward = -AiGet.FowardbyObject(ListObjectsOnIsland[0]);
        Vector3 Direction = -GetDirectionbyObject(ListObjectsOnIsland[0]);
        float Angle = AiGet.ObjectAngle(ListObjectsOnIsland[0]);  
        Vector3 Size = new(12, 30, 12);

        //Set positions
        PositionToInstall -= 8 * Forward;
        float Qty = Mathf.Ceil(LengthAvailable / 18);
        float StoolSpace = (LengthAvailable - Qty*12)/(Qty-1);
        PositionToInstall.y = -_G.HEIGHT * 0.5f + 15;

        for (int i = 0; i < Qty; i++)
        {
            if (i == 0) { PositionToInstall -= Direction * (LengthAvailable * 0.5f - 6); }
            Set_TemporySC_Deco("STOO101", "floor", Size, PositionToInstall, Angle);
            CreateStool.AddStool();
            PositionToInstall += Direction * (StoolSpace + 12);
            yield return new WaitForSecondsRealtime(0.5f);
        }

        yield return null;
    }

    //----------------------------LAMPS----------------------------------------------------------------
    public void AddLamps()
    {
        StartCoroutine(CoroutineAddLamps());
    }
    IEnumerator CoroutineAddLamps()
    {
        //List Objects
        List<GameObject> ListObjectsOnIsland = GetAllObjectsOnFloor("floor", "All", "Base_Dish", _AI.FloorLine + _AI.CabinetHeight, _AI.FloorLine, "From Start");

        //Find center point of Island
        Vector3 PositionToInstall=GetIslandCenterPoint(ListObjectsOnIsland);

        //Find Lenght of Island
        float LengthAvailable = GetIslandWide(ListObjectsOnIsland);

        //Get Directions
        Vector3 Forward = -AiGet.FowardbyObject(ListObjectsOnIsland[0]);
        Vector3 Direction = -GetDirectionbyObject(ListObjectsOnIsland[0]);
        float Angle = AiGet.ObjectAngle(ListObjectsOnIsland[0]);  
        Vector3 Size = new(6, 36, 6);

        //Set positions
        PositionToInstall += 6 * Forward;
        float Qty = Mathf.Ceil(LengthAvailable / 24);
        float StoolSpace = (LengthAvailable - Qty*12)/(Qty-1);
        PositionToInstall.y = _G.HEIGHT * 0.5f - 18;

        for (int i = 0; i < Qty; i++)
        {
            if (i == 0) { PositionToInstall -= Direction * (LengthAvailable * 0.5f - 9); }
            Set_TemporySC_Deco("LAMP102", "ceil", Size, PositionToInstall, Angle);
            CreateLamp.AddLamp();
            PositionToInstall += Direction * (StoolSpace + 12);
            yield return new WaitForSecondsRealtime(0.5f);
        }

        //Add Lamp to Sink Windows
        int IndexSinkWindow = GetWindowSinkIndex();
        //("IndexSinkWindow===" + IndexSinkWindow);
        if (IndexSinkWindow != 1000)
        {
            GameObject Window = Get.o2("SCENE", _G.OBJs[IndexSinkWindow][0]);
            PositionToInstall = Window.transform.position;
            PositionToInstall.y = _G.HEIGHT * 0.5f - 18;
            Forward = -AiGet.FowardbyObject(Window);
            PositionToInstall += 12 * Forward;
            Set_TemporySC_Deco("LAMP102", "ceil", Size, PositionToInstall, Angle);
            CreateLamp.AddLamp();
        }
        yield return null;
    }
   
    //----------------------------FLOOR----------------------------------------------------------------
    public void AddFloor()
    {
        _G.FLCs = "CERA.3?#FFFFFF?#8C8C8C?#FFFFFF?1-1?0?1?0.9?0.5?1";
        CreateFloor.SetFloor();
    }

    //----------------------------WALL & CEILING---------------------------------------------------------------
    public void PaintWalls()
    {
        StartCoroutine(PaintaWall());
    }
    IEnumerator PaintaWall()
    {
        string walllcode = "none,#ffffff,#A6A6A6,#ffffff,0.25-0.25,0,1,0.25,0,0";
        for (int i = 0; i < _G.NW; i++)
        {
            if (GameObject.Find("w" + (i + 1).ToString()))
            {
                GameObject Wall = GameObject.Find("w" + (i + 1).ToString()).transform.gameObject;
                _G.WallsMaterial[i] = Wall.transform.GetChild(0).GetComponent<MeshRenderer>().material;
                foreach(Transform s in Wall.transform)
                {
                    s.GetComponent<Renderer>().material = UIT_MATERIAL.GetMaterial(walllcode);
                    yield return null;
                }
            }
        }
        yield return RedrawOpening();
        }   
    IEnumerator RedrawOpening()
    {
        ConstructOpen.RedrawOpen();

        //Ceiliing
        Transform ceil = SceneModeManager.Ceil;
        string ceilcode = "none,#FFFFFF,#FFFFFF,#FFFFFF,1,0,0.1,0.2,0.3";
        foreach (Transform Section in ceil.transform)
        {
            Section.GetComponent<Renderer>().material = UIT_MATERIAL.GetMaterial(ceilcode);
        }
        yield return null;
    }

    //----------------------------CEILING SPOT---------------------------------------------------------------
    public void AddSpotCeilling()
    {
        StartCoroutine(CoroutineAddSpotCeilling());
    }
    IEnumerator CoroutineAddSpotCeilling()
    {
        //print("_G.NWExterior====" + _G.NWExterior);
        for (int i = 0; i < _G.NWExterior; i++)
        {
            GameObject Wall = Get.o2("ROOM", "w" + (i + 1).ToString());
            GameObject PreviuosWall = AiGet.PreviousWall(Wall);
            GameObject NextWall =AiGet.NextWall(Wall);

            if (Wall != null && PreviuosWall != null)
            {
                Vector3 DirectionWall = -GetDirectionbyObject(Wall);
                Vector3 DirectionPrevious = GetDirectionbyObject(PreviuosWall);
                Vector3 DirectionNext = GetDirectionbyObject(NextWall);
                Vector3 WallProject = Wall.transform.position - 36 * AiGet.FowardbyObject(Wall);
                Vector3 PreviousProject = PreviuosWall.transform.position - 36 * AiGet.FowardbyObject(PreviuosWall);
                Vector3 NextProject = NextWall.transform.position - 36 * AiGet.FowardbyObject(NextWall);

                //First Spot
                Vector3 PositionToInstall = GetLineIntersection(WallProject, DirectionWall, PreviousProject, DirectionPrevious);
                PositionToInstall.y = _G.HEIGHT * 0.5f + 0.5f;
                yield return StartCoroutine(CoroutineddSpotFromWall(PositionToInstall));
                yield return new WaitForSecondsRealtime(0.1f);

                //Add Point on that wall
                Vector3 PositionToInstallNext = GetLineIntersection(NextProject, DirectionNext, WallProject, DirectionWall);
                PositionToInstallNext.y = _G.HEIGHT * 0.5f + 1;
                float AvailableDistance = Vector3.Distance(PositionToInstall, PositionToInstallNext);
                float Qty = Mathf.Floor(AvailableDistance / 48) ;
                float Space = AvailableDistance / (Qty+1);
                if (Qty>0 ) { 
                    for (int s = 0; s < Qty; s++)
                    {
                        PositionToInstall -= Space * DirectionWall;
                        yield return StartCoroutine(CoroutineddSpotFromWall(PositionToInstall));
                        yield return new WaitForSecondsRealtime(0.1f);
                    }
                }
            }
        }
        DOIT.AllSelOff();
    }
    IEnumerator CoroutineddSpotFromWall(Vector3 Position)
    {
        Vector3 Size = new(5, 1, 5);
        Set_TemporySC_Deco("LAMP107", "ceil", Size, Position, 0);

        CreateLamp.AddLamp();
        yield break;
    }

    //----------------------------BACK SPLASH---------------------------------------------------------------
    public void AddBackSplash()
    {
        //Check Windows Andstove
        //GameObject Window;
        //GameObject Stove;
        for (int i = 0; i < _G.OBJnum; i++)
        {
            if (DOIT.exist(i))
            {
                string[] ADN = _G.OBJs[i];
                float ff = DOIT.ConvertStringToNumber(ADN[21]);
                string Wall = ADN[22].Replace("w", "m");
                string Left;
                string Right;
                float Height;
                string Top;
                string Under;

                if (WallSelected.Contains(Wall) && ADN[2] == "Window" && ff >= 36)
                {
                    GameObject Window = Get.o2("SCENE", ADN[0]);
                    Left = GetLeftTouch(Window).ToString();
                    Right = GetRightTouch(Window).ToString();
                    Height = AiGet.ObjectHeight(Window);
                    Top = (_G.HEIGHT - Height - ff - 12 - 2).ToString();
                    Under = (ff - 36 + 2).ToString();
                    ADN[55] = Left + "," + Top + "," + Right + "," + Under;
                    DOIT.REDOOBJECT(i);
                }

                if (WallSelected.Contains(Wall) && ADN[4] == "stov")
                {
                    //Stove = Get.o2("SCENE", ADN[22]);
                    GameObject Stove = Get.o2("SCENE", ADN[0]);
                    Left = GetLeftTouch(Stove).ToString();
                    Right = GetRightTouch(Stove).ToString();
                    Height = AiGet.ObjectHeight(Stove);
                    Top = (_G.HEIGHT - Height - 12).ToString();
                    ADN[55] = Left + "," + Top + "," + Right + ",0";
                    DOIT.REDOOBJECT(i);
                }
            }
        }
    }

    //--------------------------OVER SINK-----------------------------------------------------------------
    public void VerifyWallCabinetOverSink()
    {
        for (int i = 0; i < _G.OBJnum; i++)
        {
            if (DOIT.exist(i))
            {
                //string C55 = "0,40,0,0";
                string[] ADN = _G.OBJs[i];
                if (ADN[2] == "Cabinet" && ADN[1] == _AI.BASESINK && WallSelected.Contains(ADN[22].Replace("w", "m")))
                {
                    GameObject Target = Get.o2("SCENE", ADN[0]);
                    GameObject OverL = GetObjectOver(Target, 6);
                    GameObject OverR = GetObjectOver(Target, -6);
                    bool isCabinetOver = false;

                    if (OverL != null && OverL.name.Contains("cabi"))
                    {
                        StartCoroutine(CoroutineChangeCabinetOverSink(OverL, ADN[22]));
                        ADN[55] = "10,40,0,0";
                        isCabinetOver = true;
                    }
                    if (OverR != null && OverR.name.Contains("cabi"))
                        {
                            StartCoroutine(CoroutineChangeCabinetOverSink(OverR, ADN[22]));
                            ADN[55] = "10,40,10,0";
                            isCabinetOver = true;
                        }
                    if(isCabinetOver){DOIT.REDOCAB(i);}
                }
            }
        }
    }
    IEnumerator CoroutineChangeCabinetOverSink(GameObject Target, string WallNumber)
    {
        Vector3 PositionToInstall = Target.transform.position;
        PositionToInstall.y+= 9;
        float angle = AiGet.ObjectAngle(Target);
        float TargetWide = AiGet.ObjectWide(Target);
        string NewCab = _AI.Wall24OS;
        if (TargetWide == 24) NewCab = _AI.Wall24OS;

        if (NewCab != "")
        {
            string C61 = GetObjectADN(Target, 61);
            DestroyImmediate(Target);       
            Set_TemporySC(NewCab, WallNumber, PositionToInstall, angle, "F");
            _G.SC[61] = C61;
            _G.SC[40] = "On_25";
            CreateCAB.AddCab();
            yield return new WaitForSecondsRealtime(1);
        }
        yield return null;
    }

    //----------------------------SETTING AND DELETE----------------------------------------------------------------
    public static void Set_TemporySC(string Cabinet_UniqueName, string WallNumber, Vector3 Pos, float angle, string Flip)
    {
        print("PositionToInstall=====2=" + Pos);
        _G.SC = new string[101];
        _G.SC[0] = Cabinet_UniqueName;
        _G.SC[4] = UIT.Value(Library.Cabinet, _G.SC[0], Header.Model);//B1
        _G.SC[5] = UIT.Value(Library.Cabinet, _G.SC[0], Header.Category);//C_AI.BASE

        _G.SC[6] = UIT.Value(Library.Cabinet, _G.SC[0], Header.A);
        _G.SC[7] = UIT.Value(Library.Cabinet, _G.SC[0], Header.B);
        _G.SC[8] = UIT.Value(Library.Cabinet, _G.SC[0], Header.C);

        _G.SC[10] = UIT.Value(Library.Cabinet, _G.SC[0], Header.K);//Kick Height
        _G.SC[11] = "0";//Interiorfinish on/off     
        _G.SC[12] = "0";//Underfinish on/off           
        _G.SC[14] = _G.caCH.ToString();//Counter Height       

        _G.SC[15] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.x); //Pos.x.ToString();
        _G.SC[16] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.y);
        _G.SC[17] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.z);
        _G.SC[19] = angle.ToString();
        _G.SC[21] = UIT.Value(Library.Cabinet, _G.SC[0], Header.FF);
        _G.SC[22] = WallNumber.Replace("m", "w");
        _G.SC[23] = Flip;

        print("PositionToInstall=====3=" + _G.SC[17]);

        _G.CODEPATERN = UIT.Value(Library.Cabinet, _G.SC[0], Header.Pattern_Door_1);
        _G.CODEPATERN2 = UIT.Value(Library.Cabinet, _G.SC[0], Header.Pattern_Door_2);
        _G.SC[28] = _AI.BaseDepth.ToSafeString();
        _G.SC[29] = _AI.BaseDepth.ToSafeString();

        if (Cabinet_UniqueName == _AI.CW90)
        {
            _G.SC[28] = _AI.WallDepth.ToSafeString();
            _G.SC[29] = _AI.WallDepth.ToSafeString();
        }
        _G.SC[60] = "GLOBAL1";
        _G.SC[61] = UIT.Global(Header.Door,_G.G);//Door on/off
        _G.SC[78] = "Std";//Sides
        _G.SC[34] = UIT.Value(Library.Cabinet, _G.SC[0], Header.K_Code);
        _G.SC[55] = "0,0,0,0";
        _G.SC[73] = "LEGSKICK";
        _G.SC[100] = "FromAI";
    }
    public static void Set_TemporySC_Panel(string Panel_UniqueName, string WallNumber, Vector3 size, Vector3 Pos, float angle, string Flip)
    {
        _G.SC = new string[101];
        _G.SC[0] = Panel_UniqueName;
        _G.SC[1] = DOIT.ConvertNumberToStringWithoutSymbol(size.x);//
        _G.SC[2] = DOIT.ConvertNumberToStringWithoutSymbol(size.y);//
        _G.SC[3] = DOIT.ConvertNumberToStringWithoutSymbol(size.z);//

        _G.SC[15] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.x); //Pos.x.ToString();
        _G.SC[16] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.y);
        _G.SC[17] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.z);
        _G.SC[19] = angle.ToString();
        _G.SC[22] = WallNumber.Replace("m", "w");

        _G.SC[60] = "GLOBAL" + _G.G.ToString();
        _G.SC[61] = "1" + "?" + "0" + "?" + "0" + "?" + "0" + "?" + "0.5" + "?" + "0" + "?" + "0" + "?" + "0";//Color? Rotation? eh? ev? t? ct? ts? slat ? woodSense

        _G.SC[100] = "FromAI";
    }
    public static void Set_TemporySC_Hood(string Hood_UniqueName, string WallNumber, Vector3 size, Vector3 Pos, float angle)
    {
        _G.SC = new string[101];
        _G.SC[0] = Hood_UniqueName;

        _G.SC[1] = DOIT.ConvertNumberToStringWithoutSymbol(size.x);//
        _G.SC[2] = DOIT.ConvertNumberToStringWithoutSymbol(size.y);//
        _G.SC[3] = DOIT.ConvertNumberToStringWithoutSymbol(size.z);//

        _G.SC[15] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.x); //Pos.x.ToString();
        _G.SC[16] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.y);
        _G.SC[17] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.z);
        _G.SC[19] = angle.ToString();
        _G.SC[22] = WallNumber.Replace("m", "w");

        _G.SC[4]="F3F3F3?Glossy?none";

        _G.SC[100] = "FromAI";
    }
    public static void Set_TemporySC_Dishwasher(string Diswasher_UniqueName, string WallNumber, Vector3 size, Vector3 Pos, float angle)
    {
        _G.SC = new string[101];
        _G.SC[0] = Diswasher_UniqueName;

        _G.SC[1] = DOIT.ConvertNumberToStringWithoutSymbol(size.x);//
        _G.SC[2] = DOIT.ConvertNumberToStringWithoutSymbol(size.y);//
        _G.SC[3] = DOIT.ConvertNumberToStringWithoutSymbol(size.z);//

        _G.SC[15] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.x); //Pos.x.ToString();
        _G.SC[16] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.y);
        _G.SC[17] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.z);

        _G.SC[19] = angle.ToString();
        _G.SC[22] = WallNumber.Replace("m", "w");

        _G.SC[100] = "FromAI";
    }
    public static void Set_TemporySC_Deco(string Deco_UniqueName, string WallNumber, Vector3 size, Vector3 Pos, float angle)
    {
        _G.SC = new string[101];
        _G.SC[0] = Deco_UniqueName;

        _G.SC[1] = DOIT.ConvertNumberToStringWithoutSymbol(size.x);//
        _G.SC[2] = DOIT.ConvertNumberToStringWithoutSymbol(size.y);//
        _G.SC[3] = DOIT.ConvertNumberToStringWithoutSymbol(size.z);//

        _G.SC[4] = "#ffffff_Gloss_none";//
        _G.SC[5] = "#ffffff_Mat_none";//

        _G.SC[15] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.x); //Pos.x.ToString();
        _G.SC[16] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.y);
        _G.SC[17] = DOIT.ConvertNumberToStringWithoutSymbol(Pos.z);
        _G.SC[19] = angle.ToString();
        _G.SC[22] = WallNumber.Replace("m", "w");

        _G.SC[100] = "FromAI";
    }
    public static void DeleteAllCab()
    {
        //string wall = WallSelected[0].Replace("m", "w");
        //GameObject SCENE = Get.o1("SCENE");
        CameraAround.Show();

        for (int i = 0; i < _G.OBJnum; i++)
        {
            if (DOIT.exist(i))
            {
                if (new List<string> { "cabi", "pane", "dish", "lamp", "stoo", "hood", "micr" }.Contains(_G.OBJs[i][0][..4]))
                {
                    string ObjecName = _G.OBJs[i][0];
                    _G.OBJs[i][0] = "null";
                    Destroy(Get.o2("SCENE",ObjecName));
                }
            }
        }
    }
    public static void ShowWallSelected()
    {
        GameObject NewWallSelected = Get.o2("Panel_SCENE/PNL/AI_PNL", "WallSelected");
        NewWallSelected .GetComponent<TMP_Text>().text = "";
        foreach (string Wall in AI.WallSelected)
        {
            //print("Wall selected=====" + Wall);
            NewWallSelected .GetComponent<TMP_Text>().text += Wall + ",";
        }
    }
    public static List<Vector3> SetDeltaPoint(string Wallstring, Vector3 StartPoint, Vector3 EndPoint, string Category, List<GameObject> Obstacles)
    {
        float TopLine = _AI.FloorLine + 64;
        float ButtonLine = _AI.FloorLine;
        Vector3 Direction = (EndPoint - StartPoint).normalized;
        float DeltaLength = Vector3.Distance(StartPoint, EndPoint);
        Vector3 WallStartPoint = StartPoint;
        Vector3 WallEndPoint = EndPoint;

        if (DeltaLength < 24) { return new() { StartPoint, EndPoint }; }

        print("Direction=========================" + Direction);
        if (Category == "Wall")
        {
            TopLine = _AI.CeilingLine;
            ButtonLine = _AI.FloorLine + 30;
        }

        //Check start Angle
        string PreviousWallName=AiGet.PreviousWallName(Wallstring);
        float StartAngle = AiGet.AngleBetweenWallAndPrevious(Wallstring, PreviousWallName);
        if (StartAngle >= 100)
        {
            StartPoint += 12 * Direction;
        }

        //Check end Angle
        string NextWallName=AiGet.NextWallName(Wallstring);
        float EndAngle = AiGet.AngleBetweenWallAndNext(Wallstring,NextWallName);
        if (EndAngle >= 100)
        {
            EndPoint -= 12 * Direction;
        }


        //Check on Adjacent Wall
        NextObject = AiGet.CheckNextWall(Wallstring, TopLine, ButtonLine);
        if (NextObject != null) print("NextObject name===" + NextObject);
        PreviousObject = AiGet.CheckPreviousWall(Wallstring, TopLine, ButtonLine);
        if (NextObject != null && !string.IsNullOrEmpty(NextObject.name) && EndAngle < 100)
        {
            float DistanceOnNext = GetObjectSpaceFromNextorPrevious(NextObject.name);
            EndPoint -= DistanceOnNext * Direction;
        }
        if (PreviousObject != null && !string.IsNullOrEmpty(PreviousObject.name) && StartAngle < 100)
        {
            float DistanceOnPrevious = GetObjectSpaceFromNextorPrevious(PreviousObject.name);
            StartPoint += DistanceOnPrevious * Direction;
        }


        //Check if Obstacle is inDelta from start
        if (Obstacles.Count > 0)
        {
            Vector3 FirstObstacalePointLeft = PointAlign(Obstacles[0].transform.Find("PBLB").transform.position, _AI.FloorLine);
            Vector3 FirstObstacalePointRight = PointAlign(Obstacles[0].transform.Find("PBRB").transform.position, _AI.FloorLine);
            float Distance_RealStart_StartPoint = Vector3.Distance(WallStartPoint, StartPoint);
            float Distance_RealStart_FirstObstacalePointLeft = Vector3.Distance(WallStartPoint, FirstObstacalePointLeft);
            if (Distance_RealStart_StartPoint > Distance_RealStart_FirstObstacalePointLeft) { StartPoint = FirstObstacalePointLeft; }
            //if (Distance_RealStart_FirstObstacalePointLeft < 6) { StartPoint = FirstObstacalePointRight; }


            Vector3 LastObstacalePointLeft = PointAlign(Obstacles[^1].transform.Find("PBLB").transform.position, _AI.FloorLine);
            Vector3 LastObstacalePointRight = PointAlign(Obstacles[^1].transform.Find("PBRB").transform.position, _AI.FloorLine);
            float Distance_RealEnd_EndPoint = Vector3.Distance(WallEndPoint, EndPoint);
            float Distance_RealEnd_LastObstacalePointRight = Vector3.Distance(WallEndPoint, LastObstacalePointRight);
            if (Distance_RealEnd_EndPoint > Distance_RealEnd_LastObstacalePointRight) { EndPoint = LastObstacalePointRight; }
        }

        return new() { StartPoint, EndPoint };
    }
    public static Vector3 PointAlign(Vector3 Point, float Hight)
    {
        Vector3 NewPoint = new(Point.x, Hight, Point.z);
        return NewPoint;
    }
    public static void AllMeshDeselect()
    {
        DOIT.ResetRoomSelect();
        WallSelected.Clear();
    }
    public static void SetGlobals()
    {
        UIT.GlobalSet(Header.Counter, "COUN.9?737373?484848?F6F6F6?1-1?0?1?0.98?0.3?1", _G.G);
        //_AI.Door1 = "6?16";
        //_AI.Door2 = "5?15";

    }
    public static List<string> ReorderWallString(List<string> list)
    {

        // Trie en extrayant la partie numérique de chaque string
        list = list.OrderBy(s =>
        {
            string numberPart = new string(s.SkipWhile(c => !char.IsDigit(c)).ToArray());
            return int.Parse(numberPart);
        }).ToList();

        // Affichage pour test
        foreach (var item in list)
        {
            Console.WriteLine(item);
        }
        return list;
    }

    //-------------------------------GET------------------------------------------------------------------
    public static float GetAngleByWall(string WallNumber)
    {
        Vector3 StartPoint = AiGet.WallStartPoint(WallNumber);
        Vector3 EndPoint = AiGet.WallEndPoint(WallNumber);
        List<Vector3> Delta = new() { StartPoint, EndPoint };
        return GetAngleFromXClockwise(Delta[0], Delta[1]);
    }
    static string GetObjectADN(GameObject Object,int IndexADN)
    {
        int ADN = Get.GetObjectIndex(Object.name);
        return _G.OBJs[ADN][IndexADN];
    }
    static string GetObjectUniqueName(GameObject Object)
    {
        print("Object name ====" + Object.name);
        int ADN = Get.GetObjectIndex(Object.name);
        return _G.OBJs[ADN][1];
    }
    public static float GetAngleFromXClockwise(Vector3 fromPos, Vector3 toPos)
    {
        // Direction from A to B in XZ plane
        Vector2 dir = new Vector2(toPos.x - fromPos.x, toPos.z - fromPos.z).normalized;

        // Get angle from +X axis (atan2 returns counter-clockwise)
        float angle = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;

        // Convert to clockwise angle in [0, 360)
        float clockwiseAngle = (360 - angle + 360) % 360;

        return clockwiseAngle;
    }
    public static float GetObjectSpaceFromNextorPrevious(string NameObject)
    {
        int ADN = Get.GetObjectIndex(NameObject);
        if (_G.OBJs[ADN][1] == _AI.CB90) { return 36; }
        else if (_G.OBJs[ADN][1] == _AI.CBDEADR) { return 24; }
        else if (_G.OBJs[ADN][1] == _AI.CBDEADL) { return 24; }
        else if (_G.OBJs[ADN][1] == _AI.CWDEADR) { return 24; }
        else if (_G.OBJs[ADN][1] == _AI. CWDEADL) { return 24; }
        else if (_G.OBJs[ADN][1] == _AI.BASE) { return 24 + 12; }
        else if (_G.OBJs[ADN][1] == _AI.WALL) { return 24 + 12; }
        else if (_G.OBJs[ADN][1] == _AI.CW90) { return 24; }
        return 0;
    }
    public static GameObject FindFarthestFromPoint(string Wallstring, string Category) //List<GameObject> objects, Vector3 referencePoint)
    {
        List<GameObject> ListCabinetOnWall = new();
        if (Category == "B1") { ListCabinetOnWall = AiGet.AllObjectsOnWall(Wallstring, "Cabinet", Category, _AI.FloorLine + _AI.CabinetHeight + 1, _AI.FloorLine); }
        if (Category == "W1") { ListCabinetOnWall = AiGet.AllObjectsOnWall(Wallstring, "Cabinet", Category, _AI.CeilingLine, _AI.FloorLine + _AI.CabinetHeight + 1); }

        int IndexWall = int.Parse(Wallstring[1..]) - 1;
        Vector3 StartPoint = _G.ExteriorWallPoints[IndexWall][0];
        ListCabinetOnWall.Sort((obj1, obj2) =>
        {
            float sqrDist1 = (obj1.transform.position - StartPoint).sqrMagnitude;
            float sqrDist2 = (obj2.transform.position - StartPoint).sqrMagnitude;
            return sqrDist1.CompareTo(sqrDist2);
        });

        Vector3 PointFrom;
        if (Wallstring.Replace("w", "m") == WallSelected[0]) { PointFrom = AiGet.WallStartPoint(Wallstring); }
        else { PointFrom = AiGet.WallEndPoint(Wallstring); }

        GameObject farthest = null;
        float maxDistanceSqr = float.MinValue;

        foreach (GameObject obj in ListCabinetOnWall)
        {
            if (obj == null) continue;
            float Wide = AiGet.ObjectWide(obj);
            float distSqr = (obj.transform.position - PointFrom).sqrMagnitude;

            if (distSqr > maxDistanceSqr && Wide == 24)
            {
                maxDistanceSqr = distSqr;
                farthest = obj;
            }
        }

        return farthest;
    }
    public static List<GameObject> GetAllObjectsOnFloor(string Wallnunber, string Category, string Model, float UpLine, float downLine, string Sorting)
    {
        List<GameObject> Obstacles = new();
        bool isUnderline = false;//36

        //print("UpLine=====" + UpLine + "     downLine=====" + downLine);
        List<string> Modellist = new();
        if (Model == "CornerBASE") { Model = "B2"; Modellist = new() { "B2", "B3", "B4", "B5", "B9", "B10" }; }
        if (Model == "CornerWall") { Model = "W2"; Modellist = new() { "W2", "W3", "W4", "W5", "W9", "W10" }; }
        if (Model == "dish") { Model = "dish"; Modellist = new() { "dish"}; }
        if (Model == "Base_Dish") { Model = "dish"; Modellist = new() { "B1","dish"}; }
        if (Model == "Cabinet") { Model = "dish"; Modellist = new() { "B1","dish"}; }

        for (int i = 0; i < _G.OBJnum; i++)
        {
            if (!DOIT.exist(i)) continue;
            if (_G.OBJs[i][22] == Wallnunber && _G.OBJs[i][2] == Category || _G.OBJs[i][22] == Wallnunber && Category == "All" && _G.OBJs[i][2] != "Stool"|| _G.OBJs[i][22] =="floor" && _G.OBJs[i][4]==Model )
            {
                print("From GetAllObjectsOnFloor ===1=" + _G.OBJs[i][0]);
                GameObject Target = Get.o2("SCENE", _G.OBJs[i][0]);
                float LineBASE = Target.transform.Find("PBLB").transform.position.y;
                float LineTop = Target.transform.Find("PBLU").transform.position.y;

                if (LineBASE <= UpLine && LineBASE >= downLine || LineTop <= UpLine && LineTop >= downLine) { isUnderline = true; }
                if (_G.OBJs[i][4] == Model || Model == "All" || Modellist.Contains(_G.OBJs[i][4]))
                {
                    print("From GetAllObjectsOnFloor ===2=" + _G.OBJs[i][0]);
                    print("From GetAllObjectsOnFloor ===3=" + isUnderline);
                    if (isUnderline) { Obstacles.Add(Get.o2("SCENE", _G.OBJs[i][0])); isUnderline = false; }
                }
            }
        }
        // Obstacles.Sort((obj1, obj2) =>
        // {
        //     float sqrDist1 = (obj1.transform.position - StartPoint).sqrMagnitude;
        //     float sqrDist2 = (obj2.transform.position - StartPoint).sqrMagnitude;
        //     return sqrDist1.CompareTo(sqrDist2);
        // });
        // if (Sorting == "From End") Obstacles.Reverse();
        return Obstacles;
    }
    public static GameObject GetObjectSide(GameObject Target, List<GameObject> List)
    {
        GameObject ObjectSide = null;
        Vector3 TargetPosition = Target.transform.position;
        float Distance;
        //print("List count=====" + List.Count);
        if (List.Count > 0)
        {
            foreach (GameObject Object in List)
            {
                Vector3 ObjectPosition = Object.transform.position;
                Distance = Vector3.Distance(TargetPosition, ObjectPosition);
                if (Distance <= 30) { ObjectSide = Object; }
            }
        }
        return ObjectSide;
    }
    public static string GetWallNumberbyObjectName(string Objectname)
    {
        int ADN = Get.GetObjectIndex(Objectname);
        return _G.OBJs[ADN][22];
    }
    public static GameObject GetObject(string Category, string Wallnumber) {
        for (int i = 0; i < _G.OBJnum; i++)
        {
            if (!DOIT.exist(i)) continue;
            if (_G.OBJs[i][22] == Wallnumber.Replace("m", "w") && _G.OBJs[i][4] == Category)
            {
                return Get.o2("SCENE", _G.OBJs[i][0]);
            }
        }
        return null;
    }
    public static Vector3 GetDirectionbyObject(GameObject Target) {
        return Target.transform.right.normalized;
    }
    static string CabinetDrawerMatchSizeUniqueName(GameObject Target)
    {
        string drawerUniqueName = GetObjectUniqueName(Target);
        float TargetWide = AiGet.ObjectWide(Target);
        return TargetWide switch
        {
            12 => _AI.Drawer12,
            15 => _AI.Drawer15,
            18 => _AI.Drawer18,
            21 => _AI.Drawer21,
            24 => _AI.Drawer24,
            30 => _AI.Drawer30,
            27 => _AI.Drawer27,
            33 => _AI.Drawer33,
            36 => _AI.Drawer36,
            _ => drawerUniqueName,
        };
    }
    static Vector3 GetCenterPoint(List<Vector3> points)
    {
        if (points == null || points.Count == 0)
        {
            Debug.LogWarning("La liste est vide.");
            return Vector3.zero;
        }

        Vector3 total = Vector3.zero;
        foreach (Vector3 point in points)
        {
            total += point;
        }

        return total / points.Count;
    }
    static float GetLeftTouch(GameObject Object)
    {
        Vector3 origin = Object.transform.position;
        Vector3 Direction = -GetDirectionbyObject(Object);
        float Wide = AiGet.ObjectWide(Object);
        origin += Wide * 0.5f * Direction;

        // Perform raycast
        if (Physics.Raycast(origin, Direction, out RaycastHit hit, 24))
        {
            // Return distance to the hit object
            return hit.distance+0.5f;
        }

        // If nothing hit, return -1 or max distance
        return -1f;
    }
    static float GetRightTouch(GameObject Object)
        {
            Vector3 origin = Object.transform.position;
            Vector3 Direction = GetDirectionbyObject(Object);
            float Wide = AiGet.ObjectWide(Object);
            origin += Wide * 0.5f * Direction;   

            // Perform raycast
            if (Physics.Raycast(origin, Direction, out RaycastHit hit, 24))
            {
                // Return distance to the hit object
                return hit.distance+0.5f;
            }

            // If nothing hit, return -1 or max distance
            return -1f;
    }
    static Vector3 GetIslandCenterPoint(List<GameObject> ListObjectsOnIsland )
    {
        List<Vector3> IslandCabPositions = new();
        foreach (GameObject Object in ListObjectsOnIsland)
        {
            IslandCabPositions.Add(Object.transform.Find("PBLB").transform.position);
            IslandCabPositions.Add(Object.transform.Find("PBRB").transform.position);
        }
        return GetCenterPoint(IslandCabPositions);

    }
    static float GetIslandWide(List<GameObject> ListObjectsOnIsland)
    {
        float LengthAvailable  = 0;
        foreach (GameObject Object in ListObjectsOnIsland){
            LengthAvailable  += AiGet.ObjectWide(Object);
        }
        LengthAvailable  -= 12;
        return LengthAvailable ;

    }
    static int GetWindowSinkIndex() {
        //Windows,sinkcabinet
        for (int i = 0; i < _G.OBJnum; i++)
        {
            if (DOIT.exist(i) && _G.OBJs[i][2] == "Window" && WallSelected.Contains( _G.OBJs[i][22].Replace("w","m")  ))
            {
                float ff = DOIT.ConvertStringToNumber(_G.OBJs[i][21]);
                if (ff >= 36 )
                {
                    return  i;
                }
            }
        }
        return 1000;
    }
    public static Vector3 GetLineIntersection(Vector3 p1, Vector3 dir1, Vector3 p2, Vector3 dir2)
    {
        // Flatten to XZ plane
        Vector2 a = new(p1.x, p1.z);
        Vector2 b = new(p2.x, p2.z);
        Vector2 da = new(dir1.x, dir1.z);
        da = da.normalized;
        Vector2 db = new(dir2.x, dir2.z);
        db = db.normalized;

        Vector2 delta = b - a;

        float cross = da.x * db.y - da.y * db.x;

        if (Mathf.Abs(cross) < 1e-6f)
        {
            // Lines are parallel
            return Vector3.zero;
        }

        float t = (delta.x * db.y - delta.y * db.x) / cross;
        Vector2 intersectionXZ = a + da * t;

        return new Vector3(intersectionXZ.x, 0f, intersectionXZ.y);
    }
    public static GameObject GetObjecUnder(GameObject Cabinet) {
        Vector3 origin = Cabinet.transform.position;
        Vector3 downDirection = -Cabinet.transform.up;
        if (Physics.Raycast(origin, downDirection, out RaycastHit hit, 36))
        {
            print("hit.transform.gameObject===" + hit.transform.gameObject);
            return hit.transform.gameObject;
        }
        return null;
    }
    public static GameObject GetObjectOver(GameObject Cabinet,float Ofset) {
        Vector3 origin = Cabinet.transform.position;
        Vector3 UpDirection = Cabinet.transform.up;
        Vector3 FrontDirection = -Cabinet.transform.forward;
        Vector3 RightDirection = Cabinet.transform.right;
        origin += Ofset*RightDirection;
        origin.y=0;
        origin -= 6* FrontDirection ;

        print("Origine=====" + origin);
        if (Physics.Raycast(origin, UpDirection, out RaycastHit hit, 36))
        {
            print("hit.transform.gameObject===" + hit.transform.gameObject.name);
            return hit.transform.gameObject;
        }
        return null;
    }

    //------------------------------CHECK-----------------------------------------------------------------
    public bool IsNextWallHaveCornerCab(int IntWall)
    {
        //Check if Next wall have a Corner at start
        bool NextHaveCorner = false;
        int IntNextWall = IntWall + 1;
        if (IntNextWall > _G.NW) { IntNextWall = 1; }
        string WallNextString = "w" + IntNextWall.ToString();


        for (int i = 0; i < _G.OBJnum; i++)
        {
            if (DOIT.exist(i) && _G.OBJs[i][22] == WallNextString)
            {
                //print("_G.OBJs[i][5]====" + _G.OBJs[i][5]);
                if (_G.OBJs[i][5] == "CB") NextHaveCorner = true;
            }
        }
        return NextHaveCorner;
    }
    public static void Swap<T>(List<T> list, int indexA, int indexB)
    {
        T temp = list[indexA];
        list[indexA] = list[indexB];
        list[indexB] = temp;
    }
    public static void ChangeCabinet(GameObject Target, string NewObjectName)
    {
        Vector3 PositionToInstall = Target.transform.position;
        float angle = Target.transform.eulerAngles.y;
        string WallSelect = GetWallNumberbyObjectName(Target.name);
        string C45 = GetObjectADN(Target, 45);
        string C47 = GetObjectADN(Target, 47);
        string C55 = GetObjectADN(Target, 55);
        string C61 = GetObjectADN(Target, 61);
        string C63 = GetObjectADN(Target, 63);
        string C15 = GetObjectADN(Target, 15);
        string C16 = GetObjectADN(Target, 16);
        string C17 = GetObjectADN(Target, 17);

        Destroy(Target);
        Set_TemporySC(NewObjectName, WallSelect, PositionToInstall, angle, "F");
        _G.SC[42] = "1.25_0_10_0_1.75_0_0_0";
        _G.SC[45] = C45;
        _G.SC[47] = C47;
        _G.SC[55] = C55;
        _G.SC[61] = C61;
        _G.SC[63] = C63;
        _G.SC[15] = C15;
        _G.SC[16] = C16;
        _G.SC[17] = C17;

        if (NewObjectName == _AI.BASESINK)
        {
            _G.SC[67] = "SINK103,26,18,#666666_Gloss_None";
            _G.SC[68] = "FAUC101,10,10,#666666_Gloss_None";
        }
        CreateCAB.AddCab();
    }
    public static bool CheckSpace(Vector3 StartPoint, Vector3 EndPoint, float SpaceNeeded) {
        //print("Check distance===" + Vector3.Distance(StartPoint, EndPoint));
        return SpaceNeeded <= Vector3.Distance(StartPoint, EndPoint);
    }
    public static bool CheckCornerAtEnd(string WallNumber, string Category)
    {
        //print("CheckCornerAtEn WallNumber======" + WallNumber);
        float TopLine = _AI.FloorLine + _AI.CabinetHeight;
        float BaseLine = _AI.FloorLine;
        if (Category == "Wall")
        {
            TopLine = _AI.CeilingLine;
            BaseLine = _AI.FloorLine + _AI.CabinetHeight+10;
        }

        List<GameObject> ListCabinet = new();
        if (Category == "Base") { ListCabinet = AiGet.AllObjectsOnWall(WallNumber, "Cabinet", "CornerBASE", TopLine, BaseLine); }
        if (Category == "Wall") { ListCabinet = AiGet.AllObjectsOnWall(WallNumber, "Cabinet", "CornerWall", TopLine, BaseLine); }
        if (Category == "Tall") { ListCabinet = AiGet.AllObjectsOnWall(WallNumber, "Cabinet", "T1", TopLine, BaseLine); }

        NextObject = AiGet.CheckNextWall(WallNumber,  TopLine, BaseLine);

        if (NextObject != null)
        {
            ListCabinet.Add(NextObject);
        }
        
        foreach (GameObject Cabinet in ListCabinet)
        {
            //print("Cabinet===================================================================================================" + Cabinet.name);
            Vector3 ObjectPosition = PointAlign(Cabinet.transform.position,_AI.FloorLine);
            Vector3 EndPoint = AiGet.WallEndPoint(WallNumber);
            float Distance = Vector3.Distance(ObjectPosition, EndPoint);

            // print("CheckCornerAtEn Cabinet===" + Cabinet.name+"    ObjectPosition ==="+ObjectPosition);
            // print("CheckCornerAtEn Cabinet===" + Cabinet.name+"    EndPoint ==="+EndPoint);
            // print("CheckCornerAtEn Cabinet===" + Cabinet.name+"    distance ==="+Distance);

            if (Distance < 36) { return true; }
        }

        return false;
    }
}