using UnityEngine;
using System.Globalization;
using UnityEngine.UI;
using AutoTiling;
using System.Collections;
using System;
using TMPro;
using System.Collections.Generic;

public class DOIT : MonoBehaviour
{
    public static void DeleteAllUIElementsStartingFrom(string path, VisualElementUI firstElement)
    {
        if (firstElement == VisualElementUI.Filters)
        {
            DELETEAllChild("PNL/" + path + "/" + Define.UIElementCategory[VisualElementUI.Filters] + "/Viewport/Content");
        }
        if (firstElement == VisualElementUI.Sub_Filters)
        {
            DELETEAllChild("PNL/" + path + "/" + Define.UIElementCategory[VisualElementUI.Sub_Filters] + "/Viewport/Content");
            DELETEAllChild("PNL/" + path + "/" + Define.UIElementCategory[VisualElementUI.Models] + "/Viewport/Content");
            DELETEAllChild("PNL/" + path + "/" + Define.UIElementCategory[VisualElementUI.TextureColors] + "/Viewport/Content");
        }
        else if (firstElement == VisualElementUI.Models)
        {
            DELETEAllChild("PNL/" + path + "/" + Define.UIElementCategory[VisualElementUI.Models] + "/Viewport/Content");
            DELETEAllChild("PNL/" + path + "/" + Define.UIElementCategory[VisualElementUI.TextureColors] + "/Viewport/Content");
        }
        else if (firstElement == VisualElementUI.TextureColors)
        {
            DELETEAllChild("PNL/" + path + "/" + Define.UIElementCategory[VisualElementUI.TextureColors] + "/Viewport/Content");
        }

    }
    public static void DELETEAllChild(string path)
    {
        GameObject pathGameObject = GameObject.Find(path);
        if (pathGameObject == null) return;

        foreach (Transform obj in pathGameObject.transform)
        {
            obj.gameObject.SetActive(true);
        }

        GameObject PAPA = GameObject.Find(path).gameObject;

        for (int i = PAPA.transform.childCount - 1; i >= 0; i--)
        {
            GameObject.DestroyImmediate(PAPA.transform.GetChild(i).gameObject);
        }
    }
    public static void DELETEAllChild(Transform parent)
    {
        if (parent == null) return;

        //foreach (Transform obj in parent)
        //{
        //    obj.gameObject.SetActive(true);
        //}

        for (int i = parent.childCount - 1; i >= 0; i--)
        {
            DestroyImmediate(parent.transform.GetChild(i).gameObject);
        }
    }
    public static void DELETEAllChildName(Transform parent,List<string> ListName)
    {
        if (parent == null) return;
        for (int i = parent.childCount - 1; i >= 0; i--)
        {
            GameObject Object=parent.transform.GetChild(i).gameObject;
            if(ListName.Contains(Object.name))DestroyImmediate(Object);
        }
    }
    public static void DELETEAllObjectChild(GameObject O)
    {
        foreach (Transform obj in O.transform)
        {
            obj.gameObject.SetActive(true);
        }

        GameObject PAPA = O.gameObject;

        for (int i = PAPA.transform.childCount - 1; i >= 0; i--)
        {
            GameObject.DestroyImmediate(PAPA.transform.GetChild(i).gameObject);
        }
    }
    public static void ResetRoomSelect()
    {
        //print("-----ResetRoomSelect----");
       // if (_G.SHADEWALL == null) _G.SHADEWALL = Resources.Load("MATERIALS/SHADEWALL") as Material;
        Material mat = _G.INV; //_G.SHADEWALL;
        mat.mainTextureScale = new Vector2(1.0f, 1.0f);
        for (int i = 1; i < _G.NW + 1; i++)
        {
            string str = "m" + i.ToString();
            if (GameObject.Find(str))
            {
                // Color c=GameObject.Find(str.Replace("m","w")).transform.Find("s1").GetComponent<MeshRenderer>().material.color;
                //c.a=0.5f;
                GameObject.Find(str).GetComponent<MeshRenderer>().material = mat;
                //GameObject.Find(str).GetComponent<MeshRenderer>().material.color=c;
            }
        }
        if(_G.CeilingPoints !=null){
            for(int i=0; i<_G.CeilingPoints.Length; i++)
            {
                if (GameObject.Find("sceil"+i.ToString()))
                {
                    GameObject.Find("sceil"+i.ToString()).GetComponent<MeshRenderer>().material = mat;
                    GameObject.Find("sceil"+i.ToString()).GetComponent<MeshRenderer>().material.mainTextureScale = new Vector2(1.0f, 1.0f);
                }
            }
        }
        if (GameObject.Find("sfloor"))
        {
            GameObject.Find("sfloor").GetComponent<MeshRenderer>().material =_G.INV;
            GameObject.Find("sfloor").GetComponent<MeshRenderer>().material.mainTextureScale = new Vector2(1.0f, 1.0f);
        }
        PAINT.SEL = "";
    }
    public static void AllWall()
    {
        float mesx = 0;
        for (int i = 1; i < _G.NW + 1; i++)
        {
            string str = "m" + i.ToString();
            if (GameObject.Find(str))
            {
                mesx = getWallWide(str);
                GameObject Wall = Get.o1(str); //GameObject.Find(str).gameObject;
                Wall.GetComponent<MeshRenderer>().material = _G.MESH;
                DOIT.SetSizeTex(Wall, 60f, 60f, 0, 0, 0, 0, 90, 90);
                //GameObject.Find(str).GetComponent<MeshRenderer>().material.mainTextureScale = new Vector2(mesx / 12f, _G.HEIGHT / 12f);

            }
        }
    }
    public static void CloseALLPNL()
    {
        GameObject[] pnl = GameObject.FindGameObjectsWithTag("pnl");
        foreach (GameObject p in pnl) { p.gameObject.SetActive(false); }

        GameObject[] menu = GameObject.FindGameObjectsWithTag("Menu");
        foreach (GameObject m in menu) { m.gameObject.SetActive(false); }

        GameObject[] btn = GameObject.FindGameObjectsWithTag("btnAround");
        foreach (GameObject i in btn)
        {
            //print(i.name);
            if (i.transform.Find("Image"))
            {
                if (i.transform.Find("Image").gameObject.activeSelf)
                {
                    i.transform.Find("Image").gameObject.SetActive(false);
                    if (i.transform.Find("Image1")) i.transform.Find("Image1").gameObject.SetActive(true);
                    ButtonControl.BtnAround(i.name);
                }
            }
        }

        GameObject pnlGameObject = GameObject.Find("PNL");
        if (pnlGameObject) pnlGameObject.transform.Find("SAVEWEBpnl").transform.GetComponent<CanvasGroup>().alpha = 1;
        
        GameObject hider = GameObject.Find("HIDER");
        if (hider) hider.transform.Find("LOADpnl").transform.GetComponent<CanvasGroup>().alpha = 1;

        ResetRoomSelect();
        SceneModeManager.SelectedName = "";
        SceneModeManager.Instance.SetSceneMode(SceneModes.Navigate);
        _G.PNL = "";
        _G.NAVIGATE = true;
        AllSelOff();
        Set.alpha(Get.o2("Canvas","Language"),true);
    }
    public static void CloseALLPNLONLY()
    {
        GameObject[] pnl;
        pnl = GameObject.FindGameObjectsWithTag("pnl");
        foreach (GameObject p in pnl) { p.SetActive(false); }

        GameObject[] menu;
        menu = GameObject.FindGameObjectsWithTag("Menu");
        foreach (GameObject m in menu) { m.SetActive(false); }
        if (GameObject.Find("SAVEWEBpnl")) GameObject.Find("SAVEWEBpnl").transform.GetComponent<CanvasGroup>().alpha = 1;
        if (GameObject.Find("LOADpnl")) GameObject.Find("LOADpnl").transform.GetComponent<CanvasGroup>().alpha = 1;
    }
    public static void CloseALLMenu()
    {
        GameObject[] pnl;
        pnl = GameObject.FindGameObjectsWithTag("Menu");
        foreach (GameObject p in pnl) { p.SetActive(false); }
    }
    public static void disableActionsDropdown()
    {
        GameObject.Find("HIDER").transform.Find("SELECT").gameObject.SetActive(false);
    }
    public static void AllSelOff()
    {
        for (var i = 0; i < _G.OBJnum + 1; i++)
        {
            if (!exist(i, out Transform sceneObject)) continue;
            //string name = _G.OBJs[i][0];
            if (sceneObject.gameObject.layer != 2 ) { 
               Set.Layer(sceneObject.gameObject, 0);
             }

            if (_G.Redflag)
            {
                if (!Collision.checkBool(i) && _G.Redflag)
                {
                    sceneObject.GetComponent<MeshRenderer>().material = _G.INV;
                    continue;
                }
            }
            if (!_G.Redflag && !_G.SELECEDLIST.Contains(sceneObject.name))
            {
                sceneObject.GetComponent<MeshRenderer>().material = _G.INV;
                continue;
            }
            if (_G.SELECEDLIST.Contains(sceneObject.name))
            {
                sceneObject.GetComponent<MeshRenderer>().material = _G.GBT;
                continue;
            }

            if (_G.GHOSTLIST.Contains(sceneObject.name))
            {
                sceneObject.GetComponent<MeshRenderer>().material = _G.GBT;
                continue;
            }
            sceneObject.GetComponent<MeshRenderer>().material = _G.GRT;
        }

        Mesure.Hide();
    }
    public static void AllTogchildfalse(GameObject O)
    {
        foreach (Transform obj in O.transform)
        {
            //print("obj.name==1="+obj.name);
            if (obj.name.IndexOf("k") == -1 && obj.name != "-1" )
            {
                //print("obj.name==2="+obj.name);
                obj.gameObject.GetComponent<Toggle>().isOn = false;
            }
        }
    }
    public static void AllChildOff(GameObject O)
    {
        for (int i = 0; i < O.transform.childCount; i++)
        {
            O.transform.GetChild(i).gameObject.SetActive(false);
        }
    }
    public static void AllChildON(GameObject O)
    {
        for (int i = 0; i < O.transform.childCount; i++)
        {
            O.transform.GetChild(i).gameObject.gameObject.SetActive(true);
        }
    }
    public static void ResetRoom()
    {
        CloseALLPNL();
        AllSelOff();
        GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(false);
    }
    public static void meshlight()
    {
        //print("SceneModeManager.SelectedName===="+SceneModeManager.SelectedName);
        if (SceneModeManager.SelectedName!= "")
        {
            int ADN = Get.GetObjectIndex(SceneModeManager.SelectedName);
            float mesx;
            float mesz;
            string str;

            if (_G.OBJs[ADN][22] != SceneModeManager.Floor.name && _G.OBJs[ADN][22] != SceneModeManager.Ceil.name)
            {
                int Wallnum = int.Parse(_G.OBJs[ADN][22][1..]);
                str = "m" + Wallnum.ToString();
                mesz = _G.HEIGHT;
                mesx = getWallWide(_G.OBJs[ADN][22].Replace("w", "m"));
            }
            else
            {
                str = "s" + _G.OBJs[ADN][22];
            }
            //sceil
            if(str=="sceil")
            {
                for(int i=0; i<_G.CeilingPoints.Length; i++)
                {
                    AddMeshMaterial(str+i.ToString());
                }
            }
            else
            {
                AddMeshMaterial(str);
            }


        }
    }
    public static void  AddMeshMaterial(string str) {
        GameObject Wall = Get.o1(str); //GameObject.Find(str).gameObject;
        Wall.GetComponent<MeshRenderer>().material = _G.MESH;
        SetSizeTex(Wall, 60f, 60f, 0, 0, 0, 0, 90, 90);
    }

