using UnityEngine;
using System.Globalization;
using UnityEngine.UI;
using System.Collections.Generic;

public class DOIT : MonoBehaviour
{
    public static bool Mousecheck()
    {
        bool mouseTF = false;
#if UNITY_EDITOR
        if (Input.mousePosition.x > 100 && Input.mousePosition.y > 60 && Input.mousePosition.x <= 860 && Input.mousePosition.y <= 385) { mouseTF = true; }
#else
        if (Input.mousePosition.x <= Screen.width*100/960 && Input.mousePosition.y <= Screen.height*60/460 && Input.mousePosition.x >= Screen.width - Screen.width*100/960 && Input.mousePosition.y >= Screen.height - Screen.height*75/460) {mouseTF = true;} 
#endif
        //print("X=====" + Input.mousePosition.x + "    Y==" + Input.mousePosition.y);
        return mouseTF;
    }
    public static void DELETEAllChild(string P)
    {
        GameObject PAPA = GameObject.Find(P);
        if (PAPA == null) return;// objet absent (ex: scene vide) : rien a supprimer

        foreach (Transform obj in PAPA.transform)
        {
            obj.gameObject.SetActive(true);
        }

        for (int i = PAPA.transform.childCount - 1; i >= 0; i--)
        {
            GameObject.DestroyImmediate(PAPA.transform.GetChild(i).gameObject);
        }
    }


    public static void CloseALLPNL()
    {
        GameObject[] pnl;
        pnl = GameObject.FindGameObjectsWithTag("pnl");
        foreach (GameObject p in pnl) { p.gameObject.SetActive(false); }

        GameObject[] menu;
        menu = GameObject.FindGameObjectsWithTag("menu");
        foreach (GameObject m in menu) { m.gameObject.SetActive(false); }

        if (GameObject.Find("SAVEWEBpnl")) GameObject.Find("SAVEWEBpnl").transform.GetComponent<CanvasGroup>().alpha = 1;
        if (GameObject.Find("LOADpnl")) GameObject.Find("LOADpnl").transform.GetComponent<CanvasGroup>().alpha = 1;

        //_G.SELECTED = "";
    }
    public static void CloseALLPNLONLY()
    {
        GameObject[] pnl;
        pnl = GameObject.FindGameObjectsWithTag("pnl");
        foreach (GameObject p in pnl) { p.gameObject.SetActive(false); }

        GameObject[] menu;
        menu = GameObject.FindGameObjectsWithTag("menu");
        foreach (GameObject m in menu) { m.gameObject.SetActive(false); }

        if (GameObject.Find("SAVEWEBpnl")) GameObject.Find("SAVEWEBpnl").transform.GetComponent<CanvasGroup>().alpha = 1;
        if (GameObject.Find("LOADpnl")) GameObject.Find("LOADpnl").transform.GetComponent<CanvasGroup>().alpha = 1;
    }
    public static void CloseALLMenu()
    {
        GameObject[] pnl;
        pnl = GameObject.FindGameObjectsWithTag("menu");
        foreach (GameObject p in pnl) { p.gameObject.SetActive(false); }
    }
    public static void disableActionsDropdown()
    {
        GameObject.Find("HIDER").transform.Find("SELECT").gameObject.SetActive(false);
    }

    public static void AllTogchildfalse(GameObject O)
    {
        for (int i = 0; i < O.transform.childCount; i++)
        {
            O.transform.GetChild(i).GetComponent<Toggle>().isOn = false;
        }
    }
    public static void AllChildOff(GameObject O)
    {
        for (int i = 0; i < O.transform.childCount; i++)
        {
            O.transform.GetChild(i).gameObject.gameObject.SetActive(false);
        }
    }




    public static float getScenePos(string v,float os)
    {
        // float px = 0;
        // float pz = 0;
        // float ry = 0;
        // float osx = 0;
        // float osz = 0;

        // if (_G.WallSELECTED == "floor") { px = 0; pz = 0; ry = 0; }

        // if (_G.WallSELECTED[..1] == "w")
        // {
        //     int wn = int.Parse(_G.WallSELECTED[1..]);
        //     ry = _G.wa[wn - 1];
        //     if (ry == 0) { osx = 0; osz = -os; }
        //     if (ry == 45) { osx = -os * 0.707f; osz = -os * 0.707f; }
        //     if (ry == 90) { osx = -os; osz = 0; }
        //     if (ry == 135) { osx = -os * 0.707f; osz = +os * 0.707f; }
        //     if (ry == 180) { osx = 0; osz = os; }
        //     if (ry == 225) { osx = +os * 0.707f; osz = +os * 0.707f; }
        //     if (ry == 270) { osx = os; osz = 0; }
        //     if (ry == 315) { osx = os * 0.707f; osz = -os * 0.707f; }
        //     px = _G.WallsPointCenter[wn - 1].x + osx;
        //     pz = _G.WallsPointCenter[wn - 1].y + osz;
        // }
        // float value = 0;
        // if (v == "px") value = px;
        // if (v == "pz") value = pz;
        // if (v == "ry") value = ry;
        // return value;

        float value = 0;

        return value;
    }

