using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
//using Habrador_Computational_Geometry;
using UnityEngine;
using UnityEngine.UI.Extensions;

public class RoomCreation : MonoBehaviour
{
    static private RoomCreation _instance;

    //[SerializeField] private Transform _roomContainer;
    //[SerializeField] private Transform _sceneContainer;

    private List<Vector2> _pointPositions = new();
    private List<Vector2Int> _wallIndexPairs = new();

    private const float _presetRoomSize = 192.0f;
    private const float _presetRoomHeight = 96.0f;

    private Vector3 _roomPosition;
    private float _roomHeight = _presetRoomHeight;

    private void Awake()
    {
        if (_instance != null && _instance != this)
        {
            Destroy(gameObject);
            return;
        }
        else
        {
            _instance = this;
        }
    }

    private void CreateRoom2D(List<WallLineData> lineData = null, List<WallPointData> pointsData = null)
    {
        print("---------------------------------------------CreateRoom2D");

        _G.isExteriorWall = true;
        RectTransform wallLineContainer = WallCreationManager.GetWallLineContainer();
        RectTransform wallPointContainer = WallCreationManager.GetWallPointContainer();

        //Clear wall LINE
        for (int i = wallLineContainer.childCount - 1; i >= 0; i--)
        {
            Transform wallTransform = wallLineContainer.GetChild(i);
            wallTransform.GetComponent<WallLine>().DestroyWall();
            wallTransform.SetParent(WallCreationManager.GetDeletionContainer());
        }

        // Clear wall POINTS
        for (int i = wallPointContainer.childCount - 1; i >= 0; i--)
        {
            Transform pointTransform = wallPointContainer.GetChild(i);
            pointTransform.GetComponent<WallPoint>().DestroyPoint();
            pointTransform.SetParent(WallCreationManager.GetDeletionContainer());
        }

        List<WallPoint> points = new();
        int j = 0;
        foreach (Vector2 pointPosition in _pointPositions)
        {
            if (pointsData != null)
            {
                points.Add(WallCreationManager.CreatePoint(pointsData[j]));
            }
            else
            {
                points.Add(WallCreationManager.CreatePoint(pointPosition));
            }
            j++;
        }
        j = 0;

        print("_wallIndexPairs========"+_wallIndexPairs.Count);

        foreach (Vector2Int wallIndexPair in _wallIndexPairs)
        {
            print("wallIndexPair====="+wallIndexPair);
            if (lineData != null)
            {
                WallCreationManager.CreateLine(points[lineData[j].pointPair.x], points[lineData[j].pointPair.y], lineData[j]);
            }
            else
            {
                WallCreationManager.CreateLine(points[wallIndexPair.x], points[wallIndexPair.y]);
            }
            j++;
        }

        points.Clear();
        _G.isExteriorWall = false;
    }

    public void CreatePlan2D()
    {
        _G.Down = false;
        _G.Open = true;
        _G.WIDE = 192;
        _G.DEPTH = 168;
        _G.HEIGHT = 96;
        _G.closingWall = 1;
        _G.NW = 1;
        _G.WallsPointStart = new(new Vector2[24]);
 
        print("CreateRoomPreset======"+_G.ROOM);
        CreateRoomPreset(int.Parse(_G.ROOM[1..]));
        print("CreateRoomPreset======"+_G.ROOM);
    }


