using JetBrains.Annotations;
using Linework.EdgeDetection;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using TMPro;
using Unity.VectorGraphics;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.UI;

namespace Plan2D
{
    public class Plan2DHandler : MonoBehaviour
    {
        [Header("Plan2D Settings")]
        [SerializeField] float _offsetForIncrementalCut = 36f;
        public float OffsetForIncrementalCut { get { return _offsetForIncrementalCut * ViewScale; } }
        [SerializeField] float _offsetForIncrementalCutSides = 10.5f;    // left / right
        public float OffsetForIncrementalCutSides { get { return _offsetForIncrementalCutSides * ViewScale; } }
        [SerializeField] float _offsetForIncrementalCutTopBottom = 12f; // top / bottom — smaller spacing
        public float OffsetForIncrementalCutTopBottom { get { return _offsetForIncrementalCutTopBottom * ViewScale; } }
        [SerializeField] bool _incrementalCut = true;
        public bool IsIncrementalCut { get { return _incrementalCut; } }
        [SerializeField] bool _displayMeasureCloseToWall = true;
        public bool DisplayMeasureCloseToWall { get { return _displayMeasureCloseToWall; } }
        public bool DebugCameraZoom { get { return _debugCameraZoom; } }
        [SerializeField] bool _debugCameraZoom = false;
        public float ZoomBuffer { get { return _zoomBuffer; } }
        [SerializeField] float _zoomBuffer = 4f;
        [SerializeField] float _viewZoomMultiplier = 0.75f;
        [SerializeField] float _islandViewPadding = 1.05f;

        [Header("Measure Settings")]
        [SerializeField]
        List<Color> _linesColors = new(12)
        {
            Color.black,              // 0  Wall
            Color.black,              // 1  IslandWall
            Color.red,                // 2  FloorObject (BA)
            Color.blue,               // 3  WallObject  (WA)
            new Color(52,52,53),      // 4  StructuralElements
            Color.red,                // 5  IslandObject
            Color.black,              // 6  Floor
            Color.gray,               // 7  WallLines
            Color.black,              // 8  WallThickness
            Color.black,              // 9  CabOverlay
            Color.black,              // 10 Debug
            new Color(0.145f, 0.702f, 0.020f), // 11 TallObject (TA) — #25B305
        };

        [SerializeField]
        ObjectTypes[] objectTypes = new[]
        {
            ObjectTypes.FloorObject,
            ObjectTypes.WallObject,
            ObjectTypes.TallObject,
            ObjectTypes.Null,
            ObjectTypes.StructuralElements,
            ObjectTypes.Wall,
            ObjectTypes.IslandObject,
            ObjectTypes.IslandWall,
        };

        [SerializeField] float _distanceFromWallForObjects = 12f;
       // [SerializeField] float _distanceFromWallForCutBtn = 36f;
        [SerializeField] float _wallThickness = 12f;
        [SerializeField] float _lineThickness = 0.4f;
        [Header("Measure Filter")]
        [SerializeField] bool _showWallMeasure = true;
        [SerializeField] bool _showFloorObject = true;
        [SerializeField] bool _showWallObject = true;
        [SerializeField] bool _showHoleInWallObject = true;
        [SerializeField] bool _showIsland = true;
        [SerializeField] bool _showIslandWall = true;
        bool _showWallElevation;

        [Header("Object References")]
        [SerializeField] Canvas _mainCanvas;
        [SerializeField] Canvas _plan2DCanvas;
        [SerializeField] Canvas _worldButtonCanvas;
        [SerializeField] Button _islandButton;
        // object in scene includes cabinet, fridge etc
        [SerializeField] GameObject _scene;
        // include wall, ceiling, floor
        [SerializeField] GameObject _room;
        [SerializeField] GameObject _plan2DButtonOverlay;

        List<GameObject> _walls = new();
        List<GameObject> _objectToActive = new();
        Dictionary<ObjectTypes, List<GameObject>> _objectsInScene = new(Enum.GetValues(typeof(ObjectTypes)).Length - 1);
        List<LineDisplay> _wallLines = new();
        List<LineDisplay> _islandLines = new();
        HashSet<Camera> _camsWithIslandContent = new();
        float _islandSharedOrthoSize; // max orthoSize across all island cameras (shared scale)

        public ObjectPool _lineRendererPool;
        public ObjectPool _lineRendererForOverlayPool;
        public ObjectPool _textPool;

        Dictionary<ObjectTypes, List<GameObject>> _lineRenderers = new(Enum.GetValues(typeof(ObjectTypes)).Length - 1);
        Dictionary<ObjectTypes, List<GameObject>> _lineRenderersForOverlay = new(Enum.GetValues(typeof(ObjectTypes)).Length - 1);
        public float ViewScale => _camera != null ? _camera.orthographicSize / 150f : 1f;
        public float HalfLineThickness { get { return _lineThickness * 0.5f * ViewScale; } }
        Dictionary<ObjectTypes, List<GameObject>> _texts = new(Enum.GetValues(typeof(ObjectTypes)).Length - 1);
        Dictionary<int, GameObject> _wallCutsButtons = new();
        List<GameObject> _wallElevationButtonObjects = new();

        [Header("Camera References")]
        [SerializeField] Transform _cameraPos;
        [SerializeField] float _cameraDistance = 150f;
        [SerializeField] GameObject _lineRendererPrefab;
        [SerializeField] GameObject _lineRendererForOverlayPrefab;
        Dictionary<int, CameraSetting> _cameraSettings = new();
        int cameraViews = Enum.GetValues(typeof(CameraViews)).Length - 1;
        bool _outlineEnabled = false;
        Camera _camera;
        public List<Color> LineColors { get { return _linesColors; } }
        CameraViews _currentCameraView;

        [Header("Islands References")]
        [SerializeField] Camera _front;
        public Camera FrontCamera { get { return _front; } }
        [SerializeField] Camera _back;
        public Camera BackCamera { get { return _back; } }
        [SerializeField] Camera _left;
        public Camera LeftCamera { get { return _left; } }
        [SerializeField] Camera _right;
        public Camera RightCamera { get { return _right; } }
        [SerializeField] RectTransform _islandCutPanel;
        Vector3 _islandCenterPosition;

        [Header("Text Settings")]
        [SerializeField] GameObject _textPrefab;
        [SerializeField] float _fontSize = 6f;
        [SerializeField] float _minFontSize = 4.5f;
        public float MinFontSize { get { return _minFontSize * ViewScale; } }
        public float FontSize { get { return _fontSize * ViewScale; } }
        [SerializeField] float _fontSizeElevation = 9f;
        [SerializeField] float _minFontSizeElevation = 4.5f;
        public float FontSizeElevation { get { return _fontSizeElevation * ViewScale; } }
        public float MinFontSizeElevation { get { return _minFontSizeElevation * ViewScale; } }
        [SerializeField] float _fontSizeIsland = 4.5f;
        [SerializeField] float _minFontSizeIsland = 4.5f;
        public float FontSizeIsland { get { return _fontSizeIsland * ViewScale; } }
        public float MinFontSizeIsland { get { return _minFontSizeIsland * ViewScale; } }

        [Header("Shader Settings")]
        [SerializeField] Shader _outlineShader;
        [Tooltip("Renderer features to DISABLE while Plan2D is active (drag the blue outline feature here).")]
        [SerializeField] List<ScriptableRendererFeature> _featuresToDisableInPlan2D = new();
        [SerializeField] EdgeDetectionSettings _edgeDetectionPlan2D;
        Material _plan2DMaterial;
        bool _active = false;
        private GameObject _selectedWallForElevation;
        int _savedQualitySettings;
        List<Button> _wallCutButtons = new();
        public List<Button> WallCutButtons { get { return _wallCutButtons; } }

        Vector3[] _roomBounds = new Vector3[4];

        Dictionary<MeshRenderer, Material> _materialToChange = new();

        private static List<GameObject> ShowCabs;
        private static List<GameObject> ShowCabsIsland;

        public static Plan2DHandler Instance;
        [SerializeField] float _lineWidth = 0.8f;
        public float LineWidth { get { return _lineWidth * ViewScale; } }
        [SerializeField] float _smallBuffer = 0.062f;
        float _wallHeight = 0f;
        float _lastRefreshOrthoSize = -1f;

        Dictionary<GameObject, float> _lineRendererNormalizedWidths = new();
        private bool _showIslandElevation;
        private bool _islandCutActive = false;
        public bool IslandCutActive { get { return _islandCutActive; } }

        bool _isOpen = false;
        bool _isHD = false;


        private bool drawGizmo = false;
        private Vector3 gizmoCenter;
        private Vector3 gizmoSize;
        private Quaternion gizmoRotation;

        private void Awake()
        {
            if (Instance == null)
            {
                Instance = this;
                return;
            }

            Destroy(this);

        }
        void Start()
        {
            _plan2DMaterial = _G.FLATWHITE;//CoreUtils.CreateEngineMaterial(_outlineShader);
            InitializeObjectPools();
            HideIslandCamera();
            _currentCameraView = CameraViews.Default;
            SaveDefaultCamera();
            SaveTopViewCamera();
            //CAPS.SHOW_TOP(true);
            //CAPS.SHOW_FRONT(true);
        }
        
        public void Start2DPlan()
        {
            Debug.Log("Open Plan 2d");
            // try to stop camera coroutine
            Camera.main.GetComponent<ObjectFocus>().StopUsingCoroutine();
            
            if (!_isOpen)
            {
                _isOpen = true;
                //Save HD Value;
                _isHD = _G.HD;
                DASH.HDsetBTNcolor(false);
            }

            _wallHeight = _G.HEIGHT * 0.5f;
            _showWallElevation = false;
            _showIslandElevation = false;
            _selectedWallForElevation = null;
            _mainCanvas.GetComponent<Canvas>().enabled = false;
            _plan2DCanvas.gameObject.SetActive(true);

            // close all open panel
            DOIT.CloseALLPNL();
            SceneModeManager.Instance.SetSceneMode(SceneModes.Plan2D);
            Camera.main.GetComponent<CameraAround>().Hide();
            _G.CAMSET = CamSettings.Plan2D;
            // set outline bool value and enabled the outline vision
            _outlineEnabled = true;
            EnableOutlinePostProcess(_outlineEnabled);

            //Turn off light as it is not required
            //GameObject.Find("LIGHTS").transform.Find("ONOFF").gameObject.SetActive(false);

            // Set Camera to top position by default with chosen value
            SetTopCamera();
            Get.o2("PLAN2DHandler/CanvasPlan","BTNS").SetActive(true);

            UniversalRenderPipelineAsset urpAsset = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
            if (urpAsset != null) urpAsset.renderScale = 2f;

            RefreshPlan2D();
            //Debug.Log(_G.SM);
            float Scale=_camera.orthographicSize/150;
            CAPS.SHOW_TOP(true,Scale);
            //CAPS.SHOW_FRONT(true);
        }
           
        private void InitializeObjectPools()
        {
            if (_lineRendererPrefab) { _lineRendererPool = new ObjectPool(_lineRendererPrefab, 25, transform); }
            if (_lineRendererForOverlayPrefab) { _lineRendererForOverlayPool = new ObjectPool(_lineRendererForOverlayPrefab, 1, transform); }
            if (_textPrefab) { _textPool = new ObjectPool(_textPrefab, 15, transform); }
        }
        private void HideIslandCamera()
        {
            _front.gameObject.SetActive(false);
            _back.gameObject.SetActive(false);
            _left.gameObject.SetActive(false);
            _right.gameObject.SetActive(false);
        }
        private void ClearAllData()
        {
            SetIslandCameraActive(false);
            _islandButton?.gameObject.SetActive(false);
            int maxObjectType = Enum.GetValues(typeof(ObjectTypes)).Length;
            foreach (var item in _walls)
            {
                item.SetActive(true);
            }
            _walls.Clear();
            _walls = new List<GameObject>();

            foreach (var item in _objectsInScene)
            {
                foreach (var obj in item.Value)
                {
                    print("obj.name==="+obj.name);
                    GameObject OBJ=Get.o2("SCENE",obj.name);
                    if(OBJ != null){
                        obj.SetActive(true);
                        GameObject OgeeSet = Get.o2("OgeeContainer", "OgeeSet" + obj.name);
                        if(OgeeSet != null) { OgeeSet.SetActive(true); }
                        }
                }
            }
            _objectsInScene.Clear();
            _objectsInScene = new(maxObjectType - 1);

            _wallLines.Clear();
            _wallLines = new List<LineDisplay>();

            _islandLines.Clear();
            _islandLines = new List<LineDisplay>();

            _wallCutButtons.Clear();
            _wallCutButtons = new List<Button>();

            int layer = LayerMask.NameToLayer("Plan2D");

            foreach (var element in _lineRenderers)
            {
                List<GameObject> list = _lineRenderers[element.Key];
                foreach (var lineRenderer in list)
                {
                    ResetLayerMask(lineRenderer.gameObject);
                    _lineRendererPool.Return(lineRenderer);
                }
                _lineRenderers[element.Key].Clear();
            }
            _lineRendererNormalizedWidths.Clear();

            foreach (var element in _lineRenderersForOverlay)
            {
                List<GameObject> list = _lineRenderersForOverlay[element.Key];
                foreach (var lineRenderer in list)
                {
                    ResetLayerMask(lineRenderer.gameObject);
                    _lineRendererForOverlayPool.Return(lineRenderer);
                }
                _lineRenderersForOverlay[element.Key].Clear();
            }

            if (_texts == null)
            {
                _texts = new Dictionary<ObjectTypes, List<GameObject>>(maxObjectType);
            }

            foreach (var element in _texts)
            {
                List<GameObject> list = _texts[element.Key];

                foreach (var text in list)
                {
                    ResetLayerMask(text.gameObject);
                    _textPool.Return(text);
                }
                _texts[element.Key].Clear();

            }
            foreach (var element in _wallCutsButtons)
            {
                GameObject button = element.Value;
                if(button!=null){
                    button.SetActive(false);
                    Destroy(button);
                }

            }
            _wallCutsButtons.Clear();

            foreach (var button in _wallElevationButtonObjects)
            {
                if (button != null)
                {
                    button.SetActive(false);
                    Destroy(button);
                }
            }
            _wallElevationButtonObjects.Clear();
        }

