using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEditor;
using Raumgleiter.BaseRGDK;
using Raumgleiter.BaseRGDK.JSON;

namespace Raumgleiter.RGDKDevLab
{
    public class MtexUI_003 : MonoBehaviour
    {
        MtexDownloadFunctions mtexDownloadFunctions = new MtexDownloadFunctions();
        List<MtexType> TypeClassList;
        public GameObject GridLayout, myCanvas;
        public int TextSize=9;
        public GameObject ButtonPrefab01;
        public Text NumberOfMaterials;
        public List<MtexMaterialBasic> MatClassList;
        GameObject TypesGrid, MaterialsGrid, MaterialPreview;
        List<GameObject> Screens;
        /// Matrial and Texture
        private Material newMaterial;
        private Vector2 materialTiling = new Vector2(1f, 1f);
        private Texture newTexture, newBump, newNormal;
        private Dictionary<string, int> urlVariabels = new Dictionary<string, int>() {
            { "manufacturer_id ", 999999}, { "type_id", 999999 }, { "color_id", 999999}, {"per_page", 20} };



        // Use this for initialization
        void Start()
        {
            StartCoroutine(GetTypes());

            // create screens
            TypesGrid = MakeGridScreen("TypesGrid");
            MaterialsGrid = MakeGridScreen("MaterialsGrid");
            MaterialPreview = MakeGridScreen("MaterialsPreview");
            Screens = new List<GameObject>() { TypesGrid, MaterialsGrid, MaterialPreview };
        }

        private GameObject MakeGridScreen(string Name)
        {
            var MyGridObjectInstance = Instantiate(GridLayout, myCanvas.transform);
            MyGridObjectInstance.name = Name;
            MyGridObjectInstance.SetActive(false);
            //MyGridObjectInstance.SetActive(true);
            return MyGridObjectInstance;
        }

        private void ToggleScreens(GameObject CurrentScreen)
        {
            for (int i = 0; i < Screens.Count; i++)
            {
                Screens[i].SetActive(false);
            }
            CurrentScreen.SetActive(true);
        }

        private void CreateTypesPreview()
        {
            // activate Type grid
            ToggleScreens(TypesGrid);

            // populate grid with types
            for (int i = 0; i < TypeClassList.Count; i++)
            {
                var ButtonName = TypeClassList[i].name;
                Button myButton = AddButton(TypesGrid, ButtonPrefab01, ButtonName);
                myButton.onClick.AddListener(delegate { StartCoroutine(GetMaterials(ButtonName)); });
            }
        }

        private void CreateMaterialsPreview()
        {
            // activate grid
            ToggleScreens(MaterialsGrid);

            //populate grid
            for (int i = 0; i < MatClassList.Count; i++)
            {
                var ButtonName = MatClassList[i].name;
                Button myButton = AddButton(MaterialsGrid, ButtonPrefab01, ButtonName);
                myButton.onClick.AddListener(delegate { StartCoroutine(GetMaterial(ButtonName)); });
            }
        }

        private Button AddButton(GameObject ParentGO, GameObject ButtonPrefab, string ButtonName)
        {
            var ButtonInstance = Instantiate(ButtonPrefab, new Vector3(0, 0, 0), Quaternion.identity);
            ButtonInstance.transform.SetParent(ParentGO.transform);
            ButtonInstance.name = "button_" + ButtonName;
            ButtonInstance.GetComponentInChildren<Text>().text = ButtonName;

            Button b = ButtonInstance.GetComponent<Button>();
            return b;
        }

        private IEnumerator GetTypes()
        {
            // get types from web
            yield return StartCoroutine(mtexDownloadFunctions.GetTypes(value => TypeClassList = value));
            
            CreateTypesPreview();
        }

        private IEnumerator GetMaterials(string buttonName)
        {
            //get id from name
            var type_id = MtexType.GetMaterialIdFromName(buttonName, TypeClassList);
            urlVariabels["type_id"] = type_id;

            // add id to url
            var materialsUrl = MtexDownloadFunctions.BuildUrl(urlVariabels);

            // get coresponding materials
            yield return mtexDownloadFunctions.GetMaterials(materialsUrl, value => MatClassList = value);
            NumberOfMaterials.text = "total materials: " + MatClassList.Count.ToString();

            // deactivate IScreen
            TypesGrid.SetActive(false);
            MaterialsGrid.SetActive(true);

            CreateMaterialsPreview();

        }

        private IEnumerator GetMaterial(string ButtonName, string textureSize = "small")
        {
            ToggleScreens(MaterialPreview);
            //get id from name
            var mat_id = MtexMaterialBasic.GetMaterialIdFromName(ButtonName, MatClassList);

            // create empty json
            JSONNode json = JSONNode.Parse("");

            // get selected material info and download textures
            yield return mtexDownloadFunctions.GetMaterial(mat_id, value => json = value);
            yield return mtexDownloadFunctions.GetMainTexture(json, value => newTexture = value, textureSize);
            yield return mtexDownloadFunctions.GetBumpTexture(json, value => newBump = value, textureSize);

            // check for bump - if there is a bump, convert to normal, else clear normal
            if (newBump != null)
            {
                newNormal = TextureHelper.BumpToNormalMap((Texture2D)newBump);
            }
            else
            {
                newNormal = null;
            }

            // create material and update preview
            newMaterial = MtexDownloadFunctions.CreateMaterial((Texture2D)newTexture, (Texture2D)newNormal, ButtonName);
            UpdateMaterialPreview();

            // create material description
            //materialInfo.text = mtexDownloadFunctions.MaterialDescription(json, newTexture);

            //populate size dropdown
            //var textureSizes = MtexDownloadFunctions.GetTextureSizes(json);

        }

        private void UpdateMaterialPreview()
        {

            GameObject newGO = new GameObject("test_sprite");
            newGO.transform.SetParent(MaterialPreview.transform);
            newGO.AddComponent<RawImage>();

            
            // cube.GetComponent<MeshRenderer>().material = newMaterial;
            newGO.GetComponent<RawImage>().texture = newTexture;
        }
    }
}