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;
using System.Threading;

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_scene;
    [HideInInspector] public GameObject MainPnl;
    [SerializeField, HideInInspector] GameObject _touchInputPanel;
    [SerializeField] Paths _path = Paths.Ukitchenit;
    [SerializeField] GameObject _mobileWarningPanel;
    public static float timeKeyHold = 0;
    public static float timePassed = 0;
    public GameObject SUN;
    //[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]

    // -------------------- NEW: debounce refresh (remplace Update timer) --------------------
    private bool _refreshPending = false;
    private const float REFRESH_DELAY = 0.05f;

    private void Awake()
    {
        // CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
        // CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
        // System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
        //Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
        //Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;

        CultureInfo invariant = CultureInfo.InvariantCulture;
        Thread.CurrentThread.CurrentCulture = invariant;
        Thread.CurrentThread.CurrentUICulture = invariant;
        //Debug.Log("[CultureFix] Culture forcée en InvariantCulture");

        SetVersionNumberFromProjectSettings();
        _autoRotate = Camera.main.GetComponent<AutoRotate>();
        SetFrameRate();
        _touchInputPanel.SetActive(false);

        // Application.logMessageReceived += (condition, stackTrace, type) => {
        // if (type == LogType.Exception)
        //     Debug.LogError($"EXCEPTION: {condition}\n{stackTrace}");
        //     };
    }

    // -------------------- NEW: subscribe global event + refresh on enable --------------------
    void OnEnable()
    {
        UIEvents.RefreshRequested += RefreshUI_Deferred;

        // Optionnel debug
        UIEvents.RefreshRequestedBy += OnRefreshReason;

        // Quand l'objet devient actif => refresh
        UIEvents.RequestRefresh("MenuScript OnEnable");
    }
    void OnDisable()
    {
        UIEvents.RefreshRequested -= RefreshUI_Deferred;
        UIEvents.RefreshRequestedBy -= OnRefreshReason;

        // sécurité: annuler invoke si désactivé
        CancelInvoke(nameof(DoRefresh));
        _refreshPending = false;
    }
    void OnRefreshReason(string reason)
    {
        // Tu peux commenter si trop de logs
        //Debug.Log("[UI Refresh] " + reason);
    }
    public void Start()
    {
    #if UNITY_WEBGL
        // On teste l'URL SANS la valeur fournie par l'utilisateur (courriel de ?mt_ / ?ai_ / _savefromai) :
        // "hb3d63@gmail.com" contient "3d" et declenchait la redirection, ce qui empechait
        // l'ouverture automatique du fichier sur https://ukitchenit.com/free/?mt_...
        string urlToCheck = UrlWithoutUserValues(Application.absoluteURL);
        if (urlToCheck.IndexOf("free") != -1 && urlToCheck.IndexOf("3d") != -1
            || urlToCheck.IndexOf("Free") != -1 && urlToCheck.IndexOf("sd") != -1)
        {
            Link.OpenWindow("free", "https://ukitchenit.com/free/"); return;
        }
    #endif
        Application.targetFrameRate = -1;
        SceneModeManager.Instance.SetSceneModeVisibility();
        ReadURL.Path();
        CheckForPath();

        WaitCircle.Setting(true, TRANS.This("M_Download"));
        if (Camera.main != null)
            Camera.main.targetTexture = null;

        _G.PATH = _G.PATH.ToLower();
        Load_G();

        _G.OBJs[299] = new string[100];
        _G.OBJs[299][0] = "null";
        _G.OBJs[299][1] = "null";

        DOIT.CloseALLPNL();
        Pnl_start.SetActive(true);
        Pnl_scene.SetActive(false);

        // Le worker de rendu n'existe que sur la version Windows : masquer le bouton ailleurs (WebGL).
        GameObject btnRenderServer = Get.o2("HIDER", "BtnRenderServer");
        if (btnRenderServer != null)
        {
            bool isWindows =
                Application.platform == RuntimePlatform.WindowsPlayer ||
                Application.platform == RuntimePlatform.WindowsEditor;

            btnRenderServer.SetActive(isWindows);
        }

        UIEvents.RequestRefresh("Start init");

        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);
        Get.o2("Canvas/Panel_main", "TEMPLATE").SetActive(_G.PATH == "laminam");
        //Get.o2("Canvas", "PATH").GetComponent<Text>().text = Application.absoluteURL;

        if (Application.absoluteURL.Contains("?mt_"))
        {
            Get.o2("Canvas", "PATH").GetComponent<Text>().text = Application.absoluteURL;
            Load_WEB.OpenFileMT(Application.absoluteURL);
        }

        if (Application.absoluteURL.Contains("?ai_"))
        {
            Get.o2("Canvas", "PATH").GetComponent<Text>().text = Application.absoluteURL;
            _G.FlieCategory="ai";
            Load_WEB.OpenFileAI(Application.absoluteURL);
        }

        // Lien email du design AI : ...3d?{PATH}?{email}_savefromai -> ouvre le fichier automatiquement.
        // ("_savefromai" sans '?' devant : le nom de fichier précède le suffixe dans l'URL.)
        if (Application.absoluteURL.Contains("_savefromai"))
        {
            Get.o2("Canvas", "PATH").GetComponent<Text>().text = Application.absoluteURL;
            Load_WEB.OpenFileSaveFromAI(Application.absoluteURL);
        }


        Set.GlobalColorAndTranslate();
        //Get.o1("Global Volume").SetActive(false);//

        StartCoroutine(InitHDToLow());
    }

    // Retire de l'URL la valeur fournie par l'utilisateur (le courriel qui suit ?mt_, ?ai_
    // ou qui precede _savefromai) avant tout test de mots-cles sur l'URL.
    private static string UrlWithoutUserValues(string url)
    {
        if (string.IsNullOrEmpty(url)) return "";

        int cut = url.IndexOf("?mt_");
        if (cut == -1) cut = url.IndexOf("?ai_");
        if (cut == -1 && url.Contains("_savefromai")) cut = url.LastIndexOf('?');

        return cut == -1 ? url : url.Substring(0, cut);
    }

    private IEnumerator InitHDToLow()
    {
        yield return new WaitForEndOfFrame();
        _G.HD = false; // ensure correct initial state for HD button toggle
    }
    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;
        Application.targetFrameRate = -1;
        Get.o2("Canvas/Language", "Adminbtn").SetActive(false);