        //CAMERA======================================================================================CAMERA 
        private void SaveTopViewCamera()
        {
            _camera.cullingMask |= 1 << LayerMask.NameToLayer("Plan2D");
            CameraSetting setting = new(_cameraPos.position, _cameraPos.eulerAngles, true, false, _camera.cullingMask, _cameraDistance, Color.white);
            _cameraSettings.Add(_cameraSettings.Count, setting);
        }
        private void SaveDefaultCamera()
        {
            _camera = Camera.main;
            _camera.cullingMask &= ~(1 << LayerMask.NameToLayer("Plan2D"));
            _camera.cullingMask &= ~(1 << LayerMask.NameToLayer("ColorWallBleeding"));

            CameraSetting defaultSetting = new(_camera.transform, _camera.orthographic, _camera.allowHDR, _camera.cullingMask, 0f, _camera.backgroundColor);
            int key = (int)CameraViews.Default;
            _cameraSettings.Add(key, defaultSetting);
        }
        private void ApplyCameraSetting(CameraSetting setting)
        {
            _camera.transform.position = setting._position;
            _camera.transform.eulerAngles = setting._rotation;
            _camera.orthographic = setting._orthographic;
            _camera.allowHDR = setting._hdr;
            _camera.orthographicSize = setting._distance;
            _camera.cullingMask = setting._cullingMask;
            _camera.backgroundColor = setting._backgroundColor;

            UniversalAdditionalCameraData cameraData = _camera.GetUniversalAdditionalCameraData();

            //if (cameraData != null)
            //{
            //    cameraData.antialiasing = setting._orthographic ? AntialiasingMode.None : AntialiasingMode.FastApproximateAntialiasing;
            //}
        }
        void SetIslandCameraActive(bool active)
        {
            _front.gameObject.SetActive(active);
            _back.gameObject.SetActive(active);
            _left.gameObject.SetActive(active);
            _right.gameObject.SetActive(active);
            _islandCutPanel.gameObject.SetActive(active);

            if (active)
            {
                float distanceFromIsland = 50f;
                _front.transform.position = _islandCenterPosition - distanceFromIsland * Vector3.forward;
                _back.transform.position = _islandCenterPosition + distanceFromIsland * Vector3.forward;
                _left.transform.position = _islandCenterPosition + distanceFromIsland * Vector3.left;
                _right.transform.position = _islandCenterPosition + distanceFromIsland * Vector3.right;
            }
            CAPS.IslandCameras = active ? new[] { _front, _back, _left, _right } : null;
        }
        #region Filter Measures
        private void RefreshMeasure(ObjectTypes index, bool active)
        {
            if (_lineRenderers.ContainsKey(index))
            {
                var lines = _lineRenderers[index];
                foreach (var line in lines)
                {
                    line.SetActive(active);
                }
            }
            if (_texts.ContainsKey(index))
            {
                var texts = _texts[index];
                foreach (var text in texts)
                {
                    text.SetActive(active);
                }
            }
        }
        public void ToggleFloorObjectsMeasures()
        {
            _showFloorObject = !_showFloorObject;
            RefreshMeasure(ObjectTypes.FloorObject, _showFloorObject);
        }
        public void ToggleIslandMeasures()
        {
            _showIsland = !_showIsland;
            RefreshMeasure(ObjectTypes.IslandObject, _showIsland);
        }
        public void ToggleIslandWallMeasures()
        {
            _showIslandWall = !_showIslandWall;
            RefreshMeasure(ObjectTypes.IslandWall, _showIslandWall);
        }
        public void ToggleHoleInWallMeasures()
        {
            _showHoleInWallObject = !_showHoleInWallObject;
            RefreshMeasure(ObjectTypes.StructuralElements, _showHoleInWallObject);
        }
        #endregion
        void ResetLayerMask(GameObject gameObject, int layerMask = -1)
        {
            if (layerMask == -1)
            {
                layerMask = LayerMask.NameToLayer("Plan2D");
            }
            gameObject.layer = layerMask;
            foreach (Transform child in gameObject.transform)
            {
                child.gameObject.layer = layerMask;
            }
        }

        #region Debug
        
        public void SetDefaultCamera()
        {
            ApplyCameraSetting(_cameraSettings[(int)CameraViews.Default]);
            _currentCameraView = CameraViews.Default;
        }
        public void SetTopCamera()
        {
            ApplyCameraSetting(_cameraSettings[(int)CameraViews.Top]);
            _currentCameraView = CameraViews.Top;
        }
        public void SetFrontCamera()
        {
            ApplyCameraSetting(_cameraSettings[(int)CameraViews.Front]);
            _currentCameraView = CameraViews.Front;
        }
        public void SetBackCamera()
        {
            ApplyCameraSetting(_cameraSettings[(int)CameraViews.Back]);
            _currentCameraView = CameraViews.Back;
        }
        public void SetRightCamera()
        {
            ApplyCameraSetting(_cameraSettings[(int)CameraViews.Right]);
            _currentCameraView = CameraViews.Right;
        }
        public void SetLeftCamera()
        {
            ApplyCameraSetting(_cameraSettings[(int)CameraViews.Left]);
            _currentCameraView = CameraViews.Left;
        }
        #endregion

        public void SetPlan2DButtonOverlayActive(bool active)
        {
            if(_plan2DButtonOverlay != null)
            {
                _plan2DButtonOverlay.SetActive(active);
            }
        }
        public void SetPlanNavigationnOverlayActive(bool active)
        {
            Get.o2("PLAN2DHandler/CanvasPlan/BTNS","BtnNavigate").SetActive(active);
        }

        public void AddTextToList(GameObject text, ObjectTypes objectIndex)
        {
            if (_texts.ContainsKey(objectIndex) == false)
            {
                _texts.Add(objectIndex, new());
            }
            _texts[objectIndex].Add(text);
        }
        public void AddLineRendererToList(GameObject lineRenderer, ObjectTypes objectIndex)
        {
            if (_lineRenderers.ContainsKey(objectIndex) == false)
            {
                _lineRenderers.Add(objectIndex, new());
            }
            _lineRenderers[objectIndex].Add(lineRenderer);
        }
        public void RegisterLineRendererNormalizedWidth(GameObject go, float width)
        {
            if (ViewScale > 0f)
                _lineRendererNormalizedWidths[go] = width / ViewScale;
        }
        public void Close2DPlan()
        {
            if (_edgeDetectionPlan2D != null)
                _edgeDetectionPlan2D.InjectionPoint = Linework.Common.Utils.InjectionPoint.AfterRenderingPostProcessing;
            _G.CAMSET = CamSettings.Front;

            // Center the camera pivot on the room center
            _G.CC = _G._DefaultCameraFocusPoint;

            _selectedWallForElevation = null;
            _islandCutActive = false;

            _plan2DCanvas.gameObject.SetActive(false);
            _mainCanvas.enabled = true;

            foreach (var w in _walls)
            {
                w.SetActive(true);
            }

            // foreach (var o in _objectToActive)
            // {
            //     o.SetActive(true);
            // }
            _objectToActive.Clear();
            _objectToActive = new();

            foreach (Transform c in _scene.transform)  {
                c.gameObject.SetActive(true);
            }

            foreach (Transform c in _room.transform)  {
                c.gameObject.SetActive(true);
            }


            // set outline bool value and enabled the outline vision
            _outlineEnabled = false;
            // CloseALLPNL() reset a lot of thing in the room such a SM and set active wall and all wall subobject necessery for moveObject
            DOIT.CloseALLPNL();
            EnableOutlinePostProcess(_outlineEnabled);

            //var camData = Camera.main.GetComponent<UniversalAdditionalCameraData>();
            //camData.SetRenderer(2);

            _isOpen = false;
            //DASH.HDsetBTNcolor(_isHD);
            //DASH.HDsetBTNcolor(false);

            UniversalRenderPipelineAsset urpAsset = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
            if (urpAsset != null) urpAsset.renderScale = 1f;

            // Set Camera to Default initial position
            SetDefaultCamera();

            //Erase and destroy every plan data in case it changes and need to be recalculated
            ClearAllData();

            HideCountertop();
            SceneModeManager.Instance.SetSceneMode(SceneModes.Navigate);
            CAPS.SHOW_TOP(false,1);
            CAPS.SHOW_FRONT(false,1);
            //DASH.HDset(false);
            DASH.HDsetBTNcolor(false);
        }
        public GameObject GetTextInstance()
        {
            GameObject TextObject = _textPool.Get();
            // Reset faceColor to white so TMP writes _FaceColor=white to the shared material on Rebuild.
            // This keeps sharedMaterial._FaceColor=white for all pooled objects, allowing
            // text.color (vertex color) alone to control the displayed color without contamination.
            TextMeshPro tmp = TextObject.GetComponentInChildren<TextMeshPro>();
            if (tmp != null) tmp.faceColor = Color.white;
            return TextObject;
        }
        public GameObject GetLineRendererInstance()
        {
            GameObject lineRendererObject = _lineRendererPool.Get();
            lineRendererObject.transform.SetParent(transform, false);
            LineRenderer lineRenderer = lineRendererObject.GetComponent<LineRenderer>();
            lineRenderer.positionCount = 0;

            return lineRendererObject;
        }
   
        public void RefreshPlan2D()
        {
            Debug.Log("Refresh Plan 2d");

            if (!_active) return;
            ClearAllData();
            GetReferences();

            if (_showIslandElevation)
            {
                HandleIslandElevation();
                HideCountertop();
            }
            else if (_showWallElevation)
            {
                HandleWallElevation();
                HideCountertop();
            }
            else
            {
                HandleTopView();
                HideCountertop();
            }

            if (_camera != null && _viewZoomMultiplier > 0f && !_showIslandElevation)
                _camera.orthographicSize *= _viewZoomMultiplier;

            _lastRefreshOrthoSize = _camera != null ? _camera.orthographicSize : -1f;
        }

        public void UpdateScale()
        {
            if (!_active || _camera == null || _lastRefreshOrthoSize <= 0f) return;

            float currentViewScale = ViewScale;

            // Measurement lines: recompute from stored normalized base — no drift
            foreach (var kvp in _lineRendererNormalizedWidths)
            {
                if (kvp.Key == null) continue;
                if (kvp.Key.TryGetComponent(out LineRenderer lr))
                {
                    float w = kvp.Value * currentViewScale;
                    lr.startWidth = w;
                    lr.endWidth = w;
                }
            }

            // Texts: ratio approach (telescopes correctly, no meaningful drift)
            float ratio = _camera.orthographicSize / _lastRefreshOrthoSize;
            _lastRefreshOrthoSize = _camera.orthographicSize;

            foreach (var kvp in _texts)
                foreach (var go in kvp.Value)
                {
                    if (go == null) continue;
                    TextMeshPro tmp = go.GetComponentInChildren<TextMeshPro>();
                    if (tmp != null) tmp.fontSize *= ratio;
                }
        }

        private void RestoreEdgeThickness()
        {
            if (_edgeDetectionPlan2D == null) return;
            _edgeDetectionPlan2D.outlineThickness = 1;
            _edgeDetectionPlan2D.InjectionPoint = Linework.Common.Utils.InjectionPoint.BeforeRenderingTransparents;
        }