    public void CreateRoomPreset(RoomTypes roomType)
    {
        print("CreateRoomPreset======"+roomType);
        // TODO : clear undo redo?
        _G.WALLS_HIDDEN_LIST = new();
        _pointPositions.Clear();
        _wallIndexPairs.Clear();

        _roomHeight = _presetRoomHeight;
        Vector2 halfScreen = WallCreationManager.GetWallLineContainer().anchoredPosition; // TODO : use canvas size? also change elsewhere in scripts
        float halfRoomSize = _presetRoomSize; // / 2.0f;
        _G.EXTERIOR_WALL_PLAN_CLOSED = true;
        switch (roomType)
        {
            case RoomTypes.Empty_RDRAW:
                _G.EXTERIOR_WALL_PLAN_CLOSED = false;
                break;
            case RoomTypes.Square_R1:
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                _wallIndexPairs.Add(new Vector2Int(2, 3));
                _wallIndexPairs.Add(new Vector2Int(3, 0));
                break;
            case RoomTypes.L_Shaped_Right_R4:
                _pointPositions.Add(new Vector2(halfRoomSize / 3.0f, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize / 3.0f, halfRoomSize / 3.0f) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize / 3.0f) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                _wallIndexPairs.Add(new Vector2Int(2, 3));
                _wallIndexPairs.Add(new Vector2Int(3, 4));
                _wallIndexPairs.Add(new Vector2Int(4, 5));
                _wallIndexPairs.Add(new Vector2Int(5, 0));
                break;
            case RoomTypes.L_Shaped_Left_R5:
                _pointPositions.Add(new Vector2(-halfRoomSize / 3.0f, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize / 3.0f) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize / 3.0f, halfRoomSize / 3.0f) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                _wallIndexPairs.Add(new Vector2Int(2, 3));
                _wallIndexPairs.Add(new Vector2Int(3, 4));
                _wallIndexPairs.Add(new Vector2Int(4, 5));
                _wallIndexPairs.Add(new Vector2Int(5, 0));
                break;
            case RoomTypes.Corner_Angled_Right_R2:
                _pointPositions.Add(new Vector2(halfRoomSize / 3.0f, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize / 3.0f) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                _wallIndexPairs.Add(new Vector2Int(2, 3));
                _wallIndexPairs.Add(new Vector2Int(3, 4));
                _wallIndexPairs.Add(new Vector2Int(4, 0));
                break;
            case RoomTypes.Corner_Angled_Left_R3:
                _pointPositions.Add(new Vector2(-halfRoomSize / 3.0f, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize / 3.0f) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                _wallIndexPairs.Add(new Vector2Int(2, 3));
                _wallIndexPairs.Add(new Vector2Int(3, 4));
                _wallIndexPairs.Add(new Vector2Int(4, 0));
                break;
            case RoomTypes.U_Shaped_R6:
                _pointPositions.Add(new Vector2(halfRoomSize / 3.0f, halfRoomSize / 2.0f) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize / 3.0f, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize / 3.0f, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize / 3.0f, halfRoomSize / 2.0f) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                _wallIndexPairs.Add(new Vector2Int(2, 3));
                _wallIndexPairs.Add(new Vector2Int(3, 4));
                _wallIndexPairs.Add(new Vector2Int(4, 5));
                _wallIndexPairs.Add(new Vector2Int(5, 6));
                _wallIndexPairs.Add(new Vector2Int(6, 7));
                _wallIndexPairs.Add(new Vector2Int(7, 0));
                break;
            case RoomTypes.Podium_R10:
                _pointPositions.Add(new Vector2(halfRoomSize / 3.0f, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize / 3.0f, halfRoomSize / 3f) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize / 3f) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize / 1.5f) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize / 3.0f, halfRoomSize / 1.5f) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize / 3.0f, halfRoomSize) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                _wallIndexPairs.Add(new Vector2Int(2, 3));
                _wallIndexPairs.Add(new Vector2Int(3, 4));
                _wallIndexPairs.Add(new Vector2Int(4, 5));
                _wallIndexPairs.Add(new Vector2Int(5, 6));
                _wallIndexPairs.Add(new Vector2Int(6, 7));
                _wallIndexPairs.Add(new Vector2Int(7, 0));
                break;
            case RoomTypes.Bump_R9:
                _pointPositions.Add(new Vector2(halfRoomSize / 3.0f, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize / 1.5f, halfRoomSize / 1.5f) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize / 1.5f) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize / 1.5f) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize / 1.5f, halfRoomSize / 1.5f) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize / 3.0f, halfRoomSize) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                _wallIndexPairs.Add(new Vector2Int(2, 3));
                _wallIndexPairs.Add(new Vector2Int(3, 4));
                _wallIndexPairs.Add(new Vector2Int(4, 5));
                _wallIndexPairs.Add(new Vector2Int(5, 6));
                _wallIndexPairs.Add(new Vector2Int(6, 7));
                _wallIndexPairs.Add(new Vector2Int(7, 0));
                break;
            case RoomTypes.Open_Corner_R8: // TODO : use square room with seperators
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                break;
            case RoomTypes.Open_Bottom_R7: // TODO : use square room with seperators
                _pointPositions.Add(new Vector2(-halfRoomSize, -halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(-halfRoomSize, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, halfRoomSize) + halfScreen);
                _pointPositions.Add(new Vector2(halfRoomSize, -halfRoomSize) + halfScreen);

                _wallIndexPairs.Add(new Vector2Int(0, 1));
                _wallIndexPairs.Add(new Vector2Int(1, 2));
                _wallIndexPairs.Add(new Vector2Int(2, 3));
                break;
            case RoomTypes.FreeHandDraw:
                _G.EXTERIOR_WALL_PLAN_CLOSED = false;
                break;
            default:
                break;
        }
        _G.NW = 0;
        _G.NWExterior = 0;
        _G.NWInterior = 0;

        CreateRoom2D();
    }

    public void CreateRoomPreset(GameObject button)
    {
        CreateRoomPreset(button.name);
    }
    public void CreateRoomPreset(string objectName)
    {
        RoomTypes roomType = RoomTypes.Empty_RDRAW;
        if (int.TryParse(objectName[1..], out int enumIndex))
        {
            roomType = (RoomTypes)enumIndex;
        }

        CreateRoomPreset(roomType);
    }
    public void CreateRoomPreset(int roomNumber)
    {
        RoomTypes roomType = (RoomTypes)roomNumber;

        CreateRoomPreset(roomType);
    }
    static public void CreateRoomPreset()
    {
        _instance.CreateRoomPreset(RoomTypes.Square_R1);
    }

    public void CreateRoomPresetEmpty()
    {
        CreateRoomPreset(RoomTypes.Empty_RDRAW);
    }

    public void CreateRoomPresetSquare()
    {
        CreateRoomPreset(RoomTypes.Square_R1);
    }

    public void CreateRoomPresetCornerAngledRight()
    {
        CreateRoomPreset(RoomTypes.Corner_Angled_Right_R2);
    }

    public void CreateRoomPresetCornerAngledLeftt()
    {
        CreateRoomPreset(RoomTypes.Corner_Angled_Left_R3);
    }

    public void CreateRoomPresetLShapedRight()
    {
        CreateRoomPreset(RoomTypes.L_Shaped_Right_R4);
    }

    public void CreateRoomPresetLShapedLeft()
    {
        CreateRoomPreset(RoomTypes.L_Shaped_Left_R5);
    }

    public void CreateRoomPresetUShaped()
    {
        CreateRoomPreset(RoomTypes.U_Shaped_R6);
    }

    public void CreateRoomPresetPodium()
    {
        CreateRoomPreset(RoomTypes.Podium_R10);
    }

    public void CreateRoomPresetBump()
    {
        CreateRoomPreset(RoomTypes.Bump_R9);
    }

    public void CreateRoomPresetOpenCorner()
    {
        CreateRoomPreset(RoomTypes.Open_Corner_R8);
    }

    public void CreateRoomPresetOpenBottom()
    {
        CreateRoomPreset(RoomTypes.Open_Bottom_R7);
    }

    // temporary for quick integration
    // static public void CreateRoomTo3D()
    // {
    //     _instance.CreateRoom3D();
    // }
    // temporary for quick integration

    // public void CreateRoom3D()
    // {
    //     RectTransform wallContainer = WallCreationManager.GetWallLineContainer();
    //     //_G.ROOM = "RDRAW";

    //     _G.FloorPoints=new List<Vector3>[1];
    //     _G.FloorPoints[0]=new(){};
    //     Vector3 floorNormal = Vector3.zero; 

    //     bool isRoomCounterClockwise = floorNormal.z > 0;
    //     if (isRoomCounterClockwise)
    //     {
    //         List<RectTransform> wallTransforms = new();
    //         foreach (RectTransform item in wallContainer)
    //         {
    //             wallTransforms.Add(item);
    //             WallLine wallLine = item.GetComponent<WallLine>();
    //             wallLine.InitPoints(wallLine._pointEnd, wallLine._pointStart);
    //         }

    //         wallTransforms.Reverse();
    //         for (int i = 0; i < wallTransforms.Count; i++)
    //         {
    //             wallTransforms[i].SetSiblingIndex(i);
    //         }
    //     }
    //     _G.WallAssociateWallLine.Clear();
    //     _G.WallsWidth.Clear();
    //     _G.WallsPointCenter.Clear();
    //     _G.WallsPointStart.Clear();
    //     _G.WallsAngle.Clear();
    //     _G.WallsDirection.Clear();

    //     GameObject colliderObject = new();
    //     Collider collider = colliderObject.AddComponent<BoxCollider>();
    //     int wallIndex = 0;

    //     float MinX=0;
    //     float MaxX=0;
    //     float MinY=0;
    //     float MaxY=0;

    //     foreach (RectTransform item in wallContainer)
    //     {
    //         if (item.gameObject.GetComponent<WallLine>()._category == "Exterior")
    //         {
    //             WallLine wallLine = item.GetComponent<WallLine>();
    //             RectTransform colliderRectTransform = wallLine.GetColliderTransform();

    //             WallPoint startPoint, endPoint;
    //             WallLineInfo wallInfo;
    //             bool connectToPrevious, connectToNext;

    //             WallLine.CreateWallInfo(wallLine, out startPoint, out endPoint, out wallInfo, out connectToPrevious, out connectToNext);
    //             _G.WallAssociateWallLine.Add("w" + (wallIndex + 1) + "_" + wallIndex);
   
    //             _G.WallsWidth.Add(Vector3.Distance(wallInfo.frontProjectionStart, wallInfo.frontProjectionEnd));
    //             float wallThickness = 0.0f; //rectTransform.sizeDelta.y / WallLine.RatioWorldToScreen; // TODO : implementation
    //             Vector3 centerPoint = Vector3.Lerp(wallInfo.frontProjectionStart, wallInfo.frontProjectionEnd, 0.5f);
    //             _G.WallsPointCenter.Add(new Vector2(centerPoint.x, centerPoint.z));
    //             Vector3 pointStart = wallInfo.frontProjectionStart;
    //             _G.WallsPointStart.Add(new Vector2(pointStart.x, pointStart.z));
    //             _G.WallsAngle.Add(Mathf.Repeat(Vector2.SignedAngle(wallLine._pointEnd.GetWorldPosition() - _G.WallsPointStart[wallIndex], Vector2.right), 360.0f));
    //             _G.WallsDirection.Add(Mathf.RoundToInt(_G.WallsAngle[wallIndex] / 45.0f) % 8 + 1);

    //             Vector3 position = new(_G.WallsPointCenter[wallIndex].x, 0.0f, _G.WallsPointCenter[wallIndex].y);
    //             collider.transform.SetPositionAndRotation(position, Quaternion.AngleAxis(_G.WallsAngle[wallIndex], Vector3.up));
    //             collider.transform.localScale = new Vector3(_G.WallsWidth[wallIndex], _G.HEIGHT, wallThickness);

    //             if(pointStart.x<MinX)MinX=pointStart.x;
    //             if(pointStart.x>MaxX)MaxX=pointStart.x;
    //             if(pointStart.z<MinY)MinY=pointStart.z;
    //             if(pointStart.z>MaxY)MaxY=pointStart.z;

    //             wallIndex++;
    //             wallLine.name = $"WallLine{wallIndex}";
    //         }
    //     }
    //     _G.NW = wallIndex;//wallContainer.childCount;//wallIndex;
    //     _G.NWExterior = wallIndex;
    //     _G.NWInterior = 0;
    //     _G.WIDE = MaxX-MinX;
    //     _G.DEPTH = MaxY-MinY;

    //     Vector2 centerOffsetWalls = new( (MaxX+MinX)*0.5f, (MaxY+MinY)*0.5f );

    //     for (int i = 0; i < _G.NWExterior; i++)
    //     {
    //         _G.WallsPointCenter[i] -= centerOffsetWalls;
    //         _G.WallsPointStart[i] -= centerOffsetWalls;
    //         WallLine wallLine = WallCreationManager.GetWallLineWithWallIndex(i);
    //         wallLine.LineInfo.ApplyOffset(centerOffsetWalls);
    //     }
    //     _G.RoomOffset = new(-centerOffsetWalls.x, 0, -centerOffsetWalls.y);
    //     // foreach (Transform item in _sceneContainer)
    //     // {
    //     //     if (item.gameObject.TryGetComponent(out WallLine wallLine))
    //     //     {
    //     //         if (wallLine._category == "Exterior")
    //     //         {
    //     //             //item.position += _G.RoomOffset;
    //     //             //DOIT.SaveObjectPositionInData(item);
    //     //         }
    //     //     }
    //     // }

    //     _roomPosition = _G.RoomOffset;

    //     //print("_G.RoomOffset====="+_G.RoomOffset);

    //     //Exterior Walls
    //     //Create3D.CreateRoom();
    //     //Interior Walls
    //     //CreateInteriorWalls.InteriorWall();
    //     //ConstructOpen.RedrawOpen();
    //     Destroy(collider.gameObject);
    //     SaveRoomRecipeVariables();
    //     //Set.WallColorQueueRenderingAllWalls();
    //     //ReflectionProbesUpdater.ReflectionProbeNormal.size = new(_G.WIDE + 1+_G.RoomOffset.x, _G.HEIGHT + 1, _G.DEPTH + 1+_G.RoomOffset.z);
    // }

    // Vector3 GetCentroid(Vector3[] points)
    // {
    //     Vector3 centroid = Vector3.zero;
    //     float maxX=0;
    //     float minX=0;
    //     float maxZ=0;
    //     float minZ=0;
    //     foreach (Vector3 point in points)
    //     {
    //         if(maxX<point.x)maxX=point.x;
    //         if(minX>point.x)minX=point.x;
    //         if(maxZ<point.z)maxZ=point.z;
    //         if(minZ>point.z)minZ=point.z;
    //     }
    //     centroid.x = (maxX+minX)*0.5f;
    //     centroid.z = (maxZ+minZ)*0.5f;
    //     return centroid;
    // }

    public static void SaveRoomRecipeVariables()
    {
        RectTransform LineContainer = WallCreationManager.GetWallLineContainer();
        RectTransform PointContainer = WallCreationManager.GetWallPointContainer();
        _G.ExteriorWalllist = new();
        _G.ThicknessyWalllist = new();
        _G.CategoryWalllist = new();
        _G.HeightyWalllist = new();
        for (int i = 0; i < LineContainer.childCount; i++)
        {
            WallLine Wall = LineContainer.GetChild(i).GetComponent<WallLine>();
            if (Wall._category == "Exterior") { _G.ExteriorWalllist.Add("w" + (i + 1).ToString()); }
            _G.CategoryWalllist.Add(Wall._category);
            _G.ThicknessyWalllist.Add(Wall.Thickness);
            //print("Wallnumber==" + "w" + (i + 1).ToString() + "  thickness===" + Wall.Thickness);
        }
        for (int i = 0; i < PointContainer.childCount; i++)
        {
            WallPoint Point = PointContainer.GetChild(i).GetComponent<WallPoint>();
            _G.HeightyWalllist.Add(Point._PointHeight);
        }
    }

    // public void CreateRoom3D_TODO()
    // {
    //     return;

    //     // TODO : delete or repurpose old walls (or use dirty flags from 2D)
    //     foreach (Transform item in _roomContainer)
    //     {
    //         Destroy(item.gameObject);
    //     }

    //     // create room walls
    //     Bounds roomBounds = new();
    //     bool isFirstIteration = true;
    //     RectTransform wallContainer = WallCreationManager.GetWallLineContainer();
    //     foreach (RectTransform item in wallContainer)
    //     {
    //         Transform wallTransform = GameObject.CreatePrimitive(PrimitiveType.Cube).transform;
    //         wallTransform.parent = _roomContainer;

    //         WallLine wallLine = item.GetComponent<WallLine>();
    //         RectTransform colliderRectTransform = wallLine.GetColliderTransform();
    //         Vector3 position = new Vector3(colliderRectTransform.position.x, 0.0f, colliderRectTransform.position.y);
    //         float angle = Vector2.SignedAngle(wallLine._pointEnd.transform.position - wallLine._pointStart.transform.position, Vector2.right); // flipped for Y axis rotation
    //         wallTransform.SetPositionAndRotation(position, Quaternion.AngleAxis(angle, Vector3.up));
    //         Vector2 size = colliderRectTransform.sizeDelta;
    //         wallTransform.localScale = new Vector3(size.x, _roomHeight, size.y);

    //         if (isFirstIteration)
    //         {
    //             roomBounds.center = position;
    //             isFirstIteration = false;
    //         }
    //         roomBounds.Encapsulate(wallTransform.GetComponent<Collider>().bounds);
    //     }

    //     // center room walls
    //     Vector3 centerOffset = roomBounds.center;
    //     foreach (Transform item in _roomContainer)
    //     {
    //         item.position -= centerOffset;
    //     }
    //     roomBounds.center = Vector3.zero;

    //     // create room floor
    //     Transform floorTransform = GameObject.CreatePrimitive(PrimitiveType.Cube).transform;
    //     floorTransform.parent = _roomContainer;
    //     float floorThickness = 0.5f;
    //     floorTransform.position = new Vector3(roomBounds.center.x, -(_roomHeight + floorThickness) / 2.0f, roomBounds.center.z);
    //     floorTransform.localScale = new(roomBounds.size.x, floorThickness, roomBounds.size.z);
    // }

    static public void LoadRoomPlanFromSave(string wallPointPositions, string wallPointPairings)
    {
        _instance._pointPositions.Clear();
        _instance._wallIndexPairs.Clear();

        _instance._roomHeight = _G.HEIGHT;

        if (!string.IsNullOrEmpty(wallPointPositions))
        {
            string[] positions = wallPointPositions.Split(";", System.StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < positions.Length; i++)
            {
                string[] vectorPair = positions[i].Split(",");
                _instance._pointPositions.Add(new Vector2(float.Parse(vectorPair[0]), float.Parse(vectorPair[1])));
            }
        }
        else
        {
            for (int i = 0; i < _G.NWExterior; i++)
            {
                _instance._pointPositions.Add(_G.WallsPointStart[i] * 2.0f);
            }
        }

        if (!string.IsNullOrEmpty(wallPointPairings))
        {
            string[] indexes = wallPointPairings.Split(";", System.StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < indexes.Length; i++)
            {
                string[] vectorPair = indexes[i].Split(",");
                _instance._wallIndexPairs.Add(new Vector2Int(int.Parse(vectorPair[0]), int.Parse(vectorPair[1])));
            }
        }
        else
        {
            int count = _instance._pointPositions.Count;
            for (int i = 0; i < count; i++)
            {
                int indexesCount = _instance._wallIndexPairs.Count;
                _instance._wallIndexPairs.Add(new Vector2Int(indexesCount, (indexesCount + 1) % count));
            }
        }

        _instance.CreateRoom2D();
    }

    static public void SetRoomPlanFromLists(List<WallPointData> wallPointData, List<WallLineData> wallLineData, float roomHeight)
    {
        _instance._pointPositions.Clear();
        _instance._wallIndexPairs.Clear();

        SetRoomHeight(roomHeight);

        _instance._pointPositions.AddRange(wallPointData.Select(point => point._Position).ToList());
        _instance._wallIndexPairs.AddRange(wallLineData.Select(line => line.pointPair).ToList());

        _instance.CreateRoom2D(wallLineData, wallPointData);
    }

    static public void SetRoomHeight(float value)
    {
        _instance._roomHeight = value;
        _G.HEIGHT = value;
    }

    static public void UpdateMeasementSystem()
    {
        Get.o2("Canvas/Panel_DRAWPlan_NEW/CeilingHeight/MCe", "mCe").GetComponent<TMPro.TMP_Text>().text = DOIT.ConvertNumberToString(_G.HEIGHT);
        foreach (RectTransform item in WallCreationManager.GetWallLineContainer())
        {
            item.GetComponent<WallLine>().UpdateInputFieldValue();
        }
    }
}

public enum RoomTypes
{
    Empty_RDRAW,
    Square_R1,
    Corner_Angled_Right_R2,
    Corner_Angled_Left_R3,
    L_Shaped_Right_R4,
    L_Shaped_Left_R5,
    U_Shaped_R6,
    Open_Bottom_R7,
    Open_Corner_R8,
    Bump_R9,
    Podium_R10,
    FreeHandDraw
}