using CaoCao.XAsset;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using UnityEditor;
using UnityEngine;

namespace CaoCao.Editor
{
    public static class Builder
    {
        public static IBuildPipeline BuildPipeline { get; set; } = new DefaultBuildPipeline();
        public static Action<Build[], Settings> PreprocessBuildBundles { get; set; } = null;
        public static Action<string[]> PostprocessBuildBundles { get; set; } = null;

        //打包前所有文件
        public static List<string> BuildBeforeAllFiles = new List<string>();
        //打包后所有文件
        public static List<string> BuildAfterAllFiles = new List<string>();

        public static void BuildBundles(params Build[] builds)
        {
            FindBuildBeforeAllFiles();
            BuildBundlesInternal(false, false, builds);
        }

        public static void BuildHotfix(params Build[] builds)
        {
            FindBuildBeforeAllFiles();
            BuildBundlesInternal(false, true, builds);
        }

        public static void BuildBundlesWithLastBuild(params Build[] builds)
        {
            BuildBundlesInternal(true, false, builds);
        }

        private static void BuildBundlesInternal(bool withLastBuild, bool isHotfix, params Build[] builds)
        {
            var settings = Settings.GetDefaultSettings();
            if (builds.Length == 0) 
                builds = Settings.FindAssets<Build>();

            PreprocessBuildBundles?.Invoke(builds, settings);

            if (settings.bundle.checkReference && FindReferences()) 
                return;

            CreateDirectories();

            //获取到所有Build配置
            var assets = Array.ConvertAll(builds, AssetDatabase.GetAssetPath);

            if (assets.Length == 0)
            {
                XAsset.Logger.I("Nothing to build.");
                return;
            }

            var watch = new Stopwatch();
            watch.Start();
            var changes = new List<string>();
            foreach (var asset in assets)
            {
                var build = AssetDatabase.LoadAssetAtPath<Build>(asset);
                var parameters = build.parameters;
                parameters.name = build.name;

                ////只打hotfix  只收集
                //if (isHotfix && build.name != "HotfixB")
                //{
                //    var taskHotfix = BuildJob.StartNew(parameters, new LoadBuildAssets());
                //    continue;
                //}

                var tmps = build.name.Split('_');
#if UNITY_ANDROID
                //HotfixB_Android
                if (tmps.Length == 2)
                {
                    if (tmps[1] != "Android")
                        continue;
                }

#elif UNITY_IOS
                //HotfixB_IOS
                if (tmps.Length == 2)
                {
                    if (tmps[1] != "IOS")
                        continue;
                }
#else
                //HotfixB_Win
                if (tmps.Length == 2)
                {
                    if (tmps[1] != "Win")
                        continue;
                }
#endif
                //只打hotfix
                if (isHotfix && tmps[0] != "HotfixB")
                {
                    //var taskHotfix = BuildJob.StartNew(parameters, new LoadBuildAssets());
                    continue;
                }

                var task = withLastBuild
                ? BuildJob.StartNew(parameters, new LoadBuildAssets(), new BuildBundles(), new BuildVersions())
                : parameters.optimizeDependentAssets
                    ? BuildJob.StartNew(parameters, new CollectAssets(), new ClearDuplicateAssets(),
                        new OptimizeDependentAssets(),
                        new SaveBuildAssets(), 
                        new BuildBundles(), 
                        new BuildVersions())

                    : BuildJob.StartNew(parameters, new CollectAssets(), new ClearDuplicateAssets(),
                        new SaveBuildAssets(), 
                        new BuildBundles(), 
                        new BuildVersions());

                if (!string.IsNullOrEmpty(task.error))
                {
                    XAsset.Logger.E(task.error);
                }
                else
                {
                    if (task.changes.Count <= 0)
                        continue;

                    foreach (var change in task.changes) 
                        changes.Add(Settings.GetDataPath(change));
                }
            }

            watch.Stop();
            XAsset.Logger.I($"Finish {nameof(BuildBundles)} with {watch.ElapsedMilliseconds / 1000f}s.");
            if (changes.Count <= 0) 
                return;

            PostprocessBuildBundles?.Invoke(changes.ToArray());
            SaveVersions(changes);
        }