    public static float xfzf(string xz)
    {
        float f = 1;
        GameObject sel = GameObject.Find(SceneModeManager.SelectedName);
        int IN = Get.GetObjectIndex(SceneModeManager.SelectedName);
        int Wallnum = int.Parse(_G.OBJs[IN][22].Substring(1, 1));
        GameObject wall = GameObject.Find("w" + Wallnum.ToString());

        float Ww = 0;
        float a = 0;

        for (int i = 1; i < _G.NW + 1; i++)
        {
            if (Wallnum == i) { Ww = _G.WallsWidth[i - 1]; a = _G.WallsAngle[i - 1]; }
        }
        float xf = Mathf.Cos(a * Mathf.Deg2Rad);
        float zf = Mathf.Sin(a * Mathf.Deg2Rad);

        if (xz == "x") f = xf;
        if (xz == "z") f = zf;
        if (xz == "ww") f = Ww;

        return f;
    }
    public static float GetScenePos(string v, float os)
    {
        float value = 0;
        if (PAINT.SEL == "floor" || PAINT.SEL == "ceil") { return 0; }
        else
        {
            int wn = int.Parse(PAINT.SEL[1..]);
            float ry = _G.WallsAngle[wn - 1];
            GameObject Wall = Get.o1("ROOM/w" + wn.ToString());
            Vector3 Wallposition = Wall.transform.position;
            Vector3 newPos = Wall.transform.forward * os * -1f + Wallposition;
            if (v == "px") { value = newPos.x; }
            if (v == "pz") { value = newPos.z; }
            if (v == "ry") { value = ry; }
        }
        return value;
    }
    public static int GetWallAngle()
    {
        int ON = Get.GetObjectIndex(SceneModeManager.SelectedName);
        int Wallnum = int.Parse(_G.OBJs[ON][22].Substring(1, 1));
        int num = 0;
        GameObject wall = GameObject.Find("w" + Wallnum.ToString());
        Vector3 ANGLE = wall.transform.eulerAngles;
        num = (int)(ANGLE.y);
        return num;
    }
    public static float getPn(string p)
    {//Position xyz of wall

        int nO = int.Parse(SceneModeManager.SelectedName[4..]);
        int Wallnum = int.Parse(_G.OBJs[nO][22].Substring(1, 1));
        float num = 0;
        GameObject wall = GameObject.Find("w" + Wallnum.ToString());
        Vector3 pos = wall.transform.position;
        if (p == "x") num = pos.x;
        if (p == "y") num = pos.y;
        if (p == "z") num = pos.z;
        return num;
    }
    public static float getCabPos(string v)
    {
        GameObject T = GameObject.Find(_G.TARGET);
        Vector3 pos = T.transform.position;
        Quaternion rot = T.transform.rotation;
        float px = pos.x;
        float py = pos.y;
        float pz = pos.z;
        float rx = rot.x;
        float ry = rot.y;
        float rz = rot.z;
        float value = 0;
        if (v == "px") value = px;
        if (v == "py") value = py;
        if (v == "pz") value = pz;
        if (v == "rx") value = rx;
        if (v == "ry") value = ry;
        if (v == "rz") value = rz;
        return value;
    }
    public static float getWallWide(string W)
    {
        int nW = int.Parse(W[1..]);
        float Wide = _G. WallsWidth[nW - 1];
        return Wide;
    }


