using JetBrains.Annotations;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using TMPro;
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 = 12f;
        public float OffsetForIncrementalCut { get { return _offsetForIncrementalCut; } }
        [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;

        [Header("Measure Settings")]
        [SerializeField]
        List<Color> _linesColors = new(8)
        {
            Color.black,
            Color.black,
            Color.red,
            Color.blue,
            new Color(52,52,53),
            Color.red,
            Color.black,
            Color.gray
        };

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

        [SerializeField] float _distanceFromWallForObjects = 24f;
        [SerializeField] float _wallThickness = 6f;
        [SerializeField] float _lineThickness = 0.5f;
        [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();

        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 HalfLineThickness { get { return _lineThickness * 0.5f; } }
        Dictionary<ObjectTypes, List<GameObject>> _texts = new(Enum.GetValues(typeof(ObjectTypes)).Length - 1);
        Dictionary<int, GameObject> _wallCutsButtons = 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 = 4f;
        [SerializeField] float _minFontSize = 3f;
        public float MinFontSize { get { return _minFontSize; } }
        public float FontSize { get { return _fontSize; } }

        [Header("Shader Settings")]
        [SerializeField] Shader _outlineShader;
        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.5f;
        public float LineWidth { get { return _lineWidth; } }
        [SerializeField] float _smallBuffer = 0.062f;
        float _wallHeight = 0f;
        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);
        }
        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();
            }

            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();
        }
        
        //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);

            print("_islandCenterPosition===="+_islandCenterPosition);

            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;
            }
        }
        #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 Close2DPlan()
        {
            _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);

            _isOpen = false;
            //DASH.HDsetBTNcolor(_isHD);
            //DASH.HDsetBTNcolor(false);
            
            // 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.HDsetBTN();
        }
        public GameObject GetTextInstance()
        {
            GameObject TextObject = _textPool.Get();
            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 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);

            RefreshPlan2D();
            //Debug.Log(_G.SM);
            float Scale=_camera.orthographicSize/150;
            CAPS.SHOW_TOP(true,Scale);
            //CAPS.SHOW_FRONT(true);

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

            if (!_active) return;
            ClearAllData();
            GetReferences();
            if (_showIslandElevation)
            {
                HandleIslandElevation();
                HideCountertop();
                return;
            }
            if (_showWallElevation)
            {
                HandleWallElevation();
                HideCountertop();
                return;
            }
            HandleTopView();
            HideCountertop();

        }

        private void HandleTopView()
        {
            ZoomSettings settings = DrawGround();
            SetPlanNavigationnOverlayActive(true);
            DisplayLineToScreen(settings);
        }

        private void HandleWallElevation()
        {
            ZoomSettings settings = DrawWall();
            SetPlanNavigationnOverlayActive(true);
            ShowWallCut(settings);
        }
        private void HandleIslandElevation()
        {
            CreateCabIsIslandList();
            SetIslandCameraActive(true);
            HideNonIslandObjects();
            float upperScreenPos, downScreenPos;
            _ = new List<Vector3>() { };
            List<Vector3> islandBoundsCorner;
            CreateIslandBounds(out upperScreenPos, out downScreenPos, out islandBoundsCorner);
            CreateIslandElevationLines(_front, islandBoundsCorner, upperScreenPos, downScreenPos);
            CreateIslandElevationLines(_back, islandBoundsCorner, upperScreenPos, downScreenPos);
            CreateIslandElevationLines(_right, islandBoundsCorner, upperScreenPos, downScreenPos);
            CreateIslandElevationLines(_left, islandBoundsCorner, upperScreenPos, downScreenPos);
            DisplayLines();
            SetPlanNavigationnOverlayActive(false);
        }
        private void HideNonIslandObjects()
        {
            AllSceneObjectFalse();
            foreach(GameObject obj in ShowCabsIsland){
                obj.SetActive(true);
            }
        }
        private void ShowWallCut(GameObject btn,GameObject wall,float wallWideness)
        {
            CreateCabIsFrontList(btn,wall.transform.position,wallWideness);
            AllSceneObjectFalse();
            _selectedWallForElevation = wall;
            _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 Vector3(_G.WallsPointStart[wallIndex].x, -_wallHeight, _G.WallsPointStart[wallIndex].y),
                new Vector3(_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 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();


            // 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);
            }
        }
        
        //SHOW ELEVATIONS ======================================================================================SHOW ELEVATIONS     
        private void ShowWallCut(ZoomSettings zoomSettings)
        {
            int wallIndex = int.Parse(_selectedWallForElevation.name[1..]) - 1;
            print("ShowWallCut wall=="+wallIndex+1);
            float wallWideness = _G.WallsWidth[wallIndex];
            Vector3 direction = _selectedWallForElevation.transform.forward;
            Vector2 wallCenterPosition = _G.WallsPointCenter[wallIndex];
            Vector3 startingPointWall = new Vector3(wallCenterPosition.x, _wallHeight, wallCenterPosition.y) - wallWideness * 0.5f * _selectedWallForElevation.transform.right;
            Vector3 endingPointWall = startingPointWall + wallWideness * _selectedWallForElevation.transform.right;  // Get nextPoint of wall by offseting by measure wide _G.wW[i]
            float distanceFromWall = _distanceFromWallForObjects;
            float wallThickness = _wallThickness;
            Vector3 pointOfViewWall = _selectedWallForElevation.transform.position + distanceFromWall * -direction;
            Vector3 pointBehindWall = _selectedWallForElevation.transform.position + wallThickness * direction;

            // Hide all  walls
            foreach (var w in _walls)
            {
                w.SetActive(false);
            }
            
            //Objects
            Dictionary<int, List<GameObject>> list = new();
            AllSceneObjectFalse();
            foreach(GameObject objet in ShowCabs){
                objet.SetActive(true);
            }

            foreach(GameObject Object in ShowCabs){

                int ADN = Get.GetObjectIndex(Object.name);    
                string[] data = _G.OBJs[ADN];
                int objectType = (int)GetObjectTypeByModel(data,"Wall");
                if (!list.ContainsKey(objectType)){
                    list.Add(objectType, new List<GameObject>());
                }
                list[objectType].Add(Object);
            }


            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
            };


            //hide all object not related to this wall
            foreach (Transform c in _scene.transform) //
            {
                if (_G.HIDELIST.Contains(c.name)) {continue;}
                if(!ShowCabs.Contains(c.gameObject)){continue;}
                //Debug.Log($"object in scene check : {c.name} ; is hidden : {_G.HIDELIST.Contains(c.name)}");

                int On = Get.GetObjectIndex(c.name);
                string[] data = _G.OBJs[On];
                string attachTo = data[22];
                int objectType = (int)GetObjectType(data, attachTo);


                if (objectType == (int)ObjectTypes.Null)
                {
                    GameObject OgeeSet = Get.o2("OgeeContainer", "OgeeSet" + c.gameObject.name);
                    if (OgeeSet != null) { OgeeSet.SetActive(false); }
                    continue;
                }

                if (attachTo == _selectedWallForElevation.name)
                {
                    if (!list.ContainsKey(objectType))
                    {
                        list.Add(objectType, new List<GameObject>());
                    }
                    list[objectType].Add(c.gameObject);
                }
                else
                {
                    if (IsInFrontOfWall(_selectedWallForElevation, pointOfViewWall, pointBehindWall, c.gameObject))
                    {
                        Vector3 leftmostScreenPos1 = Vector3.zero;
                        Vector3 rightmostScreenPos1 = Vector3.zero;
                        List<Vector3> corners2 = GetObjectBounds(c.gameObject);
                        GetLeftmostAndRightmostPositions(corners2, startingPointWall, endingPointWall, ref leftmostScreenPos1, ref rightmostScreenPos1);
                        float distanceFromLeft = Vector3.Distance(startingPointWall, GetPositionOnLine(rightmostScreenPos1, startingPointWall, endingPointWall));
                        float distanceFromRight = Vector3.Distance(endingPointWall, GetPositionOnLine(leftmostScreenPos1, startingPointWall, endingPointWall));
                        if (distanceFromLeft > _smallBuffer && distanceFromRight > _smallBuffer)
                        {
                            if (!list.ContainsKey(objectType))
                            {
                                list.Add(objectType, new List<GameObject>());
                            }

                            list[objectType].Add(c.gameObject);

                            continue;
                        }
                    }
                    if(!ShowCabs.Contains(c.gameObject))c.gameObject.SetActive(false);
                    GameObject OgeeSet = Get.o2("OgeeContainer", "OgeeSet" + c.gameObject.name);
                    if (OgeeSet != null) { OgeeSet.SetActive(false); }
                }
            }

            for (int i = 0; i < corners.Count; i++)
            {
                if (i == 1) continue;

                Vector3 startingPoint = corners[i];
                Vector3 endingPoint = corners[i + 1 >= corners.Count ? 0 : i + 1];

                Vector3 offsetDirection = GetOffsetDirection(startingPoint, endingPoint, _selectedWallForElevation.transform.position);

                string measure = DOIT.ConvertNumberToString(Vector3.Distance(startingPoint, endingPoint));
                LineDisplay lineDisplay = new(_camera,
                                                -1,
                                                startingPoint,
                                                endingPoint,
                                                offsetDirection,
                                                measure,
                                                this,
                                                ObjectTypes.Wall,
                                                showWallMeasure: i == 0 || i == corners.Count - 1,
                                                true,
                                                zoomSettings,
                                                objectTypes);
                _wallLines.Add(lineDisplay);

                float distanceFromLine = 12f;
                Vector3 pointOfInsideOfWall = Vector3.Lerp(startingPoint, endingPoint, 0.5f) + distanceFromLine * offsetDirection;

            foreach (var value in list)
                {
                    foreach (GameObject objectInScene in list[value.Key])
                    {
                        if (objectInScene == null)continue;
                        int On = Get.GetObjectIndex(objectInScene.name);
                        string[] data = _G.OBJs[On];

                        print("objectInScene.name===="+objectInScene.name);
                        if (new List<string>(){"frid","stov","hood","dish"}.Contains(objectInScene.name[..4]) && _G.OBJs[On][22]=="floor")continue;

                        Vector3 pointOnline = GetPositionOnLine(objectInScene.transform.position, _selectedWallForElevation.transform.position, pointOfInsideOfWall);

                        //check if object position exist between pointof view wall and wall itself, if yes add line to line renderer

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

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

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

                        Vector3 pointOnLine = GetPositionOnLine(objectPosition, startingPoint, endingPoint);

                        Vector3 middlePoint = Vector3.Lerp(leftmostScreenPos1, rightmostScreenPos1, 0.5f);

                        ObjectTypes objectType = (ObjectTypes)value.Key;// need to get object type

                        bool wallTopWallObject = i == 0 && ((objectType == ObjectTypes.WallObject) || objectType == ObjectTypes.StructuralElements || i == 0 && (data[5] == "TA"));
                        bool floorWallFloorObject = i == corners.Count - 2 && (objectType == ObjectTypes.FloorObject);

                        if (wallTopWallObject || floorWallFloorObject)
                        {
                            lineDisplay.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, objectType);
                        }
                        else if (i == corners.Count - 1 && objectType != ObjectTypes.StructuralElements)
                        {
                            lineDisplay.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.Null);
                        }
                        else if (i == corners.Count - 1 && objectType == ObjectTypes.StructuralElements)
                        {
                            lineDisplay.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, ObjectTypes.StructuralElements);
                        }
                    }
                }
            }
            DisplayLines();
        }
        public void ShowIslandCut()
        {
            _showIslandElevation = true;
            RefreshPlan2D();
        }
        void CreateIslandElevationLines(Camera camera, List<Vector3> islandCorners, float upper, float lower)
        {
            print("_objectsInScene[ObjectTypes.IslandObject][0]====1==="+_objectsInScene[ObjectTypes.IslandObject][0]);
            if (_objectsInScene.ContainsKey(ObjectTypes.IslandObject) && _objectsInScene[ObjectTypes.IslandObject].Count > 0)
            {

                print("_objectsInScene[ObjectTypes.IslandObject][0]====2==="+_objectsInScene[ObjectTypes.IslandObject][0]);
                Vector3 upDirection = camera.transform.up;
                Vector3 rightDirection = camera.transform.right;
                Vector3 cameraPos = camera.transform.position;
                Vector3 left = Vector3.zero;
                Vector3 right = Vector3.zero;

                GetLeftmostAndRightmostForCameraView(camera, islandCorners, out left, out 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());
                zoomSettings.ResizeCamera();

                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,
                                                    zoomSettings,
                                                    objectTypes
                                                    );
                    _islandLines.Add(lineDisplay);

                    if (_objectsInScene[ObjectTypes.IslandObject].Count > 1)
                    {
                        foreach (GameObject objectInScene in _objectsInScene[ObjectTypes.IslandObject])
                        {
                            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);
                            }
                        }
                    }
                }
            }
        }
        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 _objectsInScene[ObjectTypes.IslandObject])
            {
                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;
                }
            }

            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(GameObject btn,GameObject Wall,float WallWide){
            Vector3 BtnPosition=new(btn.transform.position.x,0,btn.transform.position.z);
            Vector3 Direction=(Wall.transform.position-btn.transform.position).normalized;
            float detectionRange =40;
            float boxWidth = WallWide-4; 
            float boxHeight = _G.HEIGHT;

            Vector3 boxCenter = BtnPosition + Direction * (detectionRange / 2);
            Vector3 boxSize = new (boxWidth, boxHeight, detectionRange);
            Quaternion rot=btn.transform.rotation* Quaternion.Euler(-90, 0, 0);
            Collider[] objects = Physics.OverlapBox(boxCenter, boxSize / 2, rot);

            foreach (Collider obj in objects)
            {
                if(obj.name.Length>4)
                {
                    if (obj.name.Length>4 && new List<string>(){"cabi","door","open","pati","frid","stov","hood","wind","dish"}.Contains(obj.name[..4]))
                    {
                        return true;
                    }
                }
            }
            return false;
        }
        private void CreateCabIsFrontList(GameObject btn,Vector3 WallPosition,float WallWide){
            ShowCabs=new(){};
            Vector3 BtnPosition=new(btn.transform.position.x,0,btn.transform.position.z);
            Vector3 Direction=(WallPosition-BtnPosition).normalized;
            float detectionRange =40;
            float boxWidth = WallWide-4; 
            float boxHeight = _G.HEIGHT;

            Vector3 boxCenter = BtnPosition + Direction * (detectionRange / 2);
            Vector3 boxSize = new(boxWidth, boxHeight, detectionRange);
            Quaternion rot=btn.transform.rotation* Quaternion.Euler(-90, 0, 0);
            Collider[] objects = Physics.OverlapBox(boxCenter, boxSize / 2, rot);

            foreach (Collider obj in objects)
            {
                // Compare the object's name
                if(obj.name.Length>4)
                {
                    if (obj.name.Length>4 && new List<string>(){"cabi","door","open","pati","frid","stov","hood","wind","dish"}.Contains(obj.name[..4]))
                    {
                        Debug.Log($"Object detected: {obj.name}");
                        ShowCabs.Add(obj.gameObject);
                    }
                }
            }

            // Store Gizmo parameters for drawing
                drawGizmo = true;
                gizmoCenter = boxCenter;
                gizmoSize = boxSize;
                gizmoRotation = rot;

                print("btn.transform.rotation======"+btn.transform.eulerAngles);//0.70711, 0.00000, 0.00000, 0.70711)
        }
        private void CreateCabIsIslandList(){
            ShowCabsIsland=new(){};
            //Create list of Wall Box

            //Show All potentiial object
            foreach (Transform c in _scene.transform)  
            {
                if(IsPlan2D(c.name))
                {
                    c.gameObject.SetActive(true);
                }
            }

            List<GameObject> WallBoxes =new(){};
            foreach(string Wall in _G.ExteriorWalllist){
                int Wn=int.Parse(Wall[1..]);
                Vector3 boxCenter = new(_G.WallsPointCenter[Wn-1].x,0,_G.WallsPointCenter[Wn-1].y);
                float WallWide = _G.WallsWidth[Wn-1];
                float WallAngle = _G.WallsAngle[Wn-1];
                Vector3 boxSize=new(WallWide,_G.HEIGHT,72);
                Quaternion rot = Quaternion.Euler(0, WallAngle, 0);
                Collider[] objects = Physics.OverlapBox(boxCenter, boxSize / 2, rot);
                drawGizmo = true;
                gizmoCenter = boxCenter;
                gizmoSize = boxSize;
                gizmoRotation = rot;
                foreach (Collider Obj in objects)
                    {
                        print("  WallBoxes.Add==="+Obj.name);
                        WallBoxes.Add(Get.o1(Obj.name));
                    }

                
                
            }

            foreach(Transform Obj in _scene.transform){
                if (Obj.name.Length>4 && new List<string>(){"cabi","door","open","pati","frid","stov","hood","wind","dish"}.Contains(Obj.name[..4]) ){
                    print("  ShowCabsIsland.Add==="+Obj.gameObject.name);
                    ShowCabsIsland.Add(Obj.gameObject);
                }
            }

            foreach (GameObject Obj in WallBoxes){
                print("  ShowCabsIsland.Remov==="+Obj.name);
                ShowCabsIsland.Remove(Obj);
            }

            foreach (GameObject Obj in ShowCabsIsland){
                ObjectTypes objectType = ObjectTypes.IslandObject;
                if (!_objectsInScene.ContainsKey(objectType))
                    {
                        _objectsInScene.Add(objectType, new());
                    }
                if(!_objectsInScene[objectType].Contains(Obj)){
                    print(" in _objectsInScene==="+Obj.gameObject.name);
                    _objectsInScene[objectType].Add(Obj);
                }
            }
        }
        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 startingPoint = new Vector3(wallCenterPosition.x, _wallHeight, wallCenterPosition.y) - wallWideness * 0.5f * wall.transform.right;
                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);
                // from a point of reference in front of wall, check z buffer to decide what measure to add to that wall 
                //36""
                float distanceFromWall = _distanceFromWallForObjects;
                float wallThickness = _wallThickness;
                Vector3 pointOfViewWall = wall.transform.position + distanceFromWall * -direction;
                Vector3 pointBehindWall = wall.transform.position + wallThickness * direction;

                Button btn = AddButton(i, direction, pointOfViewWall, "W" + (wallIndex + 1).ToString());
                _wallCutButtons.Add(btn);
                _wallLines.Add(lineDisplay);
                btn.onClick = new Button.ButtonClickedEvent();
                btn.onClick.AddListener(new UnityAction(() => ShowWallCut(btn.gameObject,wall,wallWideness)));

                if(!HaveFrontCab(btn.gameObject,wall,wallWideness)){
                    btn.gameObject.SetActive(false);
                    Destroy(btn.gameObject);
                    }
                else{
                    //lineDisplay.AddButton(btn);
                    //lineDisplay._onButtonHide += RemoveButtonFromWallCutList;
                    btn.gameObject.SetActive(true);
                }

                // btn.gameObject.SetActive(true);
                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, pointOfViewWall, pointBehindWall, objectInScene))
                        {
                            Vector3 objectPosition, leftmostScreenPos1, rightmostScreenPos1;
                            objectPosition = objectInScene.transform.position;
                            if (IsOnWall(startingPoint, endingPoint, objectInScene, out leftmostScreenPos1, out 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)j;
                                lineDisplay.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, objectType);
                            }
                        }
                    }
                }
            }

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

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

                foreach (GameObject objectInScene in ShowCabsIsland)
                {
                    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;
                        }
                    }
                }
                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; // 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.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);

                    if (_objectsInScene[ObjectTypes.IslandObject].Count > 1)
                    {
                        foreach (GameObject objectInScene in _objectsInScene[ObjectTypes.IslandObject])
                        {
                            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;
                            lineDisplay.AddMeasure(leftmostScreenPos1, rightmostScreenPos1, objectType);
                        }
                    }
                }
            }
            DisplayLines();
        }
        private void RemoveButtonFromWallCutList(Button button)
        {
            _wallCutButtons.Remove(button);
        }
        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"}.Contains(c.name[..4])){
                    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;
                }
                //Debug.Log($"object in scene check : {c.name} ; is hidden : {_G.HIDELIST.Contains(c.name)}");

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

                //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(data, 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)
        {
            GameObject btnObject = Instantiate(Get.o2("HIDER", "WEbtn"));
            btnObject.SetActive(true);
            btnObject.transform.localScale= new(0.2f,0.2f,1f);
            btnObject.transform.position = position;
            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);
            _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.FloorObject;
                }
                switch(obj){
                    case "Patio":
                    case "Opening":
                    case "Door":
                    case "Window": 
                    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;
            switch (attachTo)
            {
                case "floor":
                    cabType = data[5];
                    switch (cabType)
                    {
                        case "BA":
                        case "TA":
                        case "CB":
                        case "PNL":
                            return ObjectTypes.IslandObject;
                        case "Gas":
                        case "Plumbing":
                        case "Hood":
                        case "Socket":
                            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 "StructureElements":
                                return ObjectTypes.StructuralElements;
                            case "Panel":
                                return ObjectTypes.WallObject;
                            default:
                                break;
                        }
                    }
                    break;
            }

            return ObjectTypes.Null;
        }
        #region Outline Shader
        public void EnableOutlinePostProcess(bool enabled)
        {
            //bool camPostprocess =_camera.GetComponent<UniversalAdditionalCameraData>().renderPostProcessing;
            // SwitchMaterial(enabled);

            if (enabled == _active) return;

            _active = enabled;

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

            if (enabled)
            {
                int current = QualitySettings.GetQualityLevel();
                _savedQualitySettings = current == 0 ? _savedQualitySettings : current;
                QualitySettings.SetQualityLevel(2, true);
                QualitySettings.antiAliasing = 0;
            }
            else
            {
                QualitySettings.SetQualityLevel(_savedQualitySettings, true);
                QualitySettings.antiAliasing = 8;
            }

            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);
            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");

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

            Create3D._resizeCommand = new ResizeRoomCommand();

            DOIT.CloseALLPNLONLY();
            Camera cam = Camera.main;
            CameraAround.Show();
            foreach (Transform obj in SceneModeManager.Room)
            {
                obj.gameObject.SetActive(true);
            }


            //GameObject.Find("PLAN2D").transform.Find("CanvasPlan").gameObject.SetActive(false);
            //cam.transform.position = new Vector3(0, 0, -150);
            //cam.transform.localRotation = Quaternion.Euler(0, 0, 0);
            //cam.GetComponent<Camera>().orthographic = false;
            //GameObject.Find("Canvas").gameObject.GetComponent<Canvas>().enabled = true;
            //GameObject.Find("PLAN2D").transform.Find("PLAN").gameObject.SetActive(false);

            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("BackPlan2D").gameObject.SetActive(false);
            panelDrawPlan.transform.Find("CeilingHeight/MCe/mCe").GetComponent<Text>().text = DOIT.ConvertNumberToString(_G.HEIGHT);

            //var roomDesign = panelDrawPlan.transform.Find("ChooseRoomDesign");

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

            ReflectionProbesUpdater.OnOff.SetActive(true);
            //cam.backgroundColor = DOIT.CSc("A1A1A1", 255);//A1A1A1
            //cam.cullingMask &= ~(1 << LayerMask.NameToLayer("Plan2D"));
            //cam.cullingMask |= 1 << LayerMask.NameToLayer("Default");
            //QualitySettings.antiAliasing = 2;
            //SetDefaultCamera();
            //_G.CAMSET = "FRONT";

            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"}.Contains(ObjectName[..4]) ) {return true;}
        return false;
        }

        public void HideCountertop()
        {
            print("HideCountertop==="+_showIslandElevation );
            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);}
                } 
            }
        }
    }
}