        private void HandleTopView()
        {
            RestoreEdgeThickness();
            ZoomSettings settings = DrawGround();
            SetPlanNavigationnOverlayActive(true);
            DisplayLineToScreen(settings);
        }
        private void HandleWallElevation()
        {
            RestoreEdgeThickness();
            ZoomSettings settings = DrawWall();
            ShowWallCutLines(settings);
            CAPS.IslandCameras = new[] { _camera };
            CAPS.ApplyFacingForElevation(_camera, ViewScale);
        }
        private void HandleIslandElevation()
        {
            if (_edgeDetectionPlan2D != null)
                _edgeDetectionPlan2D.outlineThickness = 2;
            CreateCabIsIslandList();
            SetIslandCameraActive(true);
            HideNonIslandObjects();
            HideCountertop();

            float upperScreenPos, downScreenPos;

            _ = new List<Vector3>() { };
            CreateIslandBounds(out upperScreenPos, out downScreenPos, out List<Vector3> islandBoundsCorner);

            _camsWithIslandContent.Clear();
            _islandSharedOrthoSize = 0f;
            CreateIslandElevationLines(_front, islandBoundsCorner, upperScreenPos, downScreenPos);
            CreateIslandElevationLines(_back, islandBoundsCorner, upperScreenPos, downScreenPos);
            CreateIslandElevationLines(_right, islandBoundsCorner, upperScreenPos, downScreenPos);
            CreateIslandElevationLines(_left, islandBoundsCorner, upperScreenPos, downScreenPos);
            foreach (Camera cam in _camsWithIslandContent)
                cam.orthographicSize = _islandSharedOrthoSize;
            DisplayLines();
            if (_edgeDetectionPlan2D != null)
                _edgeDetectionPlan2D.InjectionPoint = Linework.Common.Utils.InjectionPoint.BeforeRenderingTransparents;
            CAPS.RenderIslandCamera(_front, 0.75f);
            CAPS.RenderIslandCamera(_back,  0.75f);
            CAPS.RenderIslandCamera(_right, 0.75f);
            CAPS.RenderIslandCamera(_left,  0.75f);
            SetPlanNavigationnOverlayActive(false);
        }
        private void HideNonIslandObjects()
        {
            AllSceneObjectFalse();
            foreach(GameObject obj in ShowCabsIsland){
                obj.SetActive(true);
            }
        }
        private void HideNonWallObjects()
        {
            AllSceneObjectFalse();
            foreach(GameObject obj in ShowCabs){
                obj.SetActive(true);
            }
        }

        private void ShowWallCut(string Wallstring)
        {
            //AllSceneObjectFalse();
            CreateCabIsFrontList(Wallstring,24);
            _selectedWallForElevation = _walls.Find(w => w.name == Wallstring);
            _showWallElevation = true;
            RefreshPlan2D();
        }
        ZoomSettings DrawWall()
        {

            int wallIndex = int.Parse(_selectedWallForElevation.name.Substring(1, _selectedWallForElevation.name.Length - 1)) - 1;

            float wallWideness = _G.WallsWidth[wallIndex];
            Vector3 wallWidthOffset = wallWideness * _selectedWallForElevation.transform.right;

            Vector3[] _wallPoints = new Vector3[4]
            {
                new(_G.WallsPointStart[wallIndex].x, -_wallHeight, _G.WallsPointStart[wallIndex].y),
                new(_G.WallsPointStart[wallIndex].x, _wallHeight, _G.WallsPointStart[wallIndex].y) ,
                new Vector3(_G.WallsPointStart[wallIndex].x, _wallHeight, _G.WallsPointStart[wallIndex].y) + wallWidthOffset,
                new Vector3(_G.WallsPointStart[wallIndex].x, -_wallHeight, _G.WallsPointStart[wallIndex].y) + wallWidthOffset
            };


            Vector3 direction = _selectedWallForElevation.transform.forward;
            _camera.transform.position = _selectedWallForElevation.transform.position + -direction * 150f;
            _camera.transform.rotation = Quaternion.LookRotation(direction, _selectedWallForElevation.transform.up);

            AddLineRenderer(_wallPoints, ObjectTypes.WallLines, true);

            ZoomSettings zoomSettings = new(_camera, -1, this);
            zoomSettings.ComparePositions(_wallPoints);
            zoomSettings.ResizeCamera();

            return zoomSettings;
        }
        ZoomSettings DrawGround()
        {
            if (_walls.Count < 1) return null;

            float floorHeight = _G.HEIGHT * 0.5f;
            float thickness = 6f;

            List<Vector3> floorPoints = new();
            List<Vector3> floorPointTest = new();
            List<Vector3> wallThicknessPoints = new();

            bool enclosed = true;

            //WallCreationManager.GetWallLineContainer();

            foreach(Transform rectTransform in WallCreationManager.GetWallLineContainer())
            {
                if (rectTransform.TryGetComponent(out WallLine wallLine))
                {
                    Vector3 startingPoint = wallLine._pointStart.GetWorldPositionFlat();
                    floorPointTest.Add(startingPoint);
                    Vector3 endingPoint = wallLine._pointEnd.GetWorldPositionFlat();
                    floorPointTest.Add(endingPoint);
                }
            }

            for (int i = 0; i < _walls.Count; i++)
            {
                GameObject wall = _walls[i];

                int wallIndex = int.Parse(wall.name[1..]) - 1;

                float wallWideness = _G.WallsWidth[wallIndex];

                Vector2 wallCenterPosition1 = _G.WallsPointCenter[wallIndex];

                Vector3 direction = wall.transform.forward; // Get Direction of wall

                Vector3 startingPoint = new Vector3(wallCenterPosition1.x, floorHeight, wallCenterPosition1.y) - wallWideness * 0.5f * wall.transform.right;
                Vector3 endingPoint = startingPoint + wallWideness * wall.transform.right;

                floorPoints.Add(startingPoint);
                floorPoints.Add(endingPoint);
            }

            for (int i = 1; i < floorPoints.Count; i += 2)
            {
                int j = i + 1 >= floorPoints.Count ? 0 : i + 1;

                Vector3 endingPointWall1 = floorPoints[i];
                Vector3 startingPointNextWall = floorPoints[j];

                float distance = Vector3.Distance(endingPointWall1, startingPointNextWall);

                if (Mathf.Round(distance * 100f) / 100f > Mathf.Epsilon)
                {
                    enclosed = false;
                    break;
                }
            }
            if (enclosed)
            {
                return DrawEnclosedRoom(floorHeight, thickness, floorPoints, wallThicknessPoints);
            }
            else
            {
                return DrawNonEnclosedRoom(floorHeight, thickness, floorPoints, wallThicknessPoints);
            }
        }
        private ZoomSettings DrawNonEnclosedRoom(float floorHeight, float thickness, List<Vector3> floorPoints, List<Vector3> wallThicknessPoints)
        {
            if (_walls.Count < 1) return null;

            int begIdx = 0;
            int endIdx = 0;

            for (int i = 1; i < floorPoints.Count; i += 2)
            {
                int j = i + 1 % floorPoints.Count;

                Vector3 endingPointWall1 = floorPoints[i];
                Vector3 startingPointNextWall = floorPoints[j];

                float distance = Vector3.Distance(endingPointWall1, startingPointNextWall);

                if (Mathf.Round(distance * 100f) / 100f > Mathf.Epsilon)
                {
                    endIdx = i;
                    break;
                }
            }

            for (int i = floorPoints.Count - 2; i > 0; i -= 2)
            {
                int j = i - 1 < 0 ? floorPoints.Count - 1 : i - 1;

                Vector3 endingPointWall1 = floorPoints[i];
                Vector3 startingPointNextWall = floorPoints[j];

                float distance = Vector3.Distance(endingPointWall1, startingPointNextWall);

                if (Mathf.Round(distance * 100f) / 100f > Mathf.Epsilon)
                {
                    begIdx = i;
                    break;
                }
            }

            int idx = begIdx;
            int wallIdx = idx / 2;
            GameObject wall = _walls[wallIdx];

            Vector3 direction = wall.transform.forward; // Get Direction of wall

            List<Vector3> temp = new();

            temp.Add(floorPoints[idx]);
            wallThicknessPoints.Add(floorPoints[idx]);
            wallThicknessPoints.Add(floorPoints[idx] + direction * thickness);

            idx = idx + 1 >= floorPoints.Count ? 0 : idx + 1;

            for (int i = 0; i < _walls.Count - 1; i++)
            {
                int index1 = idx;
                int wallIdx1 = index1 / 2;
                int index2 = idx + 1 >= floorPoints.Count ? 0 : idx + 1;
                int wallIdx2 = index2 / 2;


                Transform wall1 = _walls[wallIdx1].transform;
                Vector3 wallDirection1 = wall1.forward;
                Vector3 pos1OnWall1 = floorPoints[index1];
                Vector3 pos1OnWall1Offset = floorPoints[index1] + wallDirection1 * thickness;

                Transform wall2 = _walls[wallIdx2].transform;
                Vector3 wallDirection2 = wall2.forward;
                Vector3 pos1OnWall2 = floorPoints[index2];
                Vector3 pos1OnWall2Offset = floorPoints[index2] + wallDirection2 * thickness;

                if (LineLineIntersection(out Vector3 intersection1, pos1OnWall1, wall1.transform.right, pos1OnWall2, -wall2.transform.right))
                {
                    temp.Add(intersection1);
                }

                if (LineLineIntersection(out Vector3 intersection2, pos1OnWall1Offset, wall1.transform.right, pos1OnWall2Offset, -wall2.transform.right))
                {
                    wallThicknessPoints.Add(intersection2);
                }

                idx = idx + 1 >= floorPoints.Count ? 0 : idx + 1;
                idx = idx + 1 >= floorPoints.Count ? 0 : idx + 1;
            }

            idx = endIdx;
            wallIdx = idx / 2;
            wall = _walls[wallIdx];
            direction = wall.transform.forward; // Get Direction of wall

            temp.Add(floorPoints[idx]);
            wallThicknessPoints.Add(floorPoints[idx] + direction * thickness);
            wallThicknessPoints.Add(floorPoints[idx]);


            // check if last point is same as first, if yes, loop is true
            // if not loop need to bridge out to wall width points

            floorPoints = temp;

            SetRoomBound(floorPoints);

            Bounds bounds = GetRoomBound();

            List<Vector3> cornersForCamera = new List<Vector3>()
            {
                new Vector3(bounds.min.x, bounds.min.y, bounds.min.z) ,
                new Vector3(bounds.min.x, bounds.min.y, bounds.max.z),
                new Vector3(bounds.max.x, bounds.min.y, bounds.max.z) ,
                new Vector3(bounds.max.x, bounds.min.y, bounds.min.z)
            };

            ZoomSettings zoomSettings = new(_camera, -1, this);

            zoomSettings.ComparePositions(cornersForCamera.ToArray());
            zoomSettings.ResizeCamera();

            AddLineRenderer(floorPoints.ToArray(), ObjectTypes.Floor, false);

            AddLineRenderer(wallThicknessPoints.ToArray(), ObjectTypes.WallThickness, false);

            AddCabOverlay();
            return zoomSettings;
        }
        private ZoomSettings DrawEnclosedRoom(float floorHeight, float thickness, List<Vector3> floorPoints, List<Vector3> wallThicknessPoints)
        {
            List<Vector3> temp = new();

            for (int i = 0; i < floorPoints.Count; i++)
            {
                int j = i + 1 >= floorPoints.Count ? 0 : i + 1;

                float distance = Vector3.Distance(floorPoints[i], floorPoints[j]);

                if (!(Mathf.Round(distance * 100f) / 100f > Mathf.Epsilon)) { continue; }

                temp.Add(floorPoints[i]);
            }

            floorPoints = new();

            foreach (var p in temp)
            {
                floorPoints.Add(new Vector3(p.x, floorHeight, p.z));
            }

            SetRoomBound(floorPoints);

            for (int i = 0; i < floorPoints.Count; i++)
            {
                int index1 = i;
                int index2 = (i + 1 >= floorPoints.Count ? 0 : i + 1);

                // if (_walls.Count <= index1 || _walls.Count <= index2) continue;

                Transform wall1 = _walls[index1].transform;
                Vector3 wallDirection1 = wall1.forward;
                Vector3 pos1OnWall1 = floorPoints[index2] + wallDirection1 * thickness;

                Transform wall2 = _walls[index2].transform;
                Vector3 wallDirection2 = wall2.forward;
                Vector3 pos1OnWall2 = floorPoints[index2] + wallDirection2 * thickness;

                if (LineLineIntersection(out Vector3 intersection, pos1OnWall1, wall1.transform.right, pos1OnWall2, -wall2.transform.right))
                {
                    wallThicknessPoints.Add(intersection);
                }
            }

            Bounds bounds = GetRoomBound();

            List<Vector3> cornersForCamera = new()
            {
                new Vector3(bounds.min.x, bounds.min.y, bounds.min.z),
                new Vector3(bounds.min.x, bounds.min.y, bounds.max.z),
                new Vector3(bounds.max.x, bounds.min.y, bounds.max.z),
                new Vector3(bounds.max.x, bounds.min.y, bounds.min.z)
            };


            ZoomSettings zoomSettings = new(_camera, -1, this);

            zoomSettings.ComparePositions(cornersForCamera.ToArray());

            zoomSettings.ResizeCamera();


            // ResizeCamera(_camera, cornersForCamera, -1);

            AddLineRenderer(floorPoints.ToArray(), ObjectTypes.Floor, true);

            AddLineRenderer(wallThicknessPoints.ToArray(), ObjectTypes.WallThickness, true);

           //AddCabOverlay();

            return zoomSettings;
        }
        void AddCabOverlay()
        {
            foreach (var objectCategory in _objectsInScene)
            {
                if (objectCategory.Key != ObjectTypes.FloorObject && objectCategory.Key != ObjectTypes.IslandObject) continue;

                foreach (var obj in objectCategory.Value)
                {
                    int On = Get.GetObjectIndex(obj.name);
                    string[] data = _G.OBJs[On];
                    string cabType = data[5];
                    List<Vector3> points = new();
                    Transform Point;
                    Vector3 Point1 = Vector3.zero;
                    Vector3 PosPoint;

                    if (cabType == "BA" || cabType == "CB")
                    {
                        for (int i = 1; i <= 6; i++)
                        {
                            Point = obj.transform.Find("P" + i.ToString());
                            if (Point != null)
                            {
                                PosPoint = Point.position;
                                PosPoint.y = 0;

                                if (i == 1)
                                {
                                    Point1 = PosPoint;
                                }

                                points.Add(PosPoint);
                            }
                        }

                        points.Add(Point1);

                        AddLineRendererForCabOverlay(points.ToArray(), ObjectTypes.CabOverlay, obj.name);
                    }

                    //  if (cabType == "CB")
                    // {
                    //     Transform p1 = obj.transform.Find("P1");
                    //     Transform p2 = obj.transform.Find("P6");
                    //     Transform p3 = obj.transform.Find("P5");
                    //     if (p2 == null) { squareCornerBase = true; }
                    //     else
                    //     {


                    //         Vector3 p1Pos = p1.position;
                    //         p1Pos.y = 0f;
                    //         points.Add(p1Pos);

                    //         Vector3 p2Pos = p2.position;
                    //         p2Pos.y = 0f;
                    //         points.Add(p2Pos);

                    //         Vector3 p3Pos = p3.position;
                    //         p3Pos.y = 0f;
                    //         points.Add(p3Pos);

                    //         AddLineRendererForCabOverlay(points.ToArray(), ObjectTypes.CabOverlay, obj.name);
                    //     }
                    // }

                    // if (cabType == "BA" || squareCornerBase)
                    // {
                    //     Vector3 p1 = obj.transform.Find("PFRU").position;
                    //     p1.y = 0f;
                    //     Vector3 p2 = obj.transform.Find("PFLU").position;
                    //     p2.y = 0f;
                    //     points.Add(p1);
                    //     points.Add(p2);

                    //     AddLineRendererForCabOverlay(points.ToArray(), ObjectTypes.CabOverlay, obj.name);
                    // }
                }
            }
        }
        void SetRoomBound(List<Vector3> corners)
        {
            Vector3 min = corners[0];
            Vector3 max = corners[0];

            foreach (var corner in corners)
            {
                min.x = Mathf.Min(min.x, corner.x);
                min.z = Mathf.Min(min.z, corner.z);

                max.x = Mathf.Max(max.x, corner.x);
                max.z = Mathf.Max(max.z, corner.z);
            }

            _roomBounds[0] = new Vector3(min.x, min.y, min.z);
            _roomBounds[1] = new Vector3(max.x, min.y, min.z);
            _roomBounds[2] = new Vector3(max.x, min.y, max.z);
            _roomBounds[3] = new Vector3(min.x, min.y, max.z);
        }
        public Bounds GetRoomBound()
        {
            Bounds bounds = new Bounds();

            bounds.min = _roomBounds[0];
            bounds.max = _roomBounds[2];
            return bounds;
        }
        public LineRenderer GetRoomLineRenderer()
        {
            ObjectTypes Room = ObjectTypes.Floor;
            if (_lineRenderers.ContainsKey(Room))
            {
                return _lineRenderers[Room][0].GetComponent<LineRenderer>();
            }
            return null;
        }
        public static bool LineLineIntersection(out Vector3 intersection, Vector3 linePoint1,
        Vector3 lineVec1, Vector3 linePoint2, Vector3 lineVec2)
        {

            Vector3 lineVec3 = linePoint2 - linePoint1;
            Vector3 crossVec1and2 = Vector3.Cross(lineVec1, lineVec2);
            Vector3 crossVec3and2 = Vector3.Cross(lineVec3, lineVec2);

            float planarFactor = Vector3.Dot(lineVec3, crossVec1and2);

            //is coplanar, and not parallel
            if (Mathf.Abs(planarFactor) < 0.0001f
                    && crossVec1and2.sqrMagnitude > 0.0001f)
            {
                float s = Vector3.Dot(crossVec3and2, crossVec1and2)
                        / crossVec1and2.sqrMagnitude;
                intersection = linePoint1 + (lineVec1 * s);
                return true;
            }
            else
            {
                intersection = Vector3.zero;
                return false;
            }
        }
        private void AddLineRenderer(Vector3[] points, ObjectTypes index, bool loop)
        {
            LineRenderer lineRenderer = GetLineRendererInstance().GetComponent<LineRenderer>();
            lineRenderer.name = "LineRenderer" + index;
            for (int i = 1; i <= points.Length; i++)
            {
                lineRenderer.positionCount = points.Length;

                Vector3 p1 = points[i - 1];
                Vector3 p2 = points[i == points.Length ? 0 : i];

                lineRenderer.SetPosition(i - 1, p1);
                lineRenderer.SetPosition(i == points.Length ? 0 : i, p2);
            }
            lineRenderer.startColor = Color.black;
            lineRenderer.endColor = Color.black;

            lineRenderer.loop = loop;

            if (!_lineRenderers.ContainsKey(index))
            {
                _lineRenderers.Add(index, new());
            }
            _lineRenderers[index].Add(lineRenderer.gameObject);

        }
        private void AddLineRendererForCabOverlay(Vector3[] points, ObjectTypes index, string cabName)
        {
            LineRenderer lineRenderer = _lineRendererForOverlayPool.Get().GetComponent<LineRenderer>();
            lineRenderer.transform.SetParent(transform, false);
            lineRenderer.name = cabName + " CabOverlay";
            lineRenderer.startWidth = 0.25f;
            lineRenderer.endWidth = 0.25f;
            lineRenderer.positionCount = points.Length;
            lineRenderer.SetPositions(points);

            // for (int i = 1; i <= points.Length; i++)
            // {
            //     lineRenderer.positionCount = points.Length;

            //     Vector3 p1 = points[i - 1];
            //     Vector3 p2 = points[i == points.Length ? 0 : i];

            //     lineRenderer.SetPosition(i - 1, p1);
            //     lineRenderer.SetPosition(i == points.Length ? 0 : i, p2);
            // }

            // lineRenderer.loop = false;

            if (!_lineRenderersForOverlay.ContainsKey(index))
            {
                _lineRenderersForOverlay.Add(index, new());
            }
            _lineRenderersForOverlay[index].Add(lineRenderer.gameObject);

        }
        private void AllSceneObjectFalse(){
            foreach(Transform objet in _scene.transform){
                objet.gameObject.SetActive(false);
            }
        }
        private void AllSceneObjectTrue(){
            foreach(Transform objet in _scene.transform){
                objet.gameObject.SetActive(true);
            }
        }
        
