using System.Collections;
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using UnityEngine.EventSystems;

public class KeyNumber : MonoBehaviour
{
    // [Header("Old")]
    // [SerializeField] InputField _inputField;//input value
    // [SerializeField] Text _inputText;
    // [SerializeField] GameObject _keyboardNumber;
    // [SerializeField] GameObject _fractions;

    [Header("TMP")]
    //[SerializeField] TMP_InputField _inputValueTMP;//input value
    public TMP_Text _inputTextTMP;
    [SerializeField] GameObject _keyboardNumberPro;
    [SerializeField] GameObject _fractionsPro;

    [Header("Short")]
    [SerializeField] GameObject _keyboardNumberShort;
    [SerializeField] TMP_InputField  _inputFieldShort;//input value
    [SerializeField] GameObject _ButtonLeft;
    [SerializeField] GameObject _ButtonRight;

    public TMP_InputField _inputValueTMP;
    public TMPSelectFlag _selectFlag;


    private void Awake()
    {
        if (_keyboardNumberPro == null)
        {
            _keyboardNumberPro = Get.o2("HIDER", "KEYBOARDNUMBERPRO");
            if (_keyboardNumberPro == null)
            {
                Debug.Log("Could not get access to KEYBOARDNUMBERPRO reference");
            }
        }

        if (_fractionsPro == null)
        {
            _fractionsPro = Get.o3("HIDER", "KEYBOARDNUMBERPRO", "FRACTIONS");
            if (_fractionsPro == null)
            {
                Debug.Log("Could not get access to FRACTIONS reference");
            }
        }

    }
    public void OpenPro(TMP_Text im)
    {
        _G.VTcat = "TMP";
        _inputTextTMP = im;

        print("im====="+im.text);

        _keyboardNumberPro.SetActive(true);
        _keyboardNumberPro.transform.localPosition = new Vector3(0, 0, 0);
        _fractionsPro.SetActive(false);
        if (_G.System == 2){ _fractionsPro.SetActive(false);}

        string Vs =DOIT.ConvertStringToNumber(_inputTextTMP.text).ToString();
        _inputValueTMP.text = Vs;//DOIT.ConvertStringToNumber(Vs).ToString();
        _G.VTP = im;//IM;

        _G.Vo = DOIT.ConvertStringToNumber(Vs);
        print("_G.VTP.name==" + _G.VTP.name);//nW

        //Add key board
        if (_G.Mobile == false) {_inputValueTMP.ActivateInputField();}
    }
    public void OpenShort(TMP_Text im){
         _G.VTcat = "SHORT";
        _inputTextTMP = im;
        print("_inputTextTMP.text==="+_inputTextTMP.text);
        _keyboardNumberShort.SetActive(true);
        string Vs = DOIT.ConvertStringToNumber(_inputTextTMP.text).ToString();//DOIT.CSs(_inputTextTMP.text);
        _inputFieldShort.GetComponent<TMP_InputField>().text = DOIT.ConvertStringToNumber(Vs).ToString();
        _G.VTP = _inputTextTMP;//IM;
        _G.VTP.name = im.name;
        _G.Vo = DOIT.ConvertStringToNumber(_inputTextTMP.text);
        _inputFieldShort.ActivateInputField();

        //Button Arrow
        bool isButton=true;
        if (_G.VTP.name=="mCe"){ isButton=false;}
        _ButtonLeft.SetActive(isButton);
        _ButtonRight.SetActive(isButton);

        //Close panel Setting
        GameObject SelectPnl=Get.o2("Panel_DRAWPlan_NEW","Selection Panel");
        if(SelectPnl!=null)
        {
            if(SelectPnl.activeInHierarchy){
                Get.o2("Panel_DRAWPlan_NEW/Selection Panel", "Panel_Setting").SetActive(false);
            }
         }

    }
    public void Change(string buttonClickedValue)
    {
        string txt = _inputValueTMP.text ?? "";

        // Nettoyage optionnel
        txt = txt.Replace((char)8203, ' ').Replace(" ", "");

        bool mustReplace =
            (txt == "0" && buttonClickedValue != ".") ||
            (_selectFlag != null && _selectFlag.replaceNext);

        if (mustReplace)
        {
            _inputValueTMP.text = buttonClickedValue;   // ✅ remplace tout
            if (_selectFlag != null) _selectFlag.replaceNext = false; // ✅ reset seulement ici
        }
        else
        {
            _inputValueTMP.text = txt + buttonClickedValue; // ✅ append
        }

        // ✅ Désélectionner après
        StartCoroutine(DeselectNextFrame());
    }
    IEnumerator DeselectNextFrame()
    {
        yield return null;
        _inputValueTMP.DeactivateInputField();
        EventSystem.current.SetSelectedGameObject(null);
    }

