using UnityEngine.UI;
using UnityEngine;
using UnityEngine.EventSystems;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using UnityEngine.Networking;
using System.Text;
using System.Globalization;
using TMPro;
using System.Collections.Generic;
using System;

public class MenuScript : MonoBehaviour
{
    public delegate void MobileDetected(bool isMobile);
    public MobileDetected _OnMobileDetected;
    AutoRotate _autoRotate;
    [HideInInspector] public GameObject Pnl_plan2d;
    [HideInInspector] public GameObject Pnl_start;
    [HideInInspector] public GameObject Pnl_ShowPlan;
    [HideInInspector] public GameObject Pnl_scene;
    [HideInInspector] public GameObject MainPnl;
    [SerializeField,HideInInspector] GameObject _touchInputPanel;
    [SerializeField] Paths _path = Paths.Ukitchenit;
    public static float timeKeyHold=0;
    public static float timePassed=0;

    //----------------------------------------Start-----------------------------------------------------------------
    private void Awake()
    {
        CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
        CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
        System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
        SetVersionNumberFromProjectSettings();
        _autoRotate = Camera.main.GetComponent<AutoRotate>();
        SetFrameRate();
        _touchInputPanel.SetActive(false);
    }
    public void Start()
    {
    #if !UNITY_WEBGL
        //int kernelHandle = computeShader.FindKernel("BlendScenarios");
       // computeShader.Dispatch(kernelHandle, ...);

        
    #endif
    #if UNITY_WEBGL
        if(Application.absoluteURL.IndexOf("free")!=-1 && Application.absoluteURL.IndexOf("3d")!=-1  || Application.absoluteURL.IndexOf("Free")!=-1 && Application.absoluteURL.IndexOf("sd")!=-1 )
        {
            Link.OpenWindow("free","https://ukitchenit.com/free/");return;
        }
    #endif
        Application.targetFrameRate=-1;
        SceneModeManager.Instance.SetSceneModeVisibility();
        ReadURL.path();
        CheckForPath();
        //_G.UseNewCsvFormat = _G.CheckIfLibraryUseNewFormat(_G.PATH);
        //WebGLInput.captureAllKeyboardInput=false;
        //_G.PATH="BMR";

        _G.PATH=_G.PATH.ToLower();
        Load_G();
        
        //_G.BKN = 1;//Backup number add when saving on cloud backup
        //_G.status = "nJN";//status Form or not (new no JN, old, JN  //nJN,old,JN)
        _G.OBJs[299] = new string[100];
        _G.OBJs[299][0] = "null";
        _G.OBJs[299][1] = "null";
        //_G.L = 2;//French
        DOIT.CloseALLPNL();
        Pnl_start.SetActive(true);
        Pnl_ShowPlan.SetActive(false);
        Pnl_scene.SetActive(false);
        TRANS.go();
        for (int i = 1; i < 25; i++)
        {
            _G. WallsMaterial[i - 1] = _G.GYPSE;
            _G. WallsTexture[i - 1] = "GypseHorizontal";
        }
        _G.ceilm = _G.GYPSECEIL;
        _G.ceilt = "GypseHorizontal";
        SceneModeManager.Instance.SetSceneMode(SceneModes.Start);

        UIT_LoadLibrary.Load();
        
        Get.o2("HIDER", "Login").SetActive(false);
        Get.o2("Canvas", "PATH").GetComponent<Text>().text = _G.PATH;
        DASH.HDset(false);
        //SelectLight.Setexposer(0);
        //LanguageSelection();    
        Get.o2("Canvas/Panel_main","TEMPLATE").SetActive(_G.PATH=="laminam");      
    }