        //SHOW ELEVATIONS ======================================================================================SHOW ELEVATIONS     
        public void ShowIslandCut()
        {
            _showIslandElevation = true;
            RefreshPlan2D();
        }
        void CreateIslandElevationLines(Camera camera, List<Vector3> islandCorners, float upper, float lower)
        {
            CreateCabIsIslandList();
            HideNonIslandObjects();

            if (ShowCabsIsland.Count > 0)
            {
                GetLeftmostAndRightmostForCameraView(camera, islandCorners, out Vector3 left, out Vector3 right);

                islandCorners = new List<Vector3>()
                {
                    new (left.x, lower, left.z),
                    new (left.x, upper, left.z),
                    new (right.x, upper, right.z),
                    new (right.x, lower, right.z)
                };

                ZoomSettings zoomSettings = new(camera, LayerMask.NameToLayer(camera.name), this);
                zoomSettings.ComparePositions(islandCorners.ToArray());

                // Pre-expand bounds for annotation space so ResizeCamera is called exactly once.
                Quaternion rot90 = Quaternion.AngleAxis(90f, camera.transform.forward);
                const float islandAnnotIncrement = 8f; // fixed world-unit arm, independent of room scale
                float annotationPad = islandAnnotIncrement * 2f + 3f; // = 19 units
                Vector3 annotDir0 = (rot90 * (islandCorners[1] - islandCorners[0])).normalized;
                Vector3 annotDir1 = (rot90 * (islandCorners[2] - islandCorners[1])).normalized;
                zoomSettings.ComparePosition(islandCorners[0] + annotDir0 * annotationPad);
                zoomSettings.ComparePosition(islandCorners[1] + annotDir0 * annotationPad);
                zoomSettings.ComparePosition(islandCorners[1] + annotDir1 * annotationPad);
                zoomSettings.ComparePosition(islandCorners[2] + annotDir1 * annotationPad);

                zoomSettings.ResizeCamera();

                // Size so the complete elevation drawing (island + annotation arms) fills 80 % of
                // the constraining view dimension.  contentH/contentW are the asymmetric bounding
                // box extents already expanded by annotationPad in one direction each, matching
                // exactly what ResizeCamera used for centering.  Using content (not island alone)
                // guarantees annotations are always visible and provides natural clearance around them.
                float islandW = Vector3.Distance(islandCorners[0], islandCorners[3]);
                float islandH = Vector3.Distance(islandCorners[0], islandCorners[1]);
                float contentH = islandH + annotationPad;
                float contentW = islandW + annotationPad;
                const float fillTarget = 0.80f;
                _islandSharedOrthoSize = Mathf.Max(_islandSharedOrthoSize,
                    Mathf.Max(contentH * 0.5f / fillTarget,
                              contentW * 0.5f / camera.aspect / fillTarget));

                _camsWithIslandContent.Add(camera);

                for (int i = 0; i < 2; i++)
                {
                    Vector3 startingPoint = islandCorners[i];
                    Vector3 endingPoint = islandCorners[i + 1];
                    Vector3 direction = endingPoint - startingPoint;
                    Vector3 rotationAxis = camera.transform.forward; // the axis to rotate around (in this case, the Z-axis)
                    Quaternion rotationQuaternion = Quaternion.AngleAxis(90f, rotationAxis); // create a quaternion that represents the desired rotation
                    direction = rotationQuaternion * direction; // rotate the vector by multiplying it by the quaternion
                                                                // direction = Quaternion.Euler(-90f, 0f, 0f) * direction;
                    direction.Normalize();

                    string measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));

                    LineDisplay lineDisplay = new(camera,
                                                    LayerMask.NameToLayer(camera.name),
                                                    startingPoint,
                                                    endingPoint,
                                                    direction,
                                                    measure,
                                                    this,
                                                    ObjectTypes.IslandWall,
                                                    i == 0 || i == 1,
                                                    true,
                                                    null,
                                                    objectTypes,
                                                    LineWidth * 0.5f,
                                                    incrementalOffsetOverride: islandAnnotIncrement,
                                                    fontSizeOverride: FontSizeIsland,
                                                    minFontSizeOverride: MinFontSizeIsland);
                    _islandLines.Add(lineDisplay);

                    if (ShowCabsIsland.Count > 1)
                    {
                        foreach (GameObject objectInScene in ShowCabsIsland)
                        {

                            // Objets visibles mais sans cotes en vue island
                            string grp = objectInScene.name.Length >= 4 ? objectInScene.name[..4] : "";
                            bool noCotes = grp == "buil" || grp == "tops" || grp == "micr"
                                        || grp == "pane" || grp == "bloc";
                            if (!noCotes && grp == "stov")
                            {
                                int stovIdx = Get.GetObjectIndex(objectInScene.name);
                                if (_G.OBJs[stovIdx] != null && _G.OBJs[stovIdx][1] != null)
                                {
                                    string sm4 = _G.OBJs[stovIdx][1].Length >= 4 ? _G.OBJs[stovIdx][1][..4] : _G.OBJs[stovIdx][1];
                                    if (sm4 == "BUIL" || sm4 == "TOPS" || sm4 == "PLAT")
                                        noCotes = true;
                                }
                            }
                            if (noCotes) continue;

                            Vector3 objectPosition = objectInScene.transform.position;
                            //Vector3 perpendicularLineToWall = Vector3.Normalize(endingPoint - startingPoint);

                            Vector3 leftmostScreenPos1 = Vector3.zero;
                            Vector3 rightmostScreenPos1 = Vector3.zero;
                            List<Vector3> corners = GetObjectBounds(objectInScene);

                            GetLeftmostAndRightmostPositions(corners, startingPoint, endingPoint, ref leftmostScreenPos1, ref rightmostScreenPos1);

                            Vector3 pointOnLine = GetPositionOnLine(objectPosition, startingPoint, endingPoint);
                            float distance = Vector3.Distance(leftmostScreenPos1, rightmostScreenPos1);
                            float distanceR = Vector3.Distance(pointOnLine, rightmostScreenPos1);
                            float distanceL = Vector3.Distance(pointOnLine, leftmostScreenPos1);

                            ObjectTypes objectType = ObjectTypes.IslandObject;

                            if (i == 0)
                            {
                                lineDisplay.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.Null);
                            }
                            else
                            {
                                lineDisplay.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, objectType);
                            }
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Retourne true si l'objet est visible mais ne doit PAS contribuer aux cotes
        /// (stov BUIL/TOPS/PLAT, micr, pane, bloc).
        /// </summary>
        private bool IsNoCotesIslandObject(GameObject obj)
        {
            if (obj == null || obj.name.Length < 4) return false;
            string g = obj.name[..4];
            if (g == "micr" || g == "pane" || g == "bloc") return true;
            if (g == "stov")
            {
                int idx = Get.GetObjectIndex(obj.name);
                if (idx < 0 || _G.OBJs[idx] == null || _G.OBJs[idx][1] == null || _G.OBJs[idx][1].Length < 4) return false;
                string m4 = _G.OBJs[idx][1][..4];
                return m4 == "BUIL" || m4 == "TOPS" || m4 == "PLAT";
            }
            return false;
        }

        private void CreateIslandBounds(out float upperScreenPos, out float downScreenPos, out List<Vector3> islandBoundsCorner)
        {
            float leftmostHorizontalScreenPos = Mathf.Infinity;
            float rightmostHorizontalScreenPos = -Mathf.Infinity;
            float leftmostDepthScreenPos = Mathf.Infinity;
            float rightmostDepthScreenPos = -Mathf.Infinity;
            upperScreenPos = -Mathf.Infinity;
            downScreenPos = Mathf.Infinity;

            foreach (GameObject objectInScene in ShowCabsIsland)
            {
                if (IsNoCotesIslandObject(objectInScene))
                {
                    // Include in camera bounds (no dimension lines) so all visible island objects
                    // are covered — prevents ±Infinity Y when only bloc objects are present.
                    Collider col = objectInScene.GetComponent<Collider>();
                    Bounds b = col != null ? col.bounds
                                           : new Bounds(objectInScene.transform.position, Vector3.zero);
                    leftmostHorizontalScreenPos = Mathf.Min(leftmostHorizontalScreenPos, b.min.x);
                    rightmostHorizontalScreenPos = Mathf.Max(rightmostHorizontalScreenPos, b.max.x);
                    leftmostDepthScreenPos       = Mathf.Min(leftmostDepthScreenPos,       b.min.z);
                    rightmostDepthScreenPos      = Mathf.Max(rightmostDepthScreenPos,      b.max.z);
                    // Y intentionally excluded: bloc colliders can have extreme Y extents that
                    // corrupt the height used for dimension lines. Real cabinet Y is used instead.
                    continue;
                }
                Vector3 objectPosition = objectInScene.transform.position;
                List<Vector3> corners = GetObjectBounds(objectInScene);

                foreach (var corner in corners)
                {
                    leftmostHorizontalScreenPos = corner.x < leftmostHorizontalScreenPos ? corner.x : leftmostHorizontalScreenPos;
                    rightmostHorizontalScreenPos = corner.x > rightmostHorizontalScreenPos ? corner.x : rightmostHorizontalScreenPos;

                    leftmostDepthScreenPos = corner.z < leftmostDepthScreenPos ? corner.z : leftmostDepthScreenPos;
                    rightmostDepthScreenPos = corner.z > rightmostDepthScreenPos ? corner.z : rightmostDepthScreenPos;

                    downScreenPos = corner.y < downScreenPos ? corner.y : downScreenPos;
                    upperScreenPos = corner.y > upperScreenPos ? corner.y : upperScreenPos;
                }
            }

            // If no real cabinets were found (only bloc/micr/pane), fall back to using
            // their collider Y so the camera is not sized to ±Infinity.
            if (downScreenPos == Mathf.Infinity)
            {
                foreach (GameObject obj in ShowCabsIsland)
                {
                    if (!IsNoCotesIslandObject(obj)) continue;
                    Collider col = obj.GetComponent<Collider>();
                    Bounds b = col != null ? col.bounds : new Bounds(obj.transform.position, Vector3.zero);
                    downScreenPos  = Mathf.Min(downScreenPos,  b.min.y);
                    upperScreenPos = Mathf.Max(upperScreenPos, b.max.y);
                }
            }

            islandBoundsCorner = new List<Vector3>()
            {
                    new Vector3(leftmostHorizontalScreenPos, upperScreenPos, leftmostDepthScreenPos ),
                    new Vector3(rightmostHorizontalScreenPos, upperScreenPos, leftmostDepthScreenPos ),
                    new Vector3(leftmostHorizontalScreenPos, upperScreenPos, rightmostDepthScreenPos ),
                    new Vector3(rightmostHorizontalScreenPos, upperScreenPos, rightmostDepthScreenPos ),
                    new Vector3(leftmostHorizontalScreenPos, downScreenPos, leftmostDepthScreenPos ),
                    new Vector3(rightmostHorizontalScreenPos, downScreenPos, leftmostDepthScreenPos ),
                    new Vector3(leftmostHorizontalScreenPos, downScreenPos, rightmostDepthScreenPos ),
                    new Vector3(rightmostHorizontalScreenPos, downScreenPos, rightmostDepthScreenPos )
            };
        }
        public static void GetLeftmostAndRightmostForCameraView(Camera camera, List<Vector3> corners, out Vector3 leftmost, out Vector3 rightmost)
        {
            Vector3 closest = Vector3.zero;
            float closestDistance = Mathf.Infinity;
            for (int i = 0; i < corners.Count; i++)
            {
                float distance = Vector3.Distance(camera.transform.position, corners[i]);
                if (distance < closestDistance)
                {
                    closestDistance = distance;
                    closest = corners[i];
                }
            }

            Vector3[] projectedPoints = new Vector3[corners.Count];
            for (int i = 0; i < corners.Count; i++)
            {
                projectedPoints[i] = camera.WorldToViewportPoint(corners[i]);
            }

            float maxViewportX = 0f;
            int maxViewportXIndex = -1;
            float minViewportX = 1f;
            int minViewportXIndex = -1;
            for (int i = 0; i < projectedPoints.Length; i++)
            {
                if (projectedPoints[i].x > maxViewportX)
                {
                    maxViewportX = projectedPoints[i].x;
                    maxViewportXIndex = i;
                }
                if (projectedPoints[i].x < minViewportX)
                {
                    minViewportX = projectedPoints[i].x;
                    minViewportXIndex = i;
                }
            }
            rightmost = camera.ViewportToWorldPoint(projectedPoints[maxViewportXIndex]);
            leftmost = camera.ViewportToWorldPoint(projectedPoints[minViewportXIndex]);

            float leftDistance = Vector3.Dot(camera.transform.forward, leftmost - closest);
            leftmost += -camera.transform.forward * leftDistance;

            float rightDistance = Vector3.Dot(camera.transform.forward, rightmost - closest);
            rightmost += -camera.transform.forward * rightDistance;
        }
        private Vector3 GetOffsetDirection(Vector3 startingPoint, Vector3 endingPoint, Vector3 centerObject)
        {
            Vector3 middlePoint = Vector3.Lerp(startingPoint, endingPoint, 0.5f);
            Vector3 delta = middlePoint - centerObject;
            return delta.normalized;
        }
        
        //CHECK IS FRONT OR ISLAND======================================================================================CHECK IS FRONT OR ISLAND  
        private bool HaveFrontCab(string  Wallstring,float detectionRange)
        {
            Collider[] objects = GetWallOverlapBox(Wallstring, detectionRange);
            foreach (Collider obj in objects)
            {
                if (obj.name.Length > 4)
                {
                    string prefix = obj.name[..4];
                    if (new List<string>{ "door","open","wind","pati","cabi","frid","stov","hood","dish","bloc","wine","pane","wadr" }.Contains(prefix))
                    {
                        int On = Get.GetObjectIndex(obj.name);
                        if (_G.OBJs[On] == null) continue;
                        string attachTo = _G.OBJs[On][22];
                        if (attachTo == Wallstring)
                            return true;
                    }
                }
            }
            return false;
        }
        private void CreateCabIsFrontList(string  Wallstring,float detectionRange)
        {
            //All ojects true??
            ShowCabs = new();
            Collider[] objects = GetWallOverlapBox(Wallstring, detectionRange);
            foreach (Collider obj in objects)
            {
                if (obj.name.Length > 4)
                {
                    string prefix = obj.name[..4];
                    if (new List<string>{ "cabi","door","open","pati","frid","stov","hood","wind","dish","bloc","wine","pane","wadr","buil","tops","micr" }.Contains(prefix))
                    {
                        if(!ShowCabs.Contains(obj.gameObject) && CheckStoveNotFloor(obj.name)){ 
                            ShowCabs.Add(obj.gameObject);
                            Debug.Log($"Object detected: {obj.name}");
                        }
                    }
                }
            }
        }
        private Collider[] GetWallOverlapBox(string  Wallstring,float detectionRange)
        {
            int Wn=int.Parse(Wallstring[1..]);
            if (Wn < 1 || Wn - 1 >= _G.WallsWidth.Count)
            {
                Debug.LogWarning($"[Plan2D] GetWallOverlapBox: wall index {Wn} out of range (widths:{_G.WallsWidth.Count}) — skipped.");
                return Array.Empty<Collider>();
            }
            GameObject Wall = _walls.Find(w => w.name == Wallstring);
            if (Wall == null) return Array.Empty<Collider>();
            float WallWide = _G.WallsWidth[Wn-1];
            Vector3 direction =-Wall.transform.forward.normalized;
            Vector3 boxCenter = Wall.transform.position + direction * detectionRange*0.5f; // detectionRange * 0.5f
            Vector3 boxSize = new(WallWide - 10, _G.HEIGHT, detectionRange);
            return Physics.OverlapBox(boxCenter, boxSize * 0.5f, Wall.transform.rotation);
        }
        private void CreateCabIsIslandList(){
            ShowCabsIsland = new();
            foreach(Transform Obj in _scene.transform)
            {
                if (Obj.name.Length <= 4) continue;
                if (!new List<string>{"cabi","frid","stov","hooc","dish","pane","bloc","buil","tops","micr"}.Contains(Obj.name[..4])) continue;
                int ADNnum = Get.GetObjectIndex(Obj.name);
                if (_G.OBJs[ADNnum] == null) continue;
                if (_G.OBJs[ADNnum][27] == "nonIsland") continue;
                if (_G.OBJs[ADNnum][22] != "floor" && _G.OBJs[ADNnum][27]!="Island" ) continue;
                ShowCabsIsland.Add(Obj.gameObject);
            }
            if (_islandButton != null)
                _islandButton.gameObject.SetActive(ShowCabsIsland.Count > 0);
        }
        private void OnDrawGizmos()
            {
                if (drawGizmo)
                {
                    Gizmos.color = Color.cyan; // Set the Gizmo color
                    Gizmos.matrix = Matrix4x4.TRS(gizmoCenter, gizmoRotation, Vector3.one); // Set the matrix for rotation
                    Gizmos.DrawWireCube(Vector3.zero, gizmoSize); // Draw the Gizmo
                }
            }

        //DIMENSIONS======================================================================================DIMENSIONS
        private void DisplayLineToScreen(ZoomSettings zoomSettings)
        {
            _worldButtonCanvas.transform.position = new Vector3(0f, _wallHeight, 0f);
            for (int i = 0; i < _walls.Count; i++)
            {
                GameObject wall = _walls[i];
                int wallIndex = int.Parse(wall.name.Substring(1, wall.name.Length - 1)) - 1;
                float wallWideness = _G.WallsWidth[wallIndex];
                Vector2 wallCenterPosition = _G.WallsPointCenter[wallIndex];
                Vector3 direction = wall.transform.forward; // Get Direction of wall
                Vector3 Offset=wallWideness * 0.5f * wall.transform.right; // Haft of the wall
                Vector3 startingPoint = new Vector3(wallCenterPosition.x, _wallHeight, wallCenterPosition.y) - Offset+6*direction;
                Vector3 endingPoint = startingPoint + wallWideness * wall.transform.right;  // Get nextPoint of wall by offseting by measure wide _G.wW[i]          
                string measure = DOIT.ConvertNumberToString(wallWideness); // Get adequate Measure of wall depending of camera view for now top
                LineDisplay lineDisplay = new(_camera,
                                                -1,
                                                startingPoint,
                                                endingPoint,
                                                direction,
                                                measure,
                                                this,
                                                ObjectTypes.Wall,
                                                true,
                                                false,
                                                zoomSettings,
                                                objectTypes);
                _wallLines.Add(lineDisplay);   
                float distanceFromWall = _distanceFromWallForObjects * ViewScale;
                float wallThickness = _wallThickness * ViewScale;
                Vector3 pointOfViewWallCut = wall.transform.position + 36f * ViewScale * -direction;
                Vector3 pointOfViewWallObject = wall.transform.position + distanceFromWall * -direction;
                Vector3 pointBehindWall = wall.transform.position + wallThickness * direction;

                // BTN Elevation
                if (HaveFrontCab("w" + (wallIndex + 1).ToString(), 12))
                {
                    Button elevBtn = AddButton(i, direction, pointOfViewWallCut, "E" + (wallIndex + 1).ToString(), false);
                    _wallElevationButtonObjects.Add(elevBtn.gameObject);
                    elevBtn.onClick.AddListener(new UnityAction(() => ShowWallCut(wall.name)));
                }

                foreach (var value in _objectsInScene)
                {     
                    ObjectTypes j = value.Key;
                    if (j == ObjectTypes.IslandObject) continue;
                    foreach (GameObject objectInScene in _objectsInScene[j])
                    {
                        if (objectInScene == null) continue;
                        int On = Get.GetObjectIndex(objectInScene.name);
                        string[] data = _G.OBJs[On];
                        if (IsInFrontOfWall(wall, pointOfViewWallObject, pointBehindWall, objectInScene))
                        {
                            Vector3 objectPosition, leftmostScreenPos1, rightmostScreenPos1;
                            objectPosition = objectInScene.transform.position;
                            if (IsOnWall(startingPoint, endingPoint, objectInScene, out leftmostScreenPos1, out rightmostScreenPos1))
                            {
                                ObjectTypes objectType = j;
                                lineDisplay.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, objectType);
                            }
                        }
                    }
                }
            }

            //Island Cabinets
            CreateCabIsIslandList();

            if(ShowCabsIsland!=null && ShowCabsIsland.Count!=0)
            {
                _islandCutActive = true;
                _islandButton?.gameObject.SetActive(true);

                float leftmostScreenPos = Mathf.Infinity;
                float rightmostScreenPos = -Mathf.Infinity;
                float upperScreenPos = -Mathf.Infinity;
                float downScreenPos = Mathf.Infinity;

                bool hasRealIslandObjects = false;
                foreach (GameObject objectInScene in ShowCabsIsland)
                {
                    if (IsNoCotesIslandObject(objectInScene)) continue; // pas de cotes pour BUIL/TOPS/PLAT/micr/pane/bloc
                    hasRealIslandObjects = true;
                    Vector3 objectPosition = objectInScene.transform.position;
                    List<Vector3> corners = GetObjectBounds(objectInScene);
                    foreach (var corner in corners)
                    {
                        if (corner.x < leftmostScreenPos)
                        {
                            leftmostScreenPos = corner.x;
                        }

                        if (corner.x > rightmostScreenPos)
                        {
                            rightmostScreenPos = corner.x;
                        }

                        if (corner.z < downScreenPos)
                        {
                            downScreenPos = corner.z;
                        }

                        if (corner.z > upperScreenPos)
                        {
                            upperScreenPos = corner.z;
                        }
                    }
                }
                // Si seulement des objets sans cotes (BUIL/TOPS/PLAT/micr/pane/bloc),
                // on n'affiche pas la cote d'îlot
                if (!hasRealIslandObjects)
                {
                    _islandCutActive = false;
                    _islandButton?.gameObject.SetActive(false);
                }
                else
                {
                    List<Vector3> islandBoundsCorner = new List<Vector3>()
                    {
                        new (leftmostScreenPos, _wallHeight, downScreenPos ),
                        new (leftmostScreenPos, _wallHeight, upperScreenPos ),
                        new (rightmostScreenPos, _wallHeight, upperScreenPos ),
                    };
                    _islandCenterPosition = new Vector3(leftmostScreenPos + (rightmostScreenPos - leftmostScreenPos) * 0.5f, -_G.HEIGHT*0.5f+24, downScreenPos + (upperScreenPos - downScreenPos) * 0.5f);
                    _islandButton?.gameObject.SetActive(true);

                    for (int i = 0; i < islandBoundsCorner.Count - 1; i++)
                    {
                        Vector3 startingPoint = islandBoundsCorner[i];
                        Vector3 endingPoint = islandBoundsCorner[i + 1];
                        Vector3 direction = (endingPoint - startingPoint);
                        Vector3 rotationAxis = Vector3.up;
                        Quaternion rotationQuaternion = Quaternion.AngleAxis(-90f, rotationAxis);
                        direction = rotationQuaternion * direction;
                        direction.Normalize();
                        string measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
                        LineDisplay lineDisplay = new(_camera,
                                                        -1,
                                                        startingPoint,
                                                        endingPoint,
                                                        direction,
                                                        measure,
                                                        this,
                                                        ObjectTypes.IslandWall,
                                                        i == 0 || i == islandBoundsCorner.Count - 1,
                                                        false,
                                                        zoomSettings,
                                                        objectTypes);
                        _islandLines.Add(lineDisplay);
                    }
                }
            }
            DisplayLines();
        }
        private void ShowWallCutLines(ZoomSettings zoomSettings)
        {
            int wallIndex = int.Parse(_selectedWallForElevation.name[1..]) - 1;
            float wallWideness = _G.WallsWidth[wallIndex];
            Vector2 wallCenterPosition = _G.WallsPointCenter[wallIndex];

            //Hide all walls
            foreach (var w in _walls) {w.SetActive(false);}

            AllSceneObjectTrue();

            //Objects
            List<GameObject> OpenningOnWall = new();
            List<GameObject> CabinetFloor = new();
            List<GameObject> CabinetWall = new();
            List<GameObject> CabinetTall = new();
            ShowCabs= new List<GameObject>();
            CreateCabIsFrontList(_selectedWallForElevation.name,24);
            HideNonWallObjects();

            foreach(GameObject objet in ShowCabs)
                {
                    string Group =objet.name[..4];
                    // buil/tops/micr : visibles en élévation mais sans cotes
                    if (Group == "buil" || Group == "tops" || Group == "micr") continue;
                    int ADN=Get.GetObjectIndex(objet.name);
                    float YPosition = DOIT.ConvertStringToNumber(_G.OBJs[ADN][16]);
                    if(Group=="cabi")
                        {
                            string cabType = _G.OBJs[ADN][5];
                            if(YPosition<=-10){if(!CabinetFloor.Contains(objet)) { CabinetFloor.Add(objet); }}
                            else if(cabType=="TA"){if(!CabinetTall.Contains(objet)) { CabinetTall.Add(objet); }}
                            else{if(!CabinetWall.Contains(objet)) { CabinetWall.Add(objet); }}
                        }
                    if(new List<string>(){"wind","open","pati","door"}.Contains(Group))
                        {
                            if(!OpenningOnWall.Contains(objet))
                            {
                                OpenningOnWall.Add(objet);
                                print("OpenningOnWall====="+objet.name);
                            }
                        }
                    // Appliances → CabinetFloor pour cotes élévation
                    // Exception : stoves BUIL/TOPS affichés sans cotes
                    if(_G.OBJs[ADN][2] == "Appliance")
                        {
                            bool isBuiltInStove = Group == "stov"
                                && _G.OBJs[ADN][1] != null
                                && _G.OBJs[ADN][1].Length >= 4
                                && (new[]{"BUIL","TOPS","PLAT"}.Contains(_G.OBJs[ADN][1][..4]));
                            if(!isBuiltInStove && !CabinetFloor.Contains(objet)) { CabinetFloor.Add(objet); }
                        }
                }

            List<Vector3> corners = new(4)
            {
                new Vector3(wallCenterPosition.x, _wallHeight, wallCenterPosition.y) - wallWideness * 0.5f * _selectedWallForElevation.transform.right,
                new Vector3(wallCenterPosition.x, _wallHeight, wallCenterPosition.y) + wallWideness * 0.5f * _selectedWallForElevation.transform.right,
                new Vector3(wallCenterPosition.x, -_wallHeight, wallCenterPosition.y) + wallWideness * 0.5f * _selectedWallForElevation.transform.right,
                new Vector3(wallCenterPosition.x, -_wallHeight, wallCenterPosition.y) - wallWideness * 0.5f * _selectedWallForElevation.transform.right
            };

            Vector3 startingPoint,endingPoint,leftmostScreenPos1,rightmostScreenPos1;

            //TOP WALL MEASURE WIDE
            startingPoint = corners[0];
            endingPoint = corners[1];
            Vector3 offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
            string measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
            LineDisplay lineDisplayTop = new(_camera,
                                            -1,
                                            startingPoint,
                                            endingPoint,
                                            offsetDirection,
                                            measure,
                                            this,
                                            ObjectTypes.Wall,
                                            true,//showWallMeasure: i == 0 || i == corners.Count - 1,
                                            true,
                                            zoomSettings,
                                            objectTypes,
                                            incrementalOffsetOverride: OffsetForIncrementalCutTopBottom,
                                            fontSizeOverride: FontSizeElevation,
                                            minFontSizeOverride: MinFontSizeElevation);
            _wallLines.Add(lineDisplayTop);

            //SIDE WALL MESURE HEIGHT
            startingPoint = corners[3];
            endingPoint = corners[0];
            offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
            measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
            LineDisplay lineDisplaySide = new(_camera,
                                            -1,
                                            startingPoint,
                                            endingPoint,
                                            offsetDirection,
                                            measure,
                                            this,
                                            ObjectTypes.Wall,
                                            true,//showWallMeasure: i == 0 || i == corners.Count - 1,
                                            true,
                                            zoomSettings,
                                            objectTypes,
                                            incrementalOffsetOverride: OffsetForIncrementalCutSides,
                                            fontSizeOverride: FontSizeElevation,
                                            minFontSizeOverride: MinFontSizeElevation);
            _wallLines.Add(lineDisplaySide);

            //UNDER MEASURE
            startingPoint = corners[3];
            endingPoint = corners[2];
            offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
            measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
            LineDisplay lineDisplayUNDER = new(_camera,
                                            -1,
                                            startingPoint,
                                            endingPoint,
                                            offsetDirection,
                                            measure,
                                            this,
                                            ObjectTypes.Wall,
                                            false,//showWallMeasure: i == 0 || i == corners.Count - 1,
                                            true,
                                            zoomSettings,
                                            objectTypes,
                                            incrementalOffsetOverride: OffsetForIncrementalCutTopBottom,
                                            fontSizeOverride: FontSizeElevation,
                                            minFontSizeOverride: MinFontSizeElevation);
            _wallLines.Add(lineDisplayUNDER);

            //RIGHT SIDE — TALL CABINETS
            startingPoint = corners[2];
            endingPoint = corners[1];
            offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
            measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
            LineDisplay lineDisplayRight = new(_camera,
                                            -1,
                                            startingPoint,
                                            endingPoint,
                                            offsetDirection,
                                            measure,
                                            this,
                                            ObjectTypes.Wall,
                                            false,
                                            true,
                                            zoomSettings,
                                            objectTypes,
                                            incrementalOffsetOverride: OffsetForIncrementalCutSides,
                                            fontSizeOverride: FontSizeElevation,
                                            minFontSizeOverride: MinFontSizeElevation);
            _wallLines.Add(lineDisplayRight);

            //TOP OPENING OBJECTS
            foreach (GameObject Openning in  OpenningOnWall)
            {
                startingPoint = corners[0];
                endingPoint = corners[1];
                offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
                measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
                leftmostScreenPos1 = Vector3.zero;
                rightmostScreenPos1 = Vector3.zero;
                List<Vector3> corners2 = GetObjectBounds(Openning);
                GetLeftmostAndRightmostPositions(corners2, startingPoint, endingPoint, ref leftmostScreenPos1, ref rightmostScreenPos1);
                lineDisplayTop.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.StructuralElements);//Top Line obstacle
            }
           
