using System;
using System.Linq;
using System.IO;
using UnityEngine;
using System.Collections.Generic;
namespace BFEditor.Resource
{
    public class DependenciesCheckTool
    {
        static bool checkedOver = true;

        public static bool CheckedOver
        {
            get{return checkedOver;}
            private set{}
        }

        static Dictionary<string, List<string>> abnormalDependenciesDic = new Dictionary<string, List<string>>();

        public static Dictionary<string, List<string>> AbnormalDependenciesDic
        {
            get{return abnormalDependenciesDic;}
            private set{}
        }

        public static List<BaseDependenciesChecker> GetAllCheckers()
        {
            var result = new List<BaseDependenciesChecker>()
            {
                new AnimationDependenciesChecker(),
                new AtlasDependenciesChecker(),
                new BakedataDependenciesChecker(),
                new EffectDependenciesChecker(),
                new FirstDependenciesChecker(),
                new FontDependenciesChecker(),
                new LanguageDependenciesChecker(),
                new LuaDependenciesChecker(),
                new MaterialDependenciesChecker(),
                new ModelDependenciesChecker(),
                new ShaderDependenciesChecker(),
                new ShakeDependenciesChecker(),
                new SkyboxDependenciesChecker(),
                new SoundDependenciesChecker(),
                new SpineDependenciesChecker(),
                new TextureDependenciesChecker(),
                new TimelineDependenciesChecker(),
                new VideoDependenciesChecker(),
                new EffectPrefabDependenciesChecker(),
                new TimelinePrefabDependenciesChecker(),
                new SpritePrefabDependenciesChecker(),
                new OtherPrefabDependenciesChecker(),
                new ModelPrefabDependenciesChecker(),
                new SpinePrefabDependenciesChecker(),
                new CityPrefabDependenciesChecker(),
            };
            return result;
        }
        public static void Clear()
        {
            checkedOver = false;
            abnormalDependenciesDic.Clear();
        }

        static AssetBundleManifest GetManifest()
        {
            var streamPath = Path.Combine(Application.streamingAssetsPath, "asset_bundle_manifest.ab");
            if (!File.Exists(streamPath))
            {
                Debug.LogError("文件不存在 " + streamPath);
                return null;
            }
    
            var assetBundle = AssetBundle.LoadFromFile(streamPath);
            var manifest = assetBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
            assetBundle.Unload(false);
            return manifest;
        }

        public static Dictionary<string, List<string>> CheckDependenceies(Action<bool> checkOverAction = null, List<BaseDependenciesChecker> allCheckers = null)
        {
            if(allCheckers == null)
            {
                allCheckers = GetAllCheckers();
            }
            checkedOver = false;
            abnormalDependenciesDic.Clear();
            AssetBundleManifest manifest = GetManifest();
            string[] allBundles = manifest.GetAllAssetBundles();
            foreach(var bundle in allBundles)
            {
                List<string> abnormalDependencies = new List<string>();
                string[] allDependencies = manifest.GetDirectDependencies(bundle);
                foreach(BaseDependenciesChecker checker in allCheckers)
                {
                    if(checker.Active && bundle.Contains(checker.GetCheckPathPrefix()))
                    {
                        abnormalDependencies = checker.GetAbnormalDenpendencies(bundle, allDependencies);
                        break;
                    }
                }
                if(abnormalDependencies.Count > 0)
                {
                    abnormalDependenciesDic.Add(bundle, abnormalDependencies);
                }
            }
            checkedOver = true;

            if(checkOverAction != null)
            {
                checkOverAction(abnormalDependenciesDic.Keys.Count <= 0);
            }
            return abnormalDependenciesDic;
        }
    }
}