    private void SetVersionNumberFromProjectSettings()
    {
        _G.VER = Application.version;
    }
    private static void SetFrameRate()
    {
#if !UNITY_EDITOR && UNITY_WEBGL
        Debug.Log("This is a WebGL build");
        _G.IsEditor = false;
        // Code specific to WebGL build
        Application.targetFrameRate = -1;
#endif

#if UNITY_EDITOR
        // Code specific to the Unity Editor build
        Debug.Log("This is the Unity Editor build");
        _G.IsEditor = true;
        QualitySettings.vSyncCount = 0;
        Application.targetFrameRate = -1;
#endif

#if UNITY_STANDALONE
    // Code specific to standalone platforms (Windows, macOS, Linux)
     _G.IsEditor = false;
    Debug.Log("This is a standalone build");
        QualitySettings.vSyncCount = 0;
        Application.targetFrameRate = -1;
#endif

#if UNITY_ANDROID
    // Code specific to Android build
     _G.IsEditor = false;
    Debug.Log("This is an Android build");
     Application.targetFrameRate = -1;
#endif

#if UNITY_IOS
    // Code specific to iOS build
     _G.IsEditor = false;
    Debug.Log("This is an iOS build");
     Application.targetFrameRate = -1;
#endif
    }
    void CheckForPath()
    {
        if (!string.IsNullOrEmpty(_G.PATH)) return;

        //  Initialize Key for Path // to switch key remove last variable name write Paths add the dot "." , and you should see every path defined in _G
        Paths path = _path;

        if (!_G._Paths.ContainsKey(path)) { Debug.Log("No path defined in _G for " + path.ToString()); return; }
        _G.PATH = _G._Paths[path];
    }
    void Update()
    {
        bool isMouseInsideScreenBoundaries = MouseCheck.InOut();
        if (isMouseInsideScreenBoundaries == false && !SceneModeManager.CompareSceneMode(SceneModes.MouseOut))
        {
            SceneModeManager.Instance.OnMouseOut();
        }
        if (isMouseInsideScreenBoundaries && !SceneModeManager.CompareSceneMode(SceneModes.MouseOut))//if mouse is in sofware action
        {
            //print("_G.SM=="+_G.SM);
            bool isPanal=Get.o2("Canvas","Panel_SCENE").activeInHierarchy;
            if (!EventSystem.current.IsPointerOverGameObject() && !SceneModeManager.CompareSceneMode(SceneModes.Plan2D) && isPanal) { HitObject.CheckHIT(); }
            ColorSet.Do();

            GameObject newEmptyGameObject = GameObject.Find("New Game Object");
            if (newEmptyGameObject) Destroy(newEmptyGameObject);

            if (!SceneModeManager.CompareSceneMode(SceneModes.Plan2D) && !SceneModeManager.CompareSceneMode(SceneModes.ShowTips) && !SceneModeManager.CompareSceneMode(SceneModes.CounterView)
                && !SceneModeManager.CompareSceneMode(SceneModes.ZoomTouch) && !SceneModeManager.CompareSceneMode(SceneModes.Ai))
            {
                //Navigate setup
                GameObject[] MENU = GameObject.FindGameObjectsWithTag("Menu");
                GameObject[] PNL = GameObject.FindGameObjectsWithTag("pnl");

                //bool isSelectedAndMenuShouldNormalyBeOpen = SceneModeManager.CompareSceneMode(SceneModes.ReadyMove) || SceneModeManager.CompareSceneMode(SceneModes.Move) || SceneModeManager.CompareSceneMode(SceneModes.SlidingHandle) || SceneModeManager.CompareSceneMode(SceneModes.RotationHandle);
                // menu or panel are open will be stored in array and so we must be in panel mode
                if (MENU.Length != 0 || PNL.Length != 0 || _G.NAVIGATE == false /*|| _G.LockInState*/)
                {
                    if (!_G.LockInState)
                    {
                        if (SceneModeManager.CompareSceneMode(SceneModes.Navigate) || _G.NAVIGATE == false)
                        {
                            if (!SceneModeManager.CompareSceneMode(SceneModes.Paint)
                                && !SceneModeManager.CompareSceneMode(SceneModes.Measure)
                                && !SceneModeManager.CompareSceneMode(SceneModes.Align)
                                && !SceneModeManager.CompareSceneMode(SceneModes.Plan2D)
                                && !SceneModeManager.CompareSceneMode(SceneModes.GroupMove)
                                && !SceneModeManager.CompareSceneMode(SceneModes.Move)
                                && !SceneModeManager.CompareSceneMode(SceneModes.Hit)
                                && !SceneModeManager.CompareSceneMode(SceneModes.Duplicate)
                                && !SceneModeManager.CompareSceneMode(SceneModes.ReadyMove))
                            {
                                //_G.SM = SceneModes.Panel /*"pnl"*/;
                                SceneModeManager.Instance.SetSceneMode(SceneModes.Panel);
                            }
                        }
                    }
                }
                else
                {
                    //Debug.Log("Navigate == " + _G.NAVIGATE);
                    SceneModeManager.Instance.SetSceneMode(SceneModes.Navigate);
                }

            }
            // if(GameObject.Find("MainCamera").activeInHierarchy){
            //     if (!SceneModeManager.CompareSceneMode(SceneModes.CounterView) && !SceneModeManager.CompareSceneMode(SceneModes.Plan2D) && !SceneModeManager.CompareSceneMode(SceneModes.Calcule)) { Camera.main.GetComponent<CameraAround>().Hide(); }
            //     if (!SceneModeManager.CompareSceneMode(SceneModes.CounterView)) HideTopWall();
            //  }   
        }

        timePassed += Time.deltaTime;
            if(timePassed > 0.05f)
            {
                TRANS.go();
                //CAPSSHOW();
                
                BTN_Hide.ShowBTNS();
                timePassed = 0f;
            } 
        COLORSET.On();

        HandleKeyboardInput();

        //hide object
        for (int i = 0; i < _G.HIDELIST.Count; i++)
        {
            GameObject go = GameObject.Find(_G.HIDELIST[i]);
            if (go != null)
            {
                go.SetActive(false);
            }
        }

        //COLORSET.On();
        _G.NAVIGATE = true;

        //Make Directlight off when no openning in scene
        if (!SceneModeManager.CompareSceneMode(SceneModes.CounterView) && !SceneModeManager.CompareSceneMode(SceneModes.Plan2D) && !SceneModeManager.CompareSceneMode(SceneModes.Calcule))
        {
            if (SelectLight.OpenOnScene() && _G.HD == true) { Get.o2("LIGHTS/ONOFF", "Sun").SetActive(true); }
            else if (!SelectLight.OpenOnScene() && _G.HD == true)
            {
                if (Get.o2("LIGHTS/ONOFF", "Directional Light") != null) Get.o2("LIGHTS/ONOFF", "Directional Light").SetActive(false);
            }
        }

        if (isMouseInsideScreenBoundaries && SceneModeManager.CompareSceneMode(SceneModes.MouseOut))
        {
            SceneModeManager.Instance.OnMouseIn();
        }
        BTN_Hide.ShowBTNS();

        if(SceneModeManager.Selected!=null){
            if(timeKeyHold==0 || timeKeyHold>30){
                GameObject sel = SceneModeManager.Selected;
                int nO = Get.GetObjectIndex(SceneModeManager.SelectedName);

                if(!Input.GetKey(KeyCode.LeftShift) && !Input.GetKey(KeyCode.RightShift) )
                {
                    Vector3 SelPosition=sel.transform.position;
                    float CamY=Camera.main.transform.eulerAngles.y;
                    //print("CamY===="+CamY);  
                    float X = 0;
                    float Z = 0;
                    float Y = 0;

                    if(_G.OBJs[nO][22]=="floor"){
                        if(CamY>315 || CamY<45){
                                if (Input.GetKey(KeyCode.DownArrow))Z-=1;
                                else if (Input.GetKey(KeyCode.LeftArrow))X-=1;
                                else if (Input.GetKey(KeyCode.RightArrow))X+=1;
                                else if (Input.GetKey(KeyCode.UpArrow))Z+=1;;
                            }
                        if(CamY<=315 && CamY>=225){
                                if (Input.GetKey(KeyCode.DownArrow))X+=1;
                                else if (Input.GetKey(KeyCode.LeftArrow))Z-=1;
                                else if (Input.GetKey(KeyCode.RightArrow))Z+=1;
                                else if (Input.GetKey(KeyCode.UpArrow))X-=1;
                            }
                        if(CamY<225 && CamY>135){
                                if (Input.GetKey(KeyCode.DownArrow))Z+=1;
                                else if (Input.GetKey(KeyCode.LeftArrow))X+=1;
                                else if (Input.GetKey(KeyCode.RightArrow))X-=1;
                                else if (Input.GetKey(KeyCode.UpArrow))Z-=1;
                            }
                        if(CamY<=135 && CamY>=45){
                                if (Input.GetKey(KeyCode.DownArrow))X-=1;
                                else if (Input.GetKey(KeyCode.LeftArrow))Z+=1;
                                else if (Input.GetKey(KeyCode.RightArrow))Z-=1;
                                else if (Input.GetKey(KeyCode.UpArrow))X+=1;
                            }
                        sel.transform.position=new(SelPosition.x+X,SelPosition.y+Y,SelPosition.z+Z);
                    }
                    if(_G.OBJs[nO][22]!="floor"){
                        if (Input.GetKey(KeyCode.LeftArrow)) {sel.transform.position-=sel.transform.right;}
                        if (Input.GetKey(KeyCode.RightArrow)){sel.transform.position+=sel.transform.right;} 
                        if (Input.GetKey(KeyCode.DownArrow)){sel.transform.position-=sel.transform.forward;}
                        if (Input.GetKey(KeyCode.UpArrow)) {sel.transform.position+=sel.transform.forward;}
                    }

                    //SceneModeManager.Selected.transform.GetComponent<MoveObject>().HandelObjectArrowMove(StartPoint,sel.transform.position,attachedTo.transform);
                }

                if(Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift) )
                {
                    if(Input.GetKey(KeyCode.DownArrow)){sel.transform.position-=sel.transform.up;}
                    if (Input.GetKey(KeyCode.UpArrow)) {sel.transform.position+=sel.transform.up;}
                }
            }
        }

