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

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

using IwbZero.AppServiceBase;
using IwbZero.ToolCommon.LogHelpers;
using IwbZero.ToolCommon.StringModel;

using WeEngine.ModelInfo;
using WeEngine.Packages;

using WeOnlineApp.Authorization.Users;
using WeOnlineApp.BaseInfo;
using WeOnlineApp.BaseSystem.Query.Dto;
using WeOnlineApp.BaseSystem.Users.Dto;
using WeOnlineApp.Basic;
using WeOnlineApp.Configuration;
using WeOnlineApp.Configuration.Cache;
using WeOnlineApp.TrainingCamp;
using WeOnlineApp.TrainingCamp.Dto;
using WeOnlineApp.TrainingCampPlay.Dto;

#pragma warning disable CS4014

namespace WeOnlineApp.BaseSystem.Query
{
    [AllowAnonymous, DisableAuditing]
    public class QueryAppService : IwbAppServiceBase, IQueryAppService
    {
        #region 仓储

        public QueryAppService(
            IRepository<User, long> userRepository, IRepository<CampInfo, string> campRepository, IRepository<CampPlayInfo, string> playRepository, ICacheManager cacheManager, IRepository<CampPlayScoreInfo> psRepository, IRepository<CampPlayLogInfo> plRepository, IRepository<CampSceneMapInfo> sceneMapRepository, IRepository<SysAttachFile> attachRepository, IRepository<SubjectCategoryInfo, string> scRepository)
        {
            UserRepository = userRepository;
            CampRepository = campRepository;
            PlayRepository = playRepository;
            PsRepository = psRepository;
            PlRepository = plRepository;
            SceneMapRepository = sceneMapRepository;
            AttachRepository = attachRepository;
            ScRepository = scRepository;
            CacheManager = cacheManager;
        }

        private string DataCenterUrl => SettingManager.GetSettingValue(IwbSettingNames.WeDataCenterIp).Ew("/");

        protected IRepository<User, long> UserRepository { get; }
        protected IRepository<SubjectCategoryInfo, string> ScRepository { get; }
        protected IRepository<CampInfo, string> CampRepository { get; }
        protected IRepository<CampPlayInfo, string> PlayRepository { get; }

        protected IRepository<CampPlayScoreInfo> PsRepository { get; }
        protected IRepository<CampPlayLogInfo> PlRepository { get; }

        protected IRepository<CampSceneMapInfo> SceneMapRepository { get; }
        protected IRepository<SysAttachFile> AttachRepository { get; }

        #endregion 仓储

        #region SELECT

        #region 课程类别

