using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Xml;
using System.Globalization;
using TMPro;
using System;
using System.Linq;
using NUnit.Framework;
using UnityEngine.UI;

public class LoadXML : MonoBehaviour
{
    static XmlDocument xmlDoc = null;
    static List<string> OBJS;
    static List<string> CABS;
    //static float Wait = 1;

    //------------------------------------------------CONSTRUCTION ROOM--------------------------------------
    public static IEnumerator SetGlobal(XmlDocument xmldoc)
    {
        print("SetGloba===2="+"  time==="+Time.time);
        WaitCircle.Setting(true, TRANS.This("M_Download") );
        yield return null;

        xmlDoc = xmldoc;
        _G.FileName = StringXML("//Room/FILENAME");
        //print("File name on load===" + _G.FileName);

        string oldClient = StringXML("//Room/CLIENT");
        string oldVersionNumber = StringXML("//Room/VERSION");

        if (!SaveCompatibility.RefID_CheckedOnce && StringXML("//Room/REPLACE_ROOMID") != "none")
        {
            SaveCompatibility.SetVersionCompatibility_RefID(BoolXML("//Room/REPLACE_ROOMID"));
        }

        SuspendedCab.IsCompatible_VersionAddedLine14 = IsVersionCompatible(oldVersionNumber, SuspendedCab.VersionAddedLine14);

        //Global
        _G.OW.Clear();
        _G.OP.Clear();
        _G.WallsWidth.Clear();
        _G.WallsPointCenter.Clear();
        _G.WallsPointStart.Clear();
        _G.WallsAngle.Clear();
        _G.WallsDirection.Clear();
        _G.WALL.Clear();
        //_G.Ws.Clear();
        _G.WallsMaterial.Clear();
        _G.WallsColor.Clear();
        _G.WallsTexture.Clear();
        _G.WallsAngle.Clear();

        //Global
        _G.HEIGHT = NumXML("//Room/GLOBAL/HEIGHT");
        _G.WIDE = NumXML("//Room/GLOBAL/WIDE");
        _G.DEPTH = NumXML("//Room/GLOBAL/DEPTH");
        _G.ROOM = StringXML("//Room/GLOBAL/ROOM");
        _G.FLCs = StringXML("//Room/FLOOR/code");
        _G.WMKs = StringXML("//Room/GLOBAL/WMKs");
        _G.WMOs = StringXML("//Room/GLOBAL/WMOs");
        _G.SUN = StringXML("//Room/GLOBAL/SUN");
        _G.UIT_YourLibrary = StringXML("//Room/GLOBAL/YourLibrary");
        _G.StoreZone = StringXML("//Room/GLOBAL/storezone");
        if (_G.StoreZone == "none") { _G.StoreZone = ""; }
        if (_P.ListSwitch["STORE_SELECTION"])
        {
            if (_G.PATH == "kent" && _G.StoreZone == "_1") _G.StoreZone = "_1010";
        }

        GameObject.Find("Canvas").transform.Find("Panel_main").gameObject.SetActive(false);
        GameObject.Find("Canvas").transform.Find("Panel_SCENE").gameObject.SetActive(true);
        _G.PNL = "WORLD3D";

        _G.LightSetting = GetLightSetting();
        _G.ClientInfo = GetClientInfo();

        _G.OBJnum = 0;
        _G.WMK = _G.WMKs.Split(","[0]);
        _G.WMO = _G.WMOs.Split(","[0]);

        if (_G.ROOM == "RDRAW") { _G.NW = IntXML("//Room/GLOBAL/NW"); }

        _G.OW.AddRange(new Vector2[_G.NW]);
        _G.OP.AddRange(new Vector2[_G.NW]);
        _G.WallsWidth.AddRange(new float[_G.NW]);
        _G.WallsPointCenter.AddRange(new Vector2[_G.NW]);
        _G.WallsPointStart.AddRange(new Vector2[_G.NW]);
        _G.WallsAngle.AddRange(new float[_G.NW]);
        _G.WallsDirection.AddRange(new int[_G.NW]);
        _G.WALL.AddRange(new GameObject[_G.NW]);
        //_G.Ws.AddRange(new GameObject[_G.NW]);
        _G.WallsMaterial.AddRange(new Material[_G.NW]);
        for (int i = 0; i < _G.WallsMaterial.Count; i++) { _G.WallsMaterial[i] = _G.GYPSE; }
        _G.WallsColor.AddRange(new string[_G.NW]);
        _G.WallsTexture.AddRange(new string[_G.NW]);
        _G.WallsAngle.AddRange(new float[_G.NW]);

        _G.OBJnum = 0;
        _G.WMK = _G.WMKs.Split(","[0]);
        _G.WMO = _G.WMOs.Split(","[0]);

        //Set Globals
        _G.UIT_LibraryGlobalStart = GetGlobalSetting();
        _G.UIT_LibraryCabTextures = GetCabTextureList();

        //Your Library Created
        _Add.YOUR_DOORS = GetYourLibrary("//Room/GLOBAL/YOUR_DOORS");
        _Add.YOUR_PANELS = GetYourLibrary("//Room/GLOBAL/YOUR_PANELS");
        _Add.YOUR_TEXTURES = GetYourLibrary("//Room/GLOBAL/YOUR_TEXTURES");


        LoadWallData();

        string wallPointPositions = StringXML("//Room/WallPointPositions");
        string wallPointPairings = StringXML("//Room/WallPointPairings");
        if (wallPointPositions == "none")
        {
            wallPointPositions = "-8,192;-8,8;-192,8;-192,192;";
            wallPointPairings = "0,1;1,2;2,3;3,0;";
        }
        if (wallPointPositions != "none" && wallPointPairings != "none")
        {
            RoomCreation.LoadRoomPlanFromSave(wallPointPositions, wallPointPairings);
        }
        else if (wallPointPositions != "none")
        {
            RoomCreation.LoadRoomPlanFromSave(wallPointPositions, "");
        }
        else
        {
            //print("Load pass here==="+_G.NWExterior);
            //_G.NWExterior=_G.NW;
            RoomCreation.LoadRoomPlanFromSave("", "");
        }
        //if (_G.BKN == 0) _G.BKN = 1;
        //if (_G.FLCs.Split(',').Length < 9) { _G.FLCs += ",ffffff,1"; }

        if(_G.FLCs.Contains("WOOD.1,")){_G.FLCs="WOOD.1,#E2DABD,#A89186,#D4D4D4,1,0,0.1,0.2,0.3";}

        RoomCreation.CreateRoomTo3D();
        _G.OBJs[299] = new string[100];
        _G.OBJs[299][0] = "null";
        _G.OBJs[299][1] = "null";
        yield return ColorWalls();
        Floor();
        Camera();
        yield return Molding();
        yield return Cabinets();

        CheckClient(oldClient);
        CheckVersion(oldVersionNumber);
        
        if(CABS.Count + OBJS.Count==0){CoroutineController.Start(StopLoading());}
    }