        if (Input.GetKey(KeyCode.DownArrow) || Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.RightArrow) || Input.GetKey(KeyCode.UpArrow)){
            
             if(SceneModeManager.Selected!=null){
                timeKeyHold+=1;
                //TopControl.showMesure();   
                GameObject sel = SceneModeManager.Selected;
                Vector3 StartPoint=sel.transform.position;
                int nO = Get.GetObjectIndex(SceneModeManager.SelectedName);
                sel.transform.GetComponent<MoveObject>().HandelObjectArrowMove(StartPoint,sel.transform.position,_G.OBJs[nO][22]);
             }      
            
            
            }

    }
    
    //--------------------------------------Setting------------------------------------------------------------------  
    private void HandleKeyboardInput()
    {
       //Return key
        //if (Input.GetKeyDown(KeyCode.Return)) { if (Get.Active("MESURE")) { MesureChange.Changevalue(); } }
        if (Input.GetMouseButtonUp(0)){
            if (_G.HD == true)ReflectionProbesUpdater.Instance.UpdateProbes();
            if(SceneModeManager.CompareSceneMode(SceneModes.MoveHandle) && SceneModeManager.Selected.CompareTag("cabwall")) {
                //_MOL.SetMolding();
                }
        }   
        if (Input.GetMouseButtonDown(0))
        {
            _OnMobileDetected?.Invoke(false);
            if(SceneModeManager.CompareSceneMode(SceneModes.Navigate)){Get.o2("HIDER","RightClickMenu").SetActive(false);;}
        }
        if (Input.touchCount > 0)
        {
            //_OnMobileDetected?.Invoke(true);
        }
        if (Input.GetKeyDown(KeyCode.Return))
        {
            if (Get.Active("KEYBOARDNUMBER"))
            {
                Get.o2("KEYBOARDNUMBER", "btnOK").GetComponent<Button>().onClick.Invoke();
            }
            if (Get.Active("KEYBOARDNUMBERPRO"))
            {
                Get.o2("KEYBOARDNUMBERPRO", "btnOK").GetComponent<Button>().onClick.Invoke();
            }
            if (Get.Active("KEYBOARDSHORT"))
            {
                Get.o2("KEYBOARDSHORT", "btnOK").GetComponent<Button>().onClick.Invoke();
            }
        }
        //Delete key
        if (Input.GetKeyDown(KeyCode.Delete))
        {
            if (Get.Active("CONTROL"))
            {
                CONTROL.Delete();
            }
        }
        if (!SceneModeManager.CompareSceneMode(SceneModes.Plan2D))
        {
            if (Input.GetKeyDown(KeyCode.Z) && (Input.GetKey(KeyCode.RightControl) || Input.GetKey(KeyCode.LeftControl)))
            {
                CommandHandler.Instance?.Undo();
            }
            if (Input.GetKeyDown(KeyCode.Y) && (Input.GetKey(KeyCode.RightControl) || Input.GetKey(KeyCode.LeftControl)))
            {
                CommandHandler.Instance?.Redo();
            }
        }
        if (Input.GetKeyDown(KeyCode.F7))
        {
            
        Get.o1("MainCamera").transform.position = new Vector3(162.9786f, 13.79494f, -40.10354f);
        //transform.position = new Vector3(162.9786f, 13.79494f, -40.10354f);
        Get.o1("MainCamera").transform.eulerAngles = new Vector3(4.699f, -76.176f, 0);
            _autoRotate?.ToggleAutoCameraRotation();
        }
        // if (Input.GetKeyDown(KeyCode.F4))
        // {
        //     _autoRotate?.StopAutoCameraRotation();
        // }
        if (Input.GetKeyDown(KeyCode.F6))
        {
            _touchInputPanel.SetActive(!_touchInputPanel.activeSelf);
        }
        if (Input.GetKeyDown(KeyCode.Tab))
        {
            GameObject sel = SceneModeManager.Selected;
            float closest = 100; 
            GameObject closestObject = null;
            List<GameObject> MyListOfObjects=DOLIST.OBJLIST(); 
            
            if(sel!=null ){
                Vector3 SelectedPosition=sel.transform.position;

                //Find obeject nearest
                for (var i = 0; i < MyListOfObjects.Count; i++){
                    float distY = Math.Abs(MyListOfObjects[ i ].transform.position.y-SelectedPosition.y);
                    float distX = Math.Abs(MyListOfObjects[ i ].transform.position.x-SelectedPosition.x);
                    float distZ = Math.Abs(MyListOfObjects[ i ].transform.position.z-SelectedPosition.z);

                    if (distY < closest && distY!=0 && MyListOfObjects[ i ].name.IndexOf("cabi")==-1 && !_G.ObjectInsideSelected.Contains(MyListOfObjects[ i ].name)
                    && distX<12 && distZ<12 && MyListOfObjects[ i ].name!=sel.name)
                    {
                        closest = distY;
                        closestObject = MyListOfObjects[ i ];
                    }
                }
            }

            if(closestObject==null){
                _G.ObjectInsideSelected=new();
            }
            else{
                DOIT.AllSelOff();
                SceneModeManager.SelectedName = closestObject.name;
                int _objectNumber=Get.GetObjectIndex(closestObject.name);
                CommandHandler.Instance.BeforeDataTemp = CommandHandler.CopyObjectData(_G.OBJs[_objectNumber]);
                _G.ObjectInsideSelected.Add(closestObject.name);
            }
        }

        if (Input.GetKeyUp(KeyCode.DownArrow) || Input.GetKeyUp(KeyCode.LeftArrow) || Input.GetKeyUp(KeyCode.RightArrow) || Input.GetKeyUp(KeyCode.UpArrow)){
            timeKeyHold=0;
            //DOIT.SaveObjectPositionInData(SceneModeManager.Selected);
            }

        if (Input.GetMouseButtonDown(1))
        {
            if(SceneModeManager.CompareSceneMode(SceneModes.ReadyMove))
            {
                GameObject Menu = Get.o2("HIDER","RightClickMenu");
                Menu.SetActive(true);
                Menu.transform.position=Input.mousePosition;    
            }
        }

        
    }
    public static bool IsReady()
    {
        bool isReady = false;
        List<string> faultyLibrary = new();

        foreach (var keyPair in _G.LibraryLoaded)
        {
            if (keyPair.Value == false)
            {
                faultyLibrary.Add(keyPair.Key.ToString());
            }
        }

        isReady = faultyLibrary.Count == 0;
        if (!isReady)
        {
            string debugMessage = $"The following {faultyLibrary.Count} Library have yet to load : ";

            foreach (string file in faultyLibrary)
            {
                debugMessage += file + "\n";
            }

            debugMessage += "\n which could indicate either a big file to download, a problem with the file on the server, or the server itself";

            Debug.Log(debugMessage);
        }
        return isReady;
    }
    void Load_G()
    {
        _G.INV = Resources.Load("MATERIALS/INVISIBLE") as Material;//Invisible
        _G.GRT = Resources.Load("MATERIALS/GRT") as Material;//Red Box        
        _G.GGT = Resources.Load("MATERIALS/GGT") as Material;//Green Box
        _G.GBT = Resources.Load("MATERIALS/GBT") as Material;//Blue Box
        _G.TEXTURE = Instantiate(Resources.Load("MATERIALS/TEXTURES/Mat3D") as Material);
        _G.GYPSE = UIT_MATERIAL.GetMaterial("GYPS.1,#ffffff,#A6A6A6,#ffffff,0.25-0.25,0,1,0.25,0,0");////Texture,C1,C2,C3,Tile,Rotation,Contrast,smoothness,Mettallic,relief
        _G.GYPSECEIL = _G.GYPSE;
        _G.ELEG = Resources.Load("MATERIALS/TEXTURES/ELEG") as Material;
        _G.ST = Resources.Load("MATERIALS/TEXTURES/Standard") as Material;     
        _G.BGPATIO = Resources.Load("MATERIALS/TEXTURES/SKY_REFLEX") as Material;
        _G.TRANS = Instantiate(Resources.Load("MATERIALS/TEXTURES/TRANS") as Material);
        _G.GLASS = Resources.Load("MATERIALS/TEXTURES/GLASS") as Material;
        _G.FROSTYGLASS = Resources.Load("MATERIALS/TEXTURES/FROSTYGLASS") as Material;
        _G.FLATWHITE = Resources.Load("MATERIALS/TEXTURES/FLATWHITE") as Material;
        _G.GLOW = Instantiate(Resources.Load("MATERIALS/TEXTURES/Lights") as Material);
        _G.MIRROR = Resources.Load("MATERIALS/TEXTURES/MIRROR") as Material;
        _G.MESH = Resources.Load("MATERIALS/MESH") as Material;
        _G.BG = Resources.Load("MATERIALS/BG") as Material;
 
        _G.DOORGLASS = Instantiate(Resources.Load("MATERIALS/DOORGLASS") as Material);


        //Sprite
        _G.WEs = Resources.Load<Sprite>("ICONS/PLAN2D/WE") as Sprite;
        _G.WINDs = Resources.Load<Sprite>("ICONS/PLAN2D/WIND") as Sprite;
        _G.pat1 = Resources.Load<Sprite>("ICONS/PLAN2D/pat1") as Sprite;
        _G.pat2 = Resources.Load<Sprite>("ICONS/PLAN2D/pat2") as Sprite;
        _G.pat3 = Resources.Load<Sprite>("ICONS/PLAN2D/pat3") as Sprite;
        _G.pat4 = Resources.Load<Sprite>("ICONS/PLAN2D/pat4") as Sprite;
        _G.pat5 = Resources.Load<Sprite>("ICONS/PLAN2D/pat5") as Sprite;
        _G.pat6 = Resources.Load<Sprite>("ICONS/PLAN2D/pat6") as Sprite;
        _G.kno = Resources.Load<Sprite>("ICONS/PLAN2D/kno") as Sprite;
        _G.knoR = Resources.Load<Sprite>("Other/knobR") as Sprite;
        _G.round = Resources.Load<Sprite>("Other/iEmpty") as Sprite;
        _G.patO = Resources.Load<Sprite>("ICONS/PLAN2D/patO") as Sprite;
        _G.patW = Resources.Load<Sprite>("ICONS/PLAN2D/patW") as Sprite;
        _G.patG = Resources.Load<Sprite>("ICONS/PLAN2D/patG") as Sprite;
        _G.patB = Resources.Load<Sprite>("ICONS/PLAN2D/patB") as Sprite;
        _G.btnX = Resources.Load<Sprite>("Other/fbtnx") as Sprite;

        // _G.Wood= new Texture2D[]{
        //     Instantiate(Resources.Load<Texture>("TEXTURES/TEXT/TEXT.1.2") as Texture2D),
        //     Instantiate(Resources.Load<Texture>("TEXTURES/TEXT/TEXT.1.8") as Texture2D),
        //     Instantiate(Resources.Load<Texture>("TEXTURES/TEXT/TEXT.1.50") as Texture2D)};
        // _G.Fabric=new Texture2D[]{
        //     Instantiate(Resources.Load<Texture>("TEXTURES/TEXT/TEXT.1.20") as Texture2D),
        //     Instantiate(Resources.Load<Texture>("TEXTURES/TEXT/TEXT.1.21") as Texture2D)};
    }
    void HideTopWall()
    {
        if (_G.CAMSET == CamSettings.Front || _G.CAMSET == CamSettings.Plan2D)
        {
            GameObject[] walltop = GameObject.FindGameObjectsWithTag("TopWall");
            foreach (GameObject Top in walltop)
            {
                Top.SetActive(false);
            }
        }
        else
        {
            foreach (Transform t in SceneModeManager.Room)
            {
                t.gameObject.SetActive(true);
            }
        }
    }
    void CAPSSHOW()
    {
        //CAPS.SHOW(false);
        // GameObject[] caps;
        // caps = GameObject.FindGameObjectsWithTag("caps");
        // if (_G.SHOWCAP == true)
        // {
        //     foreach (GameObject obj in caps)
        //     {
        //         obj.transform.Find("BG").gameObject.SetActive(true);
        //         obj.transform.Find("TXT").gameObject.SetActive(true);
        //         GameObject Papa = obj.transform.parent.gameObject;
        //         Vector3 SC = Papa.transform.localScale;
        //         Papa.transform.localScale = new Vector3(1, 1, 1);
        //         Camera CAM = Camera.main;
        //         Vector3 v = CAM.transform.position - obj.transform.position;
        //         v.x = 0.0f;
        //         v.z = 0.0f;
        //         obj.transform.LookAt(CAM.transform.position - v);
        //         obj.transform.Rotate(0, 180, 0);
        //         Papa.transform.localScale = SC;
        //     }
        // }
        // else
        // {
        //     foreach (GameObject obj in caps)
        //     {
        //         obj.transform.Find("BG").gameObject.SetActive(false);
        //         obj.transform.Find("TXT").gameObject.SetActive(false);
        //     }
        // }
    }
    void MESURESHOW()
    {
        GameObject[] Mesures;
        Mesures = GameObject.FindGameObjectsWithTag("mesure");
        Camera CAM = Camera.main;
        foreach (GameObject Mesure in Mesures )
            {
                GameObject Sel=Get.o1(SceneModeManager.SelectedName);
                Vector3 SelPos=Sel.transform.position;
                Vector3 MesurePos=Mesure.transform.position;
                Vector3 CamPos=CAM.transform.position;
                float disCamSel=Vector3.Distance(CamPos,SelPos);
                float disCamMesure=Vector3.Distance(CamPos,MesurePos);
                Mesure.transform.rotation=CAM.transform.rotation;
                Vector3 dir=(MesurePos-CamPos).normalized; 
                float dis=Vector3.Distance(CamPos, MesurePos)*0.007f;
                Mesure.transform.localScale=new(dis,dis,dis);
                if(Mesure.name=="MPBL" || Mesure.name=="MPBR" || disCamSel+24>disCamMesure){
                    Mesure.transform.position=Camera.main.transform.position+20*dir;
                    dis=0.15f;  
                    Mesure.transform.localScale=new(dis,dis,dis);
                }
            }
    }
    public string GetLocalIPAddress()
    {
        var host = Dns.GetHostEntry(Dns.GetHostName());
        foreach (var ip in host.AddressList)
        {
            if (ip.AddressFamily == AddressFamily.InterNetwork)
            {
                return ip.ToString();
            }
        }
        throw new System.Exception("No network adapters with an IPv4 address in the system!");
    }
    IEnumerator GetLocation()
    {
        UnityWebRequest www = UnityWebRequest.Get("http://api.hostip.info/country.php");
        yield return www.SendWebRequest();

        //if (www.isNetworkError || www.isHttpError)
        if (www.result == UnityWebRequest.Result.ConnectionError)
        {
            Debug.Log(www.error);
        }
        else
        {
            // Show results as text
            Debug.Log(www.downloadHandler.text);
            // Or retrieve results as binary data
            byte[] results = www.downloadHandler.data;

            SceneModeManager.Instance.SetSceneMode(BinaryToText(results));

            if (BinaryToText(results) == "AU")
            {
                _G.Sys = " cm";
                _G.System = 2;
                Dropdown dd = Get.o1("SYS").GetComponent<Dropdown>();
                //dd.options.Clear ();
                dd.value = 2;
            }
        }
    }
    public string BinaryToText(byte[] data)
    {
        return Encoding.UTF8.GetString(data);
    }

    //------------------------------------------PANELS-----------------------------------------------------------------
    public void ToglePnl()
    {
        if (!Pnl_scene.activeInHierarchy) { Pnl_scene.SetActive(true); PAINT.SEL = "ON"; }
        else { Pnl_scene.SetActive(false); DOIT.ResetRoomSelect(); }
    }
    public void HidePaint()
    {
        foreach (Toggle togglePaint in MainPnl.GetComponentsInChildren<Toggle>()) { togglePaint.isOn = false; }
        DOIT.ResetRoomSelect(); PAINT.SEL = "";
    }
    public void MAINOFF()
    {
        foreach (Toggle togglePaint in MainPnl.GetComponentsInChildren<Toggle>()) { togglePaint.isOn = false; }
        DOIT.ResetRoom();
        //DASH.REFRESH();
        Get.o2("Canvas","Panel_SCENE").SetActive(true);
        Get.o2("Canvas", "Language").SetActive(true);
    }
    public void PnlAllOff()
    {
        DOIT.ResetRoom();
    }

    //------------------------------------------New Design-----------------------------------------------------------------
    public void OnStartNew()
    {
        Camera cam = Camera.main;
        DOIT.CloseALLPNLONLY();
        //_G.Ds = "11";
        //_G.Woods = "11";
        Pnl_start.SetActive(false);
        Pnl_ShowPlan.SetActive(false);

        Pnl_plan2d.SetActive(true);

        _G.PNL = "PLANSELECT";
        _G.WIDE = 192;
        _G.DEPTH = 168;
        _G.HEIGHT = 96;
        cam.transform.localRotation = Quaternion.Euler(0, 0, 0);
        cam.transform.position = new Vector3(0, 0, -150);
        _G.WMKs = "ND,0,0";
        _G.WMOs = "ND,0,0";
        //_G.KNCs = "KNOB112,0,0,828282,NA,NA,r0,G";
        _G.Camx = cam.transform.position.x;
        _G.Camy = cam.transform.position.y;
        _G.Camz = cam.transform.position.z;
        _G.CamA = cam.transform.eulerAngles.y;
        GameObject.Find("HIDER").transform.Find("LOADpnl").gameObject.SetActive(false);

        RoomCreation.CreateRoomPreset();
        GoToPlan();

    }
    public void ShowPlan()
    {
        Pnl_ShowPlan.SetActive(false);
        Pnl_plan2d.SetActive(true);
        _G.PNL = "PLANSELECT";
    }
    public void allplan2DOff()
    {
        Get.o2("HIDER", "KEYBOARDNUMBER").SetActive(false);
        Get.o2("Panel_ShowPlan", "X").SetActive(false);
    }
    public void setPlan()
    {
        Pnl_plan2d.SetActive(false);
        Pnl_ShowPlan.SetActive(true);
        allplan2DOff();

        _G.ROOM = EventSystem.current.currentSelectedGameObject.name;
        _G.PNL = "PLANSETTING";

        GameObject.Find("Panel_ShowPlan").transform.Find("BackPlan2D").gameObject.SetActive(true);
        GameObject.Find("Panel_ShowPlan").transform.Find("MCe").gameObject.SetActive(true);
        GameObject.Find("Panel_ShowPlan").transform.Find("PS_H").gameObject.SetActive(true);
        GameObject.Find("Panel_ShowPlan").transform.Find("X").gameObject.SetActive(false);

        if (_G.System == 2) _G.WIDE = (Mathf.Round(_G.WIDE * 2.54f)) / 2.54f;
        if (_G.System == 2) _G.DEPTH = (Mathf.Round(_G.DEPTH * 2.54f)) / 2.54f;
        if (_G.System == 2) _G.HEIGHT = (Mathf.Round(_G.HEIGHT * 2.54f)) / 2.54f;

        SetPlan.newRooms();
        Create3D.SetRoom();
        Create3D.SetMeasureNew(_G.HEIGHT, "mCe");
        //_G.SM = "PNL";
    }
    public void setDRAWPlan()
    {
        Pnl_plan2d.SetActive(false);
        _G.ROOM = EventSystem.current.currentSelectedGameObject.name;
        _G.PNL = "PLANSETTING";

        if (_G.System == 2) _G.WIDE = (Mathf.Round(_G.WIDE * 2.54f)) / 2.54f;
        if (_G.System == 2) _G.DEPTH = (Mathf.Round(_G.DEPTH * 2.54f)) / 2.54f;
        if (_G.System == 2) _G.HEIGHT = (Mathf.Round(_G.HEIGHT * 2.54f)) / 2.54f;

        SetPlan.DRAWROOM();
        SceneModeManager.Instance.SetSceneMode(SceneModes.Panel);// "pnl";
        GameObject.Find("Panel_DRAWPlan").transform.Find("PS_1").gameObject.SetActive(true);
        GameObject.Find("Panel_DRAWPlan").transform.Find("MCe").gameObject.SetActive(true);
        GameObject.Find("Panel_DRAWPlan").transform.Find("StartHere").gameObject.SetActive(true);
        GameObject.Find("Panel_DRAWPlan").transform.Find("X").gameObject.SetActive(false);
        Create3D.SetMeasureNew(_G.HEIGHT, "mCe");
    }
    public void GoToPlan()
    {
        Pnl_plan2d.SetActive(false);
        _G.ROOM = "RDRAW";
        _G.PNL = "PLANSETTING";

        //if (_G.System == 2) _G.WIDE = (Mathf.Round(_G.WIDE * 2.54f)) / 2.54f;
        //if (_G.System == 2) _G.DEPTH = (Mathf.Round(_G.DEPTH * 2.54f)) / 2.54f;
        //if (_G.System == 2) _G.HEIGHT = (Mathf.Round(_G.HEIGHT * 2.54f)) / 2.54f;

        //SetPlan.DRAWROOM();
        GameObject Panel_DRAWPlanl=Get.o2("Canvas", "Panel_DRAWPlan_NEW");
        Panel_DRAWPlanl.SetActive(true);
        SceneModeManager.Instance.SetSceneMode(SceneModes.Panel);// "pnl";
        //GameObject.Find("Panel_DRAWPlan").transform.Find("PS_1").gameObject.SetActive(true);
        //GameObject.Find("Panel_DRAWPlan").transform.Find("MCe").gameObject.SetActive(true);
        //GameObject.Find("Panel_DRAWPlan").transform.Find("StartHere").gameObject.SetActive(true);
        Panel_DRAWPlanl.transform.Find("BackPlan2D").gameObject.SetActive(true);
        Panel_DRAWPlanl.transform.Find("X").gameObject.SetActive(false);
        Create3D.SetMeasureNew(_G.HEIGHT, "mCe");

        //Cathedral Ceiling option
        Panel_DRAWPlanl.transform.Find("BtnCreateCeiling").gameObject.SetActive(_P.ListSwitch["CATHEDRAL_CEILING"]);
    }
    
    //------------------------------------------Button-----------------------------------------------------------------
    public void BacktoStarD()
    {
        Pnl_start.SetActive(true);
        Pnl_plan2d.SetActive(false);
        _G.PNL = "START";
    }
    public void BacktoPan2D()
    {
        DOIT.CloseALLPNL();
        Pnl_plan2d.SetActive(true);
        _G.PNL = "PLANSELECT";
    }
    public void OnBack2D()
    {
        DOIT.CloseALLPNL();
        Pnl_ShowPlan.SetActive(true);
        if (GameObject.Find("BackPlan2D")) GameObject.Find("BackPlan2D").SetActive(false);
        _G.PNL = "PLANSETTING";
        GameObject.Find("Panel_ShowPlan").transform.Find("X").gameObject.SetActive(true);
        //GameObject.Find("Panel_ShowPlan").transform.Find("Plan").gameObject.SetActive(false);
        GameObject.Find("Panel_ShowPlan").transform.Find("MCe").gameObject.SetActive(false);
        GameObject.Find("Panel_ShowPlan").transform.Find("PS_H").gameObject.SetActive(false);
        SetPlan.Rooms();
        Create3D.SetRoom();
        //_G.SM = "PNL";
        GameObject.Find("Panel_ShowPlan").transform.Find("BackPlan2D").gameObject.SetActive(false);
    }
    public void DeleteRoom() { DOIT.DELETEAllChild("ROOM"); }

    //------------------------------------------Create 3D-----------------------------------------------------------------
    public void Create3DView()
    {
        Pnl_scene.SetActive(true);
        //Get.o1("MAIN BTN/BTN_TOP/2D VIEW/Image").SetActive(false);
        SceneModeManager.Instance.SetSceneMode(SceneModes.Panel);//"pnl";
        _G.PNL = "WORLD3D";

        var command = Create3D._resizeCommand;
        if (command != null)
        {
            CommandHandler.Instance.AddToHistory(command);
            Create3D._resizeCommand = null;
        }
        else
        {
            RoomCreation.CreateRoomTo3D();
        }

        Get.o2("Canvas/Panel_SCENE", "DASH").SetActive(true);
        Get.o2("DASH", "FN").GetComponent<TMP_Text>().text = TRANS.This("D_FN");
        _G.PDFon = true;
        DASH.HDsetBTNcolor(false);

        //color caps
        //Get.o2("CODETXT", "BG").GetComponent<SpriteRenderer>().color = _G.colorButton;
        //Get.o2("CODETXT", "TXT").GetComponent<TextMesh>().color = _G.colorIcon;
        Get.o2("DASH", "btnUNHIDE").GetComponent<Image>().color = _G.colorButton;
        Get.o3("DASH", "btnUNHIDE", "Icon").GetComponent<Image>().color = _G.colorIcon;
        Get.o4("HIDER", "CONTROL", "BTNGROUP", "btnHIDE").GetComponent<Image>().color = _G.colorButton;
        Get.o5("HIDER", "CONTROL", "BTNGROUP", "btnHIDE", "Icon").GetComponent<Image>().color = _G.colorIcon;
        DOIT.ResetRoomSelect();
        //if (_G.status == "JN") { Save_WEB.Save_WebJN(); }
        DOIT.CloseALLPNL();
        DASH.REFRESH();

        //SelectLight.Set_All_Lights_to_Scene();
        Shopify.ShowEcommeceIcon();
        StoreSelection.SetPnl();
        GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(false);

        Get.o2("Panel_SCENE/DASH", "btnAI").SetActive(Get.PreferenceBool("AI"));

        if (Get.PreferenceBool("AI"))
        {
            GameObject PNLMode = Get.o2("Panel_SCENE/PNL", "MODE_PNL");
            PNLMode.SetActive(true);
            Get.o2("Panel_SCENE/PNL", "AI_PNL").SetActive(false);
            Set.alpha(Get.o2("Panel_SCENE", "DASH"), false);
            Set.alpha(Get.o2("Panel_SCENE", "MAIN BTN"), false);
            //Add Buton texte
            PNLMode.transform.Find("AiMode/Text").GetComponent<TMP_Text>().text = AiText.Trans("Mode Ai");
            PNLMode.transform.Find("DesignerMode/Text").GetComponent<TMP_Text>().text = AiText.Trans("Mode Designer");
            AiButton.Instance.GetPlus().SetActive(false);
            
        }

    }
    public void REFRESH()
    {
        DASH.REFRESH();
        GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(false);
    }
}