using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using JetBrains.Annotations;

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
    [SerializeField] TMP_Text _inputTextTMP;
    [SerializeField] GameObject _keyboardNumberPro;
    [SerializeField] GameObject _fractionsPro;

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

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

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

        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 Open(Text im)
    {
        _G.VTcat = "ST";
        _inputText = im;
        _keyboardNumber.SetActive(true);
        _keyboardNumber.transform.localPosition = new Vector3(0, 0, 0);
        _fractions.SetActive(false);
        if (_G.System == 2) _fractions.SetActive(false);
        string Vs = DOIT.ConvertStringToNumber(_inputText.text).ToString();//DOIT.CSs(_inputText.text);
        _inputField.GetComponent<InputField>().text = DOIT.ConvertStringToNumber(Vs).ToString();
        _G.VT = _inputText;//IM;
        _G.VT.name = im.name;
        _G.Vo = DOIT.ConvertStringToNumber(_inputText.text);
        //Add key board
        if (_G.Mobile == false) _inputField.ActivateInputField();
        //print("IsMobile()=="+_G.Mobile);
    }
    public void OpenPro(TMP_Text im)
    {
        _G.VTcat = "TMP";

        _inputTextTMP = im;

        _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 = _inputTextTMP;//IM;

        if (_inputTextTMP.transform.parent.transform.parent.TryGetComponent(out TMP_InputField parentParentInputField))
        {
            _G.VTP.name = parentParentInputField.name;
        }

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

        //Add key board
        if (_G.Mobile == false) _inputValueTMP.ActivateInputField();
        //print("IsMobile()=="+_G.Mobile);
    }
    public void OpenShort(Text im){
         _G.VTcat = "SHORT";
        _inputText = im;
        print("_inputText.text==="+_inputText.text);
        _keyboardShort.SetActive(true);
        string Vs = DOIT.ConvertStringToNumber(_inputText.text).ToString();//DOIT.CSs(_inputText.text);
        _inputFieldShort.GetComponent<InputField>().text = DOIT.ConvertStringToNumber(Vs).ToString();_G.VT = _inputText;//IM;
        _G.VT.name = im.name;
        _G.Vo = DOIT.ConvertStringToNumber(_inputText.text);
        _inputFieldShort.ActivateInputField();

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

        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)
    {
        print("Cahnge value");
        if (_G.VTcat != "TMP")
        {
            float currentStringValue = DOIT.ConvertStringToNumber(_G.VT.GetComponent<Text>().text);
            string CurrentValueString = currentStringValue.ToString();

            if (CurrentValueString == DOIT.CSs(_inputField.text) && buttonClickedValue != ".")
            {
                // Erase the existing value of input field
                _inputField.text = "";
            }
            _inputField.text += buttonClickedValue;
        }
        else
        {
            float currentStringValue = DOIT.ConvertStringToNumber(_G.VTP.GetComponent<TMP_Text>().text);
            string CurrentValueString = currentStringValue.ToString();

            _inputValueTMP.text = _inputValueTMP.text.Replace((char)8203,' ');
            _inputValueTMP.text=_inputValueTMP.text.Replace(" ", "");

            if (CurrentValueString == _inputValueTMP.text && buttonClickedValue != ".")
            {
                _inputValueTMP.text = "";
            }
            _inputValueTMP.text += buttonClickedValue;
        }
    }
    public void back()
    {
        if (_G.VTcat != "TMP")
        {
            if (_inputField.text.Length != 0) _inputField.text = _inputField.text.Substring(0, _inputField.text.Length - 1);
        }
        else
        {
            if (_inputValueTMP.text.Length != 0) _inputValueTMP.text = _inputValueTMP.text.Substring(0, _inputValueTMP.text.Length - 1);
        }
    }
    public void addValue()
    {
        float OldValue = 0f;
        print("_G.VTcat ===="+_G.VTcat );

        if(_G.VTcat == "ST" )
        {
            Text text = null;
            if (_G.VT != null)
            {
                text = _G.VT.GetComponent<Text>();
            }
            else
            {
                Debug.Log("_G.VT is null"); 
                return; 
            }

            if (text != null)
            {
                OldValue = DOIT.ConvertStringToNumber(_G.VT.GetComponent<Text>().text);
                _G.VT.GetComponent<Text>().text = DOIT.CSs(_inputField.text) + _G.Sys;
                if (_G.VT.name == "Text") { _G.VT.transform.parent.gameObject.GetComponent<InputField>().text = DOIT.CSs(_inputField.text); }

                SetMesure(OldValue, DOIT.ConvertStringToNumber(_inputField.text));
                _keyboardNumber.SetActive(false);
                return;
            }
        }

        if (_G.VTP.TryGetComponent(out TextMeshProUGUI vtTMPUGUI))
        {
            OldValue = DOIT.ConvertStringToNumber(vtTMPUGUI.text);
        }

        _G.VTP.GetComponent<TMP_Text>().text = DOIT.CSs(_inputValueTMP.text) + _G.Sys;
        if (_G.VTP.transform.parent.parent.gameObject.TryGetComponent(out TMP_InputField parentParentInputfield))
        {
            parentParentInputfield.text = DOIT.CSs(_inputValueTMP.text);
        }
        SetMesure(OldValue, DOIT.ConvertStringToNumber(_inputValueTMP.text));
        _keyboardNumberPro.SetActive(false);

    }

    public void AddValueShort(string Side)
    {
        print("_G.VT.name fromm AddValueShort====" + _G.VT.name);

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

        if (text != null && _G.VT.name != "mCe")
        {
            OldValue = DOIT.ConvertStringToNumber(_G.VT.GetComponent<Text>().text);
            _G.VT.GetComponent<Text>().text = DOIT.CSs(_inputField.text) + _G.Sys;
            if (_G.VT.name == "Text") { _G.VT.transform.parent.gameObject.GetComponent<InputField>().text = DOIT.CSs(_inputFieldShort.text); }
            float NewValue = DOIT.ConvertStringToNumber(_inputFieldShort.text);
            _G.VT.transform.parent.gameObject.GetComponent<InputField>().text = DOIT.CNs(NewValue);

            GameObject Line = _G.VT.transform.parent.parent.parent.gameObject;
            WallLine.RedimensionLength(Side, Line, OldValue, NewValue);
            _keyboardNumberShort.SetActive(false);
            return;
        }

        if (text != null && _G.VT.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);
            print("DistanceOver====" + DistanceOver);

            if (DistanceOver >= 0)
            {
                _G.VT.GetComponent<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);
                }
                //Set all object with new Height


                print("Delta=====" + Delta);

                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(_inputField.text));
            V += DOIT.ConvertStringToNumber(K.Split("/")[0]) / DOIT.ConvertStringToNumber(K.Split("/")[1]);
            _inputField.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)
    {
        if (_G.VTcat != "TMP")
        {
            string VTname = _G.VT.name;
            Debug.Log("VTname : " + VTname);

            if (NewValue >= 480) NewValue = 480;
            if (_G.PNL == "Cabinet" && Get.Bool(VTname,"InputB_InputA_InputC_InputE_InputF_InputK_InputD"))
            {
                _G.VT.transform.parent.gameObject.GetComponent<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 != "InputROWHIGHT")
            {
                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 == "InputROWHIGHT")
            {
                print("Now go ROW Height"+"  parent name==="+_G.VT.transform.parent.gameObject.name);                
                _G.VT.transform.parent.gameObject.GetComponent<InputField>().text = DOIT.ConvertStringToNumber(DOIT.CNs(NewValue)).ToString();
                if(_G.PON=="ROWHEIGHTPNL"){
                    ROWHEIGHT.RedoPaternRowSizes(_G.VT.transform.parent.gameObject.name,NewValue);
                    PATERN.ChangeRowHeight(_G.VT.transform.parent.gameObject);
                    }
                if(_G.PON=="CABCREATORpnl")CabCreator.ChangeRowHeight(_G.VT.transform.parent.gameObject);
            }
            if (_G.PNL == "Resize" && SceneModeManager.SelectedName.IndexOf("cabi") != -1)
            {
                _G.VT.transform.parent.gameObject.GetComponent<InputField>().text = DOIT.CNs(NewValue);
                Resize.ResetCabinetDIM(VTname);
            }
            if (VTname == "InputPanel")
            {
                string Category=_G.VT.transform.parent.name; 
                print("Category====="+Category);//Category=====InputE       
                 if(Category=="InputE"){   
                    print("Category====NV="+DOIT.ConvertNumberToString(NewValue));//Category=====InputE        
                    _G.VT.transform.parent.gameObject.GetComponent<InputField>().text = DOIT.ConvertNumberToString(NewValue);
                    }
                else{
                    _G.VT.transform.parent.gameObject.GetComponent<InputField>().text = 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.VT.transform.parent.gameObject.GetComponent<InputField>().text = DOIT.CNs(NewValue);
            //     GameObject Line=_G.VT.transform.parent.parent.parent.gameObject;
            //     WallLine.RedimensionLength(Line,OldValue,NewValue);
            // }

        }
        else
        {
            string VTPname = _G.VTP.name;
            print("_G.VTP.name====" + _G.VTP.name);
            GameObject titleObject = Get.o1("CABINETpnl/Title");
            string Title = titleObject == null ? "" : titleObject.GetComponent<Text>().text;

            //BASE
             if (Title == "BASE")
            {
                if (VTPname == "Avalue")
                {
                    _G.PH = SetSizeNew.Getfloat("D");

                    //NEWCAB.redoPatern(NewValue, _G.PH);
                }
                if (VTPname == "Bvalue")
                {
                    SetSizeNew.Reset("B", NewValue, Title);//resize K fromB
                }
                if (VTPname == "Dvalue")
                {
                    _G.PW = SetSizeNew.Getfloat("A");
                    SetSizeNew.Reset("D", NewValue, Title);//resize B from D
                    //NEWCAB.redoPatern(_G.PW, NewValue);
                }
                if (VTPname == "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); }
            }

            if (VTPname == "mCe")
            {
                RoomCreation.SetRoomHeight(DOIT.ConvertStringToNumber(NewValue + _G.Sys));
            }
        
            if(_G.PON=="CABCREATORpnl"){
                CabCreator.AddPaternStart();
                CabCreator.ROW_EDIT();
            }
            else if(_G.PON=="ROWHEIGHTPNL"){
                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.VT.name, NewValue);
        }
        if (_G.ROOM == "R8")
        {
            SetPlan.RedrawRoom78(_G.VT.name, NewValue);
        }
        if (_G.ROOM == "RDRAW")
        {
            DRAW.RedrawRoom(_G.VT.name, NewValue);
        }
        if (_G.ROOM != "RDRAW" && _G.ROOM != "R7" && _G.ROOM != "R8")
        {
            SetPlan.RedrawRoom(_G.VT.name, NewValue);
            SetPlan.Rooms();
        }
    }
    public void closePNL()
    {
        Debug.Log("Close Panel KeyboardNumber");
        _keyboardNumber.SetActive(false);
        _keyboardNumberPro.SetActive(false);
        _keyboardNumberShort.SetActive(false);
    }
    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()
    {
        _fractions.SetActive(true);
        _fractionsPro.SetActive(true);

    }
}