    //------------------------------------------------VERSION CLIENT-------------------------------------
    private static void LoadWallData()
    {
        if (_G.ROOM == "RDRAW") { _G.NW = IntXML("//Room/GLOBAL/NW"); }
        //Debug.Log($"wall number on load : {_G.NW}");
        //print("_G.NW=="+_G.NW);

        _G.OW.AddRange(new Vector2[_G.NW]);
        _G.OP.AddRange(new Vector2[_G.NW]);
        _G.WallsWidth.AddRange(new float[_G.NW]);
        _G. WallsPointCenter.AddRange(new Vector2[_G.NW]);
        _G.WallsPointStart.AddRange(new Vector2[_G.NW]);
        _G.WallsAngle.AddRange(new float[_G.NW]);
        _G. WallsDirection.AddRange(new int[_G.NW]);
        _G.WALL.AddRange(new GameObject[_G.NW]);
        //_G.Ws.AddRange(new GameObject[_G.NW]);
        _G. WallsMaterial.AddRange(new Material[_G.NW]);
        for (int i = 0; i < _G. WallsMaterial.Count; i++) { _G. WallsMaterial[i] = _G.GYPSE; }
        _G. WallsColor.AddRange(new string[_G.NW]);
        _G. WallsTexture.AddRange(new string[_G.NW]);
        _G.WallsAngle.AddRange(new float[_G.NW]);

        for (int i = 1; i < _G.NW + 1; i++)
        {
            _G.WallsWidth[i - 1] = NumXML("//Room/W" + i.ToString() + "/w");
            float xCP = NumXML("//Room/W" + i.ToString() + "/px");
            float yCP = NumXML("//Room/W" + i.ToString() + "/pz");
            _G. WallsPointCenter[i - 1] = new Vector2(xCP, yCP);
            _G.WallsAngle[i - 1] = NumXML("//Room/W" + i.ToString() + "/wa");
            //_G. WallsTexture[i-1] = StringXML("//Room/W"+i.ToString()+"/tex");
            float dx = (_G.WallsWidth[i - 1] / 2) * Mathf.Cos(_G.WallsAngle[i - 1] * Mathf.PI / 180);
            float dy = (_G.WallsWidth[i - 1] / 2) * Mathf.Sin(_G.WallsAngle[i - 1] * Mathf.PI / 180);
            _G.WallsPointStart[i - 1] = new Vector2(_G. WallsPointCenter[i - 1].x - dx, _G. WallsPointCenter[i - 1].y + dy);

            //_G.WallsWidth.Add(NumXML("//Room/W" + i.ToString() + "/w"));
            //float xCP = NumXML("//Room/W" + i.ToString() + "/px");
            //float yCP = NumXML("//Room/W" + i.ToString() + "/pz");
            //_G. WallsPointCenter.Add(new Vector2(xCP, yCP));
            //_G.WallsAngle.Add(NumXML("//Room/W" + i.ToString() + "/wa"));
            ////_G. WallsTexture[i-1] = StringXML("//Room/W"+i.ToString()+"/tex");
            //float dx = (_G.WallsWidth[i - 1] / 2) * Mathf.Cos(_G.WallsAngle[i - 1] * Mathf.PI / 180);
            //float dy = (_G.WallsWidth[i - 1] / 2) * Mathf.Sin(_G.WallsAngle[i - 1] * Mathf.PI / 180);
            //_G.WallsPointStart.Add(new Vector2(_G. WallsPointCenter[i - 1].x - dx, _G. WallsPointCenter[i - 1].y + dy));
        }

  }
    public static void SetGLOBAL(XmlDocument xmldoc)
    {
        //print("SetGloba===1=" + "  time===" + Time.time);
        StaticCoroutine.Start(SetGlobal(xmldoc));
        //print("SetGloba===3="+"  time==="+Time.time);
    }
    static private void CheckClient(string client)
    {
        if (string.IsNullOrEmpty(client) || client == "none")
        {
            Debug.Log("No client found when loading UDT");
            return;
        }

        if (client != _G.PATH)
        {
            Debug.Log($"Client is not matching between saves. Old save : {client}, Current : {_G.PATH}");
            return;
        }
    }
    static private void CheckVersion(string version)
    {
        if (string.IsNullOrEmpty(version) || version == "none")
        {
            Debug.Log("No version found when loading UDT");
            return;
        }

        if (!SaveCompatibility.RefID_CheckedOnce && !string.IsNullOrEmpty(_G.ref_id))
        {
            SaveCompatibility.SetVersionCompatibility_RefID(version);
        }

        if (version != _G.VER)
        {
            Debug.Log($"Version is not matching between saves. Old save : {version}, Current : {_G.VER}");
            return;
        }
    }
    static private bool IsVersionCompatible(string savedVersion, string compatibleVersion)
    {
        bool isCompatible = false;

        List<int> savedVersionNumbers = GetVersionNumbers(savedVersion);

        List<int> compatibleVersionNumbers = GetVersionNumbers(compatibleVersion);
        for (int i = 0; i < savedVersionNumbers.Count; i++)
        {
            bool isLongerVersionLength = i >= compatibleVersionNumbers.Count;
            if (isLongerVersionLength)
            {
                bool isVersionHigherIteration = i > 0 && savedVersionNumbers[i - 1] == compatibleVersionNumbers[i - 1];
                isCompatible = isVersionHigherIteration || i == 0;
                break;
            }

            bool isVersionHigher = savedVersionNumbers[i] > compatibleVersionNumbers[i];
            if (isVersionHigher)
            {
                isCompatible = true;
                break;
            }

            bool isVersionLower = savedVersionNumbers[i] < compatibleVersionNumbers[i];
            if (isVersionLower)
            {
                isCompatible = false;
                break;
            }

            bool isSameVersion = i == savedVersionNumbers.Count - 1 && savedVersionNumbers[i] == compatibleVersionNumbers[i];
            if (isSameVersion)
            {
                isCompatible = true;
                break;
            }
        }

        return isCompatible;
    }
    static private List<int> GetVersionNumbers(string version)
    {
        List<int> outList = new();

        string[] stringVersionNumbers = version.Split('.');
        foreach (string versionNumber in stringVersionNumbers)
        {
            if (int.TryParse(versionNumber, out int number))
            {
                outList.Add(number);
            }
        }

        return outList;
    }
    private static Dictionary<string,float> GetLightSetting(){
        Dictionary<string,float> Dic=_G.LightSetting;
        string code=StringXML("//Room/GLOBAL/LightSetting");
        if(code!=null && code!="none"){
            Dic.Clear();
            string[] Code=code.Split('?');
            for(int i=0;i<Code.Length; i++){
                Dic.Add(Code[i].Split(':')[0],float.Parse(Code[i].Split(':')[1]));
            }
        }
        if(!Dic.ContainsKey("SunPosition"))Dic.Add("SunPosition",200);
        if(!Dic.ContainsKey("SunIntensity"))Dic.Add("SunIntensity",0.5f); 
        if(!Dic.ContainsKey("AmbianceExposer"))Dic.Add("AmbianceExposer",1.0f);
        if(!Dic.ContainsKey("Occlusion"))Dic.Add("Occlusion",0.25f);
        if(!Dic.ContainsKey("SceneLights"))Dic.Add("SceneLights",5000f);
        if(!Dic.ContainsKey("ShadowRoom"))Dic.Add("ShadowRoom",0.75f);
        if(!Dic.ContainsKey("CeilingIntensity"))Dic.Add("CeilingIntensity",2000f);
        if(!Dic.ContainsKey("GlowBloom"))Dic.Add("GlowBloom",1f);

        if( _G.LightSetting["AmbianceExposer"]==0)_G.LightSetting["AmbianceExposer"]=1;
        return Dic;


    }
    private static Dictionary<string,Color> GetLightColor(){
        Dictionary<string,Color> Dic=_G.LightColor;
        string code=StringXML("//Room/GLOBAL/LightColor");
        if(code!=null && code!="none"){
            Dic.Clear();
            string[] Code=code.Split('?');
            for(int i=0;i<Code.Length; i++)
            {
                string Hex = Code[i].Split(':')[1];
                Color color=DOIT.CSc(Hex,255);
                Dic.Add( Code[i].Split(':')[0],color);
            }
        }
        return Dic;
    }
    private static Dictionary<string,string> GetClientInfo(){
        Dictionary<string,string> Dic=_G.ClientInfo;
        string code=StringXML("//Room/GLOBAL/ClientInfo");
        //print("code==="+code);//code===System.Collections.Generic.Dictionary`2[System.String,System.String]
        if(code!="none" && code.IndexOf("System.Collections")==-1){
            Dic.Clear();
            string[] Code=code.Split('?');
            for(int i=0;i<Code.Length; i++){
                Dic.Add( Code[i].Split(':')[0] , Code[i].Split(':')[1]);
            }
        }
        return Dic;
    }
    private static List<string> GetGlobalSetting(){
        List<string> ListGlobal=_G.UIT_LibraryGlobalStart;
        for(int i=1; i<_G.UIT_LibraryGlobalStart.Count; i++)
        {
            string Global=StringXML("//Room/GLOBAL/Global"+i.ToString());
            if(Global!="none" && Global.Split(',')[1]!="none"){
                _G.UIT_LibraryGlobalStart[i]=Global;
            }
        }


        return ListGlobal;
    }
    private static List<string> GetCabTextureList(){
        string ListXml=StringXML("//Room/GLOBAL/CabtextureList");
        List<string> ListCabTexture = _G.UIT_LibraryCabTextures;
        if(ListXml!="none" && !string.IsNullOrEmpty(ListXml))
        {
            ListXml=ListXml.Replace("Unique_Name","UniqueName");
            ListCabTexture=new(){};
            string[] Liststring = ListXml.Split("_");
            foreach(string str in Liststring){
                if(!string.IsNullOrEmpty(str)){

                     ListCabTexture.Add(str);               
                }
            }
        }

        return ListCabTexture;
    }
    private static List<string> GetYourLibrary(string Path)
    {
        List<string> list = new();
        string YourLibrary = StringXML(Path);
             print("YourLibrary=====Load===" + YourLibrary);       
        if(YourLibrary!="none" && !string.IsNullOrEmpty(YourLibrary))
        {

            return new List<string>(YourLibrary.Split("__"));
        }
        return list;
    }
    
