using System;
using System.Web;
using System.Collections.Generic;
using System.Linq;
using System.Data;
using System.IO;
using System.IO.Compression;
using Infrastructure;
using Customer.Source;
using Common;
using System.Text.RegularExpressions;

namespace Util.MakeApp
{
    public class MakeAndroidCode
    {
        #region 生成文件

        /// <summary>
        /// 生成安卓代码
        /// </summary>
        /// <param name="AppId">APP项目ID</param>
        public static void MakerFile(string fileName, AppProject project, AppProjectVersion ver, List<AppModule> smodules, List<AppModuleAndroidCode> codes, List<AppProjectModule> modules, List<AppProjectParam> paramList, List<AppModuleFile> fileList, List<AppProjectPage> pages, List<AppProjectBottom> bottoms)
        {
            MakeAppCodePub.ProcessSet(ver.id);
            string AppPackage = project.packageName; //包名
            string PackagePath = AppPackage.Replace(".", "/"); //包名
            string AppIcon = project.appIcon; //应用桌面图标
            string AppName = project.appName; //应用名称
            string AppStartBg = project.appStartBg; //启动图
            string AppStartListPhoto = project.appStartListPhoto; //启动介绍轮播图
            string ApiHost = project.apiHost; //API主机头
            string ApiKind = project.appKind; //APP分类
            string AppStatic = ver.staticFile; //APP静态资源
            string InitPage = project.initPage; //APP首次加载界面

            //复制文件
            string sourceDir = Function.getPath("/AppTemplate/android/OmegaMainBase/"); //模版目录
            string destinationDir = Function.getPath("androidcode/" + project.id + "/"); //生成目录
            CopyFolder(sourceDir, destinationDir);
            MakeAppCodePub.ProcessSet(ver.id);

            //替换包名
            ReplaceAppPackage(destinationDir, AppPackage);
            MakeAppCodePub.ProcessSet(ver.id);

            //权限
            string androidMainPath = destinationDir + "app/src/main/";
            string androidMainFestContent = Function.ReadInstanceByFull(androidMainPath + "AndroidManifest.xml");
            androidMainFestContent = androidMainFestContent.Replace("<application", "    <!-- 权限列表 -->\n\n<application");
            androidMainFestContent = androidMainFestContent.Replace("</application>", "        <!-- 参数配置 -->\n\n</application>");
            string androidMainFestList = "";
            string ManifetsParamCodeList = "";

            //引入库
            string appGradlePath = destinationDir + "app/";
            string appGradleContent = Function.ReadInstanceByFull(appGradlePath + "build.gradle");
            appGradleContent = Function.ReplaceLast(appGradleContent, "}", "    //APP引入库\n}");
            string appGradleList = "";

            //启动页方法
            string splashActivityPath = androidMainPath + "java/" + AppPackage.Replace(".", "/") + "/activity/";
            string splashActivityFunctionContent = Function.ReadInstanceByFull(splashActivityPath + "SplashActivity.java");
            splashActivityFunctionContent = Function.ReplaceLast(splashActivityFunctionContent, "}", "    /** 初始化方法 */\n}");
            splashActivityFunctionContent = splashActivityFunctionContent.Replace("private void sdkInit() {", "private void sdkInit() {\n        /** 初始化代码 */");
            string splashActivityFunctionList = "";
            string splashActivityCodeList = "";

            //主界面方法
            string mainActivityPath = androidMainPath + "java/" + AppPackage.Replace(".", "/") + "/function/";
            string mainActivityFunctionContent = Function.ReadInstanceByFull(mainActivityPath + "WebFragmentFunction.java");
            var importIndex = mainActivityFunctionContent.LastIndexOf("import");
            var importTagIndex = mainActivityFunctionContent.Substring(importIndex).IndexOf(";") + importIndex;
            mainActivityFunctionContent = mainActivityFunctionContent.Substring(0, importTagIndex) + ";\n//引用包" + mainActivityFunctionContent.Substring(importTagIndex + 1);
            mainActivityFunctionContent = Function.ReplaceLast(mainActivityFunctionContent, "}", "    /** 接口方法 */\n}");
            string mainActivityFunctionList = "";
            string fragmentImportList = "";

            //内页面方法
            string webActivityPath = androidMainPath + "java/" + AppPackage.Replace(".", "/") + "/function/";
            string webActivityFunctionContent = Function.ReadInstanceByFull(webActivityPath + "WebFunction.java");
            importIndex = webActivityFunctionContent.LastIndexOf("import");
            importTagIndex = webActivityFunctionContent.Substring(importIndex).IndexOf(";") + importIndex;
            webActivityFunctionContent = webActivityFunctionContent.Substring(0, importTagIndex) + ";\n//引用包" + webActivityFunctionContent.Substring(importTagIndex + 1);
            webActivityFunctionContent = Function.ReplaceLast(webActivityFunctionContent, "}", "    /** 接口方法 */\n}");
            string webActivityFunctionList = "";
            string webImportList = "";

            //主界面回调方法
            string mActivityPath = androidMainPath + "java/" + AppPackage.Replace(".", "/") + "/activity/";
            string mActivityFunctionContent = Function.ReadInstanceByFull(mActivityPath + "MainActivity.java");
            importIndex = mActivityFunctionContent.LastIndexOf("import");
            importTagIndex = mActivityFunctionContent.Substring(importIndex).IndexOf(";") + importIndex;
            mActivityFunctionContent = mActivityFunctionContent.Substring(0, importTagIndex) + ";\n//引用包" + mActivityFunctionContent.Substring(importTagIndex + 1);
            mActivityFunctionContent = Function.ReplaceLast(mActivityFunctionContent, "}", "    /** 回调方法 */\n}");
            string mActivityFunctionList = "";
            string mainActivityImportList = "";

            //回调方法
            string publicActivityPath = androidMainPath + "java/" + AppPackage.Replace(".", "/") + "/activity/";
            string publicActivityFunctionContent = Function.ReadInstanceByFull(publicActivityPath + "PublicWebActivity.java");
            importIndex = publicActivityFunctionContent.LastIndexOf("import");
            importTagIndex = publicActivityFunctionContent.Substring(importIndex).IndexOf(";") + importIndex;
            publicActivityFunctionContent = publicActivityFunctionContent.Substring(0, importTagIndex) + ";\n//引用包" + publicActivityFunctionContent.Substring(importTagIndex + 1);
            publicActivityFunctionContent = Function.ReplaceLast(publicActivityFunctionContent, "}", "    /** 回调方法 */\n}");
            string publicActivityFunctionList = "";
            string publicWebActivityImportList = "";

            //初始化变量
            string initActivityPath = androidMainPath + "java/" + AppPackage.Replace(".", "/") + "/app/";
            string initActivityFunctionContent = Function.ReadInstanceByFull(initActivityPath + "MainApplication.java");
            importIndex = initActivityFunctionContent.LastIndexOf("import");
            importTagIndex = initActivityFunctionContent.Substring(importIndex).IndexOf(";") + importIndex;
            initActivityFunctionContent = initActivityFunctionContent.Substring(0, importTagIndex) + ";\n//引用包" + initActivityFunctionContent.Substring(importTagIndex + 1);
            initActivityFunctionContent = initActivityFunctionContent.Replace("private void sdkInit() {", "private void sdkInit() {\n        /** 初始化变量 */");
            initActivityFunctionContent = initActivityFunctionContent.Replace("public static class MainApp {", "public static class MainApp {\n        /** 全局变量 */");
            string initActivityFunctionList = "";
            string mainApplicationImportList = "";
            string mainApplicationStaticList = "";
            MakeAppCodePub.ProcessSet(ver.id);

            //替换基础信息
            string baseInfo = Function.ReadInstanceByFull(androidMainPath + "res/values/strings.xml");
            baseInfo = Regex.Replace(baseInfo, "<string name=\"application_name\" translatable=\"false\">.*?</string>", "<string name=\"application_name\" translatable=\"false\">" + AppName + "</string>");
            baseInfo = Regex.Replace(baseInfo, "<string name=\"authorities\" translatable=\"false\">.*?</string>", "<string name=\"authorities\" translatable=\"false\">" + AppPackage + "</string>");
            baseInfo = Regex.Replace(baseInfo, "<string name=\"server_url\" translatable=\"false\">.*?</string>", "<string name=\"server_url\" translatable=\"false\">" + ApiHost + "</string>");
            string AppVersion = ver.version.ToString();
            string VersionCode = ver.versionCode;
            string VersionName = ver.versionName;
            baseInfo = Regex.Replace(baseInfo, "<string name=\"app_kind\" translatable=\"false\">.*?</string>", "<string name=\"app_kind\" translatable=\"false\">" + ApiKind + "/" + AppVersion + "</string>");
            baseInfo = Regex.Replace(baseInfo, "<string name=\"auto_url\" translatable=\"false\">.*?</string>", "<string name=\"auto_url\" translatable=\"false\">" + InitPage + "</string>");
            baseInfo = baseInfo.Replace("</resources>", "    <!-- 参数配置 -->\n</resources>");
            string StringsParamCodeList = "";

            //替换样式信息
            string styleInfo = Function.ReadInstanceByFull(androidMainPath + "res/values/styles.xml");
            styleInfo = styleInfo.Replace("</resources>", "    <!-- 样式配置 -->\n</resources>");
            string StyleParamCodeList = "";
            MakeAppCodePub.ProcessSet(ver.id);

            //读取项目所有关联模块
            List<int> moduleIds = modules.Select(m => m.moduleId).ToList();
            //读取模块配置参数
            Dictionary<string, string> paramDic = new Dictionary<string, string>();
            foreach(var param in paramList)
            {
                if(!paramDic.ContainsKey(param.paramName)) paramDic.Add(param.paramName, param.paramValue);
            }
            foreach(AppProjectModule module in modules)
            {
                AppModule smodule = smodules.FirstOrDefault(m => m.id == module.moduleId);
                if(smodule != null)
                {
                    List<AppModuleFile> files = fileList.Where(m => m.moduleId == module.moduleId && m.appType == "Android").ToList();
                    foreach(AppModuleFile file in files)
                    {
                        string SourceFilePath = file.sourcePath;
                        string ToPath = file.makePath;
                        ToPath = ToPath.Replace("{PackagePath}", PackagePath);
                        
                        // File.Copy(Function.getPath("/AppTemplate/android/fw" + SourceFilePath), destinationDir.TrimEnd('/') + ToPath);
                        Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + "/AppModule/Android" + SourceFilePath, destinationDir.TrimEnd('/') + ToPath);
                        //替换文件内容
                        if (!ToPath.EndsWith(".aar"))
                        {
                            ReplaceFileContent(destinationDir.TrimEnd('/') + ToPath, "${PackageName}", AppPackage);
                        }
                    }
                    AppModuleAndroidCode code = codes.FirstOrDefault(m => m.moduleId == module.moduleId) ?? new AppModuleAndroidCode();
                    string MainActivityCode = Function.CheckNull(code.mainActivityCode);
                    string PublicWebCode = Function.CheckNull(code.publicWebCode);
                    string MainCallBackCode = Function.CheckNull(code.mainCallBackCode);
                    string CallBackCode = Function.CheckNull(code.callBackCode);
                    string RightCode = Function.CheckNull(code.rightCode);
                    string InitCode = Function.CheckNull(code.initCode);
                    string GradleImportCode = Function.CheckNull(code.gradleImportCode);
                    string WebImportCode = Function.CheckNull(code.webImportCode);
                    string FragmentImportCode = Function.CheckNull(code.fragmentImportCode);
                    string MainActivityImportCode = Function.CheckNull(code.mainActivityImportCode);
                    string PublicWebActivityImportCode = Function.CheckNull(code.publicWebActivityImportCode);
                    string MainApplicationImportCode = Function.CheckNull(code.mainApplicationImportCode);
                    string StringsParamCode = Function.CheckNull(code.stringsParamCode);
                    string ManifetsParamCode = Function.CheckNull(code.manifetsParamCode);
                    string MainApplicationStaticParam = Function.CheckNull(code.mainApplicationStaticParam);
                    string StartPageMethodCode = Function.CheckNull(code.startPageMethodCode);
                    string startPageInitCode = Function.CheckNull(code.startPageInitCode);
                    string StyleParamCode = Function.CheckNull(code.stylesParamCode);

                    //替换对应模块参数
                    if(module.moduleId == 1)
                    {
                        MatchCollection matches = Regex.Matches(RightCode, "\\$\\{.*?\\}");
                        foreach(Match match in matches)
                        {
                            string paramName = match.Value.Replace("${", "").Replace("}", "");
                            if(paramDic.ContainsKey(paramName)) RightCode = RightCode.Replace(match.Value, paramDic[paramName]);
                        }
                    }

                    //权限
                    if(!string.IsNullOrEmpty(RightCode))
                    {
                        string[] RightCodes = RightCode.Split('\n');
                        foreach(string sub in RightCodes)
                        {
                            if(!androidMainFestList.Contains(sub.Trim())) androidMainFestList += "    " + sub + "\n";
                        }
                    }

                    //Strings.xml参数配置
                    if(!string.IsNullOrEmpty(StringsParamCode))
                    {
                        string[] RightCodes = StringsParamCode.Split('\n');
                        foreach(string sub in RightCodes)
                        {
                            string subLine = sub;
                            MatchCollection matches = Regex.Matches(subLine, "\\$\\{.*?\\}");
                            foreach(Match match in matches)
                            {
                                string paramName = match.Value.Replace("${", "").Replace("}", "");
                                if(paramDic.ContainsKey(paramName)) subLine = subLine.Replace(match.Value, paramDic[paramName]);
                            }
                            if(!StringsParamCodeList.Contains(subLine.Trim())) StringsParamCodeList += "\n" + subLine;
                        }
                    }

                    //Style.xml参数配置
                    if(!string.IsNullOrEmpty(StyleParamCode))
                    {
                        string[] RightCodes = StyleParamCode.Split('\n');
                        foreach(string sub in RightCodes)
                        {
                            string subLine = sub;
                            MatchCollection matches = Regex.Matches(subLine, "\\$\\{.*?\\}");
                            foreach(Match match in matches)
                            {
                                string paramName = match.Value.Replace("${", "").Replace("}", "");
                                if(paramDic.ContainsKey(paramName)) subLine = subLine.Replace(match.Value, paramDic[paramName]);
                            }
                            if(!StyleParamCodeList.Contains(subLine.Trim())) StyleParamCodeList += "\n" + subLine;
                        }
                    }

                    //Manifets.xml参数配置
                    if(!string.IsNullOrEmpty(ManifetsParamCode))
                    {
                        ManifetsParamCode = ManifetsParamCode.Replace("${package}", AppPackage).Replace("}", "");
                        if(!ManifetsParamCodeList.Contains(ManifetsParamCode)) ManifetsParamCodeList += "\n" + ManifetsParamCode;
                    }

                    //引入库
                    if(!string.IsNullOrEmpty(GradleImportCode))
                    {
                        string[] GradleImportCodes = GradleImportCode.Split('\n');
                        foreach(string sub in GradleImportCodes)
                        {
                            if(!appGradleList.Contains(sub)) appGradleList += "    " + sub + "\n";
                        }
                    }

                    //主界面方法
                    if(!webActivityFunctionList.Contains(PublicWebCode) && !string.IsNullOrEmpty(PublicWebCode)) webActivityFunctionList += "    " + PublicWebCode.Replace("\n", "    \n") + "\n";

                    //内页面方法
                    if(!mainActivityFunctionList.Contains(MainActivityCode) && !string.IsNullOrEmpty(MainActivityCode)) mainActivityFunctionList += "    " + MainActivityCode.Replace("\n", "    \n") + "\n";

                    //主界面回调方法
                    if(!mActivityFunctionList.Contains(MainCallBackCode) && !string.IsNullOrEmpty(MainCallBackCode)) mActivityFunctionList += "    " + MainCallBackCode.Replace("\n", "    \n") + "\n";

                    //回调方法
                    if(!publicActivityFunctionList.Contains(CallBackCode) && !string.IsNullOrEmpty(CallBackCode)) publicActivityFunctionList += "    " + CallBackCode.Replace("\n", "    \n") + "\n";

                    //初始化变量
                    if(!initActivityFunctionList.Contains(InitCode) && !string.IsNullOrEmpty(InitCode)) initActivityFunctionList += "    " + InitCode.Replace("\n", "    \n") + "\n";

                    //全局变量
                    if(!mainApplicationStaticList.Contains(MainApplicationStaticParam) && !string.IsNullOrEmpty(MainApplicationStaticParam)) mainApplicationStaticList += MainApplicationStaticParam.Replace("\n", "    \n") + "\n";

                    //启动页初始化方法
                    if(!splashActivityFunctionList.Contains(StartPageMethodCode) && !string.IsNullOrEmpty(StartPageMethodCode)) splashActivityFunctionList += StartPageMethodCode.Replace("\n", "    \n") + "\n";

                    //启动页初始化代码
                    if(!splashActivityCodeList.Contains(startPageInitCode) && !string.IsNullOrEmpty(startPageInitCode)) splashActivityCodeList += startPageInitCode.Replace("\n", "        \n") + "\n";

                    //import包
                    if(!string.IsNullOrEmpty(FragmentImportCode))
                    {
                        string[] FragmentImportCodes = FragmentImportCode.Split('\n');
                        foreach(string sub in FragmentImportCodes)
                        {
                            string checkString = sub.Replace("${package}", AppPackage);
                            if(!fragmentImportList.Contains(checkString) && !mainActivityFunctionContent.Contains(checkString)) fragmentImportList += checkString + "\n";
                        }
                    }
                    if(!string.IsNullOrEmpty(WebImportCode))
                    {
                        string[] WebImportCodes = WebImportCode.Split('\n');
                        foreach(string sub in WebImportCodes)
                        {
                            string checkString = sub.Replace("${package}", AppPackage);
                            if(!webImportList.Contains(checkString) && !webActivityFunctionContent.Contains(checkString)) webImportList += checkString + "\n";
                        }
                    }
                    if(!string.IsNullOrEmpty(MainActivityImportCode))
                    {
                        string[] MainActivityImportCodes = MainActivityImportCode.Split('\n');
                        foreach(string sub in MainActivityImportCodes)
                        {
                            string checkString = sub.Replace("${package}", AppPackage);
                            if(!mainActivityImportList.Contains(checkString) && !mActivityFunctionContent.Contains(checkString)) mainActivityImportList += checkString + "\n";
                        }
                    }
                    if(!string.IsNullOrEmpty(PublicWebActivityImportCode))
                    {
                        string[] PublicWebActivityImportCodes = PublicWebActivityImportCode.Split('\n');
                        foreach(string sub in PublicWebActivityImportCodes)
                        {
                            string checkString = sub.Replace("${package}", AppPackage);
                            if(!publicWebActivityImportList.Contains(checkString) && !publicActivityFunctionContent.Contains(checkString)) publicWebActivityImportList += checkString + "\n";
                        }
                    }
                    if(!string.IsNullOrEmpty(MainApplicationImportCode))
                    {
                        string[] MainApplicationImportCodes = MainApplicationImportCode.Split('\n');
                        foreach(string sub in MainApplicationImportCodes)
                        {
                            string checkString = sub.Replace("${package}", AppPackage);
                            if(!mainApplicationImportList.Contains(checkString) && !initActivityFunctionContent.Contains(checkString)) mainApplicationImportList += checkString + "\n";
                        }
                    }
                }
            }
            MakeAppCodePub.ProcessSet(ver.id);

            //加入权限文件
            // if (!string.IsNullOrEmpty(androidMainFestList))
            // { 
            //     Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + "/AppModule/Android/Java/PermissionDescription.java", destinationDir.TrimEnd('/') + "/app/src/main/java/" + PackagePath + "/tool/PermissionDescription.java");
            //     //替换文件内容
            //     ReplaceFileContent(destinationDir.TrimEnd('/') + "/app/src/main/java/" + PackagePath + "/tool/PermissionDescription.java", "${PackageName}", AppPackage);
            //     Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + "/AppModule/Android/xml/permission_description_popup_bg.xml", destinationDir.TrimEnd('/') + "/app/src/main/res/drawable/permission_description_popup_bg.xml");
            //     appGradleList += "    //权限申请\n    implementation 'com.github.getActivity:XXPermissions:20.0';\n";
            // }

            androidMainFestContent = androidMainFestContent.Replace("<!-- 权限列表 -->", androidMainFestList);
            androidMainFestContent = androidMainFestContent.Replace("<!-- 参数配置 -->", ManifetsParamCodeList);
            appGradleContent = appGradleContent.Replace("//APP引入库", appGradleList);
            appGradleContent = Regex.Replace(appGradleContent, "versionCode.*?\n", "versionCode " + VersionCode + "\n");
            appGradleContent = Regex.Replace(appGradleContent, "versionName \".*?\"\n", "versionName \"" + VersionName + "\"\n");

            mainActivityFunctionContent = mainActivityFunctionContent.Replace("/** 接口方法 */", mainActivityFunctionList);
            webActivityFunctionContent = webActivityFunctionContent.Replace("/** 接口方法 */", webActivityFunctionList);
            mActivityFunctionContent = mActivityFunctionContent.Replace("/** 回调方法 */", mActivityFunctionList);
            publicActivityFunctionContent = publicActivityFunctionContent.Replace("/** 回调方法 */", publicActivityFunctionList);
            initActivityFunctionContent = initActivityFunctionContent.Replace("/** 初始化变量 */", initActivityFunctionList);
            initActivityFunctionContent = initActivityFunctionContent.Replace("/** 全局变量 */", mainApplicationStaticList);

            mainActivityFunctionContent = mainActivityFunctionContent.Replace("//引用包", fragmentImportList);
            webActivityFunctionContent = webActivityFunctionContent.Replace("//引用包", webImportList);
            mActivityFunctionContent = mActivityFunctionContent.Replace("//引用包", mainActivityImportList);
            publicActivityFunctionContent = publicActivityFunctionContent.Replace("//引用包", publicWebActivityImportList);
            initActivityFunctionContent = initActivityFunctionContent.Replace("//引用包", mainApplicationImportList);

            baseInfo = baseInfo.Replace("<!-- 参数配置 -->", StringsParamCodeList);
            styleInfo = styleInfo.Replace("<!-- 样式配置 -->", StyleParamCodeList);

            Function.WritePageFullPath(androidMainPath, "AndroidManifest.xml", androidMainFestContent);
            Function.WritePageFullPath(androidMainPath + "res/values/", "strings.xml", baseInfo);
            Function.WritePageFullPath(androidMainPath + "res/values/", "styles.xml", styleInfo);
            Function.WritePageFullPath(appGradlePath, "build.gradle", appGradleContent);
            Function.WritePageFullPath(mainActivityPath, "WebFragmentFunction.java", mainActivityFunctionContent);
            Function.WritePageFullPath(webActivityPath, "WebFunction.java", webActivityFunctionContent);
            Function.WritePageFullPath(mActivityPath, "MainActivity.java", mActivityFunctionContent);
            Function.WritePageFullPath(publicActivityPath, "PublicWebActivity.java", publicActivityFunctionContent);
            Function.WritePageFullPath(initActivityPath, "MainApplication.java", initActivityFunctionContent);

            string toPath = androidMainPath + "assets/sources/";
            //底部导航图标下载
            foreach(var bottom in bottoms)
            {
                if(!string.IsNullOrEmpty(bottom.selectIcon))
                {
                    Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + bottom.selectIcon, toPath + "static/bottom/" + bottom.selectIcon.Substring(bottom.selectIcon.LastIndexOf("/") + 1));
                }
                if(!string.IsNullOrEmpty(bottom.normalIcon))
                {
                    Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + bottom.normalIcon, toPath + "static/bottom/" + bottom.normalIcon.Substring(bottom.normalIcon.LastIndexOf("/") + 1));
                }
                if(!string.IsNullOrEmpty(bottom.pagDefaultIcon))
                {
                    Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + bottom.pagDefaultIcon, toPath + "static/bottom/" + bottom.pagDefaultIcon.Substring(bottom.pagDefaultIcon.LastIndexOf("/") + 1));
                }
                if(!string.IsNullOrEmpty(bottom.pagLocalPath))
                {
                    Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + bottom.pagLocalPath, toPath + "static/bottom/" + bottom.pagLocalPath.Substring(bottom.pagLocalPath.LastIndexOf("/") + 1));
                }
            }
            MakeAppCodePub.ProcessSet(ver.id);
            //页面图标下载
            foreach(var page in pages)
            {
                if (page.leftBtn != null)
                {
                    foreach (var btn in page.leftBtn)
                    {
                        if (!string.IsNullOrEmpty(btn.btnIcon))
                        {
                            Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + btn.btnIcon, toPath + "static/page/" + btn.btnIcon.Substring(btn.btnIcon.LastIndexOf("/") + 1));
                        }
                    }
                }
                if (page.rightBtn != null)
                {
                    foreach (var btn in page.rightBtn)
                    {
                        if(!string.IsNullOrEmpty(btn.btnIcon))
                        {
                            Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + btn.btnIcon, toPath + "static/page/" + btn.btnIcon.Substring(btn.btnIcon.LastIndexOf("/") + 1));
                        }
                    }
                }
            }
            MakeAppCodePub.ProcessSet(ver.id);

            //解压static静态资源
            // string staticFilePath = Function.getPath(AppStatic);
            Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + AppStatic, toPath + "static.zip");
            ZipFile.ExtractToDirectory(toPath + "static.zip", toPath, true);
            File.Delete(toPath + "static.zip");

            //生成app加密的配置文件
            Dictionary<string, string> appFileDic = MakeAppCodePub.getAppFile(ver, pages, bottoms, toPath);
            if(appFileDic.ContainsKey("AppInfoList")) Function.WritePageFullPath(androidMainPath + "assets/", "AppInfoList.txt", appFileDic["AppInfoList"]);
            if(appFileDic.ContainsKey("SystemSet")) Function.WritePageFullPath(androidMainPath + "assets/", "SystemSet.txt", appFileDic["SystemSet"]);
            if(appFileDic.ContainsKey("PageInfoList")) Function.WritePageFullPath(androidMainPath + "assets/", "PageInfoList.txt", appFileDic["PageInfoList"]);
            if(appFileDic.ContainsKey("GotoPages")) Function.WritePageFullPath(androidMainPath + "assets/", "GotoPages.txt", appFileDic["GotoPages"]);
            if(appFileDic.ContainsKey("LibFile")) Function.WritePageFullPath(androidMainPath + "assets/", "LibFile.txt", appFileDic["LibFile"]);

            //删除html文件
            List<string> htmlFiles = FileHelper.GetSystemFilesFromFullPath(toPath);
            foreach(string file in htmlFiles)
            {
                if(file.EndsWith(".html"))                {
                    File.Delete(file);
                }
            }
            MakeAppCodePub.ProcessSet(ver.id);

            //解压icon图标
            //解压icon图标
            // string iconPath = Function.getPath(AppIcon);
            string toIconPath = androidMainPath + "res/";
            string savePath = toPath + AppIcon.Substring(AppIcon.LastIndexOf("/") + 1);
            Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + AppIcon, savePath);
            ZipFile.ExtractToDirectory(savePath, toIconPath, true);
            File.Delete(savePath);

            //解压启动图
            // string startBgPath = Function.getPath(AppStartBg);
            string toStartBgPath = androidMainPath + "res/";
            savePath = toPath + AppStartBg.Substring(AppStartBg.LastIndexOf("/") + 1);
            Function.DownloadNetFile(App.OptionsSetting.OssConfigs.Host + AppStartBg, savePath);
            ZipFile.ExtractToDirectory(savePath, toStartBgPath, true);
            File.Delete(savePath);

            //删除 icon 的 xml 文件
            File.Delete(toIconPath + "drawable/ic_launcher_background.xml");

            ZipFile.CreateFromDirectory(Function.getPath("androidcode/" + project.id + "/"), Function.getPath("androidcode/" + fileName));
            OssHelper.Instance.Upload(Function.getPath("androidcode/" + fileName));
            File.Delete(Function.getPath("androidcode/" + fileName));
            Directory.Delete(Function.getPath("androidcode/" + project.id + "/"), true);
            MakeAppCodePub.ProcessSet(ver.id);
        }

        public static void CopyFolder(string sourceDir, string destinationDir, bool move = false)
        {
            // 如果目标文件夹不存在，则创建
            if (!Directory.Exists(destinationDir))
            {
                Directory.CreateDirectory(destinationDir);
            }

            // 获取源文件夹中的所有文件并复制到目标文件夹
            foreach (string file in Directory.GetFiles(sourceDir, "*.*", SearchOption.AllDirectories))
            {
                string destFile = file.Replace(sourceDir, destinationDir);
                string destDir = Path.GetDirectoryName(destFile);

                // 如果目标文件夹不存在，则创建
                if (!Directory.Exists(destDir))
                {
                    Directory.CreateDirectory(destDir);
                }
                if(move)
                {
                    File.Move(file, destFile, true); // 如果目标文件已存在，则覆盖
                }
                else
                {
                    File.Copy(file, destFile, true); // 如果目标文件已存在，则覆盖
                }
            }

            // 获取源文件夹中的所有子文件夹并递归复制
            foreach (string dir in Directory.GetDirectories(sourceDir, "*.*", SearchOption.AllDirectories))
            {
                string destDir = dir.Replace(sourceDir, destinationDir);
                if (!Directory.Exists(destDir))
                {
                    Directory.CreateDirectory(destDir);
                }
            }
        }
        #endregion

        #region 替换包名

        public static void ReplaceAppPackage(string destinationDir, string AppPackage)
        {
            string[] paths = new string[] { "main", "androidTest", "test"};
            foreach(string path in paths)
            {
                string fromPath = destinationDir + "app/src/" + path + "/java/com/omega/omegamainbase/";
                string toPath = destinationDir + "app/src/" + path + "/java/" + AppPackage.Replace(".", "/") + "/";
                CopyFolder(fromPath, toPath, true);
                if (Directory.Exists(destinationDir + "app/src/" + path + "/java/com/omega/"))
                {
                    Directory.Delete(destinationDir + "app/src/" + path + "/java/com/omega/", true);
                }
                string[] fileList = Directory.GetFiles(destinationDir, "*.*", SearchOption.AllDirectories);
                foreach (string file in fileList)
                {
                    bool op = true;
                    if((file.Contains(".gradle/") && !file.EndsWith(".gradle")) || file.Contains(".idea/"))
                    {
                        op = false;
                    }
                    if(!file.EndsWith(".java") && !file.EndsWith(".xml") && !file.EndsWith(".gradle"))
                    {
                        op = false;
                    }
                    if(op)
                    {
                        string content = Function.ReadInstanceByFull(file);
                        content = content.Replace("com.omega.omegamainbase", AppPackage);
                        content = content.Replace("${PackageName}", AppPackage);
                        Function.WritePageFullPath(file.Substring(0, file.LastIndexOf("/")), file.Substring(file.LastIndexOf("/")), content);
                    }
                }
            }
        }

        public static string ReplaceFileContent(string filePath, string oldStr, string newStr)
        {
            string content = Function.ReadInstanceByFull(filePath);
            content = content.Replace(oldStr, newStr);
            Function.WritePageFullPath(filePath.Substring(0, filePath.LastIndexOf("/")), filePath.Substring(filePath.LastIndexOf("/")), content);
            return content;
        }

        public static string ReplaceFileContent(string filePath, Dictionary<string, string> replaceDict)
        {
            string content = Function.ReadInstanceByFull(filePath);
            foreach(var item in replaceDict)
            {
                content = content.Replace(item.Key, item.Value);
            }
            Function.WritePageFullPath(filePath.Substring(0, filePath.LastIndexOf("/")), filePath.Substring(filePath.LastIndexOf("/")), content);
            return content;
        }

        #endregion
    }
}