    //----------------------------------------------------------------------------------------------------------------------------//
    //---------------------------------------------------------Check------------------------------------------------------------//
    //----------------------------------------------------------------------------------------------------------------------------//
    public static void SetAlignPNL()
    {
        GameObject ALIGN = GameObject.Find("HIDER").transform.Find("ALIGN").transform.Find("Abtn").gameObject;
        int nt = int.Parse(_G.TARGET[4..]);
        //int nO = int.Parse(SceneModeManager.SelectedName.Substring(4, SceneModeManager.SelectedName.Length - 4));

        bool Ax = DOIT.CheckAxe( "X");
        bool Ay = DOIT.CheckAxe( "Y");
        bool Az = DOIT.CheckAxe( "Z");

        for (int i = 0; i < ALIGN.transform.childCount; i++)
        {
            ALIGN.transform.GetChild(i).gameObject.SetActive(true);
        }
        if (_G.OBJs[nt][22] != "floor")
        {
            if (Ay == false) { ALIGN.transform.Find("AL").gameObject.SetActive(false); ALIGN.transform.Find("AC").gameObject.SetActive(false); ALIGN.transform.Find("AR").gameObject.SetActive(false); }
            if (Ax == false && Az == false) { ALIGN.transform.Find("AB").gameObject.SetActive(false); ALIGN.transform.Find("ACH").gameObject.SetActive(false); ALIGN.transform.Find("AT").gameObject.SetActive(false); }
            //if (Ax == false && Ay == true && Az == false) { ALIGN.transform.Find("AT").gameObject.SetActive(false); ALIGN.transform.Find("ACH").gameObject.SetActive(false); ALIGN.transform.Find("AB").gameObject.SetActive(false); }
        }

        else if (_G.OBJs[nt][22] == "floor")
        {
            if (Ax == false && Az == true) { ALIGN.transform.Find("AT").gameObject.SetActive(false); ALIGN.transform.Find("ACH").gameObject.SetActive(false); ALIGN.transform.Find("AB").gameObject.SetActive(false); }
            if (Ax == true && Az == false) { ALIGN.transform.Find("AL").gameObject.SetActive(false); ALIGN.transform.Find("AC").gameObject.SetActive(false); ALIGN.transform.Find("AR").gameObject.SetActive(false); }
        }
        else
        {
            GameObject.Find("HIDER").transform.Find("MESSAGE").gameObject.transform.GetChild(1).gameObject.GetComponent<UnityEngine.UI.Text>().text = "You have to select an object";
        }

    }
    public static bool CheckAxe(string A)
    {
        GameObject T = GameObject.Find(_G.TARGET);
        GameObject S = GameObject.Find(SceneModeManager.SelectedName);

        Vector3 tPOS = T.transform.position;
        Vector3 sPOS = S.transform.position;

        Vector3 SO = S.GetComponent<Collider>().bounds.size;
        float Owx = SO.x - 0.5f;
        float Ohy = SO.y - 0.5f;
        float Owz = SO.z - 0.5f;//Object depth
        Vector3 TO = T.GetComponent<Collider>().bounds.size;
        float Twx = TO.x - 0.5f;
        float Thy = TO.y - 0.5f;
        float Twz = TO.z - 0.5f;//Object depth

        //Distance center
        float Mx = Mathf.Abs(sPOS.x - tPOS.x);
        float Mz = Mathf.Abs(sPOS.z - tPOS.z);
        float My = Mathf.Abs(sPOS.y - tPOS.y);

        float Ymesure = (Ohy * 0.5f + Thy * 0.5f);

        print("My=====" + My + "   Ymesure=====" + Ymesure);

        if (A == "X") { return Mx >= (Owx * 0.5f + Twx * 0.5f); }
        if (A == "Z") { return Mz >= (Owz * 0.5f + Twz * 0.5f); }
        if (A == "Y") { return My >= (Ohy * 0.5f + Thy * 0.5f); }
        return false;
    }
    public static bool checkSpace(string TU)
    {
        //print("_G.TARGET===="+_G.TARGET);
        //print("SceneModeManager.SelectedName===="+SceneModeManager.SelectedName);

        bool t = true;
        GameObject tar = GameObject.Find(_G.TARGET);
        int ntO = Get.GetObjectIndex(_G.TARGET);
        Vector3 tPOS = tar.transform.position;
        float tpy = tPOS.y;
        float th = ConvertStringToNumber(_G.OBJs[ntO][7]);

        //GameObject sel = GameObject.Find(SceneModeManager.SelectedName).gameObject;
        int nsO = Get.GetObjectIndex(SceneModeManager.SelectedName);
        float sh = ConvertStringToNumber(_G.OBJs[nsO][7]);
        float sa = 0;
        if (TU == "T") sa = _G.HEIGHT / 2 - tpy - th / 2;
        if (TU == "U") sa = _G.HEIGHT / 2 + tpy - th / 2;

        if (sa < sh) { t = false; }
        return t;
    }
    public static void NoSelection(GameObject S)
    {
        for (int i = 0; i < S.transform.childCount; i++)
        {
            S.transform.GetChild(i).transform.GetComponent<Toggle>().isOn = false;
        }

    }