            //SIDE OPENING OBJECTS
            foreach (GameObject Openning in  OpenningOnWall)
            {
                startingPoint = corners[3];
                endingPoint = corners[0];
                offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
                measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
                leftmostScreenPos1 = Vector3.zero;
                rightmostScreenPos1 = Vector3.zero;
                List<Vector3> corners2 = GetObjectBounds(Openning);
                GetLeftmostAndRightmostPositions(corners2, startingPoint, endingPoint, ref leftmostScreenPos1, ref rightmostScreenPos1);
                lineDisplaySide.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.StructuralElements);//Top Line obstacle
            }
         
            //SIDE CABINETS FLOOR
            foreach (GameObject Cabinet in  CabinetFloor)
            {
                startingPoint = corners[3];
                endingPoint = corners[0];
                offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
                measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
                leftmostScreenPos1 = Vector3.zero;
                rightmostScreenPos1 = Vector3.zero;
                List<Vector3> corners2 = GetObjectBounds(Cabinet);
                GetLeftmostAndRightmostPositions(corners2, startingPoint, endingPoint, ref leftmostScreenPos1, ref rightmostScreenPos1);
                lineDisplaySide.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.FloorObject);//Top Line obstacle
            }

            //SIDE CABINETS WALL
            foreach (GameObject Cabinet in  CabinetWall)
            {
                startingPoint = corners[3];
                endingPoint = corners[0];
                offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
                measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
                leftmostScreenPos1 = Vector3.zero;
                rightmostScreenPos1 = Vector3.zero;
                List<Vector3> corners2 = GetObjectBounds(Cabinet);
                GetLeftmostAndRightmostPositions(corners2, startingPoint, endingPoint, ref leftmostScreenPos1, ref rightmostScreenPos1);
                lineDisplaySide.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.WallObject);//Top Line obstacle
            }

            //TOP WALL CABINET
            foreach (GameObject Cabinet in  CabinetWall)
            {
                startingPoint = corners[0];
                endingPoint = corners[1];
                offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
                leftmostScreenPos1 = Vector3.zero;
                rightmostScreenPos1 = Vector3.zero;
                List<Vector3> corners2 = GetObjectBounds(Cabinet);
                GetLeftmostAndRightmostPositions(corners2, startingPoint, endingPoint, ref leftmostScreenPos1, ref rightmostScreenPos1);
                measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
                lineDisplayTop.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.WallObject);
            }

            //UNDER BASE CABINET
            foreach (GameObject Cabinet in  CabinetFloor)
            {
                startingPoint = corners[3];
                endingPoint = corners[2];
                offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);
                measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
                leftmostScreenPos1 = Vector3.zero;
                rightmostScreenPos1 = Vector3.zero;
                List<Vector3> corners2 = GetObjectBounds(Cabinet);
                GetLeftmostAndRightmostPositions(corners2, startingPoint, endingPoint, ref leftmostScreenPos1, ref rightmostScreenPos1);
                lineDisplayUNDER.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.FloorObject);
            }

            //RIGHT SIDE TALL CABINETS
            foreach (GameObject Cabinet in CabinetTall)
            {
                startingPoint = corners[2];
                endingPoint = corners[1];
                leftmostScreenPos1 = Vector3.zero;
                rightmostScreenPos1 = Vector3.zero;
                List<Vector3> corners2 = GetObjectBounds(Cabinet);
                GetLeftmostAndRightmostPositions(corners2, startingPoint, endingPoint, ref leftmostScreenPos1, ref rightmostScreenPos1);
                lineDisplayRight.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.TallObject);
            }

            //TOP TALL CABINETS
            foreach (GameObject Cabinet in CabinetTall)
            {
                startingPoint = corners[0];
                endingPoint = corners[1];
                leftmostScreenPos1 = Vector3.zero;
                rightmostScreenPos1 = Vector3.zero;
                List<Vector3> corners2 = GetObjectBounds(Cabinet);
                GetLeftmostAndRightmostPositions(corners2, startingPoint, endingPoint, ref leftmostScreenPos1, ref rightmostScreenPos1);
                lineDisplayTop.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.TallObject);
            }

            DisplayLines();
        }
        
        private bool IsOnWall(Vector3 startingPoint, Vector3 endingPoint, GameObject objectInScene, out Vector3 leftmostScreenPos, out Vector3 rightmostScreenPos)
        {
            leftmostScreenPos = Vector3.zero;
            rightmostScreenPos = Vector3.zero;
            List<Vector3> corners = GetObjectBounds(objectInScene);

            GetLeftmostAndRightmostPositions(corners, startingPoint, endingPoint, ref leftmostScreenPos, ref rightmostScreenPos);

            return IsBetween(leftmostScreenPos, startingPoint, endingPoint) || IsBetween(rightmostScreenPos, startingPoint, endingPoint);
        }
        static public bool IsBetween(Vector3 pos, Vector3 startingPoint, Vector3 endingPoint)
        {
            Vector3 pointOnline = GetPositionOnLine(pos, startingPoint, endingPoint);

            Vector3 delta = pointOnline - startingPoint;
            Vector3 delta2 = endingPoint - startingPoint;

            float dot = Vector3.Dot(delta, delta2);
            float distance1 = Vector3.Distance(pointOnline, startingPoint);
            float distance2 = Vector3.Distance(endingPoint, startingPoint);

            return dot >= 0 && distance1 < distance2;
        }
        private bool IsInFrontOfWall(GameObject wall, Vector3 pointOfViewWall, Vector3 pointBehindWall, GameObject objectInScene)
        {
            Vector3 pointOnline = GetPositionOnLine(objectInScene.transform.position, wall.transform.position, pointOfViewWall);
            Vector3 delta = pointOnline - pointBehindWall;
            Vector3 delta2 = pointOfViewWall - pointBehindWall;
            float dot = Vector3.Dot(delta, delta2);
            float distance1 = Vector3.Distance(pointOnline, pointBehindWall);
            float distance2 = Vector3.Distance(pointOfViewWall, pointBehindWall);
            bool isAttachedToWall = wall.name == objectInScene.GetComponent<MoveObject>().AttachedTo.name;
            return dot > 0 && (distance1 < distance2 || isAttachedToWall);
        }
        private void DisplayLines()
        {
            foreach (LineDisplay line in _islandLines)
            {
                line.DisplayLines();
            }
            foreach (LineDisplay line in _wallLines)
            {
                line.DisplayLines();
            }
        }
        private void GetLeftmostAndRightmostPositions(List<Vector3> positionsToEvaluate, Vector3 startingPoint, Vector3 endingPoint, ref Vector3 leftPos, ref Vector3 rightPos)
        {
            float dist = Mathf.Infinity;
            int chosenIndex = 0;
            List<int[]> indexToConsider = new List<int[]>()
            {
                new int[]{ 0, 1},
                new int[]{ 1, 2},
                new int[]{ 2, 3},
                new int[]{ 3, 0},

                new int[]{ 4, 5},
                new int[]{ 5, 6},
                new int[]{ 6, 7},
                new int[]{ 7, 4},

                new int[]{ 0, 4},
                new int[]{ 1, 5},
                new int[]{ 2, 6},
                new int[]{ 3, 7}
            };

            for (int i = 0; i < indexToConsider.Count; i++)
            {
                Vector3 p1 = positionsToEvaluate[indexToConsider[i][0]];
                Vector3 p2 = positionsToEvaluate[indexToConsider[i][1]];

                if (Vector3.Distance(p1, p2) <= Mathf.Epsilon) continue;
                Vector3 middlePoint = Vector3.Lerp(p1, p2, 0.5f);
                Vector3 posOnLine = GetPositionOnLine(middlePoint, startingPoint, endingPoint);
                float distanceFromLine = Vector3.Distance(posOnLine, middlePoint);

                if (distanceFromLine < dist)
                {
                    chosenIndex = i;
                    dist = distanceFromLine;
                }
            }
            leftPos = positionsToEvaluate[indexToConsider[chosenIndex][0]];
            rightPos = positionsToEvaluate[indexToConsider[chosenIndex][1]];
        }
        private void GetReferences()
        {
            GetReferenceInRoom();
            foreach (Transform c in _scene.transform)  {

                c.gameObject.SetActive(false);
                if (c.name.Length>4 && new List<string>(){"cabi","dish","frid","stov","wind","open","door","pati","hood","bloc","wine","pane","wadr"}.Contains(c.name[..4])){
                    int On = Get.GetObjectIndex(c.name);
                    string[] ADN = _G.OBJs[On];
                    c.gameObject.SetActive(true);                   
                    _objectToActive.Add(c.gameObject);
                    
                }
            foreach(var Btn in _wallCutsButtons){
                Btn.Value.SetActive(true);
            }
      }

           GetReferenceInScene();
        }
        private void GetReferenceInScene()
        {
            if (_scene == null) return;

            ObjectTypes objectType = ObjectTypes.Null;
            foreach (Transform c in _scene.transform)
            {
                if (_G.HIDELIST.Contains(c.name))
                {
                    continue;
                }

                if (c.name.Length<4)
                {
                    continue;
                }

                // Objets visibles en plan2D mais sans cotes (au mur ET au centre)
                if (c.name[..4] == "micr" || c.name[..4] == "buil" || c.name[..4] == "tops"
                    || c.name[..4] == "pane" || c.name[..4] == "bloc")
                {
                    continue;
                }

                //Debug.Log($"object in scene check : {c.name} ; is hidden : {_G.HIDELIST.Contains(c.name)}");

                int On = Get.GetObjectIndex(c.name);
                string[] ADN = _G.OBJs[On];
                string attachTo = ADN[22];

                // stov avec modèle BUIL/TOPS/PLAT : visible mais sans cotes
                if (c.name[..4] == "stov" && ADN[1] != null)
                {
                    string m4 = ADN[1].Length >= 4 ? ADN[1][..4] : ADN[1];
                    if (m4 == "BUIL" || m4 == "TOPS" || m4 == "PLAT")
                        continue;
                }

                //Debug.Log(attachTo);
                // if (string.IsNullOrEmpty(attachTo))
                // {
                //     c.gameObject.SetActive(false);
                //     _objectToActive.Add(c.gameObject);
                //     GameObject OgeeSet = Get.o2("OgeeContainer", "OgeeSet" + c.gameObject.name);
                //     if (OgeeSet != null) { OgeeSet.SetActive(false); }
                //     //Debug.LogError("Should not enter here");
                //     continue;
                // }

                objectType = GetObjectType(ADN, attachTo);


                if (objectType != ObjectTypes.Null)
                {
                    if (!_objectsInScene.ContainsKey(objectType))
                    {
                        _objectsInScene.Add(objectType, new());
                    }

                    _objectsInScene[objectType].Add(c.gameObject);
                }
                else
                {
                    _objectToActive.Add(c.gameObject);
                    c.gameObject.SetActive(false);
                }
            }
        }
        private void GetReferenceInRoom()
        {
            if (_room == null) return;

            foreach (Transform c in _room.transform)
            {
                string name = c.name;

                if (name.ElementAt(0) == 'w')
                {
                    _walls.Add(c.gameObject);
                    c.gameObject.SetActive(false);
                    // continue;
                }
                else
                {
                    if (!name.StartsWith("Topw"))
                    {
                        _objectToActive.Add(c.gameObject);
                    }
                }
                c.gameObject.SetActive(false);
            }

        }
        
        //BTNS========================================================================================================BTNS
        private Button AddButton(int i, Vector3 direction, Vector3 position, string buttonText, bool trackInDict = true)
        {
            GameObject btnObject = Instantiate(Get.o2("HIDER", "WEbtn"));
            btnObject.SetActive(true);
            btnObject.transform.localScale= new(0.2f,0.2f,1f);
            float offsetBtn=0;
            GameObject BtnContainer=Get.o2("PLAN2DHandler","WorldButtonCanvas");
            foreach (Transform t in BtnContainer.transform)
            {
                float distance=Vector3.Distance(position,t.gameObject.transform.position);
                if(distance<10)
                {
                    offsetBtn=(10-distance)*0.5f;
                    t.gameObject.transform.position-=offsetBtn*direction;
                }
            }
            position+=offsetBtn*direction;

            btnObject.transform.position = new(position.x,_G.HEIGHT+2,position.z);
            btnObject.transform.SetParent(_worldButtonCanvas.transform);
            btnObject.transform.Find("Text").transform.GetComponent<Text>().text = buttonText;
            Button btn = btnObject.GetComponent<Button>();

            float angle = (int)Vector3.Angle(Vector3.forward, direction);
            Vector3 cross = Vector3.Cross(Vector3.forward, direction);

            if (Math.Abs(angle) > 90f)
            {
                //angle = (int)Vector3.Angle(Vector3.forward, -direction);
            }
            // make sure that angle between
            if (cross.y < 0)
            {
                angle *= -1;
            }
            btnObject.transform.localEulerAngles = new Vector3(90f, angle, 0f);
            GameObject text = btn.GetComponentInChildren<Text>().gameObject;
            float angle2 = (int)Vector3.SignedAngle(_camera.transform.up, text.transform.up, Vector3.up);
            text.transform.localEulerAngles = new Vector3(0f, 0f, angle2);

            btnObject.name = "btnw" + (i + 1).ToString();
            float scale = Camera.main.orthographicSize/700f;
            btnObject.transform.localScale=new(scale,scale,1);
            if (trackInDict) _wallCutsButtons.Add(i, btnObject);

            return btn;
        }
        public static ObjectTypes GetObjectTypeByModel(string[] data,string attachTo ){
            string cabType = data[5];
            string obj = data[2];
            if(attachTo=="Wall"){
                switch(cabType){
                    case "BA": return  ObjectTypes.FloorObject;
                    case "WA": return  ObjectTypes.WallObject;
                    case "TA": return  ObjectTypes.TallObject;
                }
                switch(obj){
                    case "Patio":
                    case "Opening":
                    case "Door":
                    case "Window":
                    case "Bloc":  
                    case "Appliance":return  ObjectTypes.StructuralElements;
                }
            }
            if(attachTo=="Island"){
                switch(cabType){
                    case "BA": return  ObjectTypes.IslandObject;
                    case "WA": return  ObjectTypes.IslandObject;
                    case "TA": return  ObjectTypes.IslandObject;
                }
            }
            return ObjectTypes.Null;
        }

        void SwitchMaterial(bool enabled)
        {
            if (enabled)
            {
                _materialToChange.Clear();
                _materialToChange = new();

                if (_scene != null)
                {
                    List<MeshRenderer> renderers = new();
                    foreach (Transform t in _scene.transform)
                    {
                        if(t.name.Length>3){
                            if (_G.HIDELIST.Contains(t.name))
                            {
                                continue;
                            }
                            if (t.name[..4] == "Stru")
                            {
                                continue;
                            }
                            //check for renderer to remove structural elements

                            //Debug.Log($"object in scene check : {t.name} ; is hidden : {_G.HIDELIST.Contains(t.name)}");
                            renderers.AddRange(t.GetComponentsInChildren<MeshRenderer>());
                            GameObject Ogee = Get.o1("OgeeSet" + t.name);
                            if (Ogee != null) renderers.AddRange(Ogee.GetComponentsInChildren<MeshRenderer>());
                        }
                    }

                    //MeshRenderer[] renderers = _scene.GetComponentsInChildren<MeshRenderer>();

                    foreach (var renderer in renderers)
                    {
                        //Debug.Log($"renderer name : {renderer.name}");
                        if (renderer.material != null && renderer.transform.parent != _scene.transform && renderer.gameObject.name != "pointcap")
                        {
                            if (!_materialToChange.ContainsKey(renderer))
                            {
                                _materialToChange.Add(renderer, renderer.material);
                                renderer.material = _plan2DMaterial;
                            }
                        }
                    }
                }
            }
            else
            {
                foreach (var keyValue in _materialToChange)
                {
                    MeshRenderer renderer = keyValue.Key;
                    if (renderer != null)
                    {
                        renderer.material = keyValue.Value;
                    }
                    else
                    {
                        Debug.Log($"Missing Reference of renderer {keyValue}");
                    }
                }
            }
        }
        public static ObjectTypes GetObjectType(string[] data, string attachTo)
        {
            string obj = data[2];
            string cabType;
            if(obj=="Bloc")cabType="Bloc";
            switch (attachTo)
            {
                case "floor":
                    if (obj == "Appliance") return ObjectTypes.FloorObject;
                    cabType = data[5];
                    switch (cabType)
                    {
                        case "BA":
                        case "TA":
                        case "CB":
                        return ObjectTypes.IslandObject;
                        case "PNL":
                        case "Gas":
                        case "Plumbing":
                        case "Hood":
                        case "Socket":
                        case "Bloc":
                            return ObjectTypes.StructuralElements;
                            //default:
                            //    return ObjectTypes.Null;
                    }
                    break;
                default:
                    if (!string.IsNullOrEmpty(attachTo) && attachTo.Contains('w'))
                    {
                        switch (obj)
                        {
                            case "Cabinet":
                                cabType = data[5];
                                switch (cabType)
                                {
                                    case "BA":
                                    case "TA":
                                    case "CB":
                                        return ObjectTypes.FloorObject;
                                    case "WA":
                                    case "CW":
                                        return ObjectTypes.WallObject;
                                }
                                break;
                            case "Patio":
                            case "Opening":
                            case "Door":
                            case "Window":
                            case "Bloc":
                            case "StructureElements":
                                return ObjectTypes.StructuralElements;
                            case "Panel":
                                return ObjectTypes.WallObject;
                            case "Appliance":
                            case "dish":
                            case "winer":
                            case "wadr":
                                return ObjectTypes.FloorObject;
                            default:
                                break;
                        }
                    }
                    break;
            }

            return ObjectTypes.Null;
        }
        #region Outline Shader



        public void EnableOutlinePostProcess(bool enabled)
        {
            if (enabled == _active) return;

            _active = enabled;

            UniversalAdditionalCameraData data = Camera.main.GetComponent<UniversalAdditionalCameraData>();
            data.renderPostProcessing = !enabled;

            if (enabled)
            {
                data.SetRenderer(2); // Outline renderer
            }
            else
            {
                data.SetRenderer(1); // Default renderer
            }

            // Disable/restore renderer features assigned in Inspector (e.g. blue outline)
            foreach (var feature in _featuresToDisableInPlan2D)
                if (feature != null) feature.SetActive(!enabled);

            SwitchMaterial(enabled);
        }
        #endregion
        public static Vector3 GetPositionOnLine(Vector3 positionToConvert, Vector3 p1, Vector3 p2)
        {
            Vector3 direction = p2 - p1;
            Vector3 fromFirstToThird = positionToConvert - p1;
            float distanceAlongLine = Vector3.Dot(fromFirstToThird, direction.normalized);
            Vector3 projection = direction.normalized * distanceAlongLine;
            Vector3 projectedPoint = p1 + projection;
            return projectedPoint;
        }
        private List<Vector3> GetObjectBounds(GameObject obj)
        {
            print("obj.name===="+obj.name);
            
            GameObject point =obj.transform.Find("PBLU").gameObject;
            print("obj point.name===="+point.name);

            List<Vector3> bounds = new()
            {
                obj.transform.Find("PBLU").position,        //  0 Position Back Left Upper
                obj.transform.Find("PBRU").position,       //  1 Position Back Right Upper
                obj.transform.Find("PFRU").position,      // 2 Position Front Right Upper
                obj.transform.Find("PFLU").position,     // 3 Position Front Left Upper
                obj.transform.Find("PBLB").position,    // 4 Position Back Left Bottom
                obj.transform.Find("PBRB").position,   // 5 Position Back Right Bottom
                obj.transform.Find("PFRB").position,  // 6 Position Front Left Bottom
                obj.transform.Find("PFLB").position  // 7 Position Front Left Bottom
            };

            return bounds;
        }
        public void SETDIM()
        {
            Debug.Log("SETDIM");

            // backups old
            _G.OW = _G.WallsPointCenter.GetRange(0, _G.WallsPointCenter.Count);
            _G.OP = _G.WallsPointStart.GetRange(0, _G.WallsPointStart.Count);

            // recentre UI + listes
            PlanRecentering.RecenterNow_FromCurrentUIAndLists();

            // ensuite la commande
            Create3D._resizeCommand = new ResizeRoomCommand();

            DOIT.CloseALLPNLONLY();
            Camera cam = Camera.main;
            CameraAround.Show();

            foreach (Transform obj in SceneModeManager.Room)
            obj.gameObject.SetActive(true);

            Close2DPlan();

            _G.PNL = "PLANSETTING";

            GameObject panelDrawPlan = Get.o2("Canvas", "Panel_DRAWPlan_NEW");
            panelDrawPlan.SetActive(true);
            panelDrawPlan.transform.Find("X").gameObject.SetActive(true);
            panelDrawPlan.transform.Find("BackPlan2D").gameObject.SetActive(false);
            panelDrawPlan.transform.Find("CeilingHeight/MCe/mCe").GetComponent<TMP_Text>().text =
            DOIT.ConvertNumberToString(_G.HEIGHT);

            Get.o2("Canvas", "Panel_SCENE").SetActive(false);
            Get.o2("Canvas", "Language").SetActive(false);

            ReflectionProbesUpdater.OnOff.SetActive(true);

            foreach (Transform Line in Get.o2("Panel_DRAWPlan_NEW/Plan2D_UI", "WallLineContainer").transform)
            Line.gameObject.SetActive(true);
        }

        private static bool IsPlan2D(string ObjectName) {
            if( ObjectName.Length>4 && new List<string>(){"cabi","dish","frid","stov","wind","open","door","pati","hood","bloc","pane"}.Contains(ObjectName[..4]) ) {return true;}
            return false;
        }
        public void HideCountertop()
        {
            if(_P.ListSwitch.ContainsKey("PLAN2D_HIDE_COUNTERTOP") &&_P.ListSwitch["PLAN2D_HIDE_COUNTERTOP"]){
                bool isPlan2D=true;
                if(!_showIslandElevation && !_showWallElevation && _isOpen ){isPlan2D=false;}
                foreach (Transform Object in _scene.transform)
                {
                if(Object.transform.Find("CABCOUNTER")){ Object.transform.Find("CABCOUNTER").gameObject.SetActive(isPlan2D);}
                if(Object.transform.Find("CABCOUNTER2")){Object.transform.Find("CABCOUNTER2").gameObject.SetActive(isPlan2D);}
                } 
            }
        }
    
        private List<GameObject> FilterVisibleObjects(List<GameObject> objects, Camera cam)
            {
                List<GameObject> visibleObjects = new();

                foreach (GameObject obj in objects)
                {
                    Vector3 origin = cam.transform.position;
                    Vector3 target = obj.transform.position;
                    Vector3 direction = (target - origin).normalized;
                    float distance = Vector3.Distance(origin, target);

                    bool isVisible = true;

                    RaycastHit[] hits = Physics.RaycastAll(origin, direction, distance);

                    foreach (RaycastHit hit in hits)
                    {
                        if (hit.collider.gameObject != obj && objects.Contains(hit.collider.gameObject))
                        {
                            isVisible = false;
                            break;
                        }
                    }

                    if (isVisible)
                        visibleObjects.Add(obj);
                }

                return visibleObjects;
            }
    

        /// <summary>
        /// Retourne true si l'objet doit être affiché dans l'élévation (ShowCabs).
        /// Tous les stoves (BUIL, TOPS, autres) sont affichés — plan2D / élévation / island —
        /// mais sans cotes (GetReferenceInScene exclut tous les "stov" des cotes via continue).
        /// Pour les autres objets, BUIL et TOPS sont exclus de l'élévation.
        /// </summary>
        public bool CheckStoveNotFloor(string StoveName)
        {
            // Ces types sont toujours visibles (ShowCabs) dans toutes les vues, sans cotes
            if (StoveName.Length >= 4)
            {
                string p = StoveName[..4];
                if (p == "stov" || p == "buil" || p == "tops" || p == "micr") return true;
            }

            int On = Get.GetObjectIndex(StoveName);
            if (On < 0 || _G.OBJs[On] == null) return false;
            string[] ADN = _G.OBJs[On];
            if (ADN[1] == null || ADN[1].Length < 4) return true;
            // Pour les autres objets : exclure BUIL, TOPS et PLAT (modèles plaque)
            string a4 = ADN[1][..4];
            return a4 != "BUIL" && a4 != "TOPS" && a4 != "PLAT";
        }
        //Camera view
        // Bouton "Save Camera Position"
        // public void OnSaveCameraPosition()
        // {
        //     _savedCameraViews.Add(new CameraView
        //     {
        //         Name        = $"View_{_savedCameraViews.Count + 1}",
        //         Position    = _camera.transform.position,
        //         Rotation    = _camera.transform.rotation,
        //         FieldOfView = _camera.fieldOfView,
        //         ZoomSettings = _currentZoomSettings
        //     });
        // }

    }
}