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

public class TextureCall : MonoBehaviour
{
    //-----Add to selected--------------------
    public static void TextureSplash(string code, string global_unique)
    {
         if (global_unique == "UNIQUE")
        {
            SetSplashTexturesOnObject(code, SceneModeManager.SelectedName);
        }        
        else
        {
            for (int i = 0; i < _G.OBJnum; i++)
            {
                if (DOIT.exist(i))
                {
                    string objGlobal = _G.OBJs[i][60];

                    if (objGlobal != global_unique) continue;

                    SetSplashTexturesOnObject(code, _G.OBJs[i][0]);
                }
            }
        }
    }
    private static void SetSplashTexturesOnObject(string code, string objectName)
    {
        GameObject go = Get.o2("SCENE", objectName);
        foreach (Transform t in go.GetComponentsInChildren<Transform>(true))
        {
            if (t.CompareTag("splash"))
            {
                _G.OBJs[Get.GetObjectIndex(objectName)][54] = code;
                t.GetComponent<MeshRenderer>().material = CREATE.GetMatfromRawCode(code, "SCENE");
                Material material = t.GetComponent<MeshRenderer>().material;
                material.EnableKeyword("_ALPHATEST_ON");
            }
        }
    }
    public static void TextureWall(string code)
    {
        print("code===tex====================" + code);
        if (PAINT.SEL == "ceil")
        {
            GameObject ceil = Get.o1(PAINT.SEL);
            Material Mat = ceil.GetComponent<MeshRenderer>().material;
            CREATE.ResetMaterialFromCode(Mat, code, "Variable");
            _G.ceilm = ceil.GetComponent<MeshRenderer>().material;
            //Debug.Log("texture call ceil");
        }
        else if (PAINT.SEL == "AWAL") //
        {
            for (int i = 0; i < _G.NW; i++)
            {
                string key = "w" + (i + 1).ToString();
                GameObject wall = Get.o1(key);
                if (wall == null)
                {
                    continue;
                }

                foreach (Transform child in wall.transform)
                {
                    Material Mat = child.GetComponent<Renderer>().material;
                    CREATE.ResetMaterialFromCode(Mat, code, "Variable");
                }

                _G. WallsMaterial[i] = wall.transform.Find("s1").GetComponent<Renderer>().material;
            }
            //Debug.Log("texture call all wall");
        }
        else
        {
            GameObject O = Get.o1(PAINT.SEL);
            foreach (Transform child in O.transform)
            {
                Material Mat = child.GetComponent<Renderer>().material;
                CREATE.ResetMaterialFromCode(Mat, code, "Variable");
            }

            int wallindex = int.Parse(O.name[1..]) - 1;
            _G. WallsMaterial[wallindex] = O.transform.Find("s1").GetComponent<Renderer>().material;

            //Debug.Log("texture call single wall");
        }
    }
    public static void TextureWall(List<string> codes)
    {
        int indexCode = 0;
        if (PAINT.SEL == "AWAL") //
        {
            for (int i = 0; i < _G.NW; i++)
            {
                string key = "w" + (i + 1).ToString();
                GameObject wall = Get.o1(key);
                if (wall == null)
                {
                    continue;
                }

                foreach (Transform child in wall.transform)
                {
                    Material Mat = child.GetComponent<Renderer>().material;
                    CREATE.ResetMaterialFromCode(Mat, codes[indexCode], "Variable");
                    indexCode++;
                }

                _G. WallsMaterial[i] = wall.transform.Find("s1").GetComponent<Renderer>().material;
            }
        }
    }
    public static void TextureBloc(string code,string category)
    {
        print("----code from TextureBloc===================================================" + code);
         GameObject O = SceneModeManager.Selected;
        int ind = Get.GetObjectIndex(O.name);
        switch (category)
        {
            case "Block":
            case "Bloc":
                _G.OBJs[ind][41] = code;
               //_G.OBJs[ind][61] = code;
                break;
            case "Panel":
                if(_G.OBJs[ind][90] != "FakeDoor")
                {
                    string newCode = "PA_" + code.Split("?")[0].Split("_")[1];
                    _G.OBJs[ind][61] = newCode;
                }
                break;
         }
        foreach (Transform child in O.transform)
        {
            if (Get.Bool(child.name, "top_front_left_right_under_back_Cube1_Cube2_Cube3_Arch"))
            {
                if (code.Split('?').Length==2)
                {
                    //child.GetComponent<MeshRenderer>().material = CREATE.Texture_CAB(colorID: code.Split('?')[0], rotation: code.Split('?')[1], MaterialDisplayMode.SceneMaterial);
                    //string name, float W, float H, string R, DataTypes cat,string CAB_PNL)
                    child.GetComponent<MeshRenderer>().material = UIT_MATERIAL.GetMaterial(code);//CREATE.Texture_CAB(code.Split('?')[0],18,18, code.Split('?')[1], "Bloc","CAB");
                }
                else
                {
                    child.GetComponent<MeshRenderer>().material = Instantiate(_G.TEXTURE);
                    CREATE.ResetMaterialFromCode(child.GetComponent<MeshRenderer>().material, code, "Variable");
                }
            }
            if (Get.Bool(child.name, "Cyl1_Cyl2_Cyl3_Cyl4"))
            {
                if (code.Split('?').Length==2)
                {
                    child.transform.GetChild(0).GetComponent<MeshRenderer>().material = UIT_MATERIAL.GetMaterial(code.Split('?')[0]);//CREATE.Texture_CAB(code.Split('?')[0],18,18, code.Split('?')[1], "Bloc","CAB");
                }
                else
                {
                    child.transform.GetChild(0).GetComponent<MeshRenderer>().material = Instantiate(_G.TEXTURE);
                    CREATE.ResetMaterialFromCode(child.transform.GetChild(0).GetComponent<MeshRenderer>().material, code, "Cylinder");
                }
            }
            if (Get.Bool(child.name, "Cylinder"))
            {
                if (code.Split('?').Length==2)
                {
                    child.transform.GetChild(0).GetComponent<MeshRenderer>().material = UIT_MATERIAL.GetMaterial(code.Split('?')[0]);//CREATE.Texture_CAB(code.Split('?')[0],18,18, code.Split('?')[1], "Bloc","CAB");
                }
                else
                {
                    child.transform.GetChild(0).GetComponent<MeshRenderer>().material = Instantiate(_G.TEXTURE);
                    CREATE.ResetMaterialFromCode(child.transform.GetChild(0).GetComponent<MeshRenderer>().material, code, "Cylinder");
                }
            }
            
            //for Panel
            if (Get.Bool(child.name, "Top_Front_Left_Right_Under_Back_Cube1_Cube2_Cube3"))
            {
                if (code.Split('?').Length==2)
                {
                    child.GetComponent<MeshRenderer>().material = UIT_MATERIAL.GetMaterial(code.Split('?')[0]);//CREATE.Texture_CAB(code.Split('?')[0],18,18, code.Split('?')[1], "Bloc","CAB");
                }
                else
                {
                    child.GetComponent<MeshRenderer>().material = Instantiate(_G.TEXTURE);
                    CREATE.ResetMaterialFromCode(child.GetComponent<MeshRenderer>().material, code, "Variable");
                }
            }
        }
        // int ind = Get.GetObjectIndex(SceneModeManager.SelectedName);
        // _G.OBJs[ind][41] = code;
        // GameObject O = Get.o1(SceneModeManager.SelectedName);
        // foreach (Transform child in O.transform)
        // {
        //     if (child.name != "Group") CREATE.ResetMaterialFromCode(child.GetComponent<MeshRenderer>().material, code, "Variable");
        //     //if(child.name!="Group")child.GetComponent<MeshRenderer>().material=CREATE.resetMaterial(child.GetComponent<MeshRenderer>().material,code);
        //}
    }
    public static void TextureFloor(string code)
    {
        _G.FLCs = code;
        CreateFloor.SetFloor();
        ConstructOpen.RedrawOpen();
    }
    public static void TextureCounter(List<string> name)
    {
        //print("----------------TextureCall--------------" + name);
        //COUN.1?1?1?FFFFFF?FFFFFF?1?90?S?ffffff?1?1?0.05?0.5?0

        string CodeString="";
        for(int i=0; i<name.Count; i++){
            if(i==3)name[i]=_G.SC[3];
            if(i==4)name[i]=_G.SC[4];
            CodeString+=name[i];
            if(i<name.Count-1)CodeString+="?";
        }

        //print("----------------TextureCall CodeString--------------" + CodeString);

        //Modify on list counter
        if (SceneModeManager.SelectedName != "" && _G.OBJs[Get.GetObjectIndex(SceneModeManager.SelectedName)][60] == "UNIQUE")
        {
            _G.OBJs[Get.GetObjectIndex(SceneModeManager.SelectedName)][41] = CodeString;
            DOIT.REDOCAB(Get.GetObjectIndex(SceneModeManager.SelectedName));
        }
        if (SceneModeManager.SelectedName == "" || SceneModeManager.SelectedName == null)
        {
            //print("---------------SceneModeManager.SelectedName==--------------");
            //GlobalSelectionManager.SetValue(GlobalOption.COUN_8, name);
            UIT.GlobalSet(Header.Counter,CodeString,_G.G);
            DOIT.AddtoCodeCabGlobal(41, CodeString, _G.G);
            DOIT.REDOALLCab_G();
        }
    }
    //-----Get-------------------
    public static string getCodeFromLibrary(string name)
    {
        //print("name================================="+name);  
        _G.SC[0] = Get.StdTextureValue(name, 11);
        _G.SC[1] = Get.StdTextureValue(name, 12);
        _G.SC[2] = Get.StdTextureValue(name, 13);
        _G.SC[3] = Get.StdTextureValue(name, 14);
        _G.SC[4] = Get.StdTextureValue(name, 15);
        _G.SC[5] = Get.StdTextureValue(name, 16);
        _G.SC[6] = Get.StdTextureValue(name, 17);
        _G.SC[7] = Get.StdTextureValue(name, 18);
        _G.SC[8] = "ffffff";//Get.StdTextureValue(name,18);
        _G.SC[9] = "1";//Get.StdTextureValue(name,18);
        _G.SC[10] = "1";//Get.StdTextureValue(name,18);
        _G.SC[11] = "1";//Get.StdTextureValue(name,18);
        _G.SC[12] = "1";//Get.StdTextureValue(name,18);
        _G.SC[13] = "1";//Get.StdTextureValue(name,18);

        string code = Set.CodeTexture();
        return code;
    }
    // public static string getcodeTextureFromMatCabTexture(Material MAT)
    // {

    //     string code = "";
    //     if (MAT.GetTexture("_MainTex") == null) { _G.SC[0] = "null"; }
    //     else _G.SC[0] = MAT.GetTexture("_MainTex").name;


    //     _G.SC[6] = MAT.GetFloat("_rotation").ToString();
    //     //Me_8?90



    //     code = "Me_8" + "?" + _G.SC[6];

    //     return code;
    // }
    public static string getcodeTextureFromMat(Material MAT)
    {
        //Texture,c1,c2,c3,tile,rotation,smoothness,metalic,contrast
        string code = "";
        string Tname = "none";
        if (MAT.GetTexture("_Texture") != null) { Tname =  MAT.GetTexture("_Texture").name; }

        string Tile = MAT.GetVector("_Tile").x.ToString() + "_" + MAT.GetVector("_Tile").y.ToString();

        string Contrast = MAT.GetFloat("_contrast").ToString();
        Contrast ??= "1";


        List<string> CodeList=new(){
            Tname,    
            ColorUtility.ToHtmlStringRGBA(MAT.GetColor("_c1")),
            ColorUtility.ToHtmlStringRGBA(MAT.GetColor("_c2")),
            ColorUtility.ToHtmlStringRGBA(MAT.GetColor("_c3")),
            Tile,
            MAT.GetFloat("_Rotation").ToString(),
            Contrast,
            MAT.GetFloat("_Smoothness").ToString(),
            MAT.GetFloat("_Metallic").ToString(),
            MAT.GetFloat("_Relief").ToString()
        };
          
        for(int i=0; i<CodeList.Count; i++)
            {
                code+=CodeList[i];
                if(i<CodeList.Count-1)code+=",";
            }

        //print("getcodeTextureFromMat return code===="+code);
        return code;
    }
    //-----Copy/Paste----------------
    public void copy()
    {
        //string code = Set.CodeTexture();
        _G.CLIPBOARD = _G.TCsStart;
    }
    public void copyfromUniversale()
    {
        string colorname = Get.ToggleOnInChild("Canvas/Panel_SCENE/PNL/UNIVERSALpnl/TEXTCOL/Viewport/Contenttexcol");
        _G.SC[0] = Get.LibraryValue(colorname, CsvHeaders.Texture,"CabTexture");

        Debug.Log("Need to fix this for index 12 and 16");
        _G.SC[9] = "1";//Get.CabTextureValue(colorname,16);
        _G.SC[1]="1";
        _G.SC[2]="0.5";

        if (_G.SC[5] == "")_G.SC[5]="0";

        _G.SC[10]="1";
        _G.SC[11]="0";
        _G.SC[12]="0.5";
        _G.SC[13]="0";

        _G.CLIPBOARD = Set.CodeTexture();
    }
    public void paste()
    {
        if (!string.IsNullOrEmpty(_G.CLIPBOARD))
        {
            _G.TCsNew = _G.CLIPBOARD;
            TEXTURESPNL.ShowTextureNew();
            TEXTURESPNL.AddNewTexture(_G.TCsNew); 
        }


        print("_G.CLIPBOARD====" + _G.CLIPBOARD);
        

        // string[] c = _G.CLIPBOARD.Split(',');
       
        // if (_G.PNL == "TexturesFloorPNL") { TextureFloor(_G.CLIPBOARD); }
        // if (_G.PNL == "TexturesWallPNL") { TextureWall(_G.CLIPBOARD); }
        // if (_G.PNL == "TexturesBlocPNL") { TextureBloc(_G.CLIPBOARD, "Block"); }
        // if (_G.PNL == "TexturesSplashPNL") { TextureSplash(_G.CLIPBOARD, "UNIQUE"); }

        // if (c[0].IndexOf("TEXT") != -1) { DOIT.CloseALLPNL(); }
        // else { TEXTURESPNL.Setsliders(); }
    }
}