    //----------------------------------------------------------------------------------------------------------------------------//
    //---------------------------------------------------------EMPTY------------------------------------------------------------//
    //----------------------------------------------------------------------------------------------------------------------------//       
    public static void BTNPNL(string tog, float size, string parent, string name, float num, float maxw, string path)
    {
        print("parent===="+parent);
        GameObject MODEL = Get.o1("EMPTYLpnl/" + parent);
        foreach (Transform child in MODEL.transform) { GameObject.Destroy(child.gameObject); }
        float X = 0;
        float Y = 0;
        float step = size + 10;

        if (maxw > num) maxw = num;
        float Ran = (float)num / (float)maxw;
        Ran = Mathf.CeilToInt(Ran);
        //Create BTN
        for (int i = 1; i < num + 1; i++)
        {
            GameObject M = (GameObject)Instantiate(GameObject.Find("HIDER").transform.Find(tog).gameObject);

            X = -step * maxw / 2 + (i) * step - step / 2;
            Y = (Ran - 1) * step / 2;
            if (i > maxw) { X -= step * maxw; Y -= step; }
            if (i > maxw * 2) { X -= step * maxw; Y -= step; }
            if (i > maxw * 3) { X -= step * maxw; Y -= step; }
            if (i > maxw * 4) { X -= step * maxw; Y -= step; }

            int ncat = 100;
            if (path.IndexOf("DESIGNER") != -1) ncat = 200;
            if (path.IndexOf("KNOB/") != -1) { ncat = 0; }


            string namepath = name;
            if (_G.PNLSelect == "CABBOXPNL" || _G.PNLSelect == "PanelGlobalPNL" || _G.PNLSelect == "DecoPNL") namepath = "TEXT";

            M.name = name + (i + ncat).ToString();
            Sprite T = Resources.Load<Sprite>("ICONS/" + path + namepath + (i + ncat).ToString());

            //print("T path===  "+"ICONS/" + path + namepath + (i + ncat).ToString());
            string pathS = "ICONS/SelectR2";

            if (_G.PNLSelect == "CABDOORPNL" || _G.PNLSelect == "CABBOXPNL" || _G.PNLSelect == "PanelGlobalPNL" || _G.PNLSelect == "OGEEPNL" ||
                 _G.PNLSelect == "UNDERPNL" || _G.PNLSelect == "KickGlobalPNL" || _G.PNLSelect == "HeadPNL" || _G.PNLSelect == "DecoPNL") pathS = "ICONS/Select";

            Sprite S = Resources.Load<Sprite>(pathS);
            M.transform.Find("Background").GetComponent<Image>().sprite = T;
            M.transform.Find("Background/Checkmark").GetComponent<Image>().sprite = S;
            M.SetActive(true);
            M.transform.localScale = new Vector3(size / 100, size / 100, 1);
            M.transform.SetSiblingIndex(0);
            M.transform.SetParent(MODEL.transform, false);
            M.transform.localPosition = new Vector3(X, Y, 1);
        }
    }
    public static void BTNCAT(string CAT, float Num, string n1, string n2, string n3, string n4, string n5, string n6)
    {
        //Empty Category
        GameObject C = GameObject.Find("CATEGORY");
        foreach (Transform child in C.transform) { child.gameObject.name = "destroy"; GameObject.Destroy(child.gameObject); }

        //Create BTN
        if (n1 != "") addBTNCAT(n1);
        if (n2 != "") addBTNCAT(n2);
        if (n3 != "") addBTNCAT(n3);
        if (n4 != "") addBTNCAT(n4);
        if (n5 != "") addBTNCAT(n5);
        if (n6 != "") addBTNCAT(n6);

        if (Num == 1)
        {
            GameObject.Find(n1).transform.localPosition = new Vector3(0, 0, 1);
        }
        if (Num == 2)
        {
            GameObject.Find(n1).transform.localPosition = new Vector3(-65, 0, 1);
            GameObject.Find(n2).transform.localPosition = new Vector3(65, 0, 1);
        }
        if (Num == 3)
        {
            GameObject.Find(n1).transform.localPosition = new Vector3(-125, 0, 1);
            GameObject.Find(n2).transform.localPosition = new Vector3(0, 0, 1);
            GameObject.Find(n3).transform.localPosition = new Vector3(125, 0, 1);
        }
        if (Num == 4)
        {
            GameObject.Find(n1).transform.localPosition = new Vector3(-195, 0, 1);
            GameObject.Find(n2).transform.localPosition = new Vector3(-65, 0, 1);
            GameObject.Find(n3).transform.localPosition = new Vector3(65, 0, 1);
            GameObject.Find(n4).transform.localPosition = new Vector3(195, 0, 1);
        }
        if (Num == 6)
        {
            GameObject.Find(n1).transform.localPosition = new Vector3(-325, 0, 1);
            GameObject.Find(n2).transform.localPosition = new Vector3(-195, 0, 1);
            GameObject.Find(n3).transform.localPosition = new Vector3(-65, 0, 1);
            GameObject.Find(n4).transform.localPosition = new Vector3(65, 0, 1);
            GameObject.Find(n5).transform.localPosition = new Vector3(195, 0, 1);
            GameObject.Find(n6).transform.localPosition = new Vector3(325, 0, 1);
        }
    }
    public static void addBTNCAT(string n)
    {
        GameObject Cat = (GameObject)Instantiate(GameObject.Find("HIDER").transform.Find("BTNCAT").gameObject);
        Cat.transform.SetParent(GameObject.Find("CATEGORY").transform, false);
        Cat.transform.Find("Background").transform.Find("text").gameObject.GetComponent<UnityEngine.UI.Text>().text = n;
        Cat.name = n;
        Cat.transform.Find("Background").transform.Find("text").name = "T_" + n;
        Cat.SetActive(true);
        Cat.transform.localPosition = new Vector3(0, 0, 1);
    }//Category Btn
    public static void Sizebackground(float NO, float maxw)
    {
        GameObject PNL = GameObject.Find("PNL").transform.Find("EMPTYLpnl").gameObject;
        float Wide = 200;
        if (NO == 2) Wide = 520;
        float WBG = 0;//Wide + NO * 110;
        if (WBG > Wide + maxw * 110) WBG = Wide + maxw * 110;
        WBG = Wide + maxw * 110;
        if (WBG < 450) WBG = 450;
        if (maxw == 2) WBG = 400;
        if (maxw == 1) WBG = 350;

        float HBG = 250;
        PNL.transform.Find("MODEL").transform.localPosition = new Vector3(0, 0, 0);

        if (_G.PNLSelect == "SPLASH")
        {
            HBG = 300;
            PNL.transform.Find("MODEL").transform.localPosition = new Vector3(0, 25, 0);
        }
        if (_G.PNLSelect == "OPENNING") { WBG = 450; }
        if (_G.PNLSelect == "MOLDING")
        {
            HBG = 300;
            WBG = 750;
        }
        if (_G.PNLSelect == "MIRROR") { WBG = 850; }
        if (_G.PNLSelect == "SMALLELECTRO" || _G.PNLSelect == "LAMP" || _G.PNLSelect == "STOOL" || _G.PNLSelect == "VASE")
        {
            HBG = 330;
            PNL.transform.Find("MODEL").transform.localPosition = new Vector3(0, 10, 0);
        }
        if (_G.PNLSelect == "OPENNING") { WBG = 450; }
        if (_G.PNLSelect == "HeadPNL") { WBG = 1080; }

        if (NO > maxw) HBG += 110;
        if (NO > maxw * 2) HBG += 110;
        if (NO > maxw * 3) HBG += 110;
        GameObject.Find("EMPTYLpnl").transform.Find("CATEGORY").transform.localPosition = new Vector3(0, HBG / 2 - 35, 1);
        PNL.transform.Find("BG").GetComponent<Image>().rectTransform.sizeDelta = new Vector2(WBG, HBG);
        GameObject.Find("X").transform.localPosition = new Vector3(WBG / 2 - 35, HBG / 2 - 30, 1);
        //GameObject.Find("HELP").transform.localPosition = new Vector3(-WBG / 2 + 35, -HBG / 2 + 35, 1);
        GameObject.Find("MOVE").transform.localPosition = new Vector3(-WBG / 2 + 35, HBG / 2 - 35, 1);
        GameObject.Find("ADD").transform.localPosition = new Vector3(WBG / 2 - 38, -HBG / 2 + 38, 1);

        _G.PNLSelect = "";
    }
    public static void OffMODIFYER()
    {
        GameObject MODIFY =  Get.o2("EMPTYLpnl","MODIFYER");
        MODIFY.transform.localPosition= new Vector3(0, 0, 1);
        for (int i = 0; i < MODIFY.transform.childCount; i++)
        {
            MODIFY.transform.GetChild(i).transform.gameObject.SetActive(false);
        }
    }
    public static float GetShine(string S)
    {
        float s = 0;
        if (S.IndexOf("S") != -1) s = 0.82f;//Semi|
        else if (S.IndexOf("M") != -1) s = 0.1f;//Mat
        else if (S.IndexOf("G") != -1) s = 0.95f;//Glossy
        return s;
    }
    public static Color GetIsColor(string S)
    {
        Color c;
        c = GameObject.Find(S).transform.GetComponent<MeshRenderer>().material.color;
        return c;
    }
    public static void btnSetColor(GameObject O, string col)
    {
        ColorBlock theColor = O.GetComponent<Button>().colors;
        theColor.normalColor = DOIT.CSc(col, 200);
        theColor.highlightedColor = DOIT.CSc(col, 200);
        theColor.pressedColor = DOIT.CSc(col, 200);
        theColor.selectedColor = DOIT.CSc(col, 200);
        theColor.disabledColor = DOIT.CSc(col, 200);
        O.transform.GetComponent<Button>().colors = theColor;
    }
    public static Texture2D GetTex(string tex)
    {
        string path = "STYLE/";
        if (tex[..4] == "CERA") path = "TEXTURES/FINISH/";
        else if (tex[..4] == "COUN") path = "COUNTER/";
        else if (tex[..4] == "SPLA") path = "TEXTURES/FINISH/";
        else if (tex[..4] == "WOOD") path = "TEXTURES/FINISH/";
        else if (tex[..4] == "OGEE") path = "ICONS/OGEE/";
        else if (tex[..4] == "UNDE") path = "ICONS/UNDER/";
        else if (tex[..4] == "COLO") path = "TEXTURES/GENERAL/";
        tex = tex.Replace("BCAB", "TEXT");
        tex = tex.Replace("PANE", "TEXT");
        tex = tex.Replace("FILL", "TEXT");
        tex = tex.Replace("HEAD", "TEXT");
        tex = tex.Replace("KICK", "TEXT");
        //print("path========================================================================"+path+tex);
        Texture2D T = Resources.Load<Texture2D>(path + tex) as Texture2D;
        return T;
    }
    public static Sprite GetSprite(string tex)
    {
        string path = "STYLE/";
        Sprite T = Resources.Load<Sprite>(path + tex) as Sprite;
        return T;
    }
    public static void SaveObjectPositionInData(string Oname)
    {
        if (string.IsNullOrEmpty(Oname))
        {
            Debug.LogError("object name is null or empty and should not");
            return;
        }

        SaveObjectPositionInData(SceneModeManager.GetObjectInScene(Oname));
    }
    public static void SaveObjectPositionInData(GameObject obj)
    {
        if (obj == null)
        {
            Debug.LogError("object is null and should not");
            return;
        }

        SaveObjectPositionInData(obj.transform);
    }
    public static void SaveObjectPositionInData(Transform obj)
    {
        if (obj == null)
        {
            Debug.Log("No Selected On SetPosObj for " + obj);
            return;
        }

        int nO = Get.GetObjectIndex(obj.name);
        Vector3 Pos = obj.position;
        Vector3 A = obj.eulerAngles;

        string[] ADN = _G.OBJs[nO];
        ADN[15] = Pos.x.ToString();
        ADN[16] = Pos.y.ToString();
        ADN[17] = Pos.z.ToString();

        ADN[18] = Mathf.Round(A.x).ToString();
        ADN[19] = Mathf.Round(A.y).ToString();
        ADN[20] = Mathf.Round(A.z).ToString();

        

        if (ADN[22] != "floor" && ADN[22] != "ceil")
        {
            Vector3 WallPosition = Get.o2("ROOM", ADN[22]).transform.position;
            ADN[14] = (Pos.x - WallPosition.x).ToString() + "," + (Pos.y - WallPosition.y).ToString() + "," + (Pos.z - WallPosition.z).ToString();
        }
        else ADN[14] = Pos.x.ToString() + "," + Pos.y.ToString() + "," + Pos.z.ToString();

        print("SaveObjectPositionInData C[14]==" + ADN[14]);



    }
    static public Vector3 GetObjectPositionFromData(string objectName)
    {
        int nO = Get.GetObjectIndex(objectName);
        float x = ConvertStringToNumber(_G.OBJs[nO][15]);
        float y = ConvertStringToNumber(_G.OBJs[nO][16]);
        float z = ConvertStringToNumber(_G.OBJs[nO][17]);

        return new Vector3(x, y, z);
    }
    static public Vector3 GetPosObj(string Oname)
    {
        int nO = Get.GetObjectIndex(Oname);
        float x = ConvertStringToNumber(_G.OBJs[nO][15]);
        float y = ConvertStringToNumber(_G.OBJs[nO][16]);
        float z = ConvertStringToNumber(_G.OBJs[nO][17]);
        return new Vector3(x, y, z);
    }
    