        private static void SaveVersions(List<string> changes)
        {
            var versions = Settings.GetDefaultVersions();
            var path = Settings.GetDataPath(versions.GetFilename());
            var configs = Settings.FindAssets<AssetPack>();
            var packs = new List<string>();
            foreach (var config in configs)
                if (config.deliveryMode == AssetPack.DeliveryMode.InstallTime ||
                    config.deliveryMode == AssetPack.DeliveryMode.FastFollow)
                    packs.Add(config.name);

            versions.preloadPacks = packs.ToArray();
            versions.Save(Settings.GetCachePath(Versions.Filename));
            versions.Save(path);
            changes.Add(path);
            PostprocessBuildBundles?.Invoke(changes.ToArray());
            var file = new FileInfo(path);
            BuildUpdateInfo(versions, XAsset.Utility.ComputeHash(path), file.Length);
            // updateInfo.
            var size = GetChanges(changes.ToArray(), versions.GetFilename());
            var savePath = Settings.GetCachePath(BuildRecords.Filename);
            var records = XAsset.Utility.LoadFromFile<BuildRecords>(savePath);
            records.Set(versions.GetFilename(), changes.ToArray(), size);
            var json = JsonUtility.ToJson(records);
            File.WriteAllText(savePath, json);

            CopyDifferenceFiles($"versions_v{versions.ToString()}");
        }

        public static void BuildUpdateInfo(Versions versions, string hash, long size)
        {
            var settings = Settings.GetDefaultSettings();
            var downloadURL = $"{settings.downloadURL}{Assets.Bundles}/{Settings.Platform}/";
            var updateInfoPath = Settings.GetCachePath(UpdateInfo.Filename);
            var updateInfo = CaoCao.XAsset.Utility.LoadFromFile<UpdateInfo>(updateInfoPath);
            updateInfo.hash = hash;
            updateInfo.size = (ulong) size;
            updateInfo.file = versions.GetFilename();
            updateInfo.downloadURL = downloadURL;
            //updateInfo.bigVersion = settings.BigVersion;
            File.WriteAllText(updateInfoPath, JsonUtility.ToJson(updateInfo));
        }

        private static void CreateDirectories()
        {
            var directories = new List<string>
            {
                Settings.PlatformCachePath, Settings.PlatformDataPath
            };

            foreach (var directory in directories)
                if (!Directory.Exists(directory))
                    Directory.CreateDirectory(directory);
        }

        public static bool FindReferences()
        {
            var builds = Settings.FindAssets<Build>();
            if (builds.Length == 0)
            {
                XAsset.Logger.I("Nothing to build.");
                return false;
            }

            var assets = new List<BuildAsset>();
            foreach (var build in builds)
            {
                var item = build.parameters;
                item.name = build.name;
                var task = item.optimizeDependentAssets
                    ? BuildJob.StartNew(item, new CollectAssets(), new OptimizeDependentAssets())
                    : BuildJob.StartNew(item, new CollectAssets());

                if (!string.IsNullOrEmpty(task.error))
                    return true;

                foreach (var asset in task.bundledAssets) 
                    assets.Add(asset);

                foreach (var asset in task.rawAssets) 
                    assets.Add(asset);
            }

            var assetWithGroups = new Dictionary<string, HashSet<string>>();
            foreach (var asset in assets)
            {
                if (!assetWithGroups.TryGetValue(asset.path, out var refs))
                {
                    refs = new HashSet<string>();
                    assetWithGroups.Add(asset.path, refs);
                }

                refs.Add($"{asset.group.build}-{asset.group.name}");
            }

            var sb = new StringBuilder();
            foreach (var pair in assetWithGroups.Where(pair => pair.Value.Count > 1))
            {
                sb.AppendLine(pair.Key);
                foreach (var s in pair.Value) 
                    sb.AppendLine(" - " + s);
            }

            var content = sb.ToString();
            if (string.IsNullOrEmpty(content))
            {
                XAsset.Logger.I("Checking completed, Everything is ok.");
                return false;
            }

            const string filename = "MultipleReferences.txt";
            File.WriteAllText(filename, content);
            if (EditorUtility.DisplayDialog("提示", "检测到多重引用关系，是否打开查看？", "确定"))
                EditorUtility.OpenWithDefaultApp(filename);
            return true;
        }