#endif

#if UNITY_EDITOR
        //Debug.Log("This is the Unity Editor build");
        _G.IsEditor = true;
        QualitySettings.vSyncCount = 0;
        //Application.targetFrameRate = -1;
        Application.targetFrameRate = 60;
        QualitySettings.vSyncCount = 0;
        Get.o2("Canvas/Language", "Adminbtn").SetActive(true);
#endif

#if UNITY_STANDALONE
        _G.IsEditor = false;
        Debug.Log("This is a standalone build");
        QualitySettings.vSyncCount = 0;
        Application.targetFrameRate = -1;
#endif

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

#if UNITY_IOS
        _G.IsEditor = false;
        Debug.Log("This is an iOS build");
        Application.targetFrameRate = -1;
#endif
    }
    void CheckForPath()
    {
        if (!string.IsNullOrEmpty(_G.PATH)) return;
        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()
    {
        // if (Camera.main?.targetTexture != null)
        // Debug.LogWarning($"⚠️ Camera.main.targetTexture != null : {Camera.main.targetTexture.name}");

        bool isMouseInsideScreenBoundaries = MouseCheck.InOut();
        if (isMouseInsideScreenBoundaries == false && !SceneModeManager.CompareSceneMode(SceneModes.MouseOut))
        {
            SceneModeManager.Instance.OnMouseOut();
        }
        if (isMouseInsideScreenBoundaries && !SceneModeManager.CompareSceneMode(SceneModes.MouseOut))
        {
            bool isPanal = Get.o2("Canvas", "Panel_SCENE").activeInHierarchy;
            if (!EventSystem.current.IsPointerOverGameObject() && !SceneModeManager.CompareSceneMode(SceneModes.Plan2D) && isPanal)
            {
                HitObject.CheckHIT();
            }

            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))
            {
                GameObject[] MENU = GameObject.FindGameObjectsWithTag("Menu");
                GameObject[] PNL = GameObject.FindGameObjectsWithTag("pnl");

                if (MENU.Length != 0 || PNL.Length != 0 || _G.NAVIGATE == false)
                {
                    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))
                            {
                                SceneModeManager.Instance.SetSceneMode(SceneModes.Panel);
                            }
                        }
                    }
                }
                else
                {
                    SceneModeManager.Instance.SetSceneMode(SceneModes.Navigate);
                }
            }
        }

        HandleKeyboardInput();

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

        _G.NAVIGATE = true;

        if (!SceneModeManager.CompareSceneMode(SceneModes.CounterView) && !SceneModeManager.CompareSceneMode(SceneModes.Plan2D)
            && !SceneModeManager.CompareSceneMode(SceneModes.Calcule))
        {
            if (_G.HD == true)
            {
                SUN.SetActive(SelectLight.OpenOnScene());
            }
        }

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

        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]);
             }      
            
            
            }
    }

    // -------------------- MouseDown => déclenche event global --------------------
    void OnMouseDown()
    {
        UIEvents.RequestRefresh("OnMouseDown");
    }

    // -------------------- PUBLIC: tu peux appeler ça depuis Button OnClick --------------------
    public void RequestRefreshFromUI()
    {
        UIEvents.RequestRefresh("UI Button");
    }

    // -------------------- NEW: debounce refresh 0.05s --------------------
    public void RefreshUI_Deferred()
    {
        if (_refreshPending) return;
        _refreshPending = true;
        Invoke(nameof(DoRefresh), REFRESH_DELAY);
    }
    void DoRefresh()
    {
        _refreshPending = false;
        Set.GlobalColorAndTranslate();
    }

    // -------------------- Ton refresh original --------------------
    // public static void RefreshUI()
    // {
    //     TRANS.go();
    //     BTN_Hide.ShowBTNS();
    //     COLORSET.On();        
    //     ColorSet.Do();
    // }


    //--------------------------------------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;    
                TRANS.go();
            }
        }

    }
    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);

        if(_G.PATH=="hampton_bay"){_G.GYPSE = UIT_MATERIAL.GetMaterial("none,#ffffff,#A6A6A6,#ffffff,0.25-0.25,0,1,0.25,0,0");}////Texture,C1,C2,C3,Tile,Rotation,Contrast,smoothness,Mettallic,relief
        else { _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.FROSTYGLASSDARK = Resources.Load("MATERIALS/TEXTURES/FROSTYGLASSDARK") 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 = Resources.Load("MATERIALS/TEXTURES/DOORGLASS") as Material;
        _G.MOLDINGS = Instantiate(Resources.Load("MATERIALS/TEXTURES/Molding") 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;
    }
    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();
        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, -200);
        _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";
        Set.GlobalColorAndTranslate();
    }
    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"]);
        Set.GlobalColorAndTranslate();
    }
    
    //------------------------------------------Button-----------------------------------------------------------------
    public void BacktoStarD()
    {
        Pnl_start.SetActive(true);
        Pnl_plan2d.SetActive(false);
        _G.PNL = "START";
        Set.GlobalColorAndTranslate();
    }
    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()
    {
        bool FromStart=Get.o2("Canvas/Panel_DRAWPlan_NEW", "BackPlan2D").activeInHierarchy;        
        Pnl_scene.SetActive(true);
        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;
        //SelectLight.Set_All_Lights_to_Scene();        
        DASH.HDsetBTNcolor(false);
        DOIT.ResetRoomSelect();
        DOIT.CloseALLPNL();
        DASH.REFRESH();
        

        if (FromStart)
        {
            //Tutorial Show panel
            if (Get.PreferenceBool("START_TUTORIAL"))
            {
                GameObject.Find("Panel_SCENE").transform.Find("TutorialVideo").gameObject.SetActive(!_P.ListSwitch["STORE_SELECTION"]);              
            }
 
            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);
                
            }
            StoreSelection.SetPnl();
            Shopify.ShowEcommeceIcon();          
        }

        GameObject.Find("HIDER").transform.Find("LoadingCircle").gameObject.SetActive(false);        
        Set.GlobalColorAndTranslate();

        _G.HD=false;
        SelectLight.SetEnvironent();
        if(_G.FileName == "FN")_G.FileName = TRANS.This("D_FN");


        #if UNITY_EDITOR
         _P.ListSwitch["VERSION_DESIGNER"]=true;
        #endif
         


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