    //----------------------------------------------------------------------------------------------------------------------------//
    //---------------------------------------------------------CONVERT------------------------------------------------------------//
    //----------------------------------------------------------------------------------------------------------------------------//
    public static string ConvertNumberToString(float number)
    {
        string str=number.ToString("G");
        if (str.Contains("E")){number = 0;}

        string q = "0";
        if (_G.System == 1)
        {
            float Q = number - Mathf.Floor(number);
            if (Q >= 0) { q = " ''"; }
            if (Q >= 0.062) { q = " 1/16''"; }
            if (Q >= 0.125) { q = " 1/8''"; }
            if (Q >= 0.187) { q = " 3/16''"; }
            if (Q >= 0.220) { q = " 1/4''"; }
            if (Q >= 0.312) { q = " 5/16''"; }
            if (Q >= 0.370) { q = " 3/8''"; }
            if (Q >= 0.400) { q = " 7/16''"; }
            if (Q >= 0.475) { q = " 1/2''"; }
            if (Q >= 0.562) { q = " 9/16''"; }
            if (Q >= 0.620) { q = " 5/8''"; }
            if (Q >= 0.687) { q = " 11/16''"; }
            if (Q >= 0.725) { q = " 3/4''"; }
            if (Q >= 0.812) { q = " 13/16''"; }
            if (Q >= 0.875) { q = " 7/8''"; }
            if (Q >= 0.925) { q = " 15/16''"; }
            if (Q >= 0.967) { q = " ''"; number += 1; }

            q = Mathf.Floor(number).ToString() + q.ToString();
        }
        else
        {
            number = Mathf.Round(number * 2.54f * 100) / 100;
            q = number.ToString("F2") + " cm";
        }
        return q;
    }
    public static string ConvertNumberToStringWithoutSymbol(float M)
{
    string str = M.ToString("G");
    if (str.Contains("E")) { M = 0; }

    string q = "0";

    if (_G.System == 1)
    {
        bool isNegative = M < 0;
        float absM = Mathf.Abs(M);
        float whole = Mathf.Floor(absM);
        float Q = absM - whole;

        if (Q >= 0.967f)
        {
            whole += 1;
            q = "";
        }
        else if (Q >= 0.925f) { q = " 15/16"; }
        else if (Q >= 0.875f) { q = " 7/8"; }
            else if (Q >= 0.812f) { q = " 13/16"; }
            else if (Q >= 0.725f) { q = " 3/4"; }
            else if (Q >= 0.687f) { q = " 11/16"; }
            else if (Q >= 0.620f) { q = " 5/8"; }
            else if (Q >= 0.562f) { q = " 9/16"; }
            else if (Q >= 0.475f) { q = " 1/2"; }
            else if (Q >= 0.400f) { q = " 7/16"; }
            else if (Q >= 0.370f) { q = " 3/8"; }
            else if (Q >= 0.312f) { q = " 5/16"; }
            else if (Q >= 0.220f) { q = " 1/4"; }
            else if (Q >= 0.187f) { q = " 3/16"; }
            else if (Q >= 0.125f) { q = " 1/8"; }
            else if (Q >= 0.062f) { q = " 1/16"; }
            else { q = ""; }

        // Apply sign to whole number
        if (isNegative) whole = -whole;

        q = whole.ToString() + q;
    }
    else
    {
        // Metric (cm)
        M = Mathf.Round(M * 2.54f * 100) / 100;
        q = M.ToString("F2");
    }

    return q;
}

    public static string CNs(float M)
    {
        //Convert number to string  
        string str=M.ToString("G");
        if (str.Contains("E")){M = 0;}

        string q = "0";
        if (_G.System == 1)
        {
            float Q = M - Mathf.Floor(M);
            if (Q >= 0) { q = " ''"; }
            if (Q >= 0.062) { q = " 1/16''"; }
            if (Q >= 0.125) { q = " 1/8''"; }
            if (Q >= 0.187) { q = " 3/16''"; }
            if (Q >= 0.220) { q = " 1/4''"; }
            if (Q >= 0.312) { q = " 5/16''"; }
            if (Q >= 0.370) { q = " 3/8''"; }
            if (Q >= 0.400) { q = " 7/16''"; }
            if (Q >= 0.475) { q = " 1/2''"; }
            if (Q >= 0.562) { q = " 9/16''"; }
            if (Q >= 0.620) { q = " 5/8''"; }
            if (Q >= 0.687) { q = " 11/16''"; }
            if (Q >= 0.725) { q = " 3/4''"; }
            if (Q >= 0.812) { q = " 13/16''"; }
            if (Q >= 0.875) { q = " 7/8''"; }
            if (Q >= 0.925) { q = " 15/16''"; }
            if (Q >= 0.967) { q = " ''"; M += 1; }
            q = Mathf.Floor(M).ToString() + q.ToString();
        }
        else
        {
            M = Mathf.Round(M * 2.54f * 100) / 100;
            q = M.ToString("F2") + " cm";
        }
        //if(q[..1]=="0")q=q[1..];
        return q;
    }
    public static string CNsWithoutSymbol(float M)
    {
        //Convert number to string  
        string q = "0";
        if (_G.System == 1)
        {
            float Q = M - Mathf.Floor(M);
            if (Q >= 0) { q = ""; }
            if (Q >= 0.062) { q = " 1/16"; }
            if (Q >= 0.125) { q = " 1/8"; }
            if (Q >= 0.187) { q = " 3/16"; }
            if (Q >= 0.220) { q = " 1/4"; }
            if (Q >= 0.312) { q = " 5/16"; }
            if (Q >= 0.370) { q = " 3/8"; }
            if (Q >= 0.400) { q = " 7/16"; }
            if (Q >= 0.475) { q = " 1/2"; }
            if (Q >= 0.562) { q = " 9/16"; }
            if (Q >= 0.620) { q = " 5/8"; }
            if (Q >= 0.687) { q = " 11/16"; }
            if (Q >= 0.725) { q = " 3/4"; }
            if (Q >= 0.812) { q = " 13/16"; }
            if (Q >= 0.875) { q = " 7/8"; }
            if (Q >= 0.925) { q = " 15/16"; }
            if (Q >= 0.967) { q = ""; M += 1; }
            q = Mathf.Floor(M).ToString() + q.ToString();
        }
        else
        {
            M = Mathf.Round(M * 2.54f * 100) / 100;
            q = M.ToString("F2");
        }
        return q;
    }
    public static string CSss(string M)
    {//Convert String to string with sys
        M = CSs(M);
        float FV = ConvertStringToNumber(M);
        string msys = CNs(FV);
        return msys;
    }
    public static string CSs(string M)
    {//Convert string to string
        M = M.Replace((char)8203, ' ');
        string q = M.Replace("''", "");
        q = q.Replace("cm", "");
        q = q.Replace("  ", " ");
        q = q.ToString();
        return q;
    }
    public static string CSssys(string M)
    {//Convert string to string
        float mf = float.Parse(M );
        if (_G.System == 2)
        {
            mf = Mathf.Floor(mf * 2.54f);
            mf = (mf / 2.54f * 100) / 100;
        }
        M = mf.ToString();
        return M;
    }
    public static string CSsdecimal(string M)
    {//Convert string to string decimal
        return ConvertStringToNumber(M).ToString();
    }