    //---------------------------CAMERA------------------------------------------
    public static void Camera()
    {
        //Transform cam = GameObject.Find("MainCamera").transform;
        //cam.position = new Vector3(_G.Camx, _G.Camy, _G.Camz);
        //cam.eulerAngles = new Vector3(0, _G.CamA, 0);

        DASH.RESETSCENE();
    }
    
    //---------------------------MOLDING------------------------------------------
    public static IEnumerator Molding()
    {
        //print("_G.WMK[0]=="+_G.WMK[0]);
        //print("_G.WMO[0]=="+_G.WMO[0]);
        if (_G.WMK[0] != "ND") yield return  ConstructMolding.AddMoldingCoroutine("B");
        if (_G.WMO[0] != "ND") yield return  ConstructMolding.AddMoldingCoroutine("B");

    }
    
    //---------------------------FLOOR------------------------------------------
    public static void Floor()
    {
        print("_G.FLCs=====" + _G.FLCs);
        CreateFloor.SetFloor();
    }

    //------------------------------VALIDATE---------------------------------------------------
    private static void ValidateData(int i)
    {
        string[] c = _G.OBJs[i];
        string objectType = c[0][..4];
        switch (objectType)
        {
            case "cabi":
                //ValidateExteriorFinish(ref c, i);
                //ValidateInteriorFinish(ref c, i);
                //ValidateSidePanel(ref c, i);
                //ValidateRecoverPanel(c, i);
                //ValidateDoorPattern(c, i);
                SuspendedCab.ValidateSuspendedCabs(i);
                break;
            case "pane":
                ValidateExteriorPanelColor(ref c, i);
                break;
            default: break;
        }

    }
    private static void ValidateDoorPattern(string[] C, int objNumber)
    {
        string[] code = C[25].Split("_");

        for (int i = 2; i < code.Length; i += 4)
        {
            if (!string.IsNullOrEmpty(code[i]))
            {
                if (code[i].Substring(0, 1) == "g")
                {
                    code[i] = "GL.01";
                }
            }
        }

        _G.OBJs[objNumber][25] = string.Join("_", code);

        code = C[26].Split("_");

        for (int i = 2; i < code.Length; i += 4)
        {
            if (!string.IsNullOrEmpty(code[i]))
            {
                if (code[i].Substring(0, 1) == "g")
                {
                    code[i] = "GL.01";
                }
            }
        }
        _G.OBJs[objNumber][26] = string.Join("_", code);
    }
    private static void ValidateExteriorPanelColor(ref string[] c, int i)
    {
        // if (_G.OBJs[i][90] != "FakeDoor")
        // {
        //     string texture = c[61];
        //     string[] textureSplit = texture.Split("?");
        //     var library = UIT.GetLibrary(Library.CabTexture);
        //     library.TryGetValue(textureSplit[0], out var data);

        //     if (data == null)
        //     {
        //         string newIdValue = library.ElementAt(0).Key;
        //         c[61] = $"{newIdValue}?{textureSplit[1]}";
        //         _G.OBJs[i][61] = c[61];
        //     }
        // }
    }
    private static void ValidateExteriorFinish(ref string[] c, int i)
    {
        string[] exterior = c[83].Split('_');
        int symbolToAdd = 0;
        string newValue = "";
        for (int j = 0; j < exterior.Length; j++)
        {
            if (exterior[j].Contains("0"))
            {
                symbolToAdd = 0;
            }
            else if (exterior[j].Contains("1"))
            {
                symbolToAdd = 1;
            }
            else
            {
                symbolToAdd = 0;
            }

            newValue += symbolToAdd.ToString();
            if (j < exterior.Length - 1) newValue += "_";

        }
        c[83] = newValue;
        _G.OBJs[i][83] = c[83];
    }
    private static void ValidateInteriorFinish(ref string[] c, int i)
    {
        string[] interior = c[87].Split("_");
        string[] exterior = c[83].Split('_');
        int symbolToAdd = 0;
        if (interior.Length == 1)
        {
            string newValue = "";
            if (interior[0] == "0")
            {
                symbolToAdd = 0;
            }
            else if (interior[0] == "1")
            {
                symbolToAdd = 1;
            }

            for (int j = 0; j < exterior.Length; j++)
            {
                newValue += symbolToAdd.ToString();
                if (j < exterior.Length - 1) newValue += "_";
            }

            c[87] = newValue;
            _G.OBJs[i][87] = c[87];
        }
        else if (interior.Length != exterior.Length)
        {
            string newValue = "";
            for (int j = 0; j < exterior.Length; j++)
            {
                if (j < interior.Length)
                {
                    if (interior[j].Contains("0"))
                    {
                        symbolToAdd = 0;
                    }
                    else if (interior[j].Contains("1"))
                    {
                        symbolToAdd = 1;
                    }
                    else
                    {
                        symbolToAdd = 0;
                    }
                }
                else
                {
                    symbolToAdd = 0;
                }
                newValue += symbolToAdd.ToString();
                if (j < exterior.Length - 1) newValue += "_";
            }
            c[87] = newValue;
            _G.OBJs[i][87] = c[87];
        }
    }
    public static void ValidateSidePanel(ref string[] c, int i)
    {
        string sidePanelFormula = c[78];

        bool needDefaultValue = string.IsNullOrEmpty(sidePanelFormula);

        if (!needDefaultValue)
        {
            string[] sidePanelSplit = sidePanelFormula.Split("_");

            needDefaultValue = sidePanelSplit.Length != c[83].Split("_").Length;
        }

        if (needDefaultValue)
        {
            sidePanelFormula = SidePanel.GetSide_Panel_Recipe(c);

            c[78] = sidePanelFormula;
            _G.OBJs[i][78] = sidePanelFormula;
            //print("C[78]======================================" + _G.OBJs[i][78]);
            //print("C[87]======================================" + _G.OBJs[i][87]);
        }
    }
    private static void ValidateRecoverPanel(string[] objectData, int objectIndex)
    {
        string recoverRecipe = objectData[81];
        string[] splitRecoverRecipe = recoverRecipe.Split(',');
        //Debug.Log($"recover recipe for {objectData[0]} : {recoverRecipe}");

        bool isFirstIndex = true;
        string validatedRecoverRecipe = "";
        foreach (string sideRecipe in splitRecoverRecipe)
        {
            string validatedSideRecipe = "";
            string[] splitSideRecipe = sideRecipe.Split("_");

            if (splitSideRecipe.Length == 0)
            {
                // set none
                validatedSideRecipe = "0_0_0_0_0_0_0";
            }
            else if (splitSideRecipe.Length > 1 || splitSideRecipe[0] == "0")
            {
                // set loaded value
                validatedSideRecipe = sideRecipe;
            }
            else if (splitSideRecipe.Length == 1)
            {
                // set default
                validatedSideRecipe = AddRecoverToCabinet.GetDefaultRecoverValue(objectIndex);
            }

            string recipeSeparator = isFirstIndex ? "" : "_";
            validatedRecoverRecipe += $"{recipeSeparator}{validatedSideRecipe}";
            isFirstIndex = false;
        }

        _G.OBJs[objectIndex][81] = validatedRecoverRecipe;
        return;
    }
    