        public static void RemoveBundles(params string[] assetPaths)
        {
            var bundles = new HashSet<ManifestBundle>();
            var versions = Settings.GetDefaultVersions();
            foreach (var version in versions.data)
            {
                var manifest = CaoCao.XAsset.Utility.LoadFromFile<Manifest>(Settings.GetDataPath(version.file));
                foreach (var assetPath in assetPaths)
                {
                    var bundle = manifest.GetBundle(assetPath);
                    if (bundle != null) bundles.Add(bundle);
                }
            }

            var files = new List<string>();
            foreach (var bundle in bundles)
            {
                files.Add(Settings.GetCachePath(bundle.name));
                files.Add(Settings.GetCachePath(bundle.name + ".manifest"));
                files.Add(Settings.GetDataPath(bundle.file));
            }

            var sb = new StringBuilder();
            sb.AppendLine("Delete Files:");
            foreach (var file in files)
            {
                if (!File.Exists(file)) continue;
                File.Delete(file);
                sb.AppendLine($"Delete: {file}");
            }

            CaoCao.XAsset.Logger.I(sb.ToString());
        }

        public static ManifestBundle[] GetBundlesInBuild(Settings settings, Versions versions)
        {
            var set = new HashSet<ManifestBundle>();
            var assets = new HashSet<string>();
            //只有Settings中PlayerAssetsSplitMode设置为SplitByAssetPacksWithInstallTime或IncludeAllAssets才算
            switch (settings.playerAssetsSplitMode)
            {
                case PlayerAssetsSplitMode.SplitByAssetPacksWithInstallTime:
                    var assetPackConfigs = Settings.FindAssets<AssetPack>();
                    var assetPacks = new List<AssetPack>();
                    //AssetPack中交付模式设置为InstallTime才算
                    foreach (var assetPack in assetPackConfigs)
                    {
                        if (assetPack.deliveryMode == AssetPack.DeliveryMode.InstallTime)
                            assetPacks.Add(assetPack);
                    }

                    foreach (var config in assetPacks)
                    {
                        //找到这个AssetPack中所有的asset
                        Settings.Collect(config, assets);
                        //只有在versions.data中的bundle才算
                        foreach (var version in versions.data)
                        {
                            var manifest = XAsset.Utility.LoadFromFile<Manifest>(Settings.GetDataPath(version.file));
                            foreach (var path in assets)
                            {
                                var bundle = manifest.GetBundle(path);
                                if (bundle == null)
                                    continue;

                                set.Add(bundle);
                                set.UnionWith(manifest.GetDependencies(bundle));
                            }
                        }
                    }

                    break;
                case PlayerAssetsSplitMode.ExcludeAllAssets:
                    break;
                case PlayerAssetsSplitMode.IncludeAllAssets:
                    foreach (var version in versions.data)
                    {
                        var path = Settings.GetDataPath(version.file);
                        var manifest = XAsset.Utility.LoadFromFile<Manifest>(path);
                        set.UnionWith(manifest.bundles);
                    }

                    break;
            }

            return set.ToArray();
        }

