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;

        foreach (Vector2Int wallIndexPair in _wallIndexPairs)
        {

            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 CreateRoomPreset(RoomTypes 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;
        //_G.ExteriorWallPoints = new();

        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
}