    ///// <summary>
    ///// Convert string to number.
    ///// </summary>
    ///// <param name="M">The input string to be converted to inches.</param>
    ///// <returns>The length in inches as a float.</returns>
    public static float ConvertStringToNumber(string M)
    {
        if (M.Contains("E")){M = "0";}

        //print("M===="+M);
        //4 1/2
        //4.5
        //41/2
        //4.5"
        //4.5 "
        //4.5cm
        //4.5 cm
        //4e...


        if (string.IsNullOrWhiteSpace(M) || M.Equals("none", StringComparison.OrdinalIgnoreCase))
        {
            //Debug.Log(M + " value. Value is set to 0.");
            return 0f;
        }

        if (M.Length > 10) M = M[..9];
        if (M.IndexOf("E") != -1) M = M[..4];

        float add = 0;
        Dictionary<string, float> fractions = new ()
            {
                { "15/16", 0.9375f },
                { "13/16", 0.8125f },
                { "11/16", 0.6875f },
                { "7/8", 0.875f },
                { "3/4", 0.75f },
                { "5/8", 0.625f },
                { "9/16", 0.5625f },
                { "1/2", 0.5f },
                { "7/16", 0.4375f },
                { "3/8", 0.375f },
                { "5/16", 0.3125f },
                { "1/4", 0.25f },
                { "3/16", 0.1875f },
                { "1/8", 0.125f },
                { "1/16", 0.0625f },
                { " ''", 0 },
                { " ", 0 },
                { "''", 0 }
            };

        // Check for fractions in the input and update the fraction adder.
        foreach (var fraction in fractions)
        {
            if (M.IndexOf(fraction.Key) != -1)
            {
                M = M.Replace(fraction.Key, "");
                add = fraction.Value;
                break;
            }
        }
        M = M.Replace((char)8203, '\0');

        if (M.IndexOf("cm") != -1)
        {
            M = M.Replace("cm", "");
            float centimeters = float.Parse(M);
            return centimeters / 2.54f;
        }

        float newM = 0;
        // else check for inch conversion
        M = M.Replace("''", "");
        M = M.Replace("'", "");
        M = M.Replace(" ", "_");
        float fact = 1;
        if (M.IndexOf("-") != -1) { fact = -1; }
        M = M.Replace("-", "");

        string Entity = M;
        if (M.IndexOf("_") != -1)
        {
            string[] split = M.Split('_');
            Entity = split[0];

            M = split[1];
        }

        //print("Entity===="+Entity);
        if(string.IsNullOrEmpty(Entity))Entity="0";

        newM = float.Parse(Entity, System.Globalization.NumberStyles.Float) + add;
        //newM = float.Parse(M, System.Globalization.NumberStyles.Float) + add;
        newM = (Mathf.Round(newM * 10000) / 10000) * fact;

        return newM;
    }
    public static float TryConvertStringToNumber(string M, out int system)
    {
        if (M.Contains("\'") || M.Contains("\""))
        {
            system = 1;
        }
        else if (M.Contains("cm"))
        {
            system = 2;
        }
        else // invalid system
        {
            system = 0; 
        }

        return ConvertStringToNumber(M);
    }
    public static void CSYS(string str)
    {
        if (Get.o1(str) != null)
        {
            string Vs = "";
            float Vn = 0;
            Vs = Get.o1(str).gameObject.GetComponent<UnityEngine.UI.Text>().text;
            Vn = ConvertStringToNumber(Vs);
            Vs = CNs(Vn);
            Get.o1(str).gameObject.GetComponent<UnityEngine.UI.Text>().text = Vs;
        }
    }
    public static Color CSc(string colorString, byte alpha)
    {
        //Convert string to color
        try
        {
            colorString = colorString.Replace("#", "");
            colorString = colorString.Replace(".", "");
            colorString = colorString.Replace("+", "");
            //colorString = colorString.Replace("E", "");
            byte r = byte.Parse(colorString.AsSpan(0, 2), NumberStyles.HexNumber);
            byte g = byte.Parse(colorString.AsSpan(2, 2), NumberStyles.HexNumber);
            byte b = byte.Parse(colorString.AsSpan(4, 2), NumberStyles.HexNumber);//Invalid color string format: 1. Error: Specified argument was out of the range of valid values.
            return new Color32(r, g, b, alpha);
        }
        catch (Exception e)
        {
            Debug.LogError("Invalid color string format: " + colorString + ". Error: " + e.Message);//Invalid color string format: '. Error: Input string was not in a correct format.
            return new Color32(0, 0, 0, 0); // return transparent color in case of an error

        }
    }
    public static void ColorModel(string col)
    {
        Color C = DOIT.CSc(col, 210);
        GameObject MODEL = GameObject.Find("MODEL");
        foreach (Transform child in MODEL.transform)
        {
            child.transform.Find("Background").gameObject.GetComponent<Image>().color = C;
        }
    }
    public static void REDOCAB(int nO)
    {
        _G.nO=nO;
        GameObject CAB = GameObject.Find(_G.OBJs[nO][0]);
        if (CAB)
        {
            DestroyImmediate(CAB);
            if (_G.OBJs[nO][5] == "BA") CreateCAB.CabDispatch( _G.OBJs[nO] );
            else if (_G.OBJs[nO][5] == "WA") CreateCAB.CabDispatch( _G.OBJs[nO] );
            else if (_G.OBJs[nO][5] == "TA") ConstructTALL.AddCab(nO);
            else if (_G.OBJs[nO][5] == "CB") ConstructCORNERBASE.AddCab(nO);
            else if (_G.OBJs[nO][5] == "CW") ConstructCORNERWALL.AddCab(nO);
            else if (_G.OBJs[nO][5] == "PNL") ConstructPanel.AddPanel(nO);
            else if (_G.OBJs[nO][5] == "dish") ConstructDishwasher.AddDishwasher(nO);
            else if (_G.OBJs[nO][5] == "winer") ConstructWiner.AddWiner(nO);
            else if (_G.OBJs[nO][4] == "TC") ConstructCounter.AddCounter(nO);
            else if (_G.OBJs[nO][4] == "DD") ConstructDECO.AddObject(nO);
        }
        if (CommandHandler.Instance.BeforeDataTemp != null && SceneModeManager.SelectedName != "")
        {
            string[] afterData = CommandHandler.CopyObjectData(_G.OBJs[nO]);
            CommandHandler.Instance.AddToHistory(new UniversalModifyCommand("Universal", nO, CommandHandler.CopyObjectData(CommandHandler.Instance.BeforeDataTemp), afterData));
        }
        else
        {
            //Debug.Log("Unable to create command for undo redo");
        }
        CommandHandler.Instance.BeforeDataTemp = null;
    }