        public static ulong GetChanges(IEnumerable<string> changes, string name)
        {
            var sb = new StringBuilder();
            var size = 0UL;
            var files = new List<FileInfo>();
            foreach (var change in changes)
            {
                var file = new FileInfo(change);
                if (!file.Exists) continue;
                size += (ulong) file.Length;
                files.Add(file);
            }

            files.Sort((a, b) => b.Length.CompareTo(a.Length));
            foreach (var file in files) sb.AppendLine($"{file.FullName}({CaoCao.XAsset.Utility.FormatBytes((ulong) file.Length)})");

            XAsset.Logger.I(size > 0
                ? $"GetChanges from {name} with following files({CaoCao.XAsset.Utility.FormatBytes(size)}):\n {sb}"
                : "Nothing changed.");
            return size;
        }

        public static void BuildReferences()
        {
            var builds = Settings.FindAssets<Build>();
            var assets = new List<BuildAsset>();
            foreach (var build in builds)
            {
                var job = BuildJob.StartNew(build.parameters, new CollectAssets(), new ClearDuplicateAssets(),
                    new OptimizeDependentAssets(),
                    new SaveBuildAssets());
                assets.AddRange(job.bundledAssets);
                assets.AddRange(job.rawAssets);
            }

            var cache = Settings.GetBuildAssetCache();
            var newFiles = assets.Count - cache.data.Count;
            XAsset.Logger.I($"Build Asset References with {newFiles} files.");
            cache.data = assets;
            cache.BuildReferences();
            EditorUtility.SetDirty(cache);
            AssetDatabase.SaveAssets();
            Selection.activeObject = cache;
            EditorUtility.FocusProjectWindow();
        }




        //-------------------------------------------------------比对差异文件-----------------------------------------------------
        public static void FindBuildBeforeAllFiles()
        {
            string folderPath = Settings.PlatformDataPath + "/";
            UnityEngine.Debug.Log($"热更资源文件夹 = {folderPath}");
            if (!Directory.Exists(folderPath))
                return;
            
            BuildBeforeAllFiles = Directory.GetFiles(folderPath, "*", SearchOption.AllDirectories).ToList();
            UnityEngine.Debug.Log($"打包前：文件数量 = {BuildBeforeAllFiles.Count}");

        }

        public static void CopyDifferenceFiles(string dirName)
        {
            string newFolder = $"{Environment.CurrentDirectory.Replace('\\', '/')}/{Assets.Bundles}/{dirName}";
            if (!Directory.Exists(newFolder))
                Directory.CreateDirectory(newFolder);

            string folderPath = Settings.PlatformDataPath + "/";

            BuildAfterAllFiles = Directory.GetFiles(folderPath, "*", SearchOption.AllDirectories).ToList();
            UnityEngine.Debug.Log($"打包后：文件数量 = {BuildAfterAllFiles.Count}");

            foreach(var fileName in BuildAfterAllFiles)
            {
                if (BuildBeforeAllFiles.Contains(fileName))
                    continue;

                //分层建立文件夹   F:/HxMobileProject/Bundles/iOS/assetspackb/xxx.bundle
                string t = fileName.Replace('\\', '/');
                //assetspackb/xxx.bundle
                string tmp = t.Replace(folderPath, "");
                string[] tmps = tmp.Split('/');
                foreach(var ss in tmps)
                {
                    //xxx.bundle
                    if (ss.EndsWith(".bundle")
                        || ss.EndsWith(".json"))
                        continue;

                    //ss = assetspackb
                    //F:/HxMobileProject/Bundles/iOS/assetspackb
                    string tmpDir = newFolder + "/" + ss;
                    if (!Directory.Exists(tmpDir))
                        Directory.CreateDirectory(tmpDir);
                }

                string dest = newFolder + "/" + tmp;
                File.Copy(fileName, dest);
            }

            //复制updateinfo
            var updateInfoPath = Settings.GetCachePath(UpdateInfo.Filename);
            string destPath = newFolder + "/" + UpdateInfo.Filename;
            File.Copy(updateInfoPath, destPath);
        }
    }
}