    public void Back()
    {
        if (_G.VTcat != "TMP")
        {
            if (_inputValueTMP.text.Length != 0) _inputValueTMP.text = _inputValueTMP.text.Substring(0, _inputValueTMP.text.Length - 1);
        }
        else
        {
            if (_inputValueTMP.text.Length != 0) _inputValueTMP.text = _inputValueTMP.text.Substring(0, _inputValueTMP.text.Length - 1);
        }
    }
    public void AddValue()
    {
        float OldValue;

        print("_G.VTP.text===="+_G.VTP.text);
        print("_G.VTP.name==== "+_G.VTP.name);//HR
        print("_inputValueTMP.text==== "+_inputValueTMP.text);

        OldValue = DOIT.ConvertStringToNumber(_G.VTP.GetComponent<TMP_Text>().text);
        _inputTextTMP.text = DOIT.CSs(_inputValueTMP.text) + _G.Sys;

        if (_G.VTP.name.Contains("Input")) { 
            print("_G.VTP.text===2="+_G.VTP.text+"      _G.VTP.name===2= "+_G.VTP.name+"          _inputValueTMP.text===2= "+_inputValueTMP.text);
            _G.VTP.transform.parent.parent.gameObject.GetComponent<TMP_InputField>().text = DOIT.CSs(_inputValueTMP.text); 
            //_G.VTP.name=_G.VTP.transform.parent.parent.name;
            }

        print("_G.VTP.name ===="+_G.VTP.name +"   _inputTextTMP.text===="+_inputTextTMP.text);       

         SetMesure(OldValue, DOIT.ConvertStringToNumber(_inputValueTMP.text));
        _keyboardNumberPro.SetActive(false);
    }
    public void AddValueShort(string Side)
    {
        if(_G.VTP!=null){
            print("_G.VTP.name fromm AddValueShort====" + _G.VTP.name+"     _G.VTP.text======"+_G.VTP.text);

            float OldValue;
            TMP_Text text = null;
            if (_G.VTP != null)
            {
                text = _G.VTP.GetComponent<TMP_Text>();
            }
            else
            {
                Debug.Log("_G.VTP is null");
                return;
            }

            if (text != null && _G.VTP.name != "mCe")
            {
                print("text====" + text.text);
                OldValue = DOIT.ConvertStringToNumber(_G.VTP.GetComponent<TMP_Text>().text);
                _G.VTP.GetComponent<TMP_Text>().text = DOIT.CSs(_inputValueTMP.text) + _G.Sys;
                float NewValue = DOIT.ConvertStringToNumber(_inputFieldShort.text);
                GameObject Line = _G.VTP.transform.parent.parent.parent.parent.gameObject;
                WallLine.RedimensionLength(Side, Line, OldValue, NewValue);
                _keyboardNumberShort.SetActive(false);
                return;
            }

            if (text != null && _G.VTP.name == "mCe")
            {
                float NewValue = DOIT.ConvertStringToNumber(_inputFieldShort.text);
                OldValue = _G.HEIGHT;
                _G.HEIGHT = NewValue;
                float Delta = ( OldValue-_G.HEIGHT) * 0.5f;
                float DistanceOver = CheckObjectWallHeightDistance(NewValue, Delta);

                if (DistanceOver >= 0)
                {
                    _G.VTP.GetComponent<TMP_Text>().text = NewValue.ToString() + _G.Sys;

                    CathedralCeiling.CeilingHeight();
                    _keyboardNumberShort.SetActive(false);
                    _AI.FloorLine = -_G.HEIGHT * 0.5f;
                    _AI.CeilingLine = _G.HEIGHT * 0.5f;
                    _AI.BaseHeightPosition = -_G.HEIGHT * 0.5f + 34.5f * 0.5f + 1.25f * 0.5f;
                    _AI.WallHeightPosition = -_G.HEIGHT * 0.5f + 54 + 30f * 0.5f;
                   
                    //Change wall Wall point height
                    for (int i = 0; i < _G.ExteriorWallPoints.Length; i++)
                    {
                        _G.ExteriorWallPoints[i][0] = new(_G.ExteriorWallPoints[i][0].x, -_G.HEIGHT * 0.5f, _G.ExteriorWallPoints[i][0].z);
                    }
                    
                    for (int i = 0; i < _G.OBJnum; i++)
                    {
                        if (DOIT.exist(i))
                        {
                            GameObject Object = Get.o2("SCENE", _G.OBJs[i][0]);
                            Vector3 Position = Object.transform.position;
                            Object.transform.position = new(Position.x, Position.y + Delta , Position.z);
                            if (_G.OBJs[i][22] == "ceil") 
                            {
                                float ofsetfFromCeiling = OldValue * 0.5f - Position.y;
                                Object.transform.position = new(Position.x, _G.HEIGHT * 0.5f-ofsetfFromCeiling , Position.z);
                            }
                            DOIT.SaveObjectPositionInData(Object);
                        }
                    }
                    }
                else{
                    _M.PH(34, 0, "ffffff", 1, 1);
                    _G.HEIGHT = OldValue;
                }

            // return;
            }

            }
    }
    public static float CheckObjectWallHeightDistance(float NewWallHeight, float Delta )
    {
        float Distance = 0;
        for (int i = 0; i < _G.OBJnum; i++)
        {
            if (DOIT.exist(i) && _G.OBJs[i][22] != "ceil")
            {
                //float NewWallHeight
                GameObject Object = Get.o2("SCENE", _G.OBJs[i][0]);
                float H = DOIT.ConvertStringToNumber(_G.OBJs[i][7]);
                float ObjectTop = Object.transform.position.y + H * 0.5f+Delta;
                Distance = NewWallHeight * 0.5f - ObjectTop;
                print("DistanceOver====ObjectTop===" + ObjectTop);
                print("DistanceOver====Delta==" + Delta);
                if (Distance < 0) return Distance;
            }
        }
        return Distance;
    }