    //------------------------------CABINETS---------------------------------------------------
    public static IEnumerator Cabinets()
    {
        yield return new WaitForEndOfFrame();
        CameraAround.Show();
        DASH.HDsetBTNcolor(false);
        //yield return new WaitForEndOfFrame();
        CABS = new List<string>();
        XmlNode node;
        string path;

        for (int i = 0; i < 100; i++)
        {
            path = "//Room/CABINET" + i.ToString() + "/O0";
            node = xmlDoc.DocumentElement.SelectSingleNode(path);
            if (node != null)
            {
              _G.Download_qty+=1;                
                CABS.Add(i.ToString());
                GetCode("//Room/CABINET", i);
                //ValidateData(i);
            }
            
            //yield return new WaitForEndOfFrame();
        }

        OBJS = new List<string>();
        for (int i = 0; i < 200; i++)
        {
            path = "//Room/OBJECT" + i.ToString() + "/O0";
            node = xmlDoc.DocumentElement.SelectSingleNode(path);
            if (node != null)
            {
                _G.Download_qty+=1;                
                OBJS.Add(i.ToString());
                GetCode("//Room/OBJECT", i);
                //ValidateData(i);
                //print("From load object i===="+i);

            }
            //yield return new WaitForEndOfFrame();
           
        }


        foreach (string str in CABS)
        {
            yield return CreateCabinet(str);
        }
        foreach (string str in OBJS)
        {
            StaticCoroutine.Start(CreateObjects(str));
            yield return new WaitUntil(() => _G.Load == true);
        }

    } 
    private static IEnumerator CreateCabinet(string str)
    {
        //yield return new WaitForSeconds(Wait);
        int i = int.Parse(str);
        //print("CreateCabinet()===="+str);
        if (_G.OBJs[i][0] != "null")
        {
            //CORRECTION
            CorrectionLoading(i);
            if (_G.OBJs[i][5] == "BA" && _G.OBJs[i][68] != "NONE") { CoroutineController.Start(LoadObjects(i)); }
            if (_G.OBJs[i][5] == "BA" && _G.OBJs[i][68] == "NONE") ConstructBASE.AddCab(i);
            if (_G.OBJs[i][5] == "WA") ConstructWALL.AddCab(i);
            if (_G.OBJs[i][5] == "TA") ConstructTALL.AddCab(i);
            if (_G.OBJs[i][5] == "CB") ConstructCORNERBASE.AddCab(i);
            if (_G.OBJs[i][5] == "CW") ConstructCORNERWALL.AddCab(i);
            if (_G.OBJs[i][5] == "PNL") ConstructPanel.AddPanel(i);
            //_G.OBJs[i][89]=_G.OBJs[i][0];
            if (_G.OBJnum <= i) _G.OBJnum = i + 1;
        }
        _G.Download_qty-=1;
        CoroutineController.Start(StopLoading());
        yield return null;
    }
    private static void CorrectionLoading(int i)
    {
        if (_G.OBJs[i][14] == "none") correction.C14(i);
        if (_G.OBJs[i][48] == "none") _G.OBJs[i][49]="COLLISION";
        if (_G.OBJs[i][49] == "none") _G.OBJs[i][49]="COLLISION";
        if (_G.OBJs[i][28].IndexOf("m") != -1) correction.C28(i);
        if (_G.OBJs[i][28] == "none") correction.C28(i);
        if (_G.OBJs[i][85] == "none") correction.C85(i);
        if (_G.OBJs[i][86] == "none") correction.C86(i);
        if (_G.OBJs[i][85].Split('?').Length == 1) correction.C85(i);
        if (_G.OBJs[i][86].Split('?').Length == 1) correction.C86(i);
        if (_G.OBJs[i][85].IndexOf("NONE") != -1) correction.C85(i);
        if (_G.OBJs[i][86].IndexOf("NONE") != -1) correction.C86(i);
        if (_G.OBJs[i][29] == "none") correction.C29(i);
        if (_G.OBJs[i][34] == "none") correction.C34(i);
        if (_G.OBJs[i][82] == "none") _G.OBJs[i][82] = UIT.Global(Header.Ext,_G.G);//GlobalSelectionManager.GetValue(GlobalOption.EXTPNL_2);
        if (_G.OBJs[i][83] == "none") correction.C83(i);
        correction.C41(i);
        if (_G.OBJs[i][60] == "GLOBAL") _G.OBJs[i][60] = "GLOBAL" + _G.G.ToString();
        if (_G.OBJs[i][11] == "none" || _G.OBJs[i][2] == "Panel") correction.C11(i);
        _G.OBJs[i][89] = _G.OBJs[i][0];
        //ListSetUp.namechange(i);
    }

