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

namespace Raumgleiter.RGDKDevLab
{
    /// <summary>
    /// > Basic UI script interface to use with MtexDownloadFunctions
    /// </summary>
    public class MtexUI_005 : MonoBehaviour
    {
        //------------------------------------------------------------------------------------------------------------------

        //Connections
        //[Header("Connections")]


        //Resources
        //[Header("Resources")]


        //Attributes
        //[Header("Attributes")]

        MtexDownloadFunctions mtexDownloadFunctions = new MtexDownloadFunctions();

        public GameObject Screen001, Screen002, Screen003, ColorPicker, MtexDownloader;
        public GameObject GridLayout, GridLayout1, myCanvas, ButtonPrefab01, TogglePrefab01, Cube;
        public Text NumberOfMaterials, MaterialInfo, CurrentScreenName;
        public Button 
            ButtonBackToMaterials, ButtonBackToTypes, ButtonNextPage, 
            ButtonPreviousPage, ButtonSaveMatrial, ButtonShowMtex,
            ButtonApplyMaerial;
        public RawImage TexturePreview;
        public Dropdown DropDownSize;
        private int TextSize = 9;

        private List<GameObject> Screens;
        private List<MtexType> TypeClassList;
        private List<MtexMaterialBasic> MatClassList;
        private Dictionary<string, List<int>> urlVariables = new Dictionary<string, List<int>>();

        /// Matrial and Texture
        public int Mat_id;
        private Material NewMaterial;
        public Material TempMaterial;
        private Vector2 MaterialTiling = new Vector2(1f, 1f);
        private Texture NewTexture, NewBump, NewNormal;
        private string MaterialName, TotalEntries;


        //Stats
        //[Header("Stats")]
        //protected bool IsSetUp = false;
        //protected bool IsAwoken = false;


        //Getter

        //Delegates



        //------------------------------------------------------------------------------------------------------------------
        //awake

        //protected void Awake()
        //{
        //    //Already Awoken?
        //    if (!IsAwoken)
        //    {
        //        IsAwoken = true;
        //    }
        //}


        //------------------------------------------------------------------------------------------------------------------
        //start

        void Start()
        {
            // make a list of screens for easy switching
            Screens = new List<GameObject>() { Screen001, Screen002, Screen003 };

            // add listeners to buttons
            ButtonShowMtex.onClick.AddListener(delegate { ShowMtex(); });
            ButtonApplyMaerial.onClick.AddListener(delegate { ApplyMaterial(); });
            ButtonBackToMaterials.onClick.AddListener(delegate { ToggleScreens(Screen002); });
            ButtonBackToTypes.onClick.AddListener(delegate { BackToScreen001(); });
            ButtonNextPage.onClick.AddListener(delegate { GetNext(); });
            ButtonPreviousPage.onClick.AddListener(delegate { GetPrevious(); });
            ButtonSaveMatrial.onClick.AddListener(delegate { SaveMaterial(); });
            DropDownSize.onValueChanged.AddListener(delegate { SizeDdValueChanged(DropDownSize); });

            FillUrlDictionary();
        }

        public void StartMtexDownloader()
        {
            Debug.Log("MtexUI_005::StartMtexDownloader: Well, it got to here..");

            // get the types of materials for the start screen
            StartCoroutine(StartScreen());
            StartCoroutine(GetColors());
        }

        private void ApplyMaterial()
        {
            // TempMaterial = NewMaterial;
            // MtexDownloadFunctions.SaveMaterial(NewMaterial, "TestRed", (Texture2D)NewTexture, (Texture2D)NewNormal);

            //Cube.GetComponent<TestPainter>().UpdateMaterial(NewMaterial);

            var Building = GameObject.Find("Painter").GetComponent<WorldManager>().GetThisGameObject();
            GameObject.Find("Painter").GetComponent<TestPainter>().UpdateMaterial2(NewMaterial, Building);

        }

        private void ShowMtex()
        {
            if (MtexDownloader.active)
            {
                MtexDownloader.SetActive(false);
            }
            else
            {
                MtexDownloader.SetActive(true);
            }
        }


        //------------------------------------------------------------------------------------------------------------------
        //setup

        //public void SetUp()
        //{
        //    Awake();
        //    IsSetUp = true;
        //}


        //------------------------------------------------------------------------------------------------------------------
        //destroy

        //***********************************************************************************************************************
        //update

        //***********************************************************************************************************************
        //refresh

        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------

        //***********************************************************************************************************************
        //events

        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------

        //***********************************************************************************************************************
        //private

        private IEnumerator GetColors()
        {
            // get all colors
            var ColorClassList = new List<MtexColor>();
            yield return mtexDownloadFunctions.GetColors(value => ColorClassList = value);
            
            //make toggle instance for every color
            for (int i = 0; i < ColorClassList.Count; i++)
            {
                Toggle thisToggle = AddButtonLike(ColorPicker, TogglePrefab01, ColorClassList[i].name, ColorClassList[i].id)
                    .GetComponent<Toggle>();
                // add listener
                thisToggle.onValueChanged.AddListener(delegate { ColorToggleValueChanged(thisToggle); });
                // add toggle to group to work as radio button
                thisToggle.group = ColorPicker.GetComponent<ToggleGroup>();
            }
        }

        //------------------------------------------------------------------------------------------------------------------
        private bool IsMouseOverUI()
        {
            return EventSystem.current.IsPointerOverGameObject();
        }


        //------------------------------------------------------------------------------------------------------------------

        private void ColorToggleValueChanged(Toggle thisToggle)
        {
            // add or remove color id from url
            if (thisToggle.isOn)
            {
                urlVariables["color_id"].Add(int.Parse(thisToggle.name));
            }
            else
            {
                urlVariables["color_id"].Remove(int.Parse(thisToggle.name));
            }
            // after color change always reset page to 1
            urlVariables["page"][0] = 1;
            
            //update materials 
            StartCoroutine(UpdateMaterialsAllScreen());
        }


        //------------------------------------------------------------------------------------------------------------------

        private void FillUrlDictionary()
        {
            var manufacturer_id_list = new List<int>();
            manufacturer_id_list.Add(999999);
            urlVariables.Add("manufacturer_id", manufacturer_id_list);

            var type_id_list = new List<int>();
            type_id_list.Add(999999);
            urlVariables.Add("type_id", type_id_list);

            var color_id_list = new List<int>();
            urlVariables.Add("color_id", color_id_list);

            var per_page_list = new List<int>();
            per_page_list.Add(36);
            urlVariables.Add("per_page", per_page_list);

            var page_list = new List<int>();
            page_list.Add(1);
            urlVariables.Add("page", page_list);
        }


        //------------------------------------------------------------------------------------------------------------------

        private void SaveMaterial()
        {
            MtexDownloadFunctions.SaveMaterial(NewMaterial, MaterialName, (Texture2D)NewTexture, (Texture2D)NewNormal);
        }


        //------------------------------------------------------------------------------------------------------------------

        private IEnumerator StartScreen()
        {
            // activate Screen 001
            ToggleScreens(Screen001);
            CurrentScreenName.text = "Material Types";

            // Destroy old grid with types
            ClearGrid(Screen001);

            // add new grid
            var thisGrid = AddGridToScreen(Screen001);

            // check for number of material types
            yield return mtexDownloadFunctions.GetTypes(value => TypeClassList = value);
            var totalEntries = TypeClassList.Count;

            PopulateTypesGrid(thisGrid, totalEntries);
        }

        
        //------------------------------------------------------------------------------------------------------------------


        private void PopulateTypesGrid(GameObject thisGrid, int totalEntries)
        {
            for (int i = 0; i < totalEntries; i++)
            {
                try
                {
                    // try catch block if buttons destroyed before being assigned
                    var thisButtonName = TypeClassList[i].name;
                    Button thisButton = AddButtonLike(thisGrid, ButtonPrefab01, thisButtonName, TypeClassList[i].id)
                        .GetComponent<Button>();
                    thisButton.onClick.AddListener(delegate { MaterialsAllScreen(int.Parse(thisButton.name)); });
                }
                catch
                {
                    Debug.Log("MtexUI_004::StartScreen: Probably clicked to fast next...");
                }
            }
        }


        //------------------------------------------------------------------------------------------------------------------

        private void MaterialsAllScreen(int this_type_id)
        {
            urlVariables["type_id"][0] = this_type_id;
            StartCoroutine(UpdateMaterialsAllScreen());
        }
        
        
        //------------------------------------------------------------------------------------------------------------------

        private IEnumerator UpdateMaterialsAllScreen()
        {
            // activate Screen 002
            ToggleScreens(Screen002);

            // add name to screen
            CurrentScreenName.text = GetTypeName();

            // clear grid
            ClearGrid(Screen002);

            // add new grid
            var thisGrid = AddGridToScreen(Screen002);

            // build url
            var materialsUrl = MtexDownloadFunctions.BuildUrl2(urlVariables);

            // check for total entries
            yield return MtexDownloadFunctions.GetTotalEntries(materialsUrl, value => TotalEntries = value);

            // get all materials of given type
            yield return mtexDownloadFunctions.GetMaterials(materialsUrl, value => MatClassList = value);

            // populate grid with materials of given type
            PopulateMaterialsAllGrid(thisGrid);
            NumberOfMaterials.text = urlVariables["page"][0] + " of " + GetNumberOfPages();
        }


        //------------------------------------------------------------------------------------------------------------------

        private int GetNumberOfPages()
        {
            //int NumberOfPages = 0;
            var NumberOfPages = (int)Math.Ceiling(int.Parse(TotalEntries) / (float)urlVariables["per_page"][0]);
            return NumberOfPages;
        }


        //------------------------------------------------------------------------------------------------------------------

        private void PopulateMaterialsAllGrid(GameObject thisGrid)
        {
            for (int i = 0; i < MatClassList.Count; i++)
            {
                // try catch block if buttons destroyed before being assigned
                try
                {
                    Button thisButton = AddButtonLike(thisGrid, ButtonPrefab01, MatClassList[i].name, MatClassList[i].id)
                        .GetComponent<Button>();
                    thisButton.onClick.AddListener(delegate { MaterialScreen(int.Parse(thisButton.name)); });

                    // Start async coroutine for adding material Picture
                    StartCoroutine(GetMaterialThumb(thisButton));
                }
                catch
                {
                    Debug.Log("MtexUI_004::MaterialsScreen: Probably clicked to fast next...");
                }
            }
        }


        //------------------------------------------------------------------------------------------------------------------

        private void ClearGrid(GameObject ParentGameObject)
        {
            foreach (Transform child in ParentGameObject.transform)
            {
                if (child.name == "Grid")
                {
                    Destroy(child.gameObject);
                }
            }
        }


        //------------------------------------------------------------------------------------------------------------------

        private void MaterialScreen(int this_mat_id)
        {
            // save mat_id globally
            Mat_id = this_mat_id;
            // activate Screen 003
            ToggleScreens(Screen003);

            // add name to screen
            foreach (var mtexmtexMaterial in MatClassList)
            {
                if (mtexmtexMaterial.id == Mat_id)
                {
                    MaterialName = mtexmtexMaterial.id + "_" + mtexmtexMaterial.name;
                    CurrentScreenName.text = mtexmtexMaterial.name;
                }
            }
            StartCoroutine(GetMaterial(Mat_id));
        }
        
        
        //------------------------------------------------------------------------------------------------------------------

        private IEnumerator GetMaterial(int mat_id, string textureSize = "small")
        {
            // create empty json
            JSONNode json = JSONNode.Parse("");
            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
            CheckForBump();

            // create material and update preview
            NewMaterial = MtexDownloadFunctions.CreateMaterial((Texture2D)NewTexture, (Texture2D)NewNormal, mat_id.ToString());

            //
            TexturePreview.texture = NewTexture;
            MaterialTiling = mtexDownloadFunctions.MaterialTiling(NewTexture);
            TexturePreview.uvRect = new Rect(0f,0f, MaterialTiling.y, MaterialTiling.x);

            // create material description
            MaterialInfo.text = mtexDownloadFunctions.MaterialDescription(json, NewTexture);
            
            Debug.Log("width :" + NewTexture.width);
            Debug.Log("width :" + NewTexture.height);

            // get texture sizes
            var TextureSizes = MtexDownloadFunctions.GetTextureSizes(json);
            PopulateDropdown(DropDownSize, TextureSizes);
        }


        //------------------------------------------------------------------------------------------------------------------

        private void PopulateDropdown(Dropdown dropdown, List<string> someList)
        {
            dropdown.ClearOptions();
            dropdown.options.Add(new Dropdown.OptionData("--select size--"));
            DropDownSize.value = 0;
            dropdown.AddOptions(someList);
        }

        //------------------------------------------------------------------------------------------------------------------

        private void CheckForBump()
        {
            // check for bump and convert to normal
            if (NewBump != null)
            {
                NewNormal = TextureHelper.BumpToNormalMap((Texture2D)NewBump);
            }
            else
            {
                NewNormal = null;
            }
        }


        //------------------------------------------------------------------------------------------------------------------

        private IEnumerator GetMaterialThumb(Button thisButton)
        {
            // convert button name to material id
            var this_mat_id = int.Parse(thisButton.name);

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

            // create empty textre
            Texture TexturePreview = new Texture();

            // get selected material info and download textures
            yield return mtexDownloadFunctions.GetMaterial(this_mat_id, value => json = value);
            yield return mtexDownloadFunctions.GetMainTexture(json, value => TexturePreview = value);

            // add picture to button
            try
            {
                thisButton.GetComponent<Image>().type = Image.Type.Simple;
                thisButton.GetComponent<Image>().preserveAspect = true;
                thisButton.GetComponent<Image>().sprite = Sprite.Create((Texture2D)TexturePreview, new Rect(0.0f, 0.0f, TexturePreview.width, TexturePreview.height), new Vector2(0.5f, 0.5f), 100.0f);
            }
            catch
            {
                Debug.Log("MtexUI_004::GetPreviewPicture: Probably clicked to fast next...");
            }
        }


        //------------------------------------------------------------------------------------------------------------------

        private GameObject AddGridToScreen(GameObject Screen)
        {
            var thisGrid = Instantiate(GridLayout, Screen.transform);
            thisGrid.name = "Grid";
            thisGrid.SetActive(true);
            return thisGrid;
        }


        //------------------------------------------------------------------------------------------------------------------

        private GameObject AddButtonLike(GameObject ParentGO, GameObject thisPrefab, string thisName, int thisId)
        {
            // instantiate prefab
            var thisInstance = Instantiate(thisPrefab, new Vector3(0, 0, 0), Quaternion.identity);
            // set parent game object
            thisInstance.transform.SetParent(ParentGO.transform);
            // make name of instance the id for better selection
            thisInstance.name = thisId.ToString();
            // add description to text field
            thisInstance.GetComponentInChildren<Text>().text = thisId + "\n" + thisName;
            return thisInstance;
        }


        //------------------------------------------------------------------------------------------------------------------

        private void ToggleScreens(GameObject CurrentScreen)
        {
            // turn off all screens
            for (int i = 0; i < Screens.Count; i++)
            {
                Screens[i].SetActive(false);
            }
            // activate selected
            CurrentScreen.SetActive(true);
        }


        //------------------------------------------------------------------------------------------------------------------

        private string GetTypeName()
        {
            var thisName = "";
            foreach (var mtexType in TypeClassList)
            {
                if (mtexType.id == urlVariables["type_id"][0])
                {
                    thisName = mtexType.name;
                }
            }
            return thisName;
        }


        //------------------------------------------------------------------------------------------------------------------

        private void GetNext()
        {
            // adds page in UrlVariables by one, if it exists
            if (urlVariables["page"][0] + 1 <= GetNumberOfPages())
            {
                urlVariables["page"][0] = urlVariables["page"][0] + 1;
                StartCoroutine(UpdateMaterialsAllScreen());
            }
            else
            {
                Debug.Log("MtexUI_005::GetPrevious: Too high..");
            }

        }


        //------------------------------------------------------------------------------------------------------------------

        private void GetPrevious()
        {
            // lowers page in UrlVariables by one, if it exists
            if (urlVariables["page"][0] != 1)
            {
                urlVariables["page"][0] = urlVariables["page"][0] - 1;
                StartCoroutine(UpdateMaterialsAllScreen());
            }
            else
            {
                Debug.Log("MtexUI_005::GetPrevious: Would be bellow 0..");
            }
        }


        //------------------------------------------------------------------------------------------------------------------

        private void BackToScreen001()
        {
            // activate first screen, set name and reset page to 1
            ToggleScreens(Screen001);
            urlVariables["type_id"][0] = 999999;
            urlVariables["page"][0] = 1;
            CurrentScreenName.text = "Types";
        }


        //------------------------------------------------------------------------------------------------------------------

        private void SizeDdValueChanged(Dropdown change)
        {
            if (DropDownSize.value != 0)
            {
                var selectedSize = DropDownSize.options[DropDownSize.value].text;
                Debug.Log("MtexDownload::SizeDdValueChanged: selected size: " + selectedSize);
                Debug.Log("MtexDownload::SizeDdValueChanged: mat_id: " + Mat_id);
                StartCoroutine(GetMaterial(Mat_id, selectedSize));
            }
        }
        
        
        //------------------------------------------------------------------------------------------------------------------


        //------------------------------------------------------------------------------------------------------------------

        //***********************************************************************************************************************
        //protected

        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------

        //***********************************************************************************************************************
        //internal

        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------

        //***********************************************************************************************************************
        //public

        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------

        //***********************************************************************************************************************
        //public static

        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------

        //***********************************************************************************************************************
        //getter, setter

        //------------------------------------------------------------------------------------------------------------------
        //------------------------------------------------------------------------------------------------------------------

    }

}