    public void fraction(string K)
    {
        if (_G.VTcat != "TMP")
        {
            float V = Mathf.Floor(DOIT.ConvertStringToNumber(_inputValueTMP.text));
            V += DOIT.ConvertStringToNumber(K.Split("/")[0]) / DOIT.ConvertStringToNumber(K.Split("/")[1]);
            _inputValueTMP.text = V.ToString();
        }
        else
        {
            float VP = Mathf.Floor(DOIT.ConvertStringToNumber(_inputValueTMP.text));
            VP += DOIT.ConvertStringToNumber(K.Split("/")[0]) / DOIT.ConvertStringToNumber(K.Split("/")[1]);
            _inputValueTMP.text = VP.ToString();
        }
    }
    public static void SetMesure(float OldValue, float NewValue)
    {
        print("_G.VTP.name===="+_G.VTP.name+"     NewValue===================="+NewValue+"      _G.PON========"+_G.PON);
        if (NewValue >= 480) NewValue = 480;

        string VTname = _G.VTP.name;
        Debug.Log("VTname : " + VTname);

        if (_G.PNL == "Cabinet" && VTname.Contains("Input"))
        {
            _G.VTP.transform.parent.parent.gameObject.GetComponent<TMP_InputField>().text = DOIT.CNs(NewValue);
            Resize.ResetCabinetDIM(VTname);
        }
        //Control
        if (VTname == "mcB") { Reposition.setposition(NewValue); }
        if (VTname == "mcR") { Reposition.setposition(NewValue); }
        if (VTname == "mcL") { Reposition.setposition(NewValue); }
        if (VTname.IndexOf("MP") != -1) { Mesure.Reposition(VTname, OldValue, NewValue); }
        if (VTname == "mcF") { Reposition.setposition(NewValue); }
        if (VTname == "mcT") { Reposition.setposition(NewValue); }
        if (VTname == "mcU") { Reposition.setposition(NewValue); }
        if (VTname.IndexOf("mCe") != -1) { 
            _G.HEIGHT = NewValue; 
            CathedralCeiling.CeilingHeight();
            }
        if (VTname.IndexOf("m1") != -1) { recalROOM(NewValue); }
        if (_G.PNL == "Cabinet" && VTname != "HR")
        {
            print("------------------------------PNL ON------------------------");
            //close ROWHEIGHTPNL reopen
            if(_G.PON=="ROWHEIGHTPNL"){Get.o2("CABINETpnl/", "ROWHEIGHTPNL").SetActive(false);}
            if(_G.PON=="CABCREATORpnl"){Get.o2("CABINETpnl/SHOWSELECTION", "RowHeightBtn").GetComponent<Button>().onClick.Invoke();}
        }
        if (VTname == "HR")
        {
            print("Now go ROW Height"+"  parent name==="+_G.VTP.transform.parent.gameObject.name);                
            _G.VTP.transform.parent.parent.gameObject.GetComponent<TMP_InputField>().text = DOIT.ConvertStringToNumber(DOIT.CNs(NewValue)).ToString();
            if(_G.PON=="ROWHEIGHTPNL"){
                ROWHEIGHT.RedoPaternRowSizes(_G.VTP.transform.parent.gameObject.name,NewValue);
                PATERN.ChangeRowHeight(_G.VTP.transform.parent.parent.gameObject);
                }
            if(_G.PON=="CABCREATORpnl")CabCreator.ChangeRowHeight(_G.VTP.transform.parent.gameObject);
        }
        if (_G.PNL == "Resize" && SceneModeManager.SelectedName.IndexOf("cabi") != -1)
        {
            //_G.VTP.transform.parent.gameObject.GetComponent<TMP_InputField>().text = DOIT.CNs(NewValue);
            //_G.VTP.transform.parent.parent.gameObject.GetComponent<TMP_InputField>().text = DOIT.CSs(_inputValueTMP.text); 
            Resize.ResetCabinetDIM(VTname);
        }
        if (VTname == "InputPanel")
        {
            string Category=_G.VTP.transform.parent.name; 
            print("Category====="+Category);//Category=====InputE       
                if(Category=="InputE"){   
                print("Category====NV="+DOIT.ConvertNumberToString(NewValue));//Category=====InputE        
                _G.VTP.transform.parent.gameObject.GetComponent<TMP_InputField>().text = DOIT.ConvertNumberToString(NewValue);
                }
            else{
                _G.VTP.transform.parent.gameObject.GetComponent<TMP_InputField>().text = UIT_PANELPnl.MinMaxCorection(NewValue, Category)+_G.Sys;
            }
            //Redo show
            UIT_PANELPnl.ShowSelecdedOnChange();    
        }
        if (VTname == "InputDOORWIDE"){
            CabCreator.ResetDoorWide(NewValue);
        }
        
        // if (VTname == "mW"){
        //     print("Add to plan2D");
        //     _G.VTP.transform.parent.gameObject.GetComponent<InputField>().text = DOIT.CNs(NewValue);
        //     GameObject Line=_G.VTP.transform.parent.parent.parent.gameObject;
        //     WallLine.RedimensionLength(Line,OldValue,NewValue);
        // }
        //}
        // else
        // {
            
        print("_G.VTP.name====" +VTname);
        GameObject titleObject = Get.o1("CABINETpnl/Title");
        string Title = titleObject == null ? "" : titleObject.GetComponent<Text>().text;

        //BASE
        if (Title == "BASE")
        {
            if (VTname == "Avalue")
            {
                _G.PH = SetSizeNew.Getfloat("D");
                //NEWCAB.redoPatern(NewValue, _G.PH);
            }
            if (VTname == "Bvalue")
            {
                SetSizeNew.Reset("B", NewValue, Title);//resize K fromB
            }
            if (VTname == "Dvalue")
            {
                _G.PW = SetSizeNew.Getfloat("A");
                SetSizeNew.Reset("D", NewValue, Title);//resize B from D
                //NEWCAB.redoPatern(_G.PW, NewValue);
            }
            if (VTname == "Kvalue")
            {
                SetSizeNew.Reset("K", NewValue, Title);//resize B from K
            }
        }
        //WALL
        if (Title == "WALL")
        {
            //if (VTPname == "Bvalue") { NEWCAB.redoPatern(_G.PW, NewValue); }
            //if (VTPname == "Avalue") { NEWCAB.redoPatern(NewValue, _G.PH); }
        }
        //Ceilling
        if (VTname == "mCe")
        {
            RoomCreation.SetRoomHeight(DOIT.ConvertStringToNumber(NewValue + _G.Sys));
        }
    
        if(_G.PON=="CABCREATORpnl"){
            CabCreator.AddPaternStart();
            CabCreator.ROW_EDIT();
        }
        else if(_G.PON=="ROWHEIGHTPNL"){//_G.PON========ROWHEIGHTPNL
            print("Pass row height");
            ROWHEIGHT.AddPATERN();
            ROWHEIGHT.RedoEditRow();
        }
    //}

    }
    static void recalROOM(float NewValue)
    {
        //print("recalROOM===");
        Debug.Log("recalROOM from KeyNumber.cs");

        if (NewValue > 480) { NewValue = 480; }
        if (_G.ROOM == "R7")
        {
            SetPlan.RedrawRoom78(_G.VTP.name, NewValue);
        }
        if (_G.ROOM == "R8")
        {
            SetPlan.RedrawRoom78(_G.VTP.name, NewValue);
        }
        if (_G.ROOM == "RDRAW")
        {
            DRAW.RedrawRoom(_G.VTP.name, NewValue);
        }
        if (_G.ROOM != "RDRAW" && _G.ROOM != "R7" && _G.ROOM != "R8")
        {
            SetPlan.RedrawRoom(_G.VTP.name, NewValue);
            SetPlan.Rooms();
        }
    }
    public void closePNL()
    {
        Debug.Log("Close Panel KeyboardNumber");
        //_keyboardNumber.SetActive(false);
        _keyboardNumberPro.SetActive(false);
        _keyboardNumberShort.SetActive(false);
        _G.PON="";
    }
    public void closePNLPRO()
    {
        _keyboardNumberPro.SetActive(false);
    }
    public static bool Wallexist(int wn)
    {
        bool wall = false;
        string wallnum = "w" + wn.ToString();
        /*foreach(Transform child in Get.o1("Plan").transform){
            if(child.name==wallnum)wall=true;
        }*/
        wall = true;
        return wall;
    }
    // public void close()
    // {
    //     _keyboardNumber.SetActive(true);
    // }
    public void OpenFraction()
    {
        _fractionsPro.SetActive(true);

    }
}