using UnityEngine.UI;
using UnityEngine;
using System.Collections.Generic;
using UnityEngine.SceneManagement;
using System.Linq;
using System;

public class Get : MonoBehaviour
{
    public static int MaxObjectCount => 299;

    /// <summary>
    /// Extract the index of GameObject name
    /// </summary>
    /// <param name="On">the name of the GameObject</param>
    /// <returns>Returns the index of the gameObject in the array of data _G.Objs or 299 if no value is found"</returns>
    public static int GetObjectIndex(string On)
    {
        if (On.Length > 4 && On != "sfloor" && On != "sceil")
        {
            return int.Parse(On[4..]);
        }
        Debug.Log($"object number not found : {On}");
        return MaxObjectCount;
    }
    /// <summary>
    /// Returns the name of the first GameObject that have a toggle on in the child of the parameter
    /// </summary>
    /// <param name="parentName">the name of the parent GameObject in the hierarchy on which you want to find the toggle is on</param>
    /// <returns>Returns "none or the name of the first GameObject with a toggle on in child"</returns>
    public static string ToggleOnInChild(string parentName)
    {
        //string Togname = "none";
        GameObject O = o1(parentName);
        for (int i = 0; i < O.transform.childCount; i++)
        {
            Toggle toggle = O.transform.GetChild(i).GetComponent<Toggle>();
            if (!toggle.gameObject.activeInHierarchy) continue;
            if (toggle != null && toggle.isOn) { return toggle.gameObject.name; }
        }
        if(O.transform!=null){return O.transform.GetChild(0).gameObject.name;}
        return "";
    }
    /// <summary>
    /// Returns a GameObject according to the hierarchy passed as a parameter, Able to return a GameObject even when the GameObject is not active in the hierarchy.
    /// </summary>
    /// <param name="objectHierarchy">Create an array of string that represent the hierarchy of the gameObject you are searching for</param>
    /// <returns>Returns GameObject using last value of string array, return null and print debug if GameObject doesn't exits</returns>
    public static GameObject GetGameObjectByNameArray(string[] objectHierarchy)
    {
        var scene = SceneManager.GetActiveScene();
        var sceneRoots = scene.GetRootGameObjects();

        Transform[] currentHierarchyLevel = new Transform[sceneRoots.Length];

        GameObject result = null;
        GameObject child = null;
        for (int i = 0; i < sceneRoots.Length; i++)
        {
            GameObject current = sceneRoots[i];
            if (objectHierarchy[0] == current.name)
            {
                child = current;

                if (objectHierarchy.Length == 1)
                {
                    result = current;
                }

                break;
            }
        }

        for (int i = 1; i < objectHierarchy.Length; i++)
        {
            child = GetGameObjectByNameInParent(child.transform, objectHierarchy[i]);
            if (child == null) break;

            if (i == objectHierarchy.Length - 1)
            {
                result = child;
            }
        }

        if (result == null)
        {
            Debug.Log("No GameObject found for " + objectHierarchy[^1]);
        }

        return result;
    }
    public static GameObject GetGameObjectByNameInParent(Transform parent, string child)
    {
        GameObject result = null;
        for (int i = 0; i < parent.childCount; i++)
        {
            GameObject current = parent.GetChild(i).gameObject;
            if (current.name == child)
            {
                result = current;
                break;
            }
        }

        return result;
    }
    public static GameObject GetGameObjectByName(string objName)
    {
        GameObject obj = GameObject.Find(objName);

        if (obj == null)
        {
            Debug.Log("No Object Found For Name == " + objName);
        }
        return obj;
    }
    public static GameObject o1(string O1)
    {
        GameObject O = GameObject.Find(O1);
        return O;
    }
    public static GameObject o2(string O1, string O2)
    {
        //print(GameObject.Find(O1));
        GameObject O = null;
        if (GameObject.Find(O1) != null)
        {
            O = GameObject.Find(O1);
            if (O.transform.Find(O2) != null)
            {
                O = O.transform.Find(O2).gameObject;
            }
            else { O = null; }
        }
        return O;
    }
    public static GameObject o3(string O1, string O2, string O3)
    {
        return GameObject.Find(O1).transform.Find(O2).transform.Find(O3).gameObject;
    }
    public static GameObject o4(string O1, string O2, string O3, string O4)
    {
        return GameObject.Find(O1).transform.Find(O2).transform.Find(O3).transform.Find(O4).gameObject;
    }
    public static GameObject o5(string O1, string O2, string O3, string O4, string O5)
    {
        return GameObject.Find(O1).transform.Find(O2).transform.Find(O3).transform.Find(O4).transform.Find(O5).gameObject;
    }
    public static string IVs(string Oname)
    {//Imput Value string
        return o1(Oname).GetComponent<InputField>().text;
    }
    public static float IVf(string Oname)
    {//Imput Value float
        return DOIT.ConvertStringToNumber(o1(Oname).GetComponent<InputField>().text);
    }
    public static bool Active(string Oname)
    {//Imput Value float
        bool ONOFF = false;
        if (GameObject.Find("HIDER").transform.Find(Oname).gameObject.activeInHierarchy) ONOFF = true;
        return ONOFF;
    }
    public static bool Exist(string papa, string child)
    {//Imput Value float
        bool ONOFF = false;
        if (GameObject.Find(papa).transform.Find(child).gameObject.activeInHierarchy) ONOFF = true;
        return ONOFF;
    }
    public static bool ExistActif(string O)
    {//Imput Value float
        bool ONOFF = false;
        if (GameObject.Find("Canvas"))
        {
            if (GameObject.Find("Panel_SCENE"))
            {
                if (GameObject.Find("PNL_TAB"))
                {
                    if (GameObject.Find(O)) { ONOFF = true; }
                }
            }
        }
        return ONOFF;
    }
    public static GameObject TogOn(GameObject O)
    {
        GameObject Sel = O.transform.GetChild(0).gameObject;
        for (int i = 0; i < O.transform.childCount; i++)
        {
            if (O.transform.GetChild(i).gameObject.activeInHierarchy && O.transform.GetChild(i).GetComponent<Toggle>().isOn) { Sel = O.transform.GetChild(i).gameObject; }
        }
        return Sel;
    }
    public static bool IsTogOn(GameObject O)
    {
        if (O.GetComponent<Toggle>().isOn) { return true; }
        return false;
    }
    public static Texture2D TexDoor(string tex)
    {
        string path = "CABTEXTURE/";
        Texture2D T = Resources.Load<Texture2D>(path + tex) as Texture2D;
        return T;
    }
    public static Sprite SpriteDoor(string tex)
    {
        Texture2D T = TexDoor(tex);
        Sprite mySprite = Sprite.Create(T, new Rect(0.0f, 0.0f, T.width, T.height), new Vector2(0.5f, 0.5f), 100.0f);
        return mySprite;
    }
    public static Sprite SpriteFromTexture(string tex, string R, string Cs)
    {
        Texture2D T = Resources.Load<Texture2D>("CABTEXTURE/" + tex) as Texture2D;
        T = CREATE.ChangeColors(T, DOIT.CSc(Cs, 255), Color.white);
        if (R == "90") T = DOIT.Rotate(T);
        Sprite mySprite = Sprite.Create(T, new Rect(0.0f, 0.0f, T.width, T.height), new Vector2(0.5f, 0.5f), 100.0f);
        return mySprite;
    }
    public static Sprite SpriteFromTextureCounter(string tex, string R)
    {
        //print("tex==="+tex);
        //print("R==="+R);
        Texture2D T = Resources.Load<Texture2D>("COUNTER/" + tex) as Texture2D;
        if (R == "90") T = DOIT.Rotate(T);
        Sprite mySprite = Sprite.Create(T, new Rect(0.0f, 0.0f, T.width, T.height), new Vector2(0.5f, 0.5f), 100.0f);
        return mySprite;
    }
    public static string CsvValue(string name, Dictionary<string, CabTexturesListData> library, CsvHeaders header)
    {
        if (library.TryGetValue(name, out var data))
        {
            return data.GetPropertyValue(header);
        }
        Debug.Log(header + " Not found for " + name + " in  library " + nameof(library));
        return "";
    }
    public static string CsvValue(string name, Dictionary<string, CabinetListData> library, CsvHeaders header)
    {
        if (library.TryGetValue(name, out var data))
        {
            return data.GetPropertyValue(header);
        }
        Debug.Log(header + " Not found for " + name + " in  library " + nameof(library));
        return "";
    }
    public static string CsvValue(string name, Dictionary<string, KickListData> library, CsvHeaders header)
    {
        if (library.TryGetValue(name, out var data))
        {
            return data.GetPropertyValue(header);
        }
        Debug.Log(header + " Not found for " + name + " in  library " + nameof(library));
        return "";
    }
    public static Texture2D CabTexture(string tex, string Rs)
    {
        //print("tex=="+tex);
        string path = "CABTEXTURE/";
        Texture2D T = Resources.Load<Texture2D>(path + tex) as Texture2D;
        if (Rs == "90") T = DOIT.Rotate(T);
        return T;
    }
    public static bool CheckTog(string Om)
    {
        GameObject O = o1(Om);
        bool TF = false;
        if (O.GetComponent<Toggle>().isOn == true) TF = true;
        return TF;
    }
    public static float Rot(string path)
    {
        Vector3 Rv = Get.o1(path).transform.GetChild(0).transform.Find("Background").gameObject.transform.localEulerAngles;
        return Rv.z;
    }
    public static CabinetListData CabinetCode(string name)
    {
        var dataRef = _G.LibraryCabinets.ElementAt(0).Value;
        string library = dataRef.GetPropertyValue(CsvHeaders.Library_Name);
        
        if (GameObject.Find("CABINETpnl")) library = Get.ToggleOnInChild("FILTERS/Viewport/Content");

        if (_G.LibraryCabinets.TryGetValue(name, out CabinetListData data))
        {
            if (data.GetPropertyValue(CsvHeaders.Library_Name) == library)
            {
                return data;
            }
        }
        return null;
    }
    
    //FROM LIBRARIES------------------------------------------------------------------------------------------------------------------FROM LIBRARIES-   
    public static string LibraryValue(string name, CsvHeaders header)
    {
        DataTypes dataTypeEnum = DataTypes.NULL;
        string prefix = name.Split("_")[0];
        switch (prefix)
        {
            case "ME":
                dataTypeEnum = DataTypes.CabTexture; break;
            case "CA":
                dataTypeEnum = DataTypes.Cabinet; break;
            case "CO":
                dataTypeEnum = DataTypes.Counter; break;
            case "KN":
                dataTypeEnum = DataTypes.Knob; break;
            case "DO":
                dataTypeEnum = DataTypes.Door; break;
            case "KI":
                dataTypeEnum = DataTypes.Kick; break;
            case "OG":
                dataTypeEnum = DataTypes.Ogee; break;
            case "PA":
                dataTypeEnum = DataTypes.Panel; break;
            case "FI":
                dataTypeEnum = DataTypes.Filler; break;
            case "FA":
                dataTypeEnum = DataTypes.Fascia; break;
            case "VA":
                dataTypeEnum = DataTypes.Valance; break;
            case "CR":
                dataTypeEnum = DataTypes.Cornice; break;
            case "MI":
                dataTypeEnum = DataTypes.IntTexture; break;
        }

        if (dataTypeEnum == DataTypes.NULL)
        {
            Debug.Log("Found no data type corresponding to " + name);
            return "";
        }
        return LibraryValue(name, header, dataTypeEnum);
    }
    public static string LibraryValue(string name, CsvHeaders header, string dataType)
    {
        Enum.TryParse(dataType, out DataTypes dataTypeEnum);
        return LibraryValue(name, header, dataTypeEnum);
    }
    public static string LibraryValue(string name, CsvHeaders header, DataTypes dataType)
    {
        var library = LibraryCategory(dataType);
        if (name != null)
        {
            string v = LibraryValue(name, header, library);
            if (string.IsNullOrEmpty(v))
            {
                //Debug.Log("No Header " + header + " found in " + name + " in dataType " + dataType);
            }
            return LibraryValue(name, header, library);
        }
        return "";
    }
    public static string LibraryValue(string name, CsvHeaders header, Dictionary<string, CsvData> library) 
    {
        if (name != null && library.TryGetValue(name, out CsvData data))
        {
            return data.GetPropertyValue(header);
        }
        return "";
    }
    public static string CabTextureMatch(string GlobalColor, string dataType)
    {
        var Library = LibraryCategory(dataType);
        GlobalColor = GlobalColor.Split('?')[0];
        for (int i = 0; i < Library.Count; i++)
        {
            var line = Library.ElementAt(i).Value;
            if (line.GetPropertyValue(CsvHeaders.Color_ID) == GlobalColor)
            {
                return line.GetPropertyValue(CsvHeaders.ID);
            }
        }
        return "";
    }
    public static string CabTextureMatch(string GlobalColor, DataTypes dataType)
    {
        return CabTextureMatch(GlobalColor, dataType.ToString());
    }
    public static CabinetListData CabCode(string model, string lib)
    {
        if (_G.LibraryCabinets.TryGetValue(model, out CabinetListData data))
        {
            if (data.Library_Name == "Universal")
            {
                return data;
            }
        }

        return _G.LibraryCabinets.ElementAt(0).Value;
    }
    public static string UserValue(string model, int snum, int num)
    {
        string Cat = "";
        for (int i = 0; i < _G.LibraryUsers.Count; i++)
        {
            if (_G.LibraryUsers[i] != "")
            {
                if (_G.LibraryUsers[i].Split(',')[snum] == model)
                {
                    Cat = _G.LibraryUsers[i].Split(',')[num];
                    break;
                }
            }
        }
        return "";
    }
    public static string StdTextureValue(string model, int num)
    {
        //print("model===="+model);    
        string Cat = "none";
        List<string> L = _G.LibraryWoods;
        if (model.Split('.')[0] == "WOOD") L = _G.LibraryWoods;
        if (model.Split('.')[0] == "CERA") L = _G.LibraryCeramics;
        if (model.Split('.')[0] == "SPLA") L = _G.LibrarySplashs;

        for (int i = 0; i < L.Count; i++)
        {
            if (L[i].Split(',')[0].Equals(model))
            {
                Cat = L[i].Split(',')[num];
                break;
            }
        }
        return "";
    }
    //public static string LibraryValue(string name, CsvHeaders header, DataTypes dataType)
    //{

    //    Dictionary<string, CsvData> Library = new();
    //    switch (dataType)
    //    {
    //        case DataTypes.Ogee:
    //            Library = _G.LibraryOgees.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.Cornice:
    //            Library = _G.LibraryCornices.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.Fascia:
    //            Library = _G.LibraryFacias.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.Valance:
    //            Library = _G.LibraryValances.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.Kick:
    //            Library = _G.LibraryKicks.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.Filler:
    //            Library = _G.LibraryFillers.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.Counter:
    //            Library = _G.LibraryOgees.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.Cabinet:
    //            Library = _G.LibraryCornices.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.IntTexture:
    //            Library = _G.LibraryFacias.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.CabTexture:
    //            Library = _G.LibraryValances.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.Knob:
    //            Library = _G.LibraryKicks.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.Panel:
    //            Library = _G.LibraryFillers.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value); break;
    //        case DataTypes.NULL:
    //        default: Debug.Log("Should not enter here"); break;

    //    }

    //    if (Library.TryGetValue(name, out CsvData data))
    //    {
    //        return data.GetPropertyValue(header);
    //    }
    //    return "";
    //}
    public static string BoxTex(string[] C, int sn)
    {
        string tx = "";
        if (C[83].Split('_')[sn - 1].IndexOf("0")!=-1 ) { tx = C[62]; }
        if (C[83].Split('_')[sn - 1].IndexOf("1")!=-1 ) { tx = C[82]; }
        return tx;
    }
    public static string CabCat(string str)
    {
        string newstr = str;
        switch (str)
        {
            case "Base": newstr = "BASE"; break;
            case "Tall": newstr = "TALL"; break;
            case "Wall": newstr = "WALL"; break;
            case "CBase": newstr = "CBASEL"; break;
            case "CWall": newstr = "CWALL"; break;
            case "Corner Base": newstr = "CBASE"; break;
            case "Corner Wall": newstr = "CWALL"; break;
        }
        return newstr;
    }
    public static string ChangeOnStringPos(string str, string newstring, int pos, string Separator)
    {
        string newstr = "";
        string[] strs = str.Split(Separator);
        for (int i = 0; i < strs.Length; i++)
        {
            if (i == pos) strs[i] = newstring;
            newstr += strs[i];
            if (i < strs.Length - 1) newstr += Separator;
        }
        return newstr;
    }
    public static bool ExistOnList(Dictionary<string, CsvData> list, string name)
    {
        return list.ContainsKey(name);
    }
    public static string SpaceDelete(string T)
    {
        if (T.Substring(0, 1) == " ") T = T.Substring(1, T.Length - 1);
        if (T.Substring(T.Length - 1, 1) == " ") T = T.Substring(0, T.Length - 1);
        if (T.Substring(T.Length - 1, 1) == " ") T = T.Substring(0, T.Length - 1);
        return T;
    }
    public static int IndexCSV(List<string> Library, string ColumName)
    {
        string[] items = Library[0].Split(',');
        for (int i = 0; i < items.Length; i++)
        {
            if (items[i] == ColumName) { return i; }
        }
        return -1;
    }

    public static Dictionary<string, CsvData> LibraryCategory(string dataType)
    {
        Enum.TryParse(dataType, out DataTypes dataTypeEnum);
        return LibraryCategory(dataTypeEnum);
    }
    public static Dictionary<string, CsvData> LibraryCategory(DataTypes dataType)
    {
        //cat = cat.Replace("FL", "").Replace("FR", "");
        switch (dataType)
        {
            case DataTypes.CabTexture: return _G.LibraryCabTextures.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Ogee: return _G.LibraryOgees.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Cornice: return _G.LibraryCornices.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Fascia: return _G.LibraryFacias.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Valance: return _G.LibraryValances.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Kick: return _G.LibraryKicks.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Panel: return _G.LibraryPanels.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Filler: return _G.LibraryFillers.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Counter: return _G.LibraryCounters.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Knob: return _G.LibraryKnobs.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Door: return _G.LibraryDoors.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.Cabinet: return _G.LibraryCabinets.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.IntTexture: return _G.LibraryInteriorTextures.ToDictionary(kvp => kvp.Key, kvp => (CsvData)kvp.Value);
            case DataTypes.NULL:
            default: Debug.Log("Should not enter here"); return null;
        }
    }

    public static string ActiveCabinetList(){
        string LibraryCat="Cabinet";
        if(UIT.TogOn("FILTERS")=="Ukitchenit")LibraryCat="CabinetUkitchenit";
        return LibraryCat;
    }
    public static bool Bool(string Target,string List){
        string[] Items=List.Split('_');
        for(int i=0; i<Items.Length; i++){
            if(Items[i]==Target)return true;
        }
        return false;
    }
    public static float DoorThickness(int nO){
        //print("_G.OBJs[nO][61]====="+_G.OBJs[nO][61]);
        if(_G.OBJs[nO][61]!="none" && _G.OBJs[nO][61]!="nodoor"){
            float dT = 0.75f;//door thickness           
            string DTvalue;//door thickness fron csv
            DTvalue = UIT.Value(Library.Door,_G.OBJs[nO][61].Split("?")[0],Header.Thick);//Get.LibraryValue(_G.OBJs[nO][61], CsvHeaders.Door_Thickness, DataTypes.Door);
            if (!string.IsNullOrEmpty(DTvalue)) {dT = DOIT.ConvertStringToNumber(DTvalue);}
            dT+=_G.DGap;
            return dT;
        }
        return 0;

    }
    public static bool PreferenceBool(string Key){
        //print("_P.ListSwitch.ContainsKey(Key)====" + _P.ListSwitch.ContainsKey(Key));
        
        //print("_P.ListSwitch[Key]====" + _P.ListSwitch[Key]);
        if (_P.ListSwitch.ContainsKey(Key) && _P.ListSwitch[Key]) return true;
        return false;
    }
    public static List<int> CabinetsToModifyInt()
    {
        List<int> list = new();
        for (var i = 0; i < _G.OBJnum; i++)
        {
            if (DOIT.exist(i) && _G.OBJs[i][0][..4]=="cabi")
            {
                foreach (string ObjectSelect in _G.SELECEDLIST)
                {
                    print("_G.SELECEDLIST object in======" + ObjectSelect);
                }
                string[] ADN = _G.OBJs[i];

                //isInList = false;
                print("ADN[5]=========" + ADN[5]);
                string CategoryGroup = SetSelectionBTN.GetCategoryGrooup(ADN[5]);

                if (_G.SELECEDLIST.Count == 0)
                {
                    if (_G.SelectionToAdd.Contains(CategoryGroup) && ADN[22].Contains("w")) { list.Add(i); }//Base/Wall/Tall                   
                    else if (_G.SelectionToAdd.Contains("Island") && ADN[22] == "floor") { list.Add(i); }
                    else if (_G.SelectionToAdd.Contains("All")) { list.Add(i); }
                }
                else if (_G.SELECEDLIST.Contains(ADN[0])) { list.Add(i); }
            }
        }
        return list;
    }
}