using System.Collections;
using System.Collections.Generic;
using System;
using UnityEngine;
using System.IO;
using Snxxz.UI;
using System.Threading;


[XLua.LuaCallCSharp]
public class AssetVersionUtility
{
    public static string assetVersionsLocalMd5
    {
        get { return LocalSave.GetString("AssetVersionsLocalMd5"); }
        set { LocalSave.SetString("AssetVersionsLocalMd5", value); }
    }

    static bool m_HasDownLoadFullAsset = LocalSave.GetBool("HasDownLoadFullAsset");
    public static bool hasDownLoadFullAsset
    {
        get { return m_HasDownLoadFullAsset; }
        set { LocalSave.SetBool("HasDownLoadFullAsset", value); }
    }

    static bool m_PriorAssetDownLoadDone = false;
    public static bool priorAssetDownLoadDone
    {
        get
        {
            if (VersionUtility.Instance.NeedDownAsset())
            {
                return m_PriorAssetDownLoadDone;
            }
            else
            {
                return true;
            }
        }
    }

    static bool m_UnPriorAssetDownLoadDone = false;
    public static bool unPriorAssetDownLoadDone
    {
        get
        {
            if (VersionUtility.Instance.NeedDownAsset())
            {
                return m_UnPriorAssetDownLoadDone;
            }
            else
            {
                return true;
            }
        }
    }

    public static DateTime assetsBuildTime = DateTime.MinValue;

    static Dictionary<string, AssetVersion> assetVersions = new Dictionary<string, AssetVersion>();
    static List<AssetVersion> priorDownLoadAssetVersions = new List<AssetVersion>();
    static List<AssetVersion> unpriorDownLoadAssetVersions = new List<AssetVersion>();
    public static bool checkAssetCompleted { get; private set; }

    public static void Init()
    {

    }

    public static void GetAssetVersionFile()
    {
        checkAssetCompleted = false;
        Debug.LogFormat("开始获取资源版本文件：时间 {0}", DateTime.Now);
        var assetVersionUrl = StringUtility.Contact(VersionUtility.Instance.versionInfo.GetResourcesURL(VersionConfig.Get().branch), "/", "AssetsVersion.txt");
        HttpRequest.Instance.RequestHttpGet(assetVersionUrl, HttpRequest.defaultHttpContentType, 3, OnGetAssetVersionFile);
    }

    private static void OnGetAssetVersionFile(bool _ok, string _result)
    {
        Debug.LogFormat("获取资源版本文件结果：时间 {0}，结果 {1}", DateTime.Now, _ok);

        if (_ok)
        {
            assetVersionsLocalMd5 = FileExtersion.GetStringMD5Hash(_result);
            var assetVersions = UpdateAssetVersions(_result);
            BeginCheckAssets();
        }
        else
        {
            Clock.AlarmAt(DateTime.Now + new TimeSpan(TimeSpan.TicksPerSecond), GetAssetVersionFile);
        }
    }

    private static void BeginCheckAssets()
    {
        ThreadPool.QueueUserWorkItem(
            (object aaa) =>
            {
                foreach (var assetVersion in assetVersions.Values)
                {
                    if (!assetVersion.CheckLocalFileValid(false))
                    {
                        if (assetVersion.IsPriorAsset())
                        {
                            priorDownLoadAssetVersions.Add(assetVersion);
                        }
                        else
                        {
                            unpriorDownLoadAssetVersions.Add(assetVersion);
                        }

                        assetVersion.localValid = false;
                    }
                    else
                    {
                        assetVersion.localValid = true;
                    }
                }

                m_PriorAssetDownLoadDone = priorDownLoadAssetVersions.Count <= 0;
                m_UnPriorAssetDownLoadDone = unpriorDownLoadAssetVersions.Count <= 0;

                checkAssetCompleted = true;
            }
            );
    }

    public static void BeginDownLoadTask(bool _prior)
    {
        if (_prior)
        {
            m_PriorAssetDownLoadDone = false;
            DownLoadAndDiscompressTask.Instance.Prepare(priorDownLoadAssetVersions, () => { m_PriorAssetDownLoadDone = true; });
        }
        else
        {
            m_UnPriorAssetDownLoadDone = false;
            InGameDownLoad.Instance.AssignTasks(unpriorDownLoadAssetVersions, () =>
          {
              m_UnPriorAssetDownLoadDone = true;
              hasDownLoadFullAsset = true;
          });
        }
    }

    public static Dictionary<string, AssetVersion> UpdateAssetVersions(string _assetVersionFile)
    {
        var lines = _assetVersionFile.Split(new string[] { FileExtersion.lineSplit }, StringSplitOptions.RemoveEmptyEntries);
        assetVersions.Clear();
        for (int i = 0; i < lines.Length; i++)
        {
            var assetVersion = new AssetVersion(lines[i]);
            assetVersions[assetVersion.relativePath] = assetVersion;
        }

        return assetVersions;
    }

    public static AssetVersion GetAssetVersion(string assetKey)
    {
        if (assetVersions.ContainsKey(assetKey))
        {
            return assetVersions[assetKey];
        }
        else
        {
            return null;
        }
    }

    public static bool IsAssetValid(string assetKey)
    {
        if (assetVersions.ContainsKey(assetKey))
        {
            return assetVersions[assetKey].localValid;
        }
        else
        {
            if (VersionUtility.Instance.NeedDownAsset())
            {
                return false;
            }
            else
            {
                return true;
            }
        }
    }

    public static bool IsSceneAssetValid(int mapId, int lineId)
    {
        if (AssetSource.sceneFromEditor || mapId < 100)
        {
            return true;
        }

        var dataMapId = MapUtility.GetDataMapId(mapId);
        lineId = MapUtility.GetLineId(mapId, lineId);
        var mapResConfig = MapResourcesConfig.GetConfig(dataMapId, lineId);
        if (mapResConfig == null)
        {
            return false;
        }

        if (!IsAssetValid(StringUtility.Contact("maps/", mapResConfig.MapResources.ToLower())))
        {
            return false;
        }

        if (dataMapId != 10010)
        {
            ActorShowConfig actorShowConfig = null;
            if (ActorShowConfig.GetActoreShowConfigByMapIdAndLineId(dataMapId, lineId, out actorShowConfig))
            {
                var npcs = actorShowConfig.showNpcs;
                foreach (var item in npcs)
                {
                    var npcConfig = NPCConfig.Get(item);
                    if (npcConfig != null)
                    {
                        var assetbundleName = StringUtility.Contact("prefab_race_", npcConfig.MODE.ToLower());
                        if (!IsAssetValid(StringUtility.Contact("mob/", assetbundleName)))
                        {
                            return false;
                        }
                    }
                }
            }
        }

        return true;
    }

    public static string GetAssetFilePath(string _assetKey)
    {
        var path = string.Empty;
        if (assetVersions.ContainsKey(_assetKey))
        {
            var assetVersion = assetVersions[_assetKey];
            switch (assetVersion.fileLocation)
            {
                case AssetVersion.StorageLocation.StreamingAsset:
                    path = StringUtility.Contact(ResourcesPath.Instance.StreamingAssetPath, _assetKey);
                    break;
                case AssetVersion.StorageLocation.ExternalStore:
                    path = StringUtility.Contact(ResourcesPath.Instance.ExternalStorePath, _assetKey);
                    break;
            }
        }
        else
        {
            if (Application.platform == RuntimePlatform.Android)
            {
                path = StringUtility.Contact(ResourcesPath.Instance.ExternalStorePath, _assetKey);
            }
            else
            {
                path = StringUtility.Contact(ResourcesPath.Instance.StreamingAssetPath, _assetKey);
            }
        }

        return path;
    }

    public static string GetBuiltInAssetFilePath(string _assetKey)
    {
        var path = string.Empty;
        if (Application.platform == RuntimePlatform.Android)
        {
            path = StringUtility.Contact(ResourcesPath.Instance.ExternalStorePath, _assetKey);
        }
        else
        {
            if (SDKUtility.builtinAssetCopyFinished)
            {
                path = StringUtility.Contact(ResourcesPath.Instance.ExternalStorePath, _assetKey);
            }
            else
            {
                path = StringUtility.Contact(ResourcesPath.Instance.StreamingAssetPath, _assetKey);
            }
        }

        return path;
    }

    public static bool IsUnpriorAssetDownLoadOk()
    {
        if (VersionUtility.Instance.NeedDownAsset())
        {
            return unPriorAssetDownLoadDone;
        }
        else
        {
            return true;
        }
    }


}