    //------------------------------OBJECTS---------------------------------------------------
    private static IEnumerator CreateObjects(string str)
    {

        //print("From load object str===="+str);
        int i = int.Parse(str);
        
        //print("CreateObjectst()===="+str);
        string[] c = _G.OBJs[i];
        if (c[0] != "null")
        {
            //print("c[0]===="+c[0]);
            if (_G.OBJs[i][14] == "none") correction.C14(i);
            c[89] = c[0];
            //Correction
            if (c[60] == "GLOBAL") c[60] = "GLOBAL" + _G.G.ToString();
            if (c[61].IndexOf("GPNL") != -1) correction.C61pnl(i);
            if (c[26] == "none") correction.C26(i);
            if (c[28].Length == 6 && c[4] != "wine") correction.C28(i);
            if (c[28].IndexOf("m") != -1) correction.C28(i);
            if (c[28] == "none") correction.C28(i);
            if (c[29] == "none") correction.C29(i);
            if (c[2] == "Bloc") correction.C41(i);
            if (c[11] == "none" || c[2] == "Panel") correction.C11(i);
            //print("c[0]===="+c[0]);
            if (c[2] == "Opening") { ConstructOpen.AddOpen(i); }
            if (c[2] == "Patio") { ConstructPatio.AddPatio(i); }
            if (c[2] == "Door") { ConstructDoor.AddDoor(i); }
            if (c[2] == "Bloc") { ConstructBloc.AddBloc(i); }
            if (c[2] == "Picture") { ConstructPicture.AddPicture(i); }
            if (c[2] == "Window") { ConstructWindow.AddWindow(i); }
            if (c[4] == "hood") ConstructHood.AddHood(i);
            if (c[4] == "panel") ConstructPanel.AddPanel(i);
            if (c[4] == "Slider") ConstructSlider.AddSlider(i);
            if (c[2] == "Counter") { ConstructCounter.AddCounter(i); }
            if (c[2] == "Mirrors") { ConstructMirror.AddMirror(i); }
            // if (c[2] == "Deco") {   ConstructDECO.AddObject(i); } 
            if (c[4] == "frid") { CoroutineController.Start(LoadObjects(i)); }
            if (c[4] == "micr") { CoroutineController.Start(LoadObjects(i)); }
            if (c[4] == "wadr") { CoroutineController.Start(LoadObjects(i)); }
            if (c[4] == "dish") { CoroutineController.Start(LoadObjects(i)); }
            if (c[4] == "wine") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Small") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Stool") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Chair") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Table") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Ornament") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Toilet") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Bath") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Shower") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "BathSink") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Vase") { CoroutineController.Start(LoadObjects(i)); }
            if (c[2] == "Lamp") { CoroutineController.Start(LoadObjects(i)); }
            if (c[1].Length >= 4)
            {
                if (c[1][..4] == "PLAT") { CoroutineController.Start(LoadObjects(i)); }
                if (c[1][..4] == "BUIL") { CoroutineController.Start(LoadObjects(i)); }
                if (c[1][..4] == "STOV") { CoroutineController.Start(LoadObjects(i)); }
            }
            //c[89] = c[0];
        }
        if (_G.OBJnum <= i) {_G.OBJnum = i + 1;}
        _G.Download_qty-=1;
        CoroutineController.Start(StopLoading());
        yield return null;
    }
    private static IEnumerator LoadObjects(int i)
    {
        if (_G.OBJs[i][2] == "Stool") { ConstructStool.AddStool(i); }
        if (_G.OBJs[i][2] == "Chair") { ConstructChair.AddChair(i); }
        if (_G.OBJs[i][2] == "Table") { ConstructTable.AddTable(i); }
        if (_G.OBJs[i][2] == "Ornament") { ConstructOrnament.AddOrnament(i); }
        if (_G.OBJs[i][2] == "Vase") { ConstructVase.AddVase(i); }
        if (_G.OBJs[i][2] == "Lamp") { ConstructLamp.AddLamp(i); }
        if (_G.OBJs[i][2] == "Small") ConstructSmallelectro.AddSmallElectro(i);
        if (_G.OBJs[i][2] == "Toilet") ConstructToilet.AddToilet(i);
        if (_G.OBJs[i][2] == "Bath") ConstructBath.AddBath(i);
        if (_G.OBJs[i][2] == "Shower") ConstructShower.AddShower(i);
        if (_G.OBJs[i][2] == "BathSink") ConstructBathSink.AddBathSink(i);
        if (_G.OBJs[i][5] == "BA") ConstructBASE.AddCab(i);
        if (_G.OBJs[i][4] == "frid") ConstructFRIDGE.AddFridge(i);
        if (_G.OBJs[i][4] == "micr") ConstructMicrowave.AddMicrowave(i);
        if (_G.OBJs[i][4] == "wadr") ConstructWD.AddWD(i);
        if (_G.OBJs[i][4] == "dish") ConstructDishwasher.AddDishwasher(i);
        if (_G.OBJs[i][4] == "wine") ConstructWiner.AddWiner(i);
        if (_G.OBJs[i][1].Length >= 4) if (_G.OBJs[i][1][..4] == "PLAT") ConstructPlatestove.AddStovePlates(i);
        if (_G.OBJs[i][1].Length >= 4) if (_G.OBJs[i][1][..4] == "BUIL") ConstructBuildin.AddBuilding(i);
        if (_G.OBJs[i][1].Length >= 4) if (_G.OBJs[i][1][..4]== "STOV") ConstructStove.AddStove(i);
        yield return new WaitForEndOfFrame();
        //yield return null;
    }
    private static IEnumerator StopLoading()
    {
        //print("------------------------stop loading--------------------------------------1-----"+_G.Download_qty+"  time==="+Time.time);
        if (_G.Download_qty == 0 && _G.Download_qty < 4000)
        {
            WaitCircle.Setting(true, TRANS.This("M_Download"));
            yield return null;

            if (GameObject.Find("TEMPLATEpnl"))
            {
                Set.alpha(GameObject.Find("TEMPLATEpnl"), false);
            }

            SceneModeManager.Instance.SetSceneMode(SceneModes.Navigate);
            GameObject.Find("MainCamera").GetComponent<CameraAround>().Hide();

            GameObject.Find("FN").GetComponent<TextMeshProUGUI>().text = _G.FileName;
            if (_G.NT == true) { _M.PH(19, 0, "ffffff", 1, 1); _G.NT = false; }

            Shopify.ShowEcommeceIcon();
            DASH.REFRESH();
            WaitCircle.Setting(true, TRANS.This("M_Download"));
            yield return null;

            //yield return new WaitForSeconds(3);
            Shopify.ShowEcommeceIcon();
            SelectLight.Set_All_Lights_to_Scene();

            _G.Download_qty = 5000;
            DOIT.CloseALLPNL();
            //print("StopLoading===" + _G.Download_qty + "  time===" + Time.time);
            //WaitCircle.Setting(false, "");
            //yield return null;
            _MOL.SetMolding();
            PRICE.Calprice();
        }
        if (_G.Download_qty < 0)
        {
            print("_G.Download_qty====" + _G.Download_qty + "  time===" + Time.time);
        }
        if (_Add.YOUR_DOORS.Count == 0) _Add.Door(UIT.Global(Header.Door, _G.G));
        if (_Add.YOUR_PANELS.Count == 0) _Add.Panel(UIT.Global(Header.Ext, _G.G));
    }

    //---------------------------Color Walls------------------------------------------
    public static IEnumerator ColorWalls()
    {
        int i = 0;
        for (i = 1; i < _G.NW + 1; i++)
        {
            string ns = i.ToString();
            if (GameObject.Find("w" + ns))
            {
                string codetexture = StringXML("//Room/W" + ns + "/texturecode");

                print("codetexture=====" + codetexture);
                //codetexture=====GYPS.1,FFFFFFFF,FFFFFFFF,FFFFFFFF,0.25,0.25,0,0.25,0.25
                if (codetexture.Contains("GYPS.1")) { codetexture = "GYPS.1,#ffffff,#A6A6A6,#ffffff,0.25-0.25,0,1,0,0,0"; }
                if (codetexture.IndexOf("GYPS.1") == -1)
                {
                    codetexture = Set.NewValueCode(codetexture, "null", 0, ",");
                    codetexture = Set.NewValueCode(codetexture, "0", 7, ",");
                    codetexture = Set.NewValueCode(codetexture, "0.2", 8, ",");        
                }

                if (string.IsNullOrEmpty(codetexture))
                {
                    codetexture = "null,#ffffff,#A6A6A6,#ffffff,0.25-0.25,0,1,0,0,0"; 
                }
                Debug.Log("codetexture : " + codetexture);
                
                yield return PaintaWall(GameObject.Find("w" + ns), codetexture);
            }
        }
        Transform ceil = SceneModeManager.Ceil;
        if (ceil)
        {
            string ceilcode = StringXML("//Room/CEIL/texturecode");
            if (ceilcode.Contains("GYPS.1")){ceilcode = "GYPS.1,#ffffff,#A6A6A6,#ffffff,0.25-0.25,0,1,0,0,0";}
            if (ceilcode == "none") { ceilcode = "none,#FFF0D8FF,#827A6E,#5B564D,1-1,0,1,0,0,0.3"; }

            if (ceilcode.IndexOf("GYPS.1") == -1)
            {
                ceilcode = Set.NewValueCode(ceilcode!, "null", 0, ",");

            }

            //print("ceilcode============" + ceilcode);
            foreach (Transform Section in ceil.transform)
            {
                Section.GetComponent<Renderer>().material = UIT_MATERIAL.GetMaterial(ceilcode);
                
            }
            
            //Debug.Log("ceilcode : " + ceilcode);
        }

        for (i = 0; i < _G.NW; i++)
        {
            if (GameObject.Find("w" + (i + 1).ToString()))
            {
                _G. WallsMaterial[i] = GameObject.Find("w" + (i + 1).ToString()).transform.GetChild(0).GetComponent<MeshRenderer>().material;
                //Debug.Log($"loop w{i} ; mat : {_G. WallsMaterial[i]}");
                yield return null;
            }
        }

        _G.ceilm = ceil.transform.GetChild(0).GetComponent<Renderer>().material;
    }
    public static IEnumerator PaintaWall(GameObject O, string codetexture)
    {
        if (codetexture == "none") codetexture = "none,#FFF0D8FF,#827A6E,#5B564D,1-1,0,1,0,0,0.3"; 
        
        for (int i = 0; i < O.transform.childCount; i++)
        {
            O.transform.GetChild(i).GetComponent<Renderer>().material = UIT_MATERIAL.GetMaterial(codetexture);
            if (codetexture.Split(',')[0] == "GYPS.1")
            {
                O.transform.GetChild(i).GetComponent<Renderer>().material.SetFloat("_Relief", 0);
            }
            yield return null;
        }
    }

    //---------------------------GETTING------------------------------------------
    public static float NumXML(string E)
    {
        XmlNode node = xmlDoc.DocumentElement.SelectSingleNode(E);
        float v = 0;
        if (node != null)
        {
            string NS = node.InnerText.Replace(",", ".");
            v = DOIT.ConvertStringToNumber(NS);
        }
        return v;
    }
    public static int IntXML(string E)
    {
        XmlNode node = xmlDoc.DocumentElement.SelectSingleNode(E);
        int v = 0;
        if (node != null)
        {
            string NS = node.InnerText.Replace(",", ".");
            v = int.Parse(NS);
        }
        return v;
    }
    public static string StringXML(string E)
    {
        string Estring = "none";
        XmlNode node = xmlDoc.DocumentElement.SelectSingleNode(E);
        if (node != null) Estring = node.InnerText;
        return Estring;
    }
    public static Color ColorXML(string E)
    {
        XmlNode node = xmlDoc.DocumentElement.SelectSingleNode(E);
        string Cstring = node.InnerText;
        Color col = DOIT.CSc(Cstring, 255);

        return col;
    }
    public static bool BoolXML(string E)
    {
        XmlNode node = xmlDoc.DocumentElement.SelectSingleNode(E);
        string PIN = node.InnerText;
        bool Pin = true;
        if (PIN == "false") Pin = false;
        return Pin;
    }

    //---------------------------Texture Walls------------------------------------------
    public static Texture2D TextureXML(string E)
    {
        XmlNode node = xmlDoc.DocumentElement.SelectSingleNode(E);
        string Ts = node.InnerText;
        Texture2D T;
        if (Ts == "none") T = null;
        else
        {
            string path = "" + Ts;
            if (Ts == "GypseHorizontal") path = "ROOM/GypseHorizontal";
            T = Resources.Load(path) as Texture2D;
        }
        return T;
    }
    public static Texture2D TextureXMLFloor()
    {
        string path = "";
        if (_G.FLC[0] == "Plywood12x14") { path = "Plywood12x14"; };
        if (_G.FLC[0].Substring(0, 4) == "FLOO") { path = "FINISH/FW/FW" + _G.FLC[0].Substring(4, 3); }
        if (_G.FLC[0].Substring(0, 4) == "CERA") { path = "FINISH/Ce/Ce" + _G.FLC[0].Substring(4, 3); }
        Texture2D T;
        if (_G.FLC[0] == "none") T = null;
        else T = Resources.Load(path) as Texture2D;
        return T;
    }
    public static Vector2 SetScale()
    {
        float scaleX = DOIT.ConvertStringToNumber(_G.FLC[1]);
        float scaleY = DOIT.ConvertStringToNumber(_G.FLC[2]);
        Vector2 S = new ((NumXML("//Room/FLOOR/texw") + 500) / scaleX, (NumXML("//Room/FLOOR/texh") + 500) / scaleY);
        return S;
    }
    public static void GetCode(string path, int i)
    {
       //print(_G.OBJs[i]);
        if(_G.OBJs[i]==null){
            _G.OBJs[i] = new string[100];
            for (int n = 0; n < 100; n++)
            {
                _G.OBJs[i][n] = StringXML(path + i.ToString() + "/O" + n.ToString());
                //if(n==81){print("Value 81==="+_G.OBJs[i][n]);}
            }
        }   
    }

    //---------------------------Load for web------------------------------------------

    //---------------------------Open Close------------------------------------------
    public static void CloseLoadPnl()
    {
        WaitCircle.Setting(false, "");
    }
    public void openLoadPnl()
    {
        GameObject.Find("HIDER").transform.Find("LOADpnl").gameObject.SetActive(true);
        GameObject.Find("HIDER").transform.Find("TEMPLATEpnl").gameObject.SetActive(false);
        SceneModeManager.Instance.SetSceneMode(SceneModes.Panel);//"PNL";
        Set.alpha(Get.o2("HIDER","LOADpnl"),true);
        Set.alpha(Get.o2("HIDER","OpenWebpnl"),false);
    }
}