using System;
using System.Collections.Generic;
using System.IO;
using Rukhanka.Hybrid;
using Rukhanka.Toolbox;
using Unity.Collections;
using Unity.Entities;
using UnityEditor;
using UnityEditor.Build;
using UnityEditor.Compilation;
using UnityEngine;
using UnityEngine.UIElements;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Rukhanka.Editor
{
public class BlobInspector : EditorWindow
{
    [SerializeField]
    private VisualTreeAsset menuAsset = default;
    [SerializeField]
    private VisualTreeAsset blobDBPaneAsset = default;
    [SerializeField]
    private VisualTreeAsset blobCachePaneAsset = default;
    [SerializeField]
    private VisualTreeAsset blobCacheEntryAsset = default;
    [SerializeField]
    private VisualTreeAsset listViewLabelAsset = default;
    [SerializeField]
    private VisualTreeAsset listViewInfoBtnAsset = default;
    
    VisualElement
        menuElem,
        blobCachePane,
        blobDBPane
        ;
    
    TwoPaneSplitView splitView;
    
    internal enum BlobType
    {
        AnimatorController,
        AnimationClip,
        RigInfo,
        SkinnedMeshInfo,
        AvatarMask,
        Total
    }
    
    internal class BlobAssetInfo<T> where T: unmanaged
    {
        public BlobAssetReference<T> blobAsset;
        public List<Entity> refEntities;
    }
    
    class BlobAssetsSummary
    {
        public int sizeInBytes;
        public int totalCount;
    }
        
    List<BlobAssetInfo<ControllerBlob>> allControllerBlobAssets = new ();
    List<BlobAssetInfo<AnimationClipBlob>> allAnimationClipBlobAssets = new ();
    List<BlobAssetInfo<RigDefinitionBlob>> allRigBlobAssets = new ();
    List<BlobAssetInfo<SkinnedMeshInfoBlob>> allSkinnedMeshBlobAssets = new ();
    List<BlobAssetInfo<AvatarMaskBlob>> allAvatarMaskBlobAssets = new ();
    BlobAssetsSummary blobAssetsSummary;
    
    readonly string nameColumnName = "name";
    readonly string hashColumnName = "hash";
    readonly string referencesColumnName = "references";
    readonly string sizeColumnName = "size";
    readonly string bakingTimeColumnName = "bakingTime";
    readonly string infoColumnName = "info";
        
    internal static World currentWorld;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    [MenuItem("Window/Rukhanka Animation/Blob Inspector")]
    public static void ShowWindow()
    {
        var wnd = GetWindow<BlobInspector>();
        wnd.minSize = new Vector2(1000, 400);
        wnd.titleContent = new GUIContent("Rukhanka.Animation Blob Inspector");
    }
	
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    public void CreateGUI()
    {
        // Each editor window contains a root VisualElement object
        var root = rootVisualElement;

        splitView = new TwoPaneSplitView(0, 250, TwoPaneSplitViewOrientation.Horizontal);
        root.Add(splitView);
        
        menuElem = menuAsset.Instantiate();
        menuElem.Query<Button>().ForEach((btn) => {btn.RegisterCallback<ClickEvent>(ev => MenuButtonClick(btn));});
        splitView.Add(menuElem);
        
        blobDBPane = blobDBPaneAsset.Instantiate()[0];
        blobCachePane = blobCachePaneAsset.Instantiate()[0];
        splitView.Add(blobDBPane);
        
        MenuButtonClick(menuElem.Q("blobDBBtn") as Button);
    }
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    void MenuButtonClick(Button btn)
    {
        menuElem.Query<Button>().ForEach((btn) => {btn.style.backgroundColor = new StyleColor(Color.clear);});
        btn.style.backgroundColor = new StyleColor(new Color(0.4f, 0.4f, 0.4f, 1));

        splitView.RemoveAt(1);
        switch (btn.name)
        {
            case "blobDBBtn":
                SwitchToBlobDBPane();
                break;
            case "blobCacheBtn":
                SwitchToBlobCachePane();
                break;
        }
    }
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    void FillBlobDBInifo()
    {
        FillWorldList();
    }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    void FillWorldList()
    {
        var worldSelector = blobDBPane.Q<DropdownField>("worldSelector");
        worldSelector.RegisterValueChangedCallback((worldName) => { ChangeWorld(worldName.newValue); });
        worldSelector.choices.Clear();
        foreach (var world in World.All)
        {
            worldSelector.choices.Add(world.Name);
        }
        if (worldSelector.index < 0 || worldSelector.index > worldSelector.choices.Count)
            worldSelector.index = 0;
        worldSelector.value = worldSelector.choices[worldSelector.index];
        
        var worldReloadBtn = worldSelector.Q<Button>("worldReloadBtn");
        Action clickLambda = () => { SwitchToBlobDBPane(); ChangeWorld(worldSelector.choices[worldSelector.index]); };
        var clk = new Clickable(clickLambda);
        worldReloadBtn.clickable = clk;
    }
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    void ChangeWorld(string worldName)
    {
        World world = null;
        for (var i = 0; i < World.All.Count && world == null; ++i)
        {
            if (World.All[i].Name == worldName)
                world = World.All[i];
        }
        
        if (world != null)
        {
            GatherAllBlobAssets(world);
            var totalInfoLabel = blobDBPane.Q<Label>("blobInfoTotal");
            totalInfoLabel.text = GatherBlobDBInfo();
            CreateBlobAssetList();
        }
        currentWorld = world;
    }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    unsafe BlobAssetInfo<T> RegisterBlobAsset<T>(BlobAssetReference<T> bar, List<BlobAssetInfo<T>> allBlobs) where T: unmanaged, GenericAssetBlob
    {
        blobAssetsSummary.totalCount += 1;
        blobAssetsSummary.sizeInBytes += bar.m_data.Header->Length;
        var alreadyExistIndex = allBlobs.FindIndex(x => x.blobAsset.Value.Hash() == bar.Value.Hash());
        if (alreadyExistIndex >= 0)
            return allBlobs[alreadyExistIndex];
        
        var rv = new BlobAssetInfo<T>()
        {
            blobAsset = bar,
            refEntities = new ()
        };
        allBlobs.Add(rv);
        return rv;
    }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    void GatherAllBlobAssets(World world)
    {
        blobAssetsSummary = new ();
        
        //  Gather blob assets from database
        var dbQ = new EntityQueryBuilder(Allocator.Temp)
            .WithAll<BlobDatabaseSingleton>()
            .Build(world.EntityManager);
        
        if (dbQ.TryGetSingleton<BlobDatabaseSingleton>(out var db))
        {
            allAnimationClipBlobAssets.Clear();
            foreach (var kv in db.animations)
            {
                if (!kv.Value.IsCreated)
                    continue;
                
                RegisterBlobAsset(kv.Value, allAnimationClipBlobAssets);
            }
            
            allAvatarMaskBlobAssets.Clear();
            foreach (var kv in db.avatarMasks)
            {
                if (!kv.Value.IsCreated)
                    continue;
                
                RegisterBlobAsset(kv.Value, allAvatarMaskBlobAssets);
            }
        }
        
        //  Gather animator, animation and avatar mask blob assets from entities
        allControllerBlobAssets.Clear();
        var eQ = new EntityQueryBuilder(Allocator.Temp)
            .WithAll<AnimatorControllerLayerComponent>()
            .Build(world.EntityManager);
        
        var animControllersChunks = eQ.ToArchetypeChunkArray(Allocator.Temp);
        var controllerLayerBufHandle = world.EntityManager.GetBufferTypeHandle<AnimatorControllerLayerComponent>(true);
        var entityHandle = world.EntityManager.GetEntityTypeHandle();
        for (var i = 0; i < animControllersChunks.Length; ++i)
        {
            var chunk = animControllersChunks[i];
            var bufAcc = chunk.GetBufferAccessor(ref controllerLayerBufHandle);
            var entities = chunk.GetNativeArray(entityHandle);
            for (var k = 0; k < chunk.Count; ++k)
            {
                var lb = bufAcc[k];
                var e = entities[k];
                for (var l = 0; l < lb.Length; ++l)
                {
                    var acl = lb[l];
                    
                    var controllerBlobInfo = RegisterBlobAsset(acl.controller, allControllerBlobAssets);
                    controllerBlobInfo.refEntities.Add(e);
                    
                    ref var layers = ref acl.controller.Value.layers;
                    for (var m = 0; m < layers.Length; ++m)
                    {
                        ref var layer = ref layers[m];
                        foreach (var amb in allAvatarMaskBlobAssets)
                        {
                            if (amb.blobAsset.Value.Hash() == layer.avatarMaskBlobHash)
                                amb.refEntities.Add(e);
                        }
                    }

                    ref var anims = ref acl.animations.Value.animations;
                    for (var m = 0; m < anims.Length; ++m)
                    {
                        var anmHash = anims[m];
                        foreach (var acb in allAnimationClipBlobAssets)
                        {
                            if (acb.blobAsset.Value.Hash() == anmHash)
                                acb.refEntities.Add(e);
                        }
                    }
                }
            }
        }
        
        //  Gather skinned mesh blob assets from entities
        allSkinnedMeshBlobAssets.Clear();
        var eSMR = new EntityQueryBuilder(Allocator.Temp)
            .WithAll<SkinnedMeshRendererComponent>()
            .Build(world.EntityManager);
        
        var smrChunks = eSMR.ToArchetypeChunkArray(Allocator.Temp);
        var smrTypeHandle = world.EntityManager.GetComponentTypeHandle<SkinnedMeshRendererComponent>(true);
        for (var i = 0; i < smrChunks.Length; ++i)
        {
            var chunk = smrChunks[i];
            var smrs = chunk.GetNativeArray(ref smrTypeHandle);
            var entities = chunk.GetNativeArray(entityHandle);
            for (var k = 0; k < chunk.Count; ++k)
            {
                var smr = smrs[k];
                var e = entities[k];
                    
                var skinnedMeshBlobInfo = RegisterBlobAsset(smr.smrInfoBlob, allSkinnedMeshBlobAssets);
                skinnedMeshBlobInfo.refEntities.Add(e);
            }
        }
        
        //  Gather rig definition blob assets from entities
        allRigBlobAssets.Clear();
        var eRig = new EntityQueryBuilder(Allocator.Temp)
            .WithAll<RigDefinitionComponent>()
            .Build(world.EntityManager);
        
        var rigChunks = eRig.ToArchetypeChunkArray(Allocator.Temp);
        var rigDefTypeHandle = world.EntityManager.GetComponentTypeHandle<RigDefinitionComponent>(true);
        for (var i = 0; i < rigChunks.Length; ++i)
        {
            var chunk = rigChunks[i];
            var rigs = chunk.GetNativeArray(ref rigDefTypeHandle);
            var entities = chunk.GetNativeArray(entityHandle);
            for (var k = 0; k < chunk.Count; ++k)
            {
                var rigDef = rigs[k];
                var e = entities[k];
                    
                var rigBlobInfo = RegisterBlobAsset(rigDef.rigBlob, allRigBlobAssets);
                rigBlobInfo.refEntities.Add(e);
            }
        }
        
    }
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    string GatherBlobDBInfo()
    {
        var rv = $"Summary: {blobAssetsSummary.totalCount} blob assets, total memory {CommonTools.FormatMemory(blobAssetsSummary.sizeInBytes)}";
        return rv;
    }
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    void SwitchToBlobCachePane()
    {
        splitView.Add(blobCachePane);
        var clearCacheBtn = rootVisualElement.Q<Button>("clearCacheBtn");
        var disableEnableCacheBtn = rootVisualElement.Q<Button>("disableEnableCacheBtn");
        
        Action clearCacheLambda = () =>
        {
            Directory.Delete(BlobCache.GetControllerBlobCacheDirPath(), true);
            Directory.Delete(BlobCache.GetAnimationBlobCacheDirPath(), true);
            FillBlobCacheInfo();
        };
        clearCacheBtn.clickable = new Clickable(clearCacheLambda);
        
        Action disableEnableCacheLambda = () =>
        {
            var bt = EditorUserBuildSettings.activeBuildTarget;
            var btg = BuildPipeline.GetBuildTargetGroup(bt);
            var target = NamedBuildTarget.FromBuildTargetGroup(btg);
            PlayerSettings.GetScriptingDefineSymbols(target, out var defines);
        #if RUKHANKA_NO_BLOB_CACHE
            var l = new List<string>(defines);
            l.Remove("RUKHANKA_NO_BLOB_CACHE");
            defines = l.ToArray();
        #else
            var newDefines = new string[defines.Length + 1];
            Array.Copy(defines, newDefines, defines.Length);
            newDefines[^1] = "RUKHANKA_NO_BLOB_CACHE";
            defines = newDefines;
        #endif
            PlayerSettings.SetScriptingDefineSymbols(target, defines);
            CompilationPipeline.RequestScriptCompilation();
        };
        disableEnableCacheBtn.clickable = new Clickable(disableEnableCacheLambda);
    #if RUKHANKA_NO_BLOB_CACHE
        disableEnableCacheBtn.text = "Enable Cache";
    #else
        disableEnableCacheBtn.text = "Disable Cache";
        var blobCacheDisabledLabel = rootVisualElement.Q<VisualElement>("blobCacheDisabledLabel");
        blobCacheDisabledLabel.style.display = DisplayStyle.None;
    #endif
        
        FillBlobCacheInfo();
    }
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    void SwitchToBlobDBPane()
    {
        splitView.Add(blobDBPane);
    #if RUKHANKA_DEBUG_INFO
        var noDebugInfoWarning = blobDBPane.Q("noRukhankaDebugInfoWarning");
        noDebugInfoWarning.style.display = DisplayStyle.None;
    #endif
        FillBlobDBInifo();
    }
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    unsafe void FillMultiColumnViewList<T>(MultiColumnListView lv, List<BlobAssetInfo<T>> allBlobAssets, Action<int> infoBtnClickAction) where T: unmanaged, GenericAssetBlob
    {
        lv.itemsSource = allBlobAssets;
        
        lv.columns[infoColumnName].makeCell = () => listViewInfoBtnAsset.Instantiate().Q<Button>("btn");
        lv.columns[nameColumnName].makeCell = () => listViewLabelAsset.Instantiate().Q<Label>("label");
        lv.columns[hashColumnName].makeCell = () => listViewLabelAsset.Instantiate().Q<Label>("label");
        lv.columns[referencesColumnName].makeCell = () => listViewLabelAsset.Instantiate().Q<Label>("label");
        lv.columns[bakingTimeColumnName].makeCell = () => listViewLabelAsset.Instantiate().Q<Label>("label");
        lv.columns[sizeColumnName].makeCell = () => listViewLabelAsset.Instantiate().Q<Label>("label");
        
        lv.columns[infoColumnName].bindCell = (VisualElement ve, int index) =>
            (ve as Button).clicked += () => infoBtnClickAction(index);
        lv.columns[referencesColumnName].bindCell = (VisualElement ve, int index) =>
            (ve as Label).text = allBlobAssets[index].refEntities.Count.ToString();
        lv.columns[nameColumnName].bindCell = (VisualElement ve, int index) =>
        #if RUKHANKA_DEBUG_INFO
            (ve as Label).text = allBlobAssets[index].blobAsset.Value.Name();
        #else
            (ve as Label).text = "-";
        #endif
        lv.columns[hashColumnName].bindCell = (VisualElement ve, int index) =>
            (ve as Label).text = allBlobAssets[index].blobAsset.Value.Hash().ToString();
        lv.columns[bakingTimeColumnName].bindCell = (VisualElement ve, int index) =>
        {
            var bt = -1.0f;
        #if RUKHANKA_DEBUG_INFO
            bt = allBlobAssets[index].blobAsset.Value.BakingTime();
        #endif
            (ve as Label).text = bt < 0 ? "-" : $"{bt:F3} sec";
        };
        
        lv.columns[sizeColumnName].bindCell = (VisualElement ve, int index) =>
            (ve as Label).text = CommonTools.FormatMemory(allBlobAssets[index].blobAsset.m_data.Header->Length);
    }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    void CreateBlobAssetList()
    {
        var animationClipsList = blobDBPane.Q<MultiColumnListView>("animationClipList");
        Action<int> infoCallback = (idx) =>
        {
            AnimatorClipBlobInfoWindow.animationClipBlob = allAnimationClipBlobAssets[idx];
            var wnd = GetWindow<AnimatorClipBlobInfoWindow>();
            wnd.Show();
        };
        FillMultiColumnViewList(animationClipsList, allAnimationClipBlobAssets, infoCallback);
        
        var animatorControllersList = blobDBPane.Q<MultiColumnListView>("controllerList");
        infoCallback = (idx) =>
        {
            AnimatorControllerBlobInfoWindow.controllerBlob = allControllerBlobAssets[idx];
            var wnd = GetWindow<AnimatorControllerBlobInfoWindow>();
            wnd.Show();
        };
        FillMultiColumnViewList(animatorControllersList, allControllerBlobAssets, infoCallback);
        
        var rigList = blobDBPane.Q<MultiColumnListView>("rigList");
        infoCallback = (idx) =>
        {
            RigBlobInfoWindow.rigBlob = allRigBlobAssets[idx];
            var wnd = GetWindow<RigBlobInfoWindow>();
            wnd.Show();
        };
        FillMultiColumnViewList(rigList, allRigBlobAssets, infoCallback);
        
        var avatarMaskList = blobDBPane.Q<MultiColumnListView>("avatarMaskList");
        infoCallback = (idx) =>
        {
            AvatarMaskInfoWindow.avatarMaskBlob = allAvatarMaskBlobAssets[idx];
            var wnd = GetWindow<AvatarMaskInfoWindow>();
            wnd.Show();
        };
        FillMultiColumnViewList(avatarMaskList, allAvatarMaskBlobAssets, infoCallback);
        
        var smrList = blobDBPane.Q<MultiColumnListView>("smrList");
        infoCallback = (idx) =>
        {
            SkinnedMeshBlobInfoWindow.skinnedMeshBlob = allSkinnedMeshBlobAssets[idx];
            var wnd = GetWindow<SkinnedMeshBlobInfoWindow>();
            wnd.Show();
        };
        FillMultiColumnViewList(smrList, allSkinnedMeshBlobAssets, infoCallback);
    }
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            /*
    unsafe void FillBlobAssetInfoText(BlobAssetListInfo li, BlobAssetInfo ba)
    {
        switch (ba.blobType)
        {
        case BlobType.AnimationClip:
        {
            var acb = ba.blobAsset.Reinterpret<AnimationClipBlob>();
            li.name = "-";
        #if RUKHANKA_DEBUG_INFO
            li.name = acb.Value.name.ToString();
        #endif
            li.references = ba.refEntities.Count;
            li.size = ba.blobAsset.m_data.Header->Length;
            li.bakingTime = -1;
        #if RUKHANKA_DEBUG_INFO
            li.bakingTime = acb.Value.bakingTime;
        #endif
            break;
        }
        case BlobType.AnimatorController:
        {
            var acb = ba.blobAsset.Reinterpret<ControllerBlob>();
            var nameText = $"[{acb.Value.hash}]";
        #if RUKHANKA_DEBUG_INFO
            nameText += $" '{acb.Value.name.ToString()}'";
        #endif
            var infoText = $"References: {ba.refEntities.Count}, Size: { CommonTools.FormatMemory(ba.blobAsset.m_data.Header->Length) }";
        #if RUKHANKA_DEBUG_INFO
            infoText += $" Baking time: {acb.Value.bakingTime:F3} sec";
        #endif
            infoLabel.text = infoText;
            nameLabel.text = nameText;
            infoBtn.clicked += () =>
            {
                AnimatorControllerBlobInfoWindow.controllerBlob = ba;
                var wnd = GetWindow<AnimatorControllerBlobInfoWindow>();
                wnd.Show();
            };
            break;
        }
        case BlobType.RigInfo:
        {
            var acb = ba.blobAsset.Reinterpret<RigDefinitionBlob>();
            var nameText = $"[{acb.Value.hash}]";
        #if RUKHANKA_DEBUG_INFO
            nameText = $" '{acb.Value.name.ToString()}'";
        #endif
            var infoText = $"References: {ba.refEntities.Count}, Size: {CommonTools.FormatMemory(ba.blobAsset.m_data.Header->Length)}";
        #if RUKHANKA_DEBUG_INFO
            infoText += $" Baking time: {acb.Value.bakingTime:F3} sec";
        #endif
            infoLabel.text = infoText;
            nameLabel.text = nameText;
            infoBtn.clicked += () =>
            {
                RigBlobInfoWindow.rigBlob = ba;
                var wnd = GetWindow<RigBlobInfoWindow>();
                wnd.Show();
            };
            break;
        }
        case BlobType.AvatarMask:
        {
            var acb = ba.blobAsset.Reinterpret<AvatarMaskBlob>();
            var nameText = $"[{acb.Value.hash}]";
        #if RUKHANKA_DEBUG_INFO
            nameText += $" '{acb.Value.name.ToString()}'";
        #endif
            var infoText = $"References: {ba.refEntities.Count}, Size: { CommonTools.FormatMemory(ba.blobAsset.m_data.Header->Length) }";
        #if RUKHANKA_DEBUG_INFO
            infoText += $" Baking time: {acb.Value.bakingTime:F3} sec";
        #endif
            infoLabel.text = infoText;
            nameLabel.text = nameText;
            infoBtn.clicked += () =>
            {
                AvatarMaskInfoWindow.avatarMaskBlob = ba;
                var wnd = GetWindow<AvatarMaskInfoWindow>();
                wnd.Show();
            };
            break;
        }
        case BlobType.SkinnedMeshInfo:
        {
            var acb = ba.blobAsset.Reinterpret<SkinnedMeshInfoBlob>();
            var nameText = $"[{acb.Value.hash}]";
        #if RUKHANKA_DEBUG_INFO
            nameText += $" '{acb.Value.skeletonName.ToString()}'";
        #endif
            var infoText = $"References: {ba.refEntities.Count}, Size: {CommonTools.FormatMemory(ba.blobAsset.m_data.Header->Length)}";
        #if RUKHANKA_DEBUG_INFO
            infoText += $" Baking time: {acb.Value.bakingTime:F3} sec";
        #endif
            infoLabel.text = infoText;
            nameLabel.text = nameText;
            infoBtn.clicked += () =>
            {
                SkinnedMeshBlobInfoWindow.skinnedMeshBlob = ba;
                var wnd = GetWindow<SkinnedMeshBlobInfoWindow>();
                wnd.Show();
            };
            break;
        }
        }
    }
        */
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    void FillBlobCacheInfo()
    {
        var cachePathLabel = rootVisualElement.Q<Label>("blobCachePathLabel");
        cachePathLabel.text = $"Cache Path: '{BlobCache.GetBlobCacheDirPath()}'";
        
        var controllerMem = FillBlobList("animatorControllerBlobsFoldout", "Animator Controller Blobs", BlobCache.GetControllerBlobCacheDirPath());
        var animationsMem = FillBlobList("animationBlobsFoldout", "Animation Clip Blobs", BlobCache.GetAnimationBlobCacheDirPath());
        
        var animMemLabel = rootVisualElement.Q<Label>("totalAnimationsMemLabel");
        var controllerMemLabel = rootVisualElement.Q<Label>("totalControllerMemLabel");
        animMemLabel.text = $"Total animation blob cache size: {CommonTools.FormatMemory(animationsMem)}";
        controllerMemLabel.text = $"Total animator controller blob cache size: {CommonTools.FormatMemory(controllerMem)}";
        
    }
    
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    long FillBlobList(string foldoutName, string foldoutCaption, string cachePath)
    {
        var foldout = rootVisualElement.Q<Foldout>(foldoutName);
        foldout.Clear();
        var numCachedBlobs = 0;
        var rv = 0L;
        
        if (Directory.Exists(cachePath))
        {
            var files = Directory.GetFiles(cachePath);
            for (var i = 0; i < files.Length; ++i)
            {
                var entry = blobCacheEntryAsset.Instantiate();
                var file = files[i].Replace('\\', '/');
                
                if (i % 2 == 0)
                    entry.style.backgroundColor = new StyleColor(new Color(0.3f, 0.3f, 0.3f, 1));
                
                var entryPath = entry.Q<Label>("pathLabel");
                var sizeLabel = entry.Q<Label>("sizeLabel");
                entryPath.text = file.Replace(BlobCache.GetBlobCacheDirPath(), "");
                var fs = new FileInfo(file).Length;
                sizeLabel.text = CommonTools.FormatMemory(fs);
                rv += fs;
                
                foldout.Add(entry);
            }
            numCachedBlobs += files.Length;
        }
        foldout.text = $"{numCachedBlobs} {foldoutCaption}";
        return rv;
    }
}
}