using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Diagnostics;
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 IwbZero.AppServiceBase;
using IwbZero.ToolCommon.LogHelpers;
using IwbZero.ToolCommon.StringModel;

using WeApp.Authorization.Users;
using WeApp.BaseInfo;
using WeApp.BaseSystem.Users.Dto;
using WeApp.BasicInfo;
using WeApp.BasicInfo.TrainingRoleGroup.Dto;
using WeApp.Configuration;
using WeApp.Configuration.Cache;
using WeApp.TrainingCamp;
using WeApp.TrainingCamp.Dto;
using WeApp.TrainingCampGroup.Dto;
using WeApp.TrainingEval.Dto;

using WeEngine.ModelInfo;
using WeEngine.Packages;

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

        public QueryAppService(
            IRepository<User, long> userRepository, IRepository<CampInfo, string> campRepository, IRepository<CampGroupInfo, string> groupRepository, IRepository<CampRelateGroupRoleInfo> cgrRepository, IRepository<TrainingGroupRelateRoleInfo> grrRepository, IRepository<GroupRoleInfo> groupRoleRepository, IRepository<TrainingRoleInfo, string> roleRepository, IRepository<GroupLogInfo> glRepository, IRepository<CampSceneMapInfo> sceneMapRepository, IRepository<SysAttachFile> attachRepository, IRepository<GroupScoreInfo> gsRepository, IRepository<PortraitRemarkInfo> prRepository)
        {
            UserRepository = userRepository;
            CampRepository = campRepository;
            GroupRepository = groupRepository;
            CgrRepository = cgrRepository;
            GrrRepository = grrRepository;
            GroupRoleRepository = groupRoleRepository;
            RoleRepository = roleRepository;
            GlRepository = glRepository;
            SceneMapRepository = sceneMapRepository;
            AttachRepository = attachRepository;
            GsRepository = gsRepository;
            PrRepository = prRepository;
        }

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

        protected IRepository<CampInfo, string> CampRepository { get; }
        protected IRepository<CampGroupInfo, string> GroupRepository { get; }
        protected IRepository<CampRelateGroupRoleInfo> CgrRepository { get; }
        protected IRepository<TrainingGroupRelateRoleInfo> GrrRepository { get; }
        protected IRepository<GroupRoleInfo> GroupRoleRepository { get; }
        protected IRepository<GroupScoreInfo> GsRepository { get; }
        protected IRepository<GroupLogInfo> GlRepository { get; }
        protected IRepository<TrainingRoleInfo, string> RoleRepository { get; }
        protected IRepository<User, long> UserRepository { get; }
        protected IRepository<PortraitRemarkInfo> PrRepository { get; }

        protected IRepository<CampSceneMapInfo> SceneMapRepository { get; }

        protected IRepository<SysAttachFile> AttachRepository { get; }

        #endregion 仓储

        #region SELECT

        #region Camp && Group

        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<List<SelectListItem>> GetCampGroupStateSelectList()
        {
            var list = await StatesManager.GetSelectListAsync("CampGroup", "State");
            return list;
        }

        public async Task<string> GetCampGroupStateSelectStr()
        {
            var str = await StatesManager.GetSelectListStrAsync("CampGroup", "State");
            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;
        }

        public async Task<string> GetCampGroupSelectStr(string no)
        {
            var list = await GroupRepository.GetAllListAsync(a => a.CampNo == no);
            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> GetGroupRoleSelectStr(string no)
        {
            var list = (await GroupRoleRepository.FirstOrDefaultAsync(a => a.GroupNo == no))?.RoleNames?.Split(',').ToList() ?? new List<string>();
            var str = "<option  value=\"\" selected >请选择角色...</option>";
            foreach (var l in list)
            {
                str += $"<option  value=\"{l}\"  >{l}</option>";
            }
            return str;
        }

        #endregion Camp && Group

        /// <summary>
        /// 画像预置信息类型
        /// </summary>
        /// <returns></returns>
        public async Task<string> GetPortraitRemarkTypeSelectStr()
        {
            var str = await StatesManager.GetSelectListStrAsync("PortraitRemark", "Type");
            str = "<option  value=\"\" selected >请选择信息类型...</option>" + str;
            return str;
        }

        #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 用户

        #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="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<CampGroupDto>> GetCampGroups(string no)
        {
            var query = await GroupRepository.GetAllListAsync(a => a.CampNo == no);
            var list = query.Select(ObjectMapper.Map<CampGroupDto>).ToList();
            return list;
        }

        /// <summary>
        /// 获取培训的角色组预案
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<TrainingRoleGroupDto>> GetCampRoleGroupInfos(string no)
        {
            var roleGroups = await CgrRepository.GetAllIncluding(a => a.TrainingRoleGroupInfo).Where(a => a.CampNo == no).Select(a => a.TrainingRoleGroupInfo).ToListAsync();
            var dtoList = new List<TrainingRoleGroupDto>();
            foreach (var roleGroup in roleGroups)
            {
                var dto = ObjectMapper.Map<TrainingRoleGroupDto>(roleGroup);
                var roles = GrrRepository.GetAllIncluding(a => a.TrainingRoleInfo).Where(a => a.RoleGroupNo == dto.Id);
                dto.RoleNos = roles.Select(a => a.TrainRoleNo).ToList();
                dto.RoleNames = string.Join(",", roles.Select(a => a.TrainingRoleInfo.RoleName).ToArray());
                dtoList.Add(dto);
            }

            return dtoList;
        }

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

        /// <summary>
        /// 查询培训营分组的演练角色
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<string>> GetGroupRoleInfos(string no)
        {
            var entity = await GroupRoleRepository.FirstOrDefaultAsync(a => a.GroupNo == no);
            var list = entity?.RoleNames?.Split(',').ToList() ?? new List<string>();
            return list;
        }

        /// <summary>
        /// 查询培训营分组的演练角色预案
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<GroupRolePlanDto> GetGroupRolePlans(string no)
        {
            return await CacheManager.GetCache(IwbCacheNames.GroupInfoCache).GetAsync($"Plan-{no}", async () =>
            {
                var entity = await GroupRoleRepository.FirstOrDefaultAsync(a => a.GroupNo == no);
                if (entity == null)
                {
                    return null;
                }

                var plans = new List<RolePlanDto>();
                if (entity.RoleGroupNos != null)
                {
                    var nos = entity.RoleGroupNos.Split(',');
                    foreach (var n in nos)
                    {
                        var gr = await GrrRepository.GetAllIncluding(a => a.TrainingRoleInfo, a => a.RoleGroupInfo)
                            .Where(a => a.RoleGroupNo == n).ToListAsync();
                        if (gr.Any())
                        {
                            var name = gr[0].RoleGroupInfo.RoleGroupName;
                            var roles = gr.Select(a => a.TrainingRoleInfo.RoleName).ToList();
                            plans.Add(new RolePlanDto() { Name = name, RoleName = roles });
                        }
                    }
                }

                if (entity.CustomRoles.IsNotEmpty())
                {
                    plans.Add(new RolePlanDto()
                    {
                        Name = "自定义角色",
                        RoleName = entity.CustomRoles.Split(',').ToList()
                    });
                }

                return new GroupRolePlanDto() { GroupNo = no, Plans = plans };
            });
        }

        /// <summary>
        /// 查询培训营情景路径
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<PackageDataNode>> GetCampRunningInfos(string no)
        {
            var groupNos = await GroupRepository.GetAll().Where(a => a.CampNo == no).Select(a => a.Id).ToListAsync();
            var list = new List<PackageDataNode>();
            if (groupNos.Any())
            {
                foreach (var groupNo in groupNos)
                {
                    var runGroupInfo = await CacheManager.GetGroupRunningInfo(groupNo, GroupRepository);
                    if (runGroupInfo != null)
                    {
                        list.Add(runGroupInfo);
                    }
                }
            }
            return list;
        }

        /// <summary>
        /// 获取某组的情景路径
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<PackageDataNode> GetGroupRunningInfo(string no)
        {
            var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, GroupRepository);
            return runGroupInfo;
        }

        //private RunningInfo GetRunningInfo(string no)
        //{
        //    var url =
        //        $"{EngineUrl}api/services/Engine/Run/QueryRunningInfo?runningId={no}";
        //    var result = url.RequestPost("");
        //    var info = result.Str2Obj<RunningInfo>();
        //    return info;
        //}

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

            var query = GlRepository.GetAll().Where(a =>
                    a.GroupNo == no && a.LogType == LogTypeDefinition.SceneOperation &&
                    a.RoundIndex == group.RoundIndex &&
                    (a.LogState == LogStateDefinition.New || a.LogState == LogStateDefinition.Submit || a.LogState == LogStateDefinition.HasMatch))
                .OrderByDescending(a => a.Id).Select(a => new GroupRoleLogDto()
                {
                    Id = a.Id,
                    GroupNo = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState
                });
            var dtoList = await query.ToListAsync();
            return dtoList;
        }

        /// <summary>
        /// 查询培训营分组的处理日志
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<GroupRoleLogDto>> GetGroupLogs(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }
            var query = GlRepository.GetAll().Where(a => a.GroupNo == no && a.LogType == LogTypeDefinition.SceneOperation)
                .OrderByDescending(a => a.Id).Select(a => new GroupRoleLogDto()
                {
                    Id = a.Id,
                    GroupNo = no,
                    Role = a.RoleName,
                    Word = a.LogMessage,
                    LogState = a.LogState
                });
            var dtoList = await query.ToListAsync();
            return dtoList;
        }

        /// <summary>
        /// 获取分组情景
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<SceneDto>> GetGroupScenes(string no)
        {
            var group = await GroupRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (group == null)
            {
                CheckErrors($"未查询编号为【{no}】到培训营！");
                return null;
            }
            List<SceneDto> list = new List<SceneDto>();
            var pathDto = (ScenePathDto)(await CacheManager.GetCache(IwbCacheNames.SceneInfoCache)
                .GetOrDefaultAsync($"SceneNos-{no}"));
            if (pathDto != null)
            {
                list = (List<SceneDto>)await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).GetOrDefaultAsync($"SceneInfos-{no}");
                if (pathDto.hasChange || list == null || list.Count == 0)
                {
                    pathDto.hasChange = false;
                    await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneNos-{no}", pathDto);
                    list = new List<SceneDto>();
                    foreach (var path in pathDto.PathList)
                    {
                        var scene = await GetSceneInfo_Last(no, path);
                        if (scene != null)
                        {
                            list.Add(scene);
                        }
                    }
                    await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneInfos-{no}", list);
                }
            }
            else
            {
                var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, GroupRepository);
                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);
                                            }
                                    }
                            }
                    }

                if (list.Any())
                {
                    pathDto = new ScenePathDto()
                    {
                        hasChange = false,
                        PathList = list.Select(a => a.Path).ToList()
                    };
                    await CacheManager.GetCache(IwbCacheNames.SceneInfoCache).SetAsync($"SceneNos-{no}", pathDto);
                }
            }

            if (list.Any())
            {
                list = list.OrderByDescending(a => a.HasEnd).ToList();
            }

            return list;
        }

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

        private async Task<SceneDto> GetSceneInfo_Last(string no, string scenePath)
        {
            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 GetGroupSceneInfo(no, scenePath);
            }
            return dto;
        }

        /// <summary>
        /// 查询情景信息
        /// </summary>
        /// <param name="no"></param>
        /// <param name="scenePath"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<SceneDto> GetGroupSceneInfo(string no, string scenePath)
        {
            //Stopwatch stopwatch = new Stopwatch();
            //Stopwatch stopwatch2 = new Stopwatch();
            //stopwatch.Start();
            //stopwatch2.Start();
            var groupCampNo = await GroupRepository.GetAll().Where(a => a.Id == no).Select(a => a.CampNo).FirstOrDefaultAsync();
            if (groupCampNo == 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(groupCampNo, 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, GroupRepository);
                        //if (runGroupInfo == null)
                        //{
                        //    return null;
                        //}
                        //var runScene = runGroupInfo.RunSceneInfos.FirstOrDefault(a => a.Path == scene.Path);
                        //stopwatch.Stop();
                        //this.LogInfo($"1耗时{scenePath}：{stopwatch.ElapsedMilliseconds}毫秒");
                        //stopwatch.Restart();
                        var runScene = await GetRunScene(no, scene);
                        if (runScene != null)
                        {
                            dto.HasEnd = runScene.IsEnd;
                            dto.Variables = dto.Variables.MergeHashtable(runScene.GetVariables());
                        }
                        //stopwatch.Stop();
                        //this.LogInfo($"2耗时{scenePath}：{stopwatch.ElapsedMilliseconds}毫秒");
                        //stopwatch.Restart();
                        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(groupCampNo, scene.Id, SceneMapRepository, AttachRepository);
                        dto.Attaches = attachList;
                    }
                    catch (Exception e)
                    {
                        this.LogError(e);
                    }

                    //stopwatch2.Stop();
                    //this.LogInfo($"【总耗时】：{stopwatch2.ElapsedMilliseconds}毫秒");
                    return dto;
                });
            if (sceneDto != null && 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 < 5)
            {
                var runGroupInfo = await CacheManager.GetGroupRunningInfo(no, GroupRepository);
                runScene = runGroupInfo?.RunSceneInfos.FirstOrDefault(a => a.Path == scene.Path);
                i++;
                //if (runScene == null)
                //{
                //    await CacheManager.GetCache(IwbCacheNames.GroupRunningInfoCache).RemoveAsync(no);
                //    Thread.Sleep(500 * i);
                //}
                int time = 400 - i * 50;
                time = time > 0 ? time : 50;
                Thread.Sleep(time);
            }

            return runScene;
        }

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

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

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

        /// <summary>
        /// 查询培训营得分
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<List<QueryGroupScoreDto>> GetScoreInfo(string no)
        {
            var score = await GsRepository.GetAllIncluding(a => a.CampGroupInfo, a => a.CampGroupInfo.CampInfo).Where(a => a.CampNo == no).OrderByDescending(a => a.RoundIndex).Select(a => new QueryGroupScoreDto()
            {
                GroupNo = a.GroupNo,
                GroupName = a.CampGroupInfo.Name,
                CampNo = a.CampNo,
                RoundIndex = a.RoundIndex,
                SystemScore = a.FinalTotalScore,
                TotalScore = a.CampGroupInfo.CampInfo.RoundScore,
                BehaviorTagScoreInfo = a.BehaviorTagScoreInfo
            }).ToListAsync();
            return score;
        }
    }
}