    public static void REDOOBJECT(int nO)
    {
        if (_G.OBJs[nO][0] != "null")
        {
            GameObject OBJ = GameObject.Find(_G.OBJs[nO][0]);
            DestroyImmediate(OBJ);
        }
        print("From reobject _G.OBJs[nO][2]===="+_G.OBJs[nO][2]);
        if (_G.OBJs[nO][2] == "Bloc") ConstructBloc.AddBloc(nO);
        else if (_G.OBJs[nO][5] == "WA") ConstructWALL.AddCab(nO);
        else if (_G.OBJs[nO][5] == "TA") ConstructTALL.AddCab(nO);
        else if (_G.OBJs[nO][5] == "CB") ConstructCORNERBASE.AddCab(nO);
        else if (_G.OBJs[nO][5] == "CW") ConstructCORNERWALL.AddCab(nO);
        else if (_G.OBJs[nO][5] == "PNL") ConstructPanel.AddPanel(nO);
        else if (_G.OBJs[nO][5] == "dish") ConstructDishwasher.AddDishwasher(nO);
        else if (_G.OBJs[nO][4] == "TC") ConstructCounter.AddCounter(nO);
        else if (_G.OBJs[nO][2] == "Picture") ConstructPicture.AddPicture(nO);
        else if (_G.OBJs[nO][2] == "BathSink") ConstructBathSink.AddBathSink(nO);
        else if (_G.OBJs[nO][2] == "Shower") ConstructShower.AddShower(nO);
        else if (_G.OBJs[nO][2] == "Vase") ConstructVase.AddVase(nO);
        else if (_G.OBJs[nO][2] == "Small") ConstructSmallelectro.AddSmallElectro(nO);
        else if (_G.OBJs[nO][2] == "Stool") ConstructStool.AddStool(nO);  
        else if (_G.OBJs[nO][2] == "Lamp") ConstructLamp.AddLamp(nO);      
        else if (_G.OBJs[nO][2] == "Chair") ConstructChair.AddChair(nO);
        else if (_G.OBJs[nO][2] == "Table") ConstructTable.AddTable(nO);
        else if (_G.OBJs[nO][2] == "Mirrors") ConstructMirror.AddMirror(nO);
        else if (_G.OBJs[nO][2] == "Window") ConstructWindow.AddWindow(nO);
        else if (_G.OBJs[nO][4] == "stov") ConstructStove.AddStove(nO);
    }
    public static void REDOALLCab_G()
    {
        string G = "GLOBAL" + _G.G.ToString();
        for (var i = 0; i < _G.OBJnum + 1; i++)
        {
            if (exist(i))
            {
                if (_G.OBJs[i][2] == "Cabinet" && _G.OBJs[i][60].IndexOf("GLOBAL") != -1)
                {
                    REDOCAB(i);
                }
                if (_G.OBJs[i][4] == "dish" && _G.OBJs[i][60].IndexOf("GLOBAL") != -1)
                {
                    print("dish");
                    REDOCAB(i);
                }
                if (_G.OBJs[i][4] == "hood" && _G.OBJs[i][60].IndexOf("GLOBAL") != -1)
                {
                    REDOCAB(i);
                }
                if (_G.OBJs[i][2] == "Panel" && _G.OBJs[i][60].IndexOf("GLOBAL") != -1)
                {
                    REDOCAB(i);
                }
                if (_G.OBJs[i][4] == "wine" && _G.OBJs[i][60].IndexOf("GLOBAL") != -1)
                {
                    REDOCAB(i);
                }
            }
        }
    }
    public static void REDOALLCab_GNum(int GG)
    {
        GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(true);
        StaticCoroutine.Start(RedoCabALL(GG));
    }
    public static IEnumerator RedoCabALL(int GG)
    {
        string G = "GLOBAL" + GG.ToString();
        for (var i = 0; i < _G.OBJnum + 1; i++)
        {
            if (exist(i) && _G.OBJs[i][60] == G)
            {
                if (_G.OBJs[i][2] == "Cabinet")
                {
                    print("--------------Pass test---------------" + _G.OBJs[i][60] + "   _G.OBJs[i][61]====" + _G.OBJs[i][61]);
                    REDOCAB(i);
                    yield return null;
                }
                if (_G.OBJs[i][4] == "dish")
                {
                    REDOCAB(i);
                    yield return null;
                }
                if (_G.OBJs[i][4] == "hood")
                {
                    REDOCAB(i);
                    yield return null;
                }
                if (_G.OBJs[i][2] == "Panel")
                {
                    REDOCAB(i);
                    yield return null;
                }
                if (_G.OBJs[i][5] == "winer")
                {
                    REDOCAB(i);
                    yield return null;
                }
            }
        }
        GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(false);
        _MOL.SetMolding();
         yield return new WaitForSecondsRealtime(1);
        DOIT.AllSelOff();
    }
    public static void REDOThisSplash(int nO)
    {
        if (exist(nO))
        {
            DestroyImmediate(GameObject.Find(_G.OBJs[nO][0]).gameObject);
            if (_G.OBJs[nO][4] == "B1") ConstructBASE.AddCab(nO);
            if (_G.OBJs[nO][4] == "B2") ConstructCORNERBASE.AddCab(nO);
            if (_G.OBJs[nO][4] == "B3") ConstructCORNERBASE.AddCab(nO);
            if (_G.OBJs[nO][4] == "B4") ConstructCORNERBASE.AddCab(nO);
            if (_G.OBJs[nO][4] == "B5") ConstructCORNERBASE.AddCab(nO);
            if (_G.OBJs[nO][4] == "B9") ConstructCORNERBASE.AddCab(nO);
            if (_G.OBJs[nO][4] == "B10") ConstructCORNERBASE.AddCab(nO);
            if (_G.OBJs[nO][4] == "W1") ConstructWALL.AddCab(nO);
            if (_G.OBJs[nO][4] == "W2") ConstructCORNERWALL.AddCab(nO);
            if (_G.OBJs[nO][4] == "W3") ConstructCORNERWALL.AddCab(nO);
            if (_G.OBJs[nO][4] == "W4") ConstructCORNERWALL.AddCab(nO);
            if (_G.OBJs[nO][4] == "W5") ConstructCORNERWALL.AddCab(nO);
            if (_G.OBJs[nO][4] == "W9") ConstructCORNERWALL.AddCab(nO);
            if (_G.OBJs[nO][4] == "W10") ConstructCORNERWALL.AddCab(nO);
            if (_G.OBJs[nO][4] == "T1") ConstructTALL.AddCab(nO);
            if (_G.OBJs[nO][4] == "frid") ConstructFRIDGE.AddFridge(nO);
            if (_G.OBJs[nO][4] == "stov") ConstructStove.AddStove(nO);
            if (_G.OBJs[nO][4] == "dish") ConstructDishwasher.AddDishwasher(nO);
            if (_G.OBJs[nO][4] == "hood") ConstructHood.AddHood(nO);
            if (_G.OBJs[nO][4] == "wind") ConstructWindow.AddWindow(nO);
        }
    }
    public static void REDOALLSplash()
    {
        GameObject[] Splash = GameObject.FindGameObjectsWithTag("splash");
        foreach (GameObject child in Splash)
        {
            if (child != null)
            {
                int nO = Get.GetObjectIndex(child.transform.parent.name);
                if (_G.OBJs[nO][60] == "GLOBAL" && _G.OBJs[nO][0] != "null") { REDOThisSplash(nO); }
            }
        }
    }
    public static void AddtoCodeCabGlobal(int k, string str, int GG)
    {
        string G = "GLOBAL" + GG.ToString();
        //print("G==================================="+G);
        for (var i = 0; i < _G.OBJnum ; i++)
        {
            if (exist(i))
            {
                //print("_G.OBJs[i][60]==="+_G.OBJs[i][60]);
                if (_G.OBJs[i][2] == "Cabinet" && _G.OBJs[i][60] == G)
                {
                    _G.OBJs[i][k] = str;
                    //print("str===="+str);
                }

                //Back splash
                else if ( new List<string>(){"hood","wine","stov","dish","wind"}.Contains(_G.OBJs[i][4])  && k==54 || k==55)
                {
                    _G.OBJs[i][k] = str;
                }

                //CounterTop
                else if ( new List<string>(){"wine","dish"}.Contains(_G.OBJs[i][4]) && _G.OBJs[i][60] == G && k==41 || k==42 )
                {
                    _G.OBJs[i][k] = str;
                }
            }
        }
    }
    public static void AddtoCodeCabGlobalFiller(int k, string str, int GG)
    {
        if (str.Split('?').Length == 1) str += "?0";
        //1?0

        string G = "GLOBAL" + GG.ToString();
        for (var i = 0; i < _G.OBJnum + 1; i++)
        {
            if (exist(i) && _G.OBJs[i][2]=="Cabinet"  )
            {
                if (_G.OBJs[i][k] != "NONE" && _G.OBJs[i][60] == G)
                {
                    if (str.Split('?').Length == 2) {
                        string[] OldCode =_G.OBJs[i][k].Split("?");
                        string FillerID=OldCode[0];
                        string ColorID=str.Split("?")[0];
                        string Sens=str.Split("?")[1];
                        string wide ="3";
                        if(OldCode.Length==3){ wide=OldCode[3]; }
                        _G.OBJs[i][k]=FillerID+"?"+ ColorID+"?"+Sens+'?'+wide;
                        }
                    else {_G.OBJs[i][k] = str;}
                }
            }
        }
    }
    public static void AddtoCodeSplashGlobal(int k, string str)
    {
        GameObject[] Splash = GameObject.FindGameObjectsWithTag("splash");
        foreach (GameObject child in Splash)
        {
            int nO = Get.GetObjectIndex(child.transform.parent.name);
            if (_G.OBJs[nO][0] != "null") _G.OBJs[nO][k] = str;
        }

    }
    public static void AddtoCodePNLGlobal(int k, string str, int GG)
    {
        string G = "GLOBAL" + GG.ToString();
        for (var i = 0; i < _G.OBJnum + 1; i++)
        {
            if (exist(i))
            {
                if (_G.OBJs[i] != null)
                {
                    if (_G.OBJs[i][2] == "Panel" && _G.OBJs[i][60] == G)
                    {
                        _G.OBJs[i][k] = str;
                    }
                }
            }

        }

    }
    public static bool exist(int i)
    {
        return exist(i, out Transform transform);
    }
    public static bool exist(int i, out Transform elementGameObject)
    {
        elementGameObject = null;
        bool e = false;
        if (_G.OBJs[i] != null)
        {
            string objectName = _G.OBJs[i][0];
            if (!string.IsNullOrEmpty(objectName) && objectName != "null")
            {
                elementGameObject = SceneModeManager.Scene.Find(objectName);
                e = elementGameObject != null;
            }
        }

        return e;
    }
    //Need Clarification on purpuse

    public static string getColorString(string col)
    {
        string COL = "";
        switch (col)
        {
            case "FFFFFF": COL = "1"; break;
            case "ffffff": COL = "1"; break;
            case "E0DDD5": COL = "2"; break;
            case "CFC6B1": COL = "3"; break;
            case "E3C69D": COL = "4"; break;
            case "9A897A": COL = "5"; break;
            case "826B57": COL = "6"; break;
            case "91683A": COL = "7"; break;
            case "6A4C47": COL = "8"; break;
            case "6A5C4D": COL = "9"; break;
            case "5C3F23": COL = "10"; break;
            case "52433C": COL = "11"; break;
            case "764443": COL = "12"; break;
            case "CDCCCC": COL = "13"; break;
            case "9D9B9B": COL = "14"; break;
            case "7E7D7D": COL = "15"; break;
            case "5C5B5B": COL = "16"; break;
            case "333333": COL = "17"; break;
            case "CFC890": COL = "18"; break;
            case "ECE229": COL = "19"; break;
            case "C8972C": COL = "20"; break;
            case "9DCC8C": COL = "21"; break;
            case "92C5B2": COL = "22"; break;
            case "7AA494": COL = "23"; break;
            case "516F68": COL = "24"; break;
            case "51B76F": COL = "25"; break;
            case "04D744": COL = "26"; break;
            case "58DBC2": COL = "27"; break;
            case "94A7BC": COL = "28"; break;
            case "376BA4": COL = "29"; break;
            case "61769A": COL = "30"; break;
            case "4F5E6F": COL = "31"; break;
            case "DB674E": COL = "32"; break;
            case "DB2C0C": COL = "33"; break;
            case "7E090C": COL = "34"; break;
        }
        return COL;
    }

    //TEXTURE
    //Need Clarification on Function Names Perhaps should be rename RotateTexture??
    public static Texture2D Rotate(Texture2D image)
    {
        Texture2D Tex2D = new Texture2D(image.height, image.width);
        for (int y = 0; y < image.height; ++y)
        {
            for (int x = 0; x < image.width; ++x)
            {
                Tex2D.SetPixel(y, image.width - 1 - x, image.GetPixel(x, y));
            }
        }
        Tex2D.Apply();
        return Tex2D;
    }
    //Need Clarification on Parameter Name
    public static void SetSizeTex(GameObject O, float sX, float sY, float fr, float br, float lr, float rr, float tr, float ur)
    {
        AutoTextureTiling autoTextureTiling = O.GetComponent<AutoTextureTiling>();
        if (autoTextureTiling != null)
        {
            Destroy(autoTextureTiling);
        }
        autoTextureTiling = O.AddComponent<AutoTextureTiling>();
        autoTextureTiling.unwrapMethod = 0;
        autoTextureTiling.faceUnwrapData[0].uvScale = new Vector2(sX, sY);
        autoTextureTiling.frontScale = new Vector2(sX, sY);
        autoTextureTiling.backScale = new Vector2(sX, sY);
        autoTextureTiling.leftScale = new Vector2(sX, sY);
        autoTextureTiling.rightScale = new Vector2(sX, sY);
        autoTextureTiling.topScale = new Vector2(sX, sY);
        autoTextureTiling.bottomScale = new Vector2(sX, sY);

        autoTextureTiling.frontRotation = fr;
        autoTextureTiling.backRotation = br;
        autoTextureTiling.leftRotation = lr;
        autoTextureTiling.rightRotation = rr;
        autoTextureTiling.topRotation = tr;
        autoTextureTiling.bottomRotation = ur;

        float xOffset =O.transform.position.x / sX;
        float yOffset =O.transform.position.y / sY;

        autoTextureTiling.useUnifiedOffset = true;
        autoTextureTiling.backOffset = new Vector2(xOffset, yOffset);
        //autoTextureTiling.frontOffset = new Vector2(-1, -1);

        autoTextureTiling.CreateMeshAndUVs();
    }

    //Need Clarification on variable Names and Function Name
    public static float GetRn(string r)
    {
        float R = 0;
        if (r == "r0") R = 0;
        if (r == "r45") R = 45;
        if (r == "r9") R = 90;
        return R;
    }
    //Need Clarification on variable Names
    public static string ChangeOnTextureCode(string code, int N, string NS)
    {
        string[] cs = code.Split(","[0]);
        cs[N] = NS;
        string newcode = cs[0] + "," + cs[1] + "," + cs[2] + "," + cs[3] + "," + cs[4];
        if (cs.Length >= 6) newcode = newcode + "," + cs[5];
        if (cs.Length >= 7) newcode = newcode + "," + cs[6];
        return newcode;
    }
    //Need Clarification on variable Names
    public static string ChangeCodeOnPos(string code, int Intposition, string NewValue, string Spliter)
    {
        // string SP = "'" + Sp + "'";
        string[] cs = code.Split(Spliter);
        cs[Intposition] = NewValue;
        string newcode = "";
        for (int i = 0; i < cs.Length; i++)
        {
            newcode += cs[i];
            if (i < cs.Length - 1) { newcode += Spliter; }
        }

        return newcode;
    }
}