using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;

using IwbZero.AppServiceBase;
using IwbZero.Auditing;
using IwbZero.ToolCommon.Lambda;
using IwbZero.ToolCommon.StringModel;

using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Mvc;

using WeEngine.CommonDto.WeInfo;
using WeEngine.ComponentInfo;
using WeEngine.ModelInfo;

using WePlatform.Authorization;
using WePlatform.Configuration;
using WePlatform.WeBase;
using WePlatform.WeLib.Package.Dto;

namespace WePlatform.WeLib.Package
{
    [AbpAuthorize, AuditLog("方案包")]
    public class PackageAppService : IwbAsyncCrudAppService<PackageInfo, PackageDto, string, IwbPagedRequestDto, PackageCreateDto, PackageUpdateDto>, IPackageAppService
    {
        public PackageAppService(
            ICacheManager cacheManager,
            IRepository<PackageInfo, string> repository, IRepository<SceneFlowInfo, string> flowRepository, IRepository<SceneInfo, string> sceneRepository, IRepository<EnvironResourceRelatedInfo> errRepository, IRepository<BehaviorInfo, string> behaviorRepository, IRepository<BehaviorRelateRoleInfo> brrRepository, IRepository<GuideRelatedInfo> grRepository, IRepository<SceneBehaviorInfo> sbRepository, IRepository<BehaviorRoleInfo, string> behaviorRoleRepository, IRepository<PackageXmlInfo> xmlRepository, IRepository<GuideInfo, string> guideRepository, IRepository<BehaviorKnowledgeInfo> bkRepository) : base(repository, "Id")
        {
            FlowRepository = flowRepository;
            SceneRepository = sceneRepository;
            ErrRepository = errRepository;
            BehaviorRepository = behaviorRepository;
            BrrRepository = brrRepository;
            GrRepository = grRepository;
            SbRepository = sbRepository;
            BehaviorRoleRepository = behaviorRoleRepository;
            XmlRepository = xmlRepository;
            GuideRepository = guideRepository;
            BkRepository = bkRepository;
            CacheManager = cacheManager;
        }

        protected override bool KeyIsAuto { get; set; } = false;
        protected IRepository<SceneFlowInfo, string> FlowRepository { get; }
        protected IRepository<SceneInfo, string> SceneRepository { get; }
        protected IRepository<SceneBehaviorInfo> SbRepository { get; }
        protected IRepository<BehaviorInfo, string> BehaviorRepository { get; }
        protected IRepository<BehaviorRoleInfo, string> BehaviorRoleRepository { get; }
        protected IRepository<GuideInfo, string> GuideRepository { get; }
        protected IRepository<BehaviorRelateRoleInfo> BrrRepository { get; }
        protected IRepository<GuideRelatedInfo> GrRepository { get; }
        protected IRepository<EnvironResourceRelatedInfo> ErrRepository { get; }
        protected IRepository<PackageXmlInfo> XmlRepository { get; }
        protected IRepository<BehaviorKnowledgeInfo> BkRepository { get; }

        #region GetSelect

        [DisableAuditing]
        public override async Task<List<SelectListItem>> GetSelectList()
        {
            var list = await Repository.GetAllListAsync();
            var sList = new List<SelectListItem> { new SelectListItem { Text = @"请选择...", Value = "", Selected = true } };
            foreach (var l in list)
            {
                sList.Add(new SelectListItem { Value = l.Id, Text = l.PackageName });
            }
            return sList;
        }

        [DisableAuditing]
        public override async Task<string> GetSelectStr()
        {
            var list = await Repository.GetAllListAsync();
            string str = "<option value=\"\" selected>请选择...</option>";
            foreach (var l in list)
            {
                str += $"<option value=\"{l.Id}\">{l.PackageName}</option>";
            }
            return str;
        }

        #endregion GetSelect

        #region CURD

        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgCreate)]
        public override async Task Create(PackageCreateDto input)
        {
            input.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.PackageInfo);
            input.PackageState = PackageStateDefinition.New;
            await CreateEntity(input);
        }

        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgUpdate)]
        public override async Task Update(PackageUpdateDto input)
        {
            var entity = await Repository.FirstOrDefaultAsync(a => a.Id == input.Id);
            if (entity?.PackageState == PackageStateDefinition.Solidified)
            {
                CheckErrors("方案包已固化确认，不能再操作！");
                return;
            }
            await UpdateEntity(input);
            await CacheManager.GetCache(IwbCacheNames.PackageModelCache).RemoveAsync($"PM-{input.Id}");
        }

        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgDelete)]
        public override async Task Delete(EntityDto<string> input)
        {
            var entity = await Repository.FirstOrDefaultAsync(a => a.Id == input.Id);
            if (entity?.PackageState == PackageStateDefinition.Solidified)
            {
                CheckErrors($"方案包已固化确认，不能再操作！");
                return;
            }

            await base.Delete(input);
            await CacheManager.GetCache(IwbCacheNames.PackageModelCache).RemoveAsync($"PM-{input.Id}-0");
            await CacheManager.GetCache(IwbCacheNames.PackageModelCache).RemoveAsync($"PM-{input.Id}-1");
        }

        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgQuery)]
        public override async Task<PagedResultDto<PackageDto>> GetAll(IwbPagedRequestDto input)
        {
            var query = CreateFilteredQuery(input);
            //query = ApplyFilter(query, input);
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);
            query = ApplySorting(query, input);
            query = ApplyPaging(query, input);
            var entities = await AsyncQueryableExecuter.ToListAsync(query);
            var dtoList = new PagedResultDto<PackageDto>(totalCount, entities.Select(MapToEntityDto).ToList());
            return dtoList;
        }

        #region GetEntity/Dto

        /// <summary>
        ///  查询实体Dto
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgQuery)]
        public override async Task<PackageDto> GetDto(EntityDto<string> input)
        {
            var entity = await GetEntity(input);
            return MapToEntityDto(entity);
        }

        /// <summary>
        ///  查询实体Dto
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgQuery)]
        public override async Task<PackageDto> GetDtoById(string id)
        {
            var entity = await GetEntityById(id);
            return MapToEntityDto(entity);
        }

        /// <summary>
        /// 查询实体Dto（需指明自定义字段）
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgQuery)]
        public override async Task<PackageDto> GetDtoByNo(string no)
        {
            var entity = await GetEntityByNo(no);
            return MapToEntityDto(entity);
        }

        /// <summary>
        /// 查询实体
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgQuery)]
        public override async Task<PackageInfo> GetEntity(EntityDto<string> input)
        {
            var entity = await GetEntityById(input.Id);
            return entity;
        }

        /// <summary>
        /// 查询实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgQuery)]
        public override async Task<PackageInfo> GetEntityById(string id)
        {
            return await Repository.FirstOrDefaultAsync(a => a.Id == id);
        }

        /// <summary>
        /// 查询实体（需指明自定义字段）
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgQuery)]
        public override async Task<PackageInfo> GetEntityByNo(string no)
        {
            //CheckGetPermission();
            if (string.IsNullOrEmpty(KeyFiledName))
            {
                ThrowError("NoKeyFieldName");
            }
            return await base.GetEntityByNo(no);
        }

        #endregion GetEntity/Dto

        #region Hide

        /// <summary>
        /// 根据给定的<see cref="IwbPagedRequestDto"/>创建 <see cref="IQueryable{PackageInfo}"/>过滤查询.
        /// </summary>
        /// <param name="input">The input.</param>
        protected override IQueryable<PackageInfo> CreateFilteredQuery(IwbPagedRequestDto input)
        {
            var query = Repository.GetAllIncluding(a => a.SceneCategoryInfo);
            var pagedInput = input as IIwbPagedRequest;
            if (pagedInput == null)
            {
                return query;
            }
            if (!string.IsNullOrEmpty(pagedInput.KeyWords))
            {
                object keyWords = pagedInput.KeyWords;
                LambdaObject obj = new LambdaObject()
                {
                    FieldType = (LambdaFieldType)pagedInput.FieldType,
                    FieldName = pagedInput.KeyField,
                    FieldValue = keyWords,
                    ExpType = (LambdaExpType)pagedInput.ExpType
                };
                var exp = obj.GetExp<PackageInfo>();
                query = exp != null ? query.Where(exp) : query;
            }
            if (pagedInput.SearchList != null && pagedInput.SearchList.Count > 0)
            {
                List<LambdaObject> objList = new List<LambdaObject>();
                foreach (var o in pagedInput.SearchList)
                {
                    if (string.IsNullOrEmpty(o.KeyWords))
                        continue;
                    if (o.KeyField.ToLower() == "sceneCategory".ToLower())
                    {
                        query = query.Where(a => a.SceneCategoryInfo.CategoryPath.Contains(o.KeyWords));
                        continue;
                    }
                    object keyWords = o.KeyWords;
                    objList.Add(new LambdaObject
                    {
                        FieldType = (LambdaFieldType)o.FieldType,
                        FieldName = o.KeyField,
                        FieldValue = keyWords,
                        ExpType = (LambdaExpType)o.ExpType
                    });
                }
                var exp = objList.GetExp<PackageInfo>();
                query = exp != null ? query.Where(exp) : query;
            }
            return query;
        }

        //protected override IQueryable<PackageInfo> ApplySorting(IQueryable<PackageInfo> query, IwbPagedRequestDto input)
        //{
        //    return query.OrderBy(a => a.No);
        //}

        //protected override IQueryable<PackageInfo> ApplyPaging(IQueryable<PackageInfo> query, IwbPagedRequestDto input)
        //{
        //    if (input is IPagedResultRequest pagedInput)
        //    {
        //        return query.Skip(pagedInput.SkipCount).Take(pagedInput.MaxResultCount);
        //    }
        //    return query;
        //}

        #endregion Hide

        #endregion CURD

        /// <summary>
        /// 拷贝方案包
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgCopy), AuditLog("拷贝方案包")]
        public async Task Copy(EntityDto<string> input)
        {
            var entity = await Repository.FirstOrDefaultAsync(a => a.Id == input.Id);
            if (entity == null)
            {
                CheckErrors($"没有查询到编号为{input.Id}的方案包！");
            }

            var dto = MapToEntityDto(entity);
            var newEntity = ObjectMapper.Map<PackageInfo>(dto);
            newEntity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.PackageInfo);
            newEntity.PackageName = $"{newEntity.PackageName}_副本";
            newEntity.PackageState = PackageStateDefinition.New;
            await Repository.InsertAsync(newEntity);
        }

        /// <summary>
        /// 固化方案包
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgSolidify), AuditLog("固化方案包")]
        public async Task<bool> Solidify(SolidifyDto input)
        {
            var entity = await Repository.GetAllIncluding(a => a.EvalModelInfo).FirstOrDefaultAsync(a => a.Id == input.Id);
            if (entity == null)
            {
                CheckErrors($"没有查询到编号为{input.Id}的方案包！");
                return false;
            }
            if (entity.PackageState == PackageStateDefinition.Solidified)
            {
                CheckErrors($"情景流已固化确认，请勿重复操作！");
                return false;
            }

            var flag = await PackageVerify(input.Id);
            if (flag)
            {
                entity.PackageName = input.NewName.IsEmpty() ? entity.PackageName : input.NewName;
                entity.PackageState = PackageStateDefinition.Solidified;
                var xmlDto = await PackageFillXml(entity);
                var xmlEntity = await XmlRepository.FirstOrDefaultAsync(a => a.PackageNo == input.Id);
                if (xmlEntity == null)
                {
                    xmlEntity = ObjectMapper.Map<PackageXmlInfo>(xmlDto);
                    await XmlRepository.InsertAsync(xmlEntity);
                }
                else
                {
                    xmlEntity.PackageXml = xmlDto.PackageXml;
                    xmlEntity.FlowXml = xmlDto.FlowXml;
                    xmlEntity.SceneXml = xmlDto.SceneXml;
                    xmlEntity.BehaviorXml = xmlDto.BehaviorXml;
                    xmlEntity.GuideXml = xmlDto.GuideXml;
                    xmlEntity.EnvironResourceXml = xmlDto.EnvironResourceXml;
                    xmlEntity.ComponentXml = xmlDto.ComponentXml;
                    xmlEntity.AllRoles = xmlDto.AllRoles;
                    await XmlRepository.UpdateAsync(xmlEntity);
                }
            }

            return flag;
        }

        /// <summary>
        /// 固化方案包详情
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgDetail), AuditLog("固化方案包详情")]
        public async Task<PackageDetailDto> Detail(string no)
        {
            return await CacheManager.GetCache(IwbCacheNames.PackageCache).GetAsync($"PD_D-{no}", async () =>
            {
                var detail = await GetSolidifiedPackageDetail(no);
                detail.Flows = detail.Flows.IwbDistinct(a => a.Id).ToList();
                detail.Scenes = detail.Scenes.IwbDistinct(a => a.Id).ToList();
                detail.Behaviors = detail.Behaviors.IwbDistinct(a => a.Id).ToList();
                detail.Guides = detail.Guides.IwbDistinct(a => a.Id).ToList();
                detail.EnvironResources = detail.EnvironResources.IwbDistinct(a => a.Id).ToList();
                return detail;
            });
        }

        /// <summary>
        /// 获取方案包变量
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<ComponentVariable>> GetVariable(string no)
        {
            var list = new List<ComponentVariable>();
            if (no.IsEmpty())
            {
                return list;
            }
            var variableStr = (await Repository.FirstOrDefaultAsync(a => a.Id == no))?.Variable;

            var variableArr = variableStr?.Split(',');
            if (variableArr != null)
            {
                foreach (var v in variableArr)
                {
                    list.Add(new ComponentVariable(v));
                }
            }

            return list;
        }

        #region ROLE

        /// <summary>
        /// 设置考核角色
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AuditLog("设定考核角色")]
        public async Task SetAssessRole(AssessRoleDto input)
        {
            var entity = await Repository.FirstOrDefaultAsync(a => a.Id == input.Id);
            if (entity == null)
            {
                CheckErrors($"未查询到编号为【{input.Id}】的方案包！");
                return;
            }

            entity.AssessAuto = input.AssessAuto;
            entity.AssessRoleNos = input.AssessRoleNos;
            entity.AssessRoleNames = input.AssessRoleNames;
            await CacheManager.GetCache(IwbCacheNames.PackageModelCache).RemoveAsync($"PM-{entity.Id}");
            await Repository.UpdateAsync(entity);
        }

        /// <summary>
        /// 获取方案包角色
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing, AllowAnonymous]
        public async Task<AssessRoleDto> GetPackageRoles(string no)
        {
            if (no.IsEmpty())
            {
                CheckErrors("请确认方案包已保存后再进行角色配置！");
            }
            var entity = await Repository.GetAllIncluding(a => a.EvalModelInfo).FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckErrors($"未查询到编号为【{no}】的方案包！");
                return null;
            }
            var package = await GetPackageModel(entity);
            var roles = package.RoleInfos.OrderByDescending(a => a.RolePer).ToList();

            var dto = new AssessRoleDto()
            {
                AllRoles = roles,
                AllRoleNames = roles.Select(a => a.RoleName).ToList(),
                AssessRoleNames = entity.AssessRoleNames,
                AssessRoleNos = entity.AssessRoleNos,
                AssessAuto = entity.AssessAuto
            };
            return dto;
        }

        /// <summary>
        /// 获取方案包角色
        /// </summary>
        /// <param name="no"></param>
        /// <param name="roleModels"></param>
        /// <returns></returns>
        [DisableAuditing, AllowAnonymous]
        public async Task<List<WeRoleDto>> GetPackageRoleLists(string no, List<RoleModel> roleModels = null)
        {
            return await CacheManager.GetCache(IwbCacheNames.PackageModelCache).Get($"PR{no}", async () =>
            {
                if (roleModels != null)
                {
                    return roleModels.Select(a => new WeRoleDto(a.RoleNo, a.RoleName, a.RoleWeight, a.TotalWeight))
                        .ToList();
                }
                var names = (await XmlRepository.FirstOrDefaultAsync(a => a.PackageNo == no))?.AllRoles;
                var list = new List<WeRoleDto>();
                if (!string.IsNullOrEmpty(names))
                {
                    var arr = names.Split(',');
                    foreach (var s in arr)
                    {
                        list.Add(WeRoleDto.DtoFrom(s));
                    }
                }

                return list;
            });
        }

        #endregion ROLE

        #region 校验方案包

        /// <summary>
        /// 方案包验证
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<bool> PackageVerify(string no)
        {
            var entity = await Repository.GetAllIncluding(a => a.EvalModelInfo).FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckErrors($"没有查询到编号为{no}的方案包！");
                return false;
            }
            if (entity.AssessRoleNames.IsEmpty())
            {
                CheckErrors("没有检查到考核角色，请配置考核角色！");
                return false;
            }
            await CacheManager.GetCache(IwbCacheNames.PackageModelCache).RemoveAsync($"PM-{entity.Id}");
            var packageModel = await GetPackageModel(entity);
            if (packageModel.AssessRoles.IsEmpty())
            {
                CheckErrors("没有检查到考核角色，请配置考核角色！");
                return false;
            }
            if (packageModel.AssessRoleNos.IsEmpty())
            {
                CheckErrors("没有检查到考核角色，请配置考核角色！");
                return false;
            }

            var assessRoles = packageModel.AssessRoleNos.Split(',');
            decimal per = 0, minRolePer = 60;
            if (packageModel.RoleInfos?.Count > 0)
            {
                foreach (var roleNo in assessRoles)
                {
                    var role = packageModel.RoleInfos?.FirstOrDefault(a => a.RoleNo == roleNo);
                    per += role?.RolePer ?? 0;
                }

                if (per < minRolePer)
                {
                    CheckErrors($"设置的考核角色占比小于{minRolePer}%,请重新配置！");
                    return false;
                }
            }

            foreach (var child in packageModel.Children)
            {
                if (!CheckRound(child))
                {
                    return false;
                }
            }

            return true;
        }

        private bool CheckRound(RoundModel round)
        {
            if (round.Children != null && round.Children.Count > 0)
            {
                foreach (var child in round.Children)
                {
                    if (!CheckBlock(child))
                    {
                        return false;
                    }
                }
            }
            else
            {
                CheckErrors($"轮次{round.RoundIndex}没有配置情景块，请检查后再试！");
            }
            return true;
        }

        private bool CheckBlock(BlockModel block)
        {
            if (block.Children != null && block.Children.Count > 0)
            {
                foreach (var child in block.Children)
                {
                    if (!CheckFlow(child))
                    {
                        return false;
                    }
                }
            }
            else
            {
                CheckErrors($"情景块[{block.Path}]没有配置情景流，请检查后再试！");
            }
            return true;
        }

        private bool CheckFlow(SceneFlowModel flow)
        {
            if (flow.Children != null && flow.Children.Count > 0)
            {
                foreach (var child in flow.Children)
                {
                    if (!CheckFlowNode(child))
                    {
                        return false;
                    }
                }
            }
            else
            {
                CheckErrors($"情景流{flow.Path}没有配置节点，请检查后再试！");
            }
            return true;
        }

        private bool CheckFlowNode(FlowModel flow)
        {
            if (flow.SceneInfos?.Count <= 0)
            {
                CheckErrors($"情景节点{flow.Path}没有配置情景，请检查后再试！");
                return false;
            }
            if (flow.Children != null && flow.Children.Count > 0)
            {
                foreach (var child in flow.Children)
                {
                    if (!CheckFlowNode(child))
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        #endregion 校验方案包

        #region Package

        /// <summary>
        /// 保存方案包xml信息
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        private async Task<PackageXmlDto> PackageFillXml(PackageInfo entity)
        {
            var package = await GetPackageModel(entity);
            package.AssessAuto = entity.AssessAuto;
            package.AssessRoles = entity.AssessRoleNames;
            package.AssessRoleNos = entity.AssessRoleNos;
            package.VariableStr = entity.Variable;
            package.RoundScore = 0;
            package.AutoNextRound = false;
            var xmlDto = package.Package2Xml();
            xmlDto.PackageNo = entity.Id;
            return new PackageXmlDto(xmlDto);
        }

        /// <summary>
        /// 组建 方案包模型
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        private async Task<PackageModel> GetPackageModel(PackageInfo entity)
        {
            PackageModel model = await CacheManager.GetCache(IwbCacheNames.PackageModelCache).GetAsync($"PM-{entity.Id}",
                 async () =>
                 {
                     var package = entity.ContentInfo.Str2Obj<PackageModel>();
                     if (package != null)
                     {
                         package.No = package.No.IsEmpty() ? "P" : package.No;
                         var components = entity.ComponentInfo?.Str2Obj<List<EngineComponent>>();
                         package.Id = entity.Id;
                         package.AssessRoles = entity.AssessRoleNames;
                         package.AssessRoleNos = entity.AssessRoleNos;
                         package.Name = entity.PackageName;
                         package.VariableStr = entity.Variable;
                         package.EvalQualitativeExpression = entity.EvalModelInfo?.QualitativeExpression;
                         package.Components = components ?? new List<EngineComponent>();
                         package = await PackageFrom(package);
                     }

                     return package;
                 });

            return model;
        }

        /// <summary>
        /// 构建方案包
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        private async Task<PackageModel> PackageFrom(PackageModel model)
        {
            foreach (var round in model.Children)
            {
                round.GuideInfos = await QueryGuidesModel(round.Id);
                foreach (var block in round.Children)
                {
                    block.GuideInfos = await QueryGuidesModel(block.Id);
                    block.Children = new List<SceneFlowModel>();
                    var flowNoArr = block.FlowNos.IsEmpty() ? null : block.FlowNos.Split(',');
                    if (flowNoArr != null && flowNoArr.Length > 0)
                    {
                        foreach (var no in flowNoArr)
                        {
                            var flowEntity = await FlowRepository.GetAllIncluding(a => a.SceneCategoryInfo).Where(a => a.Id == no).FirstOrDefaultAsync();
                            if (flowEntity == null)
                            {
                                continue;
                            }
                            var flowComponents = flowEntity.ComponentInfo?.Str2Obj<List<EngineComponent>>() ?? new List<EngineComponent>();
                            foreach (var component in flowComponents)
                            {
                                if (model.Components.All(a => a.No != component.No))
                                {
                                    component.Id = component.No;
                                    model.Components.Add(component);
                                }
                            }

                            var sceneFlow = new SceneFlowModel()
                            {
                                Id = flowEntity.Id,
                                No = flowEntity.Id,
                                Name = flowEntity.FlowName,
                                SceneCategory = flowEntity.SceneCategory,
                                SceneCategoryName = flowEntity.SceneCategoryName,
                                Path = $"{block.Path}_{flowEntity.Id}",
                                ParentPath = $"{block.Path}",
                                GuideInfos = await QueryGuidesModel(no),
                                Children = new List<FlowModel>(),
                            };
                            var flowModel = flowEntity.ContentInfo.Str2Obj<FlowModel>();
                            flowModel.Id = flowEntity.Id;
                            flowModel.Name = flowEntity.FlowName;
                            flowModel.Path = $"{sceneFlow.Path}_{flowModel.No}";
                            flowModel.ParentPath = $"{sceneFlow.Path}";
                            flowModel = await FlowFrom(flowModel, model.Components);
                            flowModel.PreComponent = ConvertComponentStr(flowModel.PreComponent, model.Components);
                            flowModel.RunningComponent = ConvertComponentStr(flowModel.RunningComponent, model.Components);
                            flowModel.PostComponent = ConvertComponentStr(flowModel.PostComponent, model.Components);
                            sceneFlow.Children.Add(flowModel);
                            block.Children.Add(sceneFlow);
                        }
                    }
                }
            }
            return model;
        }

        /// <summary>
        /// 构建情景流
        /// </summary>
        /// <param name="model"></param>
        /// <param name="components"></param>
        /// <returns></returns>
        private async Task<FlowModel> FlowFrom(FlowModel model, List<EngineComponent> components)
        {
            model.SceneInfos = new List<SceneModel>();
            int i = 0;
            if (model.SceneNos.IsNotEmpty())
            {
                var sceneNoArr = model.SceneNos.Split(',');
                foreach (var sceneNo in sceneNoArr)
                {
                    i++;
                    var scene = await SceneRepository.GetAllIncluding(a => a.SceneCategoryInfo).Where(a => a.Id == sceneNo).FirstOrDefaultAsync();
                    if (scene == null)
                    {
                        continue;
                    }

                    var sceneModal = await SceneFrom(new SceneModel()
                    {
                        Id = scene.Id,
                        No = $"S{i}",
                        Path = $"{model.Path}_S{i}",
                        ParentPath = $"{model.Path}",
                        Name = scene.Name,
                        SceneCategory = scene.SceneCategory,
                        SceneCategoryName = scene.SceneCategoryInfo.CategoryName,
                        SceneType = scene.SceneType,
                        SceneTag = scene.SceneTag,
                        _description = scene.Description,
                        VariableStr = scene.Variable.IsEmpty() ? "" : $"{scene.Variable}",
                        GuideInfos = await QueryGuidesModel(sceneNo),
                        EnvironResources = await QueryEnvironResourcesModel(sceneNo, DataLibType.SceneInfo.ToInt()),
                        Children = new List<BehaviorModel>()
                    });
                    model.SceneInfos.Add(sceneModal);
                }
            }

            i = 1;
            foreach (var child in model.Children)
            {
                i++;
                child.No = child.No.IsEmpty() ? child.Id : child.No;
                child.ParentPath = model.Path;
                child.Path = $"{model.Path}_{child.No}";
                child.PreComponent = ConvertComponentStr(child.PreComponent, components);
                child.RunningComponent = ConvertComponentStr(child.RunningComponent, components);
                child.PostComponent = ConvertComponentStr(child.PostComponent, components);
                await FlowFrom(child, components);
            }

            return model;
        }

        private string ConvertComponentStr(string compStr, List<EngineComponent> components)
        {
            if (compStr.EndsWith("|") && components.Any(a => compStr.StartsWith(a.No)))
            {
                compStr += "已配置事务";
            }

            return compStr;
        }

        /// <summary>
        /// 构建情景
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        private async Task<SceneModel> SceneFrom(SceneModel model)
        {
            var behaviors = await SbRepository.GetAllIncluding(a => a.BehaviorInfo, a => a.BehaviorInfo.SceneCategoryInfo).Where(a => a.SceneNo == model.Id).Select(a =>
                     new BehaviorModel()
                     {
                         Id = a.BehaviorNo,
                         Name = a.BehaviorInfo.BehaviorName,
                         SceneCategory = a.BehaviorInfo.SceneCategory,
                         SceneCategoryName = a.BehaviorInfo.SceneCategoryInfo.CategoryName,
                         BehaviorTag = a.BehaviorInfo.BehaviorTag,
                         Description = a.BehaviorInfo.Description,
                         RuleKeyword = a.BehaviorInfo.RuleKeyword,
                         RoleLogicType = a.BehaviorInfo.RoleLogicType,
                         Weights = a.BehaviorWeight,
                         BehaviorScoreType = a.BehaviorEvalType,
                     }).ToListAsync();
            int i = 0;
            foreach (var behavior in behaviors)
            {
                i++;
                behavior.No = $"B{i}";
                behavior.Path = $"{model.Path}_{behavior.No}";
                behavior.ParentPath = $"{model.Path}";
                var roles = BrrRepository.GetAllIncluding(a => a.RoleInfo).Where(s => s.BehaviorNo == behavior.Id).ToList();
                behavior.BehaviorRoles = roles.Select(d => new RoleModel(d.RoleInfo.Id, d.RoleInfo.RoleName)).ToList();
                behavior.KnowledgeNos = string.Join(",", BkRepository.GetAll().Where(a => a.BehaviorNo == behavior.Id).Select(a => a.KnowledgeNo));
                behavior.GuideInfos = await QueryGuidesModel(behavior.Id);
                behavior.EnvironResources =
                    await QueryEnvironResourcesModel(behavior.Id, DataLibType.BehaviorInfo.ToInt());
            }
            model.Children.AddRange(behaviors);
            return model;
        }

        ///// <summary>
        ///// 固化方案包
        ///// </summary>
        ///// <param name="input"></param>
        ///// <returns></returns>
        //[AbpAuthorize(PermissionNames.PagesWePlayerMgPackageMgSolidify), AuditLog("强制固化方案包")]
        //public async Task EnforceSolidify(SolidifyDto input)
        //{
        //    var entity = await Repository.FirstOrDefaultAsync(a => a.Id == input.Id);
        //    if (entity == null)
        //    {
        //        CheckErrors($"没有查询到编号为{input.Id}的方案包！");
        //        return;
        //    }
        //    if (entity.PackageState == PackageStateDefinition.Solidified)
        //    {
        //        CheckErrors($"情景流已固化确认，请勿重复操作！");
        //        return;
        //    }

        //    entity.PackageName = input.NewName.IsEmpty() ? entity.PackageName : input.NewName;
        //    entity.PackageState = PackageStateDefinition.Solidified;
        //    var xmlDto = await PackageFillXml(entity);
        //    var xmlEntity = await XmlRepository.FirstOrDefaultAsync(a => a.PackageNo == input.Id);
        //    if (xmlEntity == null)
        //    {
        //        xmlEntity = ObjectMapper.Map<PackageXmlInfo>(xmlDto);
        //        await XmlRepository.InsertAsync(xmlEntity);
        //    }
        //    else
        //    {
        //        ObjectMapper.Map(xmlEntity, xmlDto);
        //        await XmlRepository.UpdateAsync(xmlEntity);
        //    }
        //    await Repository.UpdateAsync(entity);
        //}

        /// <summary>
        /// 获取固化方案包详情
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<PackageDetailDto> GetSolidifiedPackageDetail(string no)
        {
            var detail = await CacheManager.GetCache(IwbCacheNames.PackageCache + "_S").GetAsync($"PD-{no}", async () =>
               {
                   var xmlEntity = await XmlRepository.GetAllIncluding(a => a.PackageInfo)
                       .FirstOrDefaultAsync(a => a.PackageNo == no);
                   if (xmlEntity == null)
                   {
                       CheckErrors($"未查询到编号为【{no}】的方案包详情，请确认方案包已固化！");
                       return null;
                   }
                   var weXmlDto = new WePackageXmlDto()
                   {
                       PackageXml = xmlEntity.PackageXml,
                       FlowXml = xmlEntity.FlowXml,
                       SceneXml = xmlEntity.SceneXml,
                       BehaviorXml = xmlEntity.BehaviorXml,
                       GuideXml = xmlEntity.GuideXml,
                       EnvironResourceXml = xmlEntity.EnvironResourceXml,
                       ComponentXml = xmlEntity.ComponentXml,
                       AllRoles = xmlEntity.AllRoles
                   };
                   var packageModel = new PackageModel().BuildPackageModelByXml(weXmlDto);
                   var dto = new PackageDetailDto
                   {
                       PackageNo = no,
                       Detail = ObjectMapper.Map<PackageDto>(xmlEntity.PackageInfo),
                       Flows = packageModel.AllFlowModels,
                       Scenes = packageModel.AllSceneModels,
                       Behaviors = packageModel.AllBehaviorModels,
                       Guides = packageModel.AllGuideModels,
                       Components = new EngineComponent().BuildByXml(xmlEntity.ComponentXml),
                       EnvironResources = packageModel.AllEnvironResourceModels,
                       AllRoles = await GetPackageRoleLists(no, packageModel.RoleInfos)
                   };

                   var roleNos = xmlEntity.PackageInfo.AssessRoleNames?.StrToArray() ?? new string[0];
                   dto.AssessRoleNames = string.Join(",", dto.AllRoles.Where(a => roleNos.Any(s => s.StartsWith(a.RoleName + "("))).Select(d => d.RoleName).ToArray());
                   return dto;
               });

            return detail;

            //var xmlEntity = await XmlRepository.GetAllIncluding(a => a.PackageInfo)
            //    .FirstOrDefaultAsync(a => a.PackageNo == no);
            //if (xmlEntity == null)
            //{
            //    CheckErrors($"未查询到编号为【{no}】的方案包详情，请确认方案包已固化！");
            //    return null;
            //}
            //var weXmlDto = new WePackageXmlDto()
            //{
            //    PackageXml = xmlEntity.PackageXml,
            //    FlowXml = xmlEntity.FlowXml,
            //    SceneXml = xmlEntity.SceneXml,
            //    BehaviorXml = xmlEntity.BehaviorXml,
            //    GuideXml = xmlEntity.GuideXml,
            //    EnvironResourceXml = xmlEntity.EnvironResourceXml,
            //    ComponentXml = xmlEntity.ComponentXml,
            //    AllRoles = xmlEntity.AllRoles
            //};
            //var packageModel = new PackageModel().BuildPackageModelByXml(weXmlDto);
            //var dto = new PackageDetailDto
            //{
            //    PackageNo = no,
            //    Detail = ObjectMapper.Map<PackageDto>(xmlEntity.PackageInfo),
            //    Flows = packageModel.AllFlowModels,
            //    Scenes = packageModel.AllSceneModels,
            //    Behaviors = packageModel.AllBehaviorModels,
            //    Guides = packageModel.AllGuideModels,
            //    Components = new EngineComponent().BuildByXml(xmlEntity.ComponentXml),
            //    EnvironResources = packageModel.AllEnvironResourceModels,
            //    AllRoles = await GetPackageRoleLists(no, packageModel.RoleInfos)
            //};

            //var roleNos = xmlEntity.PackageInfo.AssessRoleNames?.StrToArray() ?? new string[0];
            //dto.AssessRoleNames = string.Join(",", dto.AllRoles.Where(a => roleNos.Any(s => s.StartsWith(a.RoleName + "("))).Select(d => d.RoleName).ToArray());
            //return dto;
        }

        //private async Task<BehaviorRoleInfo> GetBehaviorRoleInfo(string roleNo)
        //{
        //    return await CacheManager.GetCache(IwbCacheNames.BehaviorRoleCache).GetAsync(roleNo,
        //        async () =>
        //        {
        //            var r = await BehaviorRoleRepository.FirstOrDefaultAsync(a =>
        //                a.Id == roleNo);
        //            return r;
        //        });
        //}

        #endregion Package

        #region Guide

        /// <summary>
        /// 查询关联的引导信息
        /// </summary>
        /// <param name="relatedNo"></param>
        /// <returns></returns>
        private async Task<List<GuideModel>> QueryGuidesModel(string relatedNo)
        {
            var guides = await GrRepository.GetAllIncluding(a => a.GuideInfo).Where(s => s.RelatedNo == relatedNo).Select(a => a.GuideInfo).ToListAsync();
            return guides.Select(GuideModelFrom).ToList();
        }

        private GuideModel GuideModelFrom(GuideInfo entity)
        {
            if (entity == null)
            {
                return null;
            }

            return new GuideModel()
            {
                Id = entity.Id,
                Name = entity.Name,
                GuideType = entity.GuideType,
                Description = entity.Description
            };
        }

        #endregion Guide

        #region EnvironResource

        /// <summary>
        /// 查询关联的引导信息
        /// </summary>
        /// <param name="relatedNo"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private async Task<List<EnvironResourceModel>> QueryEnvironResourcesModel(string relatedNo, int type)
        {
            var entities = await ErrRepository.GetAllIncluding(a => a.EnvironResourceInfo)
                .Where(a => a.RelatedNo == relatedNo && a.RelatedType == type).Select(a => a.EnvironResourceInfo
                    ).ToListAsync();
            return entities.Select(EnvironResourceModelFrom).ToList();
        }

        private EnvironResourceModel EnvironResourceModelFrom(EnvironResourceInfo entity)
        {
            if (entity == null)
            {
                return null;
            }

            return new EnvironResourceModel()
            {
                Id = entity.Id,
                ResourceName = entity.ResourceName,
                ResourcePath = entity.ResourcePath,
                ResourceType = entity.ResourceType,
                MessageCode = entity.MessageCode,
                Description = entity.Description,
            };
        }

        #endregion EnvironResource
    }
}