using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEngine;
using UnityEngine.Rendering;
using System.Threading.Tasks;

public class GenerateItemSprites
{

    private List<Texture2D> itemMetallicMaps;
    
    
    [MenuItem("Generation/GenerateInventoryItemSprites")]
    public static void Generate()
    {
        GameObject tempCamera = new GameObject("temp Camera");
        Camera cam = tempCamera.AddComponent<Camera>();
        tempCamera.transform.position = new Vector3(0, 0, -0.5f);
        cam.clearFlags = CameraClearFlags.Depth;
        cam.backgroundColor = Color.clear;
        cam.targetTexture = Resources.Load("Misc/InventoryItem") as RenderTexture;
        cam.nearClipPlane = 0.1f;
        cam.farClipPlane = 100f;

        TogglePostProcessing(true);
        ToggleBlit(false);
        SetAmbientLighting(true);
        GenerateSprites(cam);
    }

    public static void GenerateSprites(Camera cam)
    {
        int amountOfItems = GetItemAmount();
        
        if (OnDemandLoader.LoadAll<Texture2D>("Sprites/ItemSprites/").Length - 1 == amountOfItems) return;

        GameObject itemClone;
        Debug.Log("Item amounts not synced! Regenerating!");

        for (int i = 0; i < amountOfItems; i++)
        {
            string path = $"Assets/Resources/Sprites/ItemSprites/{i}.png";
            AssetDatabase.DeleteAsset(path);
            Debug.Log(path);
            InventoryItemStats objectsToRender = OnDemandLoader.Load<GameObject>("items/" + i).GetComponent<InventoryItemStats>();
            itemClone = Object.Instantiate(objectsToRender.gameObject);

            foreach (MeshRenderer renderer in itemClone.GetComponentsInChildren<MeshRenderer>())
            {
                ToggleMaterialSettings(renderer.sharedMaterial, false);
            }

            itemClone.transform.position = new Vector3(objectsToRender.inventoryOffsetX, objectsToRender.inventoryOffsetY, objectsToRender.inventoryZoom);
            itemClone.transform.localScale = new Vector3(objectsToRender.inventoryScale, objectsToRender.inventoryScale, objectsToRender.inventoryScale);
            itemClone.transform.localRotation = Quaternion.Euler(objectsToRender.inventoryRotationX, objectsToRender.inventoryRotationY, objectsToRender.inventoryRotationZ);

            LoopThroughChildrenRenderers(itemClone);

            RenderTexture.active = cam.targetTexture;
            GL.Clear(true, true, Color.clear);

            cam.Render();

            Texture2D image = new Texture2D(cam.targetTexture.width, cam.targetTexture.height, TextureFormat.ARGB32, false, true);
            image.ReadPixels(new Rect(0, 0, cam.targetTexture.width, cam.targetTexture.height), 0, 0);

            for (int x = 0; x < image.width; x++)
            {
                for (int y = 0; y < image.height; y++)
                {
                    Color color = image.GetPixel(x, y);
                    float a = color.a;

                    Color.RGBToHSV(image.GetPixel(x, y), out float h, out float s, out float v);
                    v *= 1.5f;

                    color = Color.HSVToRGB(h, s, v);
                    color.a = a;

                    image.SetPixel(x, y, color);
                }
            }

            image.Apply();

            foreach (MeshRenderer renderer in itemClone.GetComponentsInChildren<MeshRenderer>())
            {
                ToggleMaterialSettings(renderer.sharedMaterial, true);
            }

            itemClone.SetActive(false);
            Object.DestroyImmediate(itemClone);
            RenderTexture.active.Release();

            byte[] itemTexBytes = image.EncodeToPNG();
            File.WriteAllBytes(path, itemTexBytes);
        }

        TogglePostProcessing(true);
        SetAmbientLighting(false);
        Object.DestroyImmediate(cam.gameObject);
        AssetDatabase.Refresh();
    }

    private static void LoopThroughChildrenRenderers(GameObject itemClone)
    {
        itemClone.layer = LayerMask.NameToLayer("Item");
        foreach (Transform child in itemClone.transform)
        {
            child.gameObject.layer = LayerMask.NameToLayer("Item");
            foreach (Transform grandChild in child.transform)
            {
                grandChild.gameObject.layer = LayerMask.NameToLayer("Item");
            }
        }
    }

    private static int GetItemAmount()
    {
        GameObject[] items = OnDemandLoader.LoadAll<GameObject>("items/");
        //Debug.Log($"Amount of Items in location: {items.Length}");

        return items.Length;
    }

    private static void ToggleMaterialSettings(Material mat, bool isEnabled)
    {
        EditorUtility.SetDirty(mat);
        float enabled = isEnabled ? 1f : 0f;
        mat.EnableKeyword("");
        mat.SetFloat("_SpecularHighlights", enabled);
        mat.SetFloat("_EnvironmentReflections", enabled);
        mat.enableInstancing = isEnabled;
        EditorUtility.SetDirty(mat);
    }

    private static void TogglePostProcessing(bool isOn)
    {
        Volume postProcessing = GameObject.FindObjectOfType<Volume>();
        if (postProcessing != null)
        {
            postProcessing.enabled = isOn;
        }
    }

    private static void ToggleBlit(bool isOn)
    {
        Client client = GameObject.FindObjectOfType<Client>();
        client.ToggleBlit(isOn);
    }

    private static void SetAmbientLighting(bool isWhite)
    {
        RenderSettings.ambientLight =  isWhite ? Color.white : new Color(0.6f, 0.6431f, 0.749f, 1f);
    }

    public static Color ScaleValue(Color color, float scale)
    {
        Color.RGBToHSV(color, out var h, out var s, out var v);
        v *= scale;
        var result = Color.HSVToRGB(h, s, v);
        result.a = color.a;
        return result;
    }
}