        [DisableAuditing]
        public async Task<List<SelectListItem>> GetCategorySelectList()
        {
            var list = await ScRepository.GetAllListAsync(a => a.ParentNo != null);
            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.CategoryName });
            }
            return sList;
        }

        [DisableAuditing]
        public async Task<string> GetCategorySelectStr()
        {
            var list = await ScRepository.GetAllListAsync();
            string str = "";//"<option  value=\"\" selected >请选择课程类别...</option>";
            var tempParentNo = list.FirstOrDefault(a => a.ParentNo == null)?.Id ?? "";
            foreach (var l in list)
            {
                var name = l.CategoryName;
                var parentNo = l.ParentNo;
                var id = l.Id;
                if (l.ParentNo == null)
                {
                    parentNo = "0";
                    id = "";
                    name = "请选择课程类别";
                }
                else if (l.ParentNo == tempParentNo)
                {
                    parentNo = "";
                }
                str += $"<option parent=\"{parentNo}\" value=\"{id}\">{name}</option>";
            }
            return str;
        }

        #endregion 课程类别

        #region 用户

        [DisableAuditing]
        public async Task<List<SelectListItem>> GetUserSelectList()
        {
            var list = await UserRepository.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.Name });
            }
            return sList;
        }

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

        //[DisableAuditing]
        //public async Task<string> GetCategorySelectStr()
        //{
        //    var list = await CategoryRepository.GetAllListAsync();
        //    string str = "";//"<option  value=\"\" selected >请选择类别...</option>";
        //    var tempParentNo = list.FirstOrDefault(a => a.ParentNo == null)?.Id ?? "";
        //    foreach (var l in list)
        //    {
        //        var name = l.CategoryName;
        //        var parentNo = l.ParentNo;
        //        var id = l.Id;
        //        if (l.ParentNo == null)
        //        {
        //            parentNo = "0";
        //            id = "";
        //            name = "请选择类别";
        //        }
        //        else if (l.ParentNo == tempParentNo)
        //        {
        //            parentNo = "";
        //        }
        //        str += $"<option parent=\"{parentNo}\" value=\"{id}\">{name}</option>";
        //    }
        //    return str;
        //}

        #endregion 用户

        #region CAMP

        public async Task<List<SelectListItem>> GetCampStateSelectList()
        {
            var list = await StatesManager.GetSelectListAsync("Camp", "State");
            return list;
        }

        public async Task<string> GetCampStateSelectStr()
        {
            var str = await StatesManager.GetSelectListStrAsync("Camp", "State");
            str = "<option  value=\"\" selected >请选择培训营状态.</option>" + str;
            return str;
        }

        public async Task<string> GetCampStateSelectStr(params string[] states)
        {
            var str = await StatesManager.GetSelectListStrAsync("Camp", "State", a => states.Contains(a.CodeValue));
            str = "<option  value=\"\" selected >请选择培训营状态.</option>" + str;
            return str;
        }

        public async Task<string> GetCanUseCampSelectStr()
        {
            var list = await CampRepository.GetAllListAsync(a => a.CampState == CampStateDefinition.Active);
            var str = "<option  value=\"\" selected >请选择演练培训营...</option>";
            foreach (var l in list)
            {
                str += $"<option  value=\"{l.Id}\"  >{l.Name}</option>";
            }
            return str;
        }

        public async Task<string> GetCampSelectStr(params int[] states)
        {
            var list = await CampRepository.GetAllListAsync(a => states.Contains(a.CampState));
            var str = "<option  value=\"\" selected >请选择演练培训营...</option>";
            foreach (var l in list)
            {
                str += $"<option  value=\"{l.Id}\"  >{l.Name}</option>";
            }
            return str;
        }

        #endregion CAMP

        #endregion SELECT

        /// <summary>
        /// 查询用户信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<PagedResultDto<UserDto>> QueryUsers(IwbPagedRequestDto input)
        {
            var query = UserRepository.GetAll().Where(a => a.IsActive);
            query = ApplyFilter(query, input);
            var totalCount = await query.CountAsync();
            query = query.OrderBy(a => a.Id);
            query = query.Skip(input.SkipCount).Take(input.MaxResultCount);
            var entities = await query.ToListAsync();
            var dtoList = new PagedResultDto<UserDto>(totalCount, ObjectMapper.Map<List<UserDto>>(entities));
            return dtoList;
        }

        /// <summary>
        /// 查询用户信息
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        private User QueryUserInfo(long id)
        {
            return CacheManager.GetCache(IwbCacheNames.UserInfoCache).Get($"{id}", () =>
          {
              var user = UserRepository.FirstOrDefault(a => a.Id == id);
              return user;
          });
        }

        /// <summary>
        /// 查询课程根据类别
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<PlayDto>> QueryCampBySc(string no)
        {
            var nowDate = DateTime.Now.Date;
            var camp = await CampRepository.GetAllIncluding(a => a.Subject).Where(a => string.IsNullOrEmpty(no) || (a.Subject.CategoryPath).Contains(no))
                .Where(a => a.CampState == CampStateDefinition.Active && a.StartDate <= nowDate && a.EndDate >= nowDate)
                .Select(a => new PlayDto()
                {
                    Id = a.Id,
                    CampName = a.Name,
                    PackageName = a.PackageName,
                    MaxTrainingMinute = a.MaxTrainingMinute,
                    SubjectPoint = a.SubjectPoint,
                    EndDate = a.EndDate
                }).ToListAsync();
            return camp;
        }

        /// <summary>
        /// 查询可用训练营
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<PlayDto>> QueryCanUseCamp()
        {
            var nowDate = DateTime.Now.Date;
            var camp = await CampRepository.GetAll()
                .Where(a => a.CampState == CampStateDefinition.Active && a.StartDate <= nowDate && a.EndDate >= nowDate)
                .Select(a => new PlayDto()
                {
                    Id = a.Id,
                    CampName = a.Name,
                    PackageName = a.PackageName,
                    MaxTrainingMinute = a.MaxTrainingMinute,
                    SubjectPoint = a.SubjectPoint,
                    EndDate = a.EndDate ?? DateTime.Now.AddDays(10)
                }).ToListAsync();
            return camp;
        }

        /// <summary>
        /// 查询可加入训练营
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<PlayDto>> QueryCanJoinCamp()
        {
            var camp = await PlayRepository.GetAllIncluding(a => a.CampInfo).Where(a => a.PlayModel == CampPlayModelDefinition.Team && a.PlayState == CampPlayStateDefinition.New)
                .Select(a => new PlayDto()
                {
                    Id = a.Id,
                    Name = a.Name,
                    CampName = a.CampInfo.Name,
                    PackageName = a.CampInfo.PackageName,
                    MaxTrainingMinute = a.CampInfo.MaxTrainingMinute,
                    IsPublic = a.IsPublic
                }).ToListAsync();
            return camp;
        }

        /// <summary>
        /// 查询演练详情
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<CampPlayDto> QueryPlay(string no)
        {
            var camp = await PlayRepository.GetAll()
                .Select(a => new CampPlayDto()
                {
                    Id = a.Id,
                    Name = a.Name,
                    CampNo = a.CampNo,
                    PlayRoleNames = a.PlayRoleNames,
                    IsPublic = a.IsPublic,
                    InvitationCode = a.InvitationCode,
                    PlayModel = a.PlayModel,
                    PlayState = a.PlayState,
                    RoundIndex = a.RoundIndex,
                    StartDate = a.StartDate,
                    EndDate = a.EndDate
                }).FirstOrDefaultAsync(a => a.Id == no);
            return camp;
        }

        /// <summary>
        /// 查询演练详情
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<CampDto> QueryCampWithStudy(string no)
        {
            var camp = await CampRepository.GetAll()
                .Select(a => new CampDto()
                {
                    Id = a.Id,
                    Name = a.Name,
                    PackageName = a.PackageName,
                    MaxTrainingMinute = a.MaxTrainingMinute,
                    AssessRoleNames = a.AssessRoleNames,
                    Description = a.Description,
                    Purposes = a.Purposes,
                    Organizer = a.Organizer,
                    ContactInfo = a.ContactInfo,
                    StartDate = a.StartDate,
                    EndDate = a.EndDate,
                    SubjectPoint = a.SubjectPoint,
                    StudyContent = a.StudyContent
                }).FirstOrDefaultAsync(a => a.Id == no);
            return camp;
        }

        /// <summary>
        /// 预加载
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task LoadPackagePre(int type)
        {
            if (type != 0)
            {
                CacheMangerEx.HasLoadPackageCache = true;
            }

            await CacheManager.LoadPackageInfos(DataCenterUrl);
        }

        /// <summary>
        /// 预加载
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task LoadCampPre(string no, int type)
        {
            var camp = await CampRepository.GetAll().Select(a => new CampDto { Id = a.Id, PackageNo = a.PackageNo }).FirstOrDefaultAsync(a => a.Id == no);
            if (camp != null)
            {
                await Task.Run(() => { CacheManager.GetPackageDetail(camp.PackageNo, DataCenterUrl); });
                if (type != 0)
                {
                    await Task.Run(() => { CacheManager.GetPackageDataNode(camp.PackageNo, DataCenterUrl); });
                }
            }
        }

        /// <summary>
        /// 查询训练营详情
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<CampDto> QueryCamp(string no)
        {
            var camp = await CampRepository.GetAll()
                .Select(a => new CampDto()
                {
                    Id = a.Id,
                    Name = a.Name,
                    PackageNo = a.PackageNo,
                    PackageName = a.PackageName,
                    MaxTrainingMinute = a.MaxTrainingMinute,
                    AssessRoleNames = a.AssessRoleNames,
                    Description = a.Description,
                    Purposes = a.Purposes,
                    Organizer = a.Organizer,
                    ContactInfo = a.ContactInfo,
                    StartDate = a.StartDate,
                    EndDate = a.EndDate,
                    SubjectPoint = a.SubjectPoint
                }).FirstOrDefaultAsync(a => a.Id == no);
            //if (camp != null)
            //{
            //    try
            //    {
            //        new TaskFactory().StartNew(() => { CacheManager.GetPackageDetail(camp.PackageNo, DataCenterUrl); });
            //    }
            //    catch
            //    {
            //        //
            //    }
            //}
            return camp;
        }

        /// <summary>
        /// 查询训练营详情
        /// </summary>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<CampDto> QueryCampByPlay(string no)
        {
            var camp = await PlayRepository.GetAllIncluding(a => a.CampInfo).Where(a => a.Id == no)
                .Select(a => new CampDto()
                {
                    Id = a.CampInfo.Id,
                    Name = a.CampInfo.Name,
                    PackageName = a.CampInfo.PackageName,
                    MaxTrainingMinute = a.CampInfo.MaxTrainingMinute,
                    AssessRoleNames = a.CampInfo.AssessRoleNames,
                    Description = a.CampInfo.Description,
                    Purposes = a.CampInfo.Purposes,
                    Organizer = a.CampInfo.Organizer,
                    ContactInfo = a.CampInfo.ContactInfo,
                    StartDate = a.StartDate,
                    EndDate = a.EndDate
                }).FirstOrDefaultAsync();
            return camp;
        }

        /// <summary>
        /// 查询演练运行信息
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<PackageDataNode> GetPlayRunningInfo(string no)
        {
            return await CacheManager.GetGroupRunningInfoAsync(no, PlayRepository);
        }

        /// <summary>
        /// 查询当前情景的处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<PlayRoleLogDto>> GetCurrentSceneLog(string no)
        {
            var playInfo = await GetPlayDto(no);
            if (playInfo == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var query = PlRepository.GetAll().Where(a =>
                    a.PlayNo == no && a.LogType == LogTypeDefinition.SceneOperation &&
                    a.RoundIndex == playInfo.RoundIndex &&
                    (a.LogState == LogStateDefinition.New || a.LogState == LogStateDefinition.Submit ||
                     a.LogState == LogStateDefinition.HasMatch))
                .OrderByDescending(a => a.Id).Select(a => new PlayRoleLogDto()
                {
                    Id = a.Id,
                    Play = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState,
                    ScenePath = a.ScenePath
                });
            var dtoList = (await query.ToListAsync()).Select(MapLogDto).ToList();
            return dtoList;
        }

        /// <summary>
        /// 查询培训营分组的处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<PlayRoleLogDto>> GetPlayLogs(string no)
        {
            var playInfo = await GetPlayDto(no);
            if (playInfo == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var query = PlRepository.GetAll()
                .Where(a => a.PlayNo == no && a.LogType == LogTypeDefinition.SceneOperation)
                .OrderByDescending(a => a.Id).Select(a => new PlayRoleLogDto()
                {
                    Id = a.Id,
                    Play = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState,
                    UserId = a.UserId,
                    ScenePath = a.ScenePath
                });
            var dtoList = (await query.ToListAsync()).Select(MapLogDto).ToList();
            return dtoList;
        }

        /// <summary>
        /// 查询培训营分组的处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<PlayRoleLogDto>> GetPlayChats(string no)
        {
            var playInfo = await GetPlayDto(no);
            if (playInfo == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var query = PlRepository.GetAll()
                .Where(a => a.PlayNo == no && a.LogType == LogTypeDefinition.Comment && a.LogCommand == LogCommandDefinition.Chat)
                .OrderBy(a => a.CreationTime).Select(a => new PlayRoleLogDto()
                {
                    Id = a.Id,
                    Play = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState,
                    UserId = a.UserId,
                    UserName = a.UserName,
                    LogDate = a.CreationTime
                });
            var dtoList = (await query.ToListAsync()).Select(MapLogDto).ToList();
            return dtoList;
        }

        public PlayRoleLogDto MapLogDto(PlayRoleLogDto input)
        {
            var user = QueryUserInfo(input.UserId);
            if (user != null)
            {
                input.Name = user.Name;
                input.ImagePath = user.ImagePath;
            }

            return input;
        }

        /// <summary>
        /// 获取分组情景
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<SceneDto>> GetPlayScenes(string no)
        {
            var playInfo = await GetPlayDto(no);
            if (playInfo == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            List<SceneDto> list = new List<SceneDto>();
            var sceneNoDto = (ScenePathDto)(await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetOrDefaultAsync($"SceneNos-{no}"));
            if (sceneNoDto != null)
            {
                list = (List<SceneDto>)await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetOrDefaultAsync($"SceneInfos-{no}");
                if (sceneNoDto.hasChange || list == null || list.Count == 0)
                {
                    sceneNoDto.hasChange = false;
                    await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneNos-{no}", sceneNoDto);
                    list = new List<SceneDto>();
                    foreach (var sNo in sceneNoDto.PathList)
                    {
                        var scene = await GetPlaySceneInfo_Last(no, sNo);
                        if (scene != null)
                        {
                            list.Add(scene);
                        }
                    }

                    if (list.Any())
                    {
                        list = list.OrderBy(a => a.Path.Substring(0, 4)).ThenBy(a => a.Path.Length).ToList();
                    }
                    await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneInfos-{no}", list);
                }
            }
            else
            {
                var runGroupInfo = await CacheManager.GetGroupRunningInfoAsync(no, PlayRepository);
                if (runGroupInfo == null)
                {
                    return list;
                }

                var runRounds = runGroupInfo.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                if (runRounds != null)
                    foreach (var r in runRounds)
                    {
                        var runBlocks = r.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                        if (runBlocks != null)
                            foreach (var b in runBlocks)
                            {
                                var runFlows = b.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                                if (runFlows != null)
                                    foreach (var f in runFlows)
                                    {
                                        var runNodes = f.Children?.Where(a => a.IsStart).OrderBy(a => a.Id);
                                        if (runNodes != null)
                                            foreach (var node in runNodes)
                                            {
                                                list = await GetSceneFromNode(list, node, no, playInfo.CampNo);
                                            }
                                    }
                            }
                    }

                if (list.Any())
                {
                    list = list.OrderBy(a => a.Path.Substring(0, 4)).ThenBy(a => a.Path.Length).ToList();
                    sceneNoDto = new ScenePathDto()
                    {
                        hasChange = false,
                        PathList = list.Select(a => a.Id).ToList()
                    };
                    await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneNos-{no}", sceneNoDto);
                    await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneInfos-{no}", list);
                }
            }
            if (list.Any())
            {
                list = list.OrderByDescending(a => a.HasEnd).ToList();
            }

            return list;
        }

        public async Task<CampPlayDto> GetPlayDto(string no)
        {
            var playInfo = await PlayRepository.GetAllIncluding(a => a.CampInfo).Select(a => new CampPlayDto
            {
                Id = a.Id,
                Name = a.Name,
                StartDate = a.StartDate,
                EndDate = a.EndDate,
                CampNo = a.CampNo,
                CampName = a.CampInfo.Name,
                RoundIndex = a.RoundIndex,
                InvitationCode = a.InvitationCode,
                IsPublic = a.IsPublic,
                PlayState = a.PlayState,
                PlayRoleNames = a.PlayRoleNames,
                TrainingMinute = a.TrainingMinute,
                PlayModel = a.PlayModel,
            }).FirstOrDefaultAsync(a => a.Id == no);
            return playInfo;
        }

        /// <summary>
        /// 提取情景节点中的情景信息
        /// </summary>
        /// <param name="list"></param>
        /// <param name="node"></param>
        /// <param name="playNo"></param>
        /// <param name="campNo"></param>
        /// <returns></returns>
        private async Task<List<SceneDto>> GetSceneFromNode(List<SceneDto> list, FlowNodeDataNode node, string playNo, string campNo)
        {
            if (node.SceneNodes != null)
            {
                foreach (var scene in node.SceneNodes)
                {
                    //var dto = await GetSceneInfo(playNo, campNo, scene);
                    //var dto = await GetPlaySceneInfo(playNo, scene.Id);
                    var dto = await GetPlaySceneInfo_Last(playNo, scene.Path);
                    if (dto != null)
                    {
                        dto.HasEnd = scene.IsEnd;
                        list.Add(dto);
                    }
                }
            }
            var runChild = node.Children?.FirstOrDefault(a => a.IsStart);
            if (runChild != null)
            {
                list = await GetSceneFromNode(list, runChild, playNo, campNo);
            }

            return list;
        }

        private async Task<SceneDto> GetSceneInfo(string no, string campNo, SceneDataNode runScene)
        {
            return await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetAsync($"{no}-{runScene.Id}",
              async () =>
              {
                  try
                  {
                      var detail = await CacheManager.GetCampPackageDetail(campNo, DataCenterUrl, CampRepository);
                      var scene = detail?.Scenes.FirstOrDefault(a => a.Id == runScene.Id);
                      if (scene == null)
                      {
                          return null;
                      }

                      var dto = scene.Obj2String().Str2Obj<SceneDto>();
                      var runGroupInfo = await CacheManager.GetGroupRunningInfoAsync(no, PlayRepository);
                      if (runGroupInfo == null)
                      {
                          return null;
                      }
                      dto.HasEnd = runScene.IsEnd;
                      dto.Variables = dto.Variables.MergeHashtable(runScene.GetVariables());
                      var gList = new List<GuideModel>();
                      if (scene.GuideNos.IsNotEmpty())
                      {
                          var arr = scene.GuideNos.Split(',');
                          foreach (var gNo in arr)
                          {
                              var g = detail.Guides?.FirstOrDefault(a => a.Id == gNo);
                              if (g != null)
                              {
                                  gList.Add(g);
                              }
                          }
                      }
                      dto.GuideInfos = gList;
                      var attachList =
                          await CacheManager.GetSceneAttaches(campNo, runScene.Id, SceneMapRepository, AttachRepository);
                      dto.Attaches = attachList;
                      return dto;
                  }
                  catch (Exception e)
                  {
                      this.LogError(e);
                  }
                  return null;
              });
        }

        /// <summary>
        /// 查询情景（缓存中未结束的重新查询）
        /// </summary>
        /// <param name="no"></param>
        /// <param name="scenePath"></param>
        /// <returns></returns>
        private async Task<SceneDto> GetPlaySceneInfo_Last(string no, string scenePath)
        {
            //return await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetAsync($"{no}-{sceneNo}-end", async () =>
            //{
            //});
            var dto = CacheManager.GetCache(IwbCacheNames.SceneInfoCache)
                .Get($"{no}-{scenePath}-end", () => default(SceneDto));
            if (dto == null)
            {
                await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).RemoveAsync($"{no}-{scenePath}");
                dto = await GetPlaySceneInfo(no, scenePath);
            }
            return dto;
        }

        [DisableAuditing, AbpAllowAnonymous]
        [WrapResult(false)]
        public Task<SceneDto> GetSceneInfo(string no, string sceneNo)
        {
            return GetPlaySceneInfo(no, sceneNo);
        }

        /// <summary>
        /// 查询情景信息
        /// </summary>
        /// <param name="no"></param>
        /// <param name="scenePath"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<SceneDto> GetPlaySceneInfo(string no, string scenePath)
        {
            var playCampNo = await PlayRepository.GetAll().Where(a => a.Id == no).Select(a => a.CampNo)
                .FirstOrDefaultAsync();
            if (playCampNo == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var sceneDto = await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetAsync($"{no}-{scenePath}",
                async () =>
                {
                    SceneDto dto = null;
                    try
                    {
                        var detail = await CacheManager.GetCampPackageDetail(playCampNo, DataCenterUrl, CampRepository);
                        var scene = detail?.Scenes.FirstOrDefault(a => a.Path == scenePath);
                        if (scene == null)
                        {
                            return null;
                        }
                        dto = scene.Obj2String().Str2Obj<SceneDto>();
                        //var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, PlayRepository);
                        //var runScene = runGroupInfo.RunSceneInfos.FirstOrDefault(a => a.Path == scene.Path);
                        var runScene = await GetRunScene(no, scene);
                        if (runScene != null)
                        {
                            dto.HasEnd = runScene.IsEnd;
                            dto.Variables = dto.Variables.MergeHashtable(runScene.GetVariables());
                        }
                        var gList = new List<GuideModel>();
                        if (scene.GuideNos.IsNotEmpty())
                        {
                            var arr = scene.GuideNos.Split(',');
                            foreach (var gNo in arr)
                            {
                                var g = detail.Guides?.FirstOrDefault(a => a.Id == gNo);
                                if (g != null)
                                {
                                    gList.Add(g);
                                }
                            }
                        }
                        dto.GuideInfos = gList;
                        var attachList =
                            await CacheManager.GetSceneAttaches(playCampNo, scene.Id, SceneMapRepository, AttachRepository);
                        dto.Attaches = attachList;
                    }
                    catch (Exception e)
                    {
                        this.LogError(e);
                    }

                    return dto;
                });
            if (sceneDto.HasEnd)
            {
                await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"{no}-{scenePath}-end", sceneDto);
            }

            return sceneDto;
        }

        private async Task<SceneDataNode> GetRunScene(string no, SceneModel scene)
        {
            SceneDataNode runScene = null;
            var i = 0;
            while (runScene == null && i < 20)
            {
                var runGroupInfo = await CacheManager.GetGroupRunningInfoAsync(no, PlayRepository);
                runScene = runGroupInfo?.RunSceneInfos.FirstOrDefault(a => a.Path == scene.Path);
                //if (runScene == null)
                //{
                //    await CacheManager.GetCache(IwbCacheNames.PlayRunningInfoCache).RemoveAsync(no);
                //    Thread.Sleep(200);
                //}
                int time = 300 - i * 50;
                time = time > 0 ? time : 50;
                Thread.Sleep(time);
                i++;
            }

            return runScene;
        }

        /// <summary>
        /// 查询分组当前轮次得分
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<PlayScoreDto> GetPlayScoreInfo(string no)
        {
            var playInfo = await GetPlayDto(no);
            if (playInfo == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }

            var score = await PsRepository.GetAll().Where(a => a.PlayNo == no).OrderByDescending(a => a.RoundIndex)
                .FirstOrDefaultAsync();
            if (score == null)
            {
                return null;
            }

            var dto = ObjectMapper.Map<PlayScoreDto>(score);
            return dto;
        }

        /// <summary>
        /// 获取子课程类别
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<JsTreeDto>> GetChildSubjectCategory(EntityDto<string> input)
        {
            if (input.Id.IsEmpty() || input.Id == "#" || input.Id == "0")
            {
                input.Id = IwbConsts.SubjectCategoryRootNo;
                this.LogDebug(input.Id);
            }
            var list = new List<JsTreeDto>();
            var children = await ScRepository.GetAllListAsync(a => a.ParentNo == input.Id);
            if (children.Any())
            {
                foreach (var child in children)
                {
                    list.Add(new JsTreeDto()
                    {
                        Id = child.Id,
                        Text = child.CategoryName,
                        Children = (await ScRepository.CountAsync(a => a.ParentNo == child.Id)) > 0
                    });
                }
            }

            return list;
        }
    }
}