    public static string getColectionNamebyAbr(string str)
    {
        string N = "";
        if (str == "CO") N = "SENSATION";
        if (str == "BL") N = "FINESE";
        if (str == "EG") N = "ÉLÉGANCE";

        return N;
    }
    public static void AllTogdOff(GameObject O)
    {
        for (int i = 0; i < O.transform.childCount; i++)
        {
            O.transform.GetChild(i).GetComponent<Toggle>().isOn = false;
        }

    }

    public static int getint(string On)
    {
        int nO = int.Parse(On[4..]);
        return nO;
    }
    public static string getAbrCol(string str)
    {
        string c = "";
        if (str == "BROWN") c = "CO";
        if (str == "WHITE") c = "BL";
        if (str == "GRAY") c = "EG";
        return c;
    }
    public static string getCABCollectionNamebyColAbr(string CD)
    {
        string col = TRANS.This(CD);
        return col;
    }
    public static string getColorTextPNLbyDoorcab(string CD)
    {
        string num = CD.Substring(6, 1);
        string col = "TEXT10" + num + ",2,FFFFFF,r0,SG";
        return col;
    }



    //----------------------------------------------------------------------------------------------------------------------------//
    //---------------------------------------------------------Check------------------------------------------------------------//
    //----------------------------------------------------------------------------------------------------------------------------//
    public static void NoSelection(GameObject S)
    {
        for (int i = 0; i < S.transform.childCount; i++)
        {
            S.transform.GetChild(i).transform.GetComponent<Toggle>().isOn = false;
        }
    }

    //----------------------------------------------------------------------------------------------------------------------------//
    //---------------------------------------------------------EMPTY PANEL------------------------------------------------------------//
    //----------------------------------------------------------------------------------------------------------------------------//
    public static Color GetIsColor(string S)
    {
        Color c;
        c = GameObject.Find(S).transform.GetComponent<MeshRenderer>().material.color;
        return c;
    }
    public static void btnColor()
    {
        ColorBlock theColor;

        string Ncol = _G.Color1;//"1664B5";


        GameObject[] btn = GameObject.FindGameObjectsWithTag("btn");
        foreach (GameObject obj in btn)
        {
            theColor = obj.GetComponent<Button>().colors;
            theColor.highlightedColor = DOIT.CSc("575757", 150);//00FDFF
            theColor.normalColor = DOIT.CSc(Ncol, 255);
            theColor.pressedColor = DOIT.CSc("A9A9A9", 150);
            theColor.selectedColor = DOIT.CSc("A9A9A9", 150);
            obj.GetComponent<Button>().colors = theColor;
        }
        GameObject[] btnToggle = GameObject.FindGameObjectsWithTag("btnToggle");
        foreach (GameObject obj in btnToggle)
        {
            theColor = obj.GetComponent<Toggle>().colors;
            theColor.highlightedColor = DOIT.CSc("A9A9A9", 150);
            theColor.normalColor = DOIT.CSc(Ncol, 255);
            theColor.pressedColor = DOIT.CSc("A9A9A9", 150);
            theColor.selectedColor = DOIT.CSc("A9A9A9", 150);
            theColor.disabledColor = DOIT.CSc(Ncol, 255);
            obj.GetComponent<Toggle>().colors = theColor;
        }
        GameObject[] Checkers = GameObject.FindGameObjectsWithTag("checkmark");
        foreach (GameObject obj in Checkers)
        {
            obj.GetComponent<Image>().color = DOIT.CSc("FFFFFF", 255);
        }
        GameObject[] Checkers2 = GameObject.FindGameObjectsWithTag("checkmark2");
        foreach (GameObject obj in Checkers2)
        {
            obj.GetComponent<Image>().color = DOIT.CSc(Ncol, 255);
        }

        GameObject[] Images = GameObject.FindGameObjectsWithTag("image");
        foreach (GameObject obj in Images)
        {
            obj.GetComponent<Image>().color = DOIT.CSc(_G.Color2, 255);
        }

        GameObject[] TextColor = GameObject.FindGameObjectsWithTag("textcolor");
        foreach (GameObject obj in TextColor)
        {
            obj.GetComponent<Text>().color = DOIT.CSc(Ncol, 255);
        }
    }
    public static Texture2D GetTex(string tex)
    {
        string path = "STYLE/";
        if (tex.Substring(0, 4) == "CERA") path = "TEXTURES/FINISH/";
        if (tex.Substring(0, 4) == "COUN") path = "TEXTURES/FINISH/";
        if (tex.Substring(0, 4) == "SPLA") path = "TEXTURES/FINISH/";
        if (tex.Substring(0, 4) == "WOOD") path = "TEXTURES/FINISH/";
        if (tex.Substring(0, 4) == "OGEE") path = "ICONS/OGEE/";
        if (tex.Substring(0, 4) == "UNDE") path = "ICONS/UNDER/";
        if (tex.Substring(0, 4) == "COLO") path = "TEXTURES/GENERAL/";
        tex = tex.Replace("BCAB", "TEXT");
        tex = tex.Replace("PANE", "TEXT");
        tex = tex.Replace("KICK", "TEXT");
        tex = tex.Replace("FILL", "TEXT");
        tex = tex.Replace("HEAD", "TEXT");
        Texture2D T = Resources.Load<Texture2D>(path + tex) as Texture2D;
        return T;
    }
    public static Sprite GetSprite(string tex)
    {
        string path = "STYLE/";
        Sprite T = Resources.Load<Sprite>(path + tex) as Sprite;
        return T;
    }


    //----------------------------------------------------------------------------------------------------------------------------//
    //---------------------------------------------------------CONVERT------------------------------------------------------------//
    //----------------------------------------------------------------------------------------------------------------------------//
    public static string CNs(float M)//Convert number to string
    {
        string q = "0";
        if (_G.System == 1)
        {
            float Q;
            Q = M - Mathf.Floor(M);
            if (Q >= 0) { q = " ''"; }
            if (Q >= 0.062) { q = " 1/16''"; }
            if (Q >= 0.125) { q = " 1/8''"; }
            if (Q >= 0.187) { q = " 3/16''"; }
            if (Q >= 0.25) { q = " 1/4''"; }
            if (Q >= 0.312) { q = " 5/16''"; }
            if (Q >= 0.375) { q = " 3/8''"; }
            if (Q >= 0.437) { q = " 7/16''"; }
            if (Q >= 0.5) { q = " 1/2''"; }
            if (Q >= 0.562) { q = " 9/16''"; }
            if (Q >= 0.620) { q = " 5/8''"; }
            if (Q >= 0.687) { q = " 11/16''"; }
            if (Q >= 0.75) { q = " 3/4''"; }
            if (Q >= 0.812) { q = " 13/16''"; }
            if (Q >= 0.875) { q = " 7/8''"; }
            if (Q >= 0.925) { q = " 15/16''"; }
            if (Q >= 0.967) { q = " ''"; M += 1; }
            q = Mathf.Floor(M).ToString() + q;
        }
        else q = (Mathf.Floor(M * 2.54f * 10) / 10).ToString() + " cm";
        return q;
    }
    public static string CSs(string M)//Convert string to string
    {
        string q = M.Replace("''", "");
        q = q.Replace("cm", "");
        q = q.Replace(" ", "");
        return q;
    }

    public static Color CSc(string C, byte a)//Convert string to color
    {
        byte r = byte.Parse(C.Substring(0, 2), NumberStyles.HexNumber);
        byte g = byte.Parse(C.Substring(2, 2), NumberStyles.HexNumber);
        byte b = byte.Parse(C.Substring(4, 2), NumberStyles.HexNumber);
        Color col = new Color32(r, g, b, a);
        return col;
    }

    public static string CSssys(string M)//Convert string to string
    {
        float mf = float.Parse(M);
        if (_G.System == 2)
        {
            mf = Mathf.Floor(mf * 2.54f);
            mf = (mf / 2.54f * 100) / 100;
        }
        M = mf.ToString();
        return M;
    }
    public static float CSn(string M)//Convert string to number
    {
        if (M == "") M = "0";
        float newM = 0;
        float newMcm = 0;
        int num = M.Length;
        if (M.Length > 10) M = M.Substring(0, 9);
        if (M.IndexOf("E") != -1) M = M.Substring(0, 4);
        M = M.Replace("''", "");
        M = M.Replace("'", "");
        M = M.Replace(" ", "");
        if (M.IndexOf("cm") != -1) { M = M.Replace("cm", ""); newMcm = float.Parse(M) / 2.54f; }

        if (_G.System == 1)
        {
            float add = 0;
            if (M.IndexOf("11/16") != -1) { M = M.Replace("11/16", ""); add = 0.6875f; }
            if (M.IndexOf("13/16") != -1) { M = M.Replace("13/16", ""); add = 0.8125f; }
            if (M.IndexOf("15/16") != -1) { M = M.Replace("15/16", ""); add = 0.9375f; }
            if (M.IndexOf("1/16") != -1) { M = M.Replace("1/16", ""); add = 0.0625f; }
            if (M.IndexOf("1/8") != -1) { M = M.Replace("1/8", ""); add = 0.125f; }
            if (M.IndexOf("3/16") != -1) { M = M.Replace("3/16", ""); add = 0.1875f; }
            if (M.IndexOf("1/4") != -1) { M = M.Replace("1/4", ""); add = 0.25f; }
            if (M.IndexOf("5/16") != -1) { M = M.Replace("5/16", ""); add = 0.3125f; }
            if (M.IndexOf("3/8") != -1) { M = M.Replace("3/8", ""); add = 0.375f; }
            if (M.IndexOf("7/16") != -1) { M = M.Replace("7/16", ""); add = 0.4375f; }
            if (M.IndexOf("1/2") != -1) { M = M.Replace("1/2", ""); add = 0.5f; }
            if (M.IndexOf("9/16") != -1) { M = M.Replace("9/16", ""); add = 0.5625f; }
            if (M.IndexOf("5/8") != -1) { M = M.Replace("5/8", ""); add = 0.625f; }
            if (M.IndexOf("3/4") != -1) { M = M.Replace("3/4", ""); add = 0.75f; }
            if (M.IndexOf("7/8") != -1) { M = M.Replace("7/8", ""); add = 0.875f; }
            if (M.IndexOf(" ''") != -1) { M = M.Replace(" ''", ""); add = 0; }
            if (M.IndexOf(" ''") != -1) { M = M.Replace(" ", ""); add = 0; }
            if (M.IndexOf("''") != -1) { M = M.Replace("''", ""); add = 0; }
            newM = float.Parse(M) + add;
            newM = Mathf.Round(newM * 10000) / 10000;
            //newM = Grid.addGrid(newM);
        }
        if (_G.System == 2)
        {
            newM = float.Parse(M);
            if (newMcm != 0) newM = newMcm;
        }
        return newM;
    }//Fin	

    public static Color CScf(string C)//Convert string to color
    {
        byte r = byte.Parse(C.Substring(0, 2), NumberStyles.HexNumber);
        byte g = byte.Parse(C.Substring(2, 2), NumberStyles.HexNumber);
        byte b = byte.Parse(C.Substring(4, 2), NumberStyles.HexNumber);
        Color col = new Color32(r, g, b, 50);
        return col;
    }
    public static void ColorModel(string col)
    {
        Color C = DOIT.CSc(col, 210);
        GameObject MODEL = GameObject.Find("MODEL").gameObject;
        foreach (Transform child in MODEL.transform)
        {
            child.transform.Find("Background").gameObject.GetComponent<Image>().color = C;
        }
    }




    //TEXTURE
    public static Texture2D Rotate(Texture2D image)
    {
        Texture2D Tex2D = new Texture2D(image.height, image.width);
        for (int y = 0; y < image.height; ++y)
        {
            for (int x = 0; x < image.width; ++x)
            {
                Tex2D.SetPixel(y, image.width - 1 - x, image.GetPixel(x, y));
            }
        }
        Tex2D.Apply();
        return Tex2D;
    }


    public static float GetRn(string r)
    {
        float R = 0;
        if (r == "r0") R = 0;
        if (r == "r45") R = 45;
        if (r == "r9") R = 90;
        return R;
    }


    public static float ConvertStringToNumber(string M)
    {
        if (M.Contains("E")) { M = "0"; }

        //print("M===="+M);
        //4 1/2
        //4.5
        //41/2
        //4.5"
        //4.5 "
        //4.5cm
        //4.5 cm
        //4e...


        // if (string.IsNullOrWhiteSpace(M) || M.Equals("none", StringComparison.OrdinalIgnoreCase))
        // {
        //     //Debug.Log(M + " value. Value is set to 0.");
        //     return 0f;
        // }

        if (M.Length > 10) M = M[..9];
        if (M.IndexOf("E") != -1) M = M[..4];

        float add = 0;
        Dictionary<string, float> fractions = new()
            {
                { "15/16", 0.9375f },
                { "13/16", 0.8125f },
                { "11/16", 0.6875f },
                { "7/8", 0.875f },
                { "3/4", 0.75f },
                { "5/8", 0.625f },
                { "9/16", 0.5625f },
                { "1/2", 0.5f },
                { "7/16", 0.4375f },
                { "3/8", 0.375f },
                { "5/16", 0.3125f },
                { "1/4", 0.25f },
                { "3/16", 0.1875f },
                { "1/8", 0.125f },
                { "1/16", 0.0625f },
                { " ''", 0 },
                { " ", 0 },
                { "''", 0 }
            };

        // Check for fractions in the input and update the fraction adder.
        foreach (var fraction in fractions)
        {
            if (M.IndexOf(fraction.Key) != -1)
            {
                M = M.Replace(fraction.Key, "");
                add = fraction.Value;
                break;
            }
        }
        M = M.Replace((char)8203, '\0');

        if (M.IndexOf("cm") != -1)
        {
            M = M.Replace("cm", "");
            float centimeters = float.Parse(M);
            return centimeters / 2.54f;
        }

        float newM = 0;
        // else check for inch conversion
        M = M.Replace("''", "");
        M = M.Replace("'", "");
        M = M.Replace(" ", "_");
        float fact = 1;
        if (M.IndexOf("-") != -1) { fact = -1; }
        M = M.Replace("-", "");

        string Entity = M;
        if (M.IndexOf("_") != -1)
        {
            string[] split = M.Split('_');
            Entity = split[0];

            M = split[1];
        }

        //print("Entity===="+Entity);
        if (string.IsNullOrEmpty(Entity)) Entity = "0";

        newM = float.Parse(Entity, System.Globalization.NumberStyles.Float) + add;
        //newM = float.Parse(M, System.Globalization.NumberStyles.Float) + add;
        newM = (Mathf.Round(newM * 10000) / 10000) * fact;

        return newM;
    }
    public static float TryConvertStringToNumber(string M, out int system)
    {
        if (M.Contains("\'") || M.Contains("\""))
        {
            system = 1;
        }
        else if (M.Contains("cm"))
        {
            system = 2;
        }
        else // invalid system
        {
            system = 0;
        }

        return ConvertStringToNumber(M);
    }
        public static string ConvertNumberToString(float number)
    {
        string str=number.ToString("G");
        if (str.Contains("E")){number = 0;}

        string q = "0";
        if (_G.System == 1)
        {
            float Q = number - Mathf.Floor(number);
            if (Q >= 0) { q = " ''"; }
            if (Q >= 0.062) { q = " 1/16''"; }
            if (Q >= 0.125) { q = " 1/8''"; }
            if (Q >= 0.187) { q = " 3/16''"; }
            if (Q >= 0.220) { q = " 1/4''"; }
            if (Q >= 0.312) { q = " 5/16''"; }
            if (Q >= 0.370) { q = " 3/8''"; }
            if (Q >= 0.400) { q = " 7/16''"; }
            if (Q >= 0.475) { q = " 1/2''"; }
            if (Q >= 0.562) { q = " 9/16''"; }
            if (Q >= 0.620) { q = " 5/8''"; }
            if (Q >= 0.687) { q = " 11/16''"; }
            if (Q >= 0.725) { q = " 3/4''"; }
            if (Q >= 0.812) { q = " 13/16''"; }
            if (Q >= 0.875) { q = " 7/8''"; }
            if (Q >= 0.925) { q = " 15/16''"; }
            if (Q >= 0.967) { q = " ''"; number += 1; }

            q = Mathf.Floor(number).ToString() + q.ToString();
        }
        else
        {
            number = Mathf.Round(number * 2.54f * 100) / 100;
            q = number.ToString("F2") + " cm";
        }
        return q;
    }



    public static string ChangeCodeOnPos(string code, int Intposition, string NewValue, string Spliter)
    {
        // string SP = "'" + Sp + "'";
        string[] cs = code.Split(Spliter);
        cs[Intposition] = NewValue;
        string newcode = "";
        for (int i = 0; i < cs.Length; i++)
        {
            newcode += cs[i];
            if (i < cs.Length - 1) { newcode += Spliter; }
        }

        return newcode;
    }
    
 
}