IEnumerator LoadAssetBundleFromServerWithCache(string url, Action<AssetBundle> response)
{
    // Ждем, готовности системы кэширования
    while (!Caching.ready)
    {
        yield return null;
    }

    // получаем манифест с сервера
    var request = UnityWebRequest.Get(url + ".manifest");
    
    yield return request.SendWebRequest();

    if (!request.isHttpError && !request.isNetworkError)
    {
        Hash128 hash = default;

        //получаем hash
        var hashRow = request.downloadHandler.text.ToString().Split("\n".ToCharArray())[5];
        hash = Hash128.Parse(hashRow.Split(':')[1].Trim());

        if (hash.isValid == true)
        {
            request.Dispose();

            request = UnityWebRequestAssetBundle.GetAssetBundle(url, hash, 0);

            yield return request.SendWebRequest();
            
            if (!request.isHttpError && !request.isNetworkError)
            {
                response(DownloadHandlerAssetBundle.GetContent(request));
            }
            else
            {
                response(null);
            }
        }
        else
        {
            response(null);
        }
    }
    else
    {
        response(null);
    }

    request.Dispose();
}

public class AssetBundleWrapper
{
    
#if UNITY_EDITOR
        private readonly List<string> _assets;

        public AssetBundleWrapper(string url)
        {
            var uri = new Uri(url);
            var bundleName = Path.GetFileNameWithoutExtension(uri.LocalPath);

            _assets = new List<string>(AssetDatabase.GetAssetPathsFromAssetBundle(bundleName));           
        }

        public T LoadAsset<T>(string name) where T : UnityEngine.Object
        {
            var assetPath = _assets.Find(item =>
            {
                var assetName = Path.GetFileNameWithoutExtension(item);

                return string.CompareOrdinal(name, assetName) == 0;                
            });

            if (!string.IsNullOrEmpty(assetPath))
            {
                return AssetDatabase.LoadAssetAtPath<T>(assetPath);
            } else
            {
                return default;
            }
        }

        public T[] LoadAssets<T>() where T : UnityEngine.Object
        {
            var returnedValues = new List<T>();

            foreach(var assetPath in _assets)
            {
                returnedValues.Add(AssetDatabase.LoadAssetAtPath<T>(assetPath));
            }

            return returnedValues.ToArray();
        }

        public void LoadAssetAsync<T>(string name, Action<T> result) where T : UnityEngine.Object
        {
            result(LoadAsset<T>(name));
        }

        public void LoadAssetsAsync<T>(Action<T[]> result) where T : UnityEngine.Object
        {
            result(LoadAssets<T>());
        }

        public string[] GetAllScenePaths()
        {
            return _assets.ToArray();
        }

        public void Unload(bool includeAllLoadedAssets = false)
        {
            _assets.Clear();
        }
#else
    private readonly AssetBundle _assetBundle;

    public AssetBundleWrapper(AssetBundle assetBundle)
    {
        _assetBundle = assetBundle;
    }

    public T LoadAsset<T>(string name) where T : UnityEngine.Object
    {
        return _assetBundle.LoadAsset<T>(name);
    }

    public T[] LoadAssets<T>() where T : UnityEngine.Object
    {
        return _assetBundle.LoadAllAssets<T>();
    }

    public void LoadAssetAsync<T>(string name, Action<T> result) where T : UnityEngine.Object
    {
        var request = _assetBundle.LoadAssetAsync<T>(name);

        TaskManager.Task.Create(request)
                        .Subscribe(() =>
                        {
                            result(request.asset as T);

                            Unload(false);
                        })
                        .Start();
    }

    public void LoadAssetsAsync<T>(Action<T[]> result) where T : UnityEngine.Object
    {
        var request = _assetBundle.LoadAllAssetsAsync<T>();

        TaskManager.Task.Create(request)
                        .Subscribe(() =>
                        {
                            var assets = new T[request.allAssets.Length];

                            for (var i = 0; i < request.allAssets.Length; i++)
                            {
                                assets[i] = request.allAssets[i] as T;
                            }

                            result(assets);

                            Unload(false);
                        })
                        .Start();
    }

    public string[] GetAllScenePaths()
    {
        return _assetBundle.GetAllScenePaths();
    }

    public void Unload(bool includeAllLoadedAssets = false)
    {
        _assetBundle.Unload(includeAllLoadedAssets);
    }
#endif
}

private IEnumerator WebRequest(UnityWebRequest request, Action<float> progress, Action<UnityWebRequest> response)
{
    while (!Caching.ready)
    {
        yield return null;
    }

    if (progress != null)
    {
        request.SendWebRequest(); _currentRequests.Add(request);

        while (!request.isDone)
        {
            progress(request.downloadProgress);

            yield return null;
        }

        progress(1f);
    }
    else
    {
        yield return request.SendWebRequest();
    }

    response(request);

    if (_currentRequests.Contains(request))
    {
        _currentRequests.Remove(request);
    }

    request.Dispose();
}

private IEnumerator WebRequestBundle(string url, Hash128 hash, Action<float> progress, Action<UnityWebRequest> response)
{
    var request = UnityWebRequestAssetBundle.GetAssetBundle(url, hash, 0);

    return WebRequest(request, progress, response);
}

private IEnumerator WebRequestPost(string url, Dictionary<string, string> formFields, Action<float> progress, Action<UnityWebRequest> response)
{
    var request = UnityWebRequest.Post(url, formFields);

    return WebRequest(request, progress, response);
}

private IEnumerator WebRequestPost(string url, string data, Action<float> progress, Action<UnityWebRequest> response)
{
    var request = new UnityWebRequest(url, UnityWebRequest.kHttpVerbPOST)
    {
        uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(data)),
        downloadHandler = new DownloadHandlerBuffer()
    };

    request.uploadHandler.contentType = "application/json";

    return WebRequest(request, progress, response);
}

public void Request(string url, Hash128 hash, Action<float> progress, Action<AssetBundle> response, TaskManager.TaskPriorityEnum priority = TaskManager.TaskPriorityEnum.Default)
{
        _taskManager.AddTask(WebRequestBundle(url, hash, progress, (uwr) =>
        {
            if (!uwr.isHttpError && !uwr.isNetworkError)
            {
                response(DownloadHandlerAssetBundle.GetContent(uwr));
            }
            else
            {
                Debug.LogWarningFormat("[Netowrk]: error request [{0}]", uwr.error);

                response(null);
            }
        }), priority);
}

public void Request(string url, Action<int> response, TaskManager.TaskPriorityEnum priority = TaskManager.TaskPriorityEnum.Default)
{
    var request = UnityWebRequest.Head(url);

        _taskManager.AddTask(WebRequest(request, null, uwr =>
        {
            var contentLength = uwr.GetResponseHeader("Content-Length");

            if (int.TryParse(contentLength, out int returnValue))
            {
                response(returnValue);
            }
            else
            {
                response(-1);
            }

        }), priority);
}

public void Clear()
{
    _taskManager.Clear();

    foreach (var request in _currentRequests)
    {
        request.Abort();
        request.Dispose();
    }

    _currentRequests.Clear();    
}

public class ExternalResourceManager
{
    public enum ResourceEnumType
    {
        Text,
        Texture,
        AssetBundle
    }
    private readonly Network _network = new Network();
    public void ExternalResourceManager()
    {
#if UNITY_EDITOR
       var path = Path.Combine(Directory.GetParent(Application.dataPath).FullName,   "_EditorCache");
#else
       var path = Path.Combine(Application.persistentDataPath, "_AppCache");                                
#endif

       if (!System.IO.Directory.Exists(path))
       {
           System.IO.Directory.CreateDirectory(path);

           #if UNITY_IOS
	    UnityEngine.iOS.Device.SetNoBackupFlag(path);			     		  
           #endif
       }

       Caching.currentCacheForWriting = Caching.AddCache(path);
    }
}

public void ClearAssetBundleCache(string url)
{
    var fileName = GetFileNameFromUrl(url);            
            
     Caching.ClearAllCachedVersions(fileName);
}

public void ClearAllRequest()
{
    _network.Clear();
}

public void AssetBundleIsCached(string url, Action<bool> result)
{
var manifestFileUrl = "{0}.manifest".Fmt(url);

_network.Request(manifestFileUrl, null, (string manifest) =>
{
                var hash = string.IsNullOrEmpty(manifest) ? default : GetHashFromManifest(manifest);

                result(Caching.IsVersionCached(url, hash));
} , 
TaskManager.TaskPriorityEnum.RunOutQueue);
}

public void CheckFreeSpace(string url, Action<bool, float> result)
{
    GetSize(url, lengthInMb =>
    {

#if UNITY_EDITOR_WIN
        var logicalDrive = Path.GetPathRoot(Utils.Path.Cache);
        var availableSpace = SimpleDiskUtils.DiskUtils.CheckAvailableSpace(logicalDrive);
#elif UNITY_EDITOR_OSX
        var availableSpace = SimpleDiskUtils.DiskUtils.CheckAvailableSpace();
#elif UNITY_IOS
        var availableSpace = SimpleDiskUtils.DiskUtils.CheckAvailableSpace();
#elif UNITY_ANDROID
        var availableSpace = SimpleDiskUtils.DiskUtils.CheckAvailableSpace(true);
#endif
        result(availableSpace > lengthInMb, lengthInMb);
    });
}

public void GetSize(string url, Action<float> result)
{
    _network.Request(url, length => result(length / 1048576f));
}

private string GetFileNameFromUrl(string url)
{
    var uri = new Uri(url);
    var fileName = Path.GetFileNameWithoutExtension(uri.LocalPath);

    return fileName;
}

private Hash128 GetHashFromManifest(string manifest)
{
    var hashRow = manifest.Split("\n".ToCharArray())[5];
    var hash = Hash128.Parse(hashRow.Split(':')[1].Trim());

    return hash;
}

public void GetAssetBundle(string url,
                           Action start,
                           Action<float> progress,
                           Action stop,
                           Action<AssetBundleWrapper> result,
                           TaskManager.TaskPriorityEnum taskPriority = TaskManager.TaskPriorityEnum.Default)
{
#if DONT_USE_SERVER_IN_EDITOR
    start?.Invoke();

    result(new AssetBundleWrapper(url));

    stop?.Invoke();
#else
void loadAssetBundle(Hash128 bundleHash)
{
    start?.Invoke();

    _network.Request(url, bundleHash, progress,
    (AssetBundle value) =>
    {   
        if(value != null)
        {
            _externalResourcesStorage.SetCachedHash(url, bundleHash);
        }
        
        result(new AssetBundleWrapper(value));

        stop?.Invoke();
    }, taskPriority);
};

var manifestFileUrl = "{0}.manifest".Fmt(url);

_network.Request(manifestFileUrl, null, (string manifest) =>
{
    var hash = string.IsNullOrEmpty(manifest) ? default : GetHashFromManifest(manifest);                                

    if (!hash.isValid || hash == default)
    {
        hash = _externalResourcesStorage.GetCachedHash(url);                    

        if (!hash.isValid || hash == default)
        {
            result(new AssetBundleWrapper(null));
        }
        else
        {
            loadAssetBundle(hash);
        }
    }
    else
    {                    
        if (Caching.IsVersionCached(url, hash))
        {
            loadAssetBundle(hash);
        }
        else
        {
            CheckFreeSpace(url, (spaceAvailable, length) =>
            {
                if (spaceAvailable)
                {
                    loadAssetBundle(hash);
                }
                else
                {
                     result(new AssetBundleWrapper(null));

                    NotEnoughDiskSpace.Call();
                }
             });
         }
    }
#endif
}

public void GetPack(Dictionary<string, ResourceEnumType> urls, 
                            Action start,
                            Action<float> progress,
                            Action stop, Action<string, object, bool> result)
{            
    
    var commonProgress = (float)urls.Count;
    var currentProgress = 0f;
    var completeCounter = 0;

    void progressHandler(float value)            
    {
        currentProgress += value;                

        progress?.Invoke(currentProgress / commonProgress);                
    };

    void completeHandler()
    {
        completeCounter++;

        if (completeCounter == urls.Count)
        {
            stop?.Invoke();
        }
    };

    start?.Invoke();

    foreach (var url in urls.Keys)
    {
        var resourceType = urls[url];

        switch (resourceType)
        {
            case ResourceEnumType.Text:
                {
                    GetText(url, null, progressHandler, completeHandler,
                                    (value, isCached) =>
                                    {
                                        result(url, value, isCached);
                                    });
                }
                break;
            case ResourceEnumType.Texture:
                {
                    GetTexture(url, null, progressHandler, completeHandler,
                                       (value, isCached) =>
                                       {
                                           result(url, value, isCached);
                                       });
                }
                break;
            case ResourceEnumType.AssetBundle:
                {
                    GetAssetBundle(url, null, progressHandler, completeHandler,
                                           (value) =>
                                           {
                                               result(url, value, false);
                                           });
                }
                break;
        }
    }
}