using Microsoft.AspNetCore.Authorization;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System.Text.Json;
using VOL.Core.Extensions.AutofacManager;
using VOL.Core.ManageUser;
using VOL.Core.Utilities;
using VOL.Entity.DomainModels;
using VOL.Entity.DomainModels.Business.People;
using VOL.Entity.Enum;
using VOL.IOT.IServices;
using VOL.Model;
using VOL.Model.IOT.Request;
using VOL.Model.IOT.Response;
using VOL.System.IRepositories;

namespace VOL.IOT.Services
{
    public class IOTUserService : IIOTUserService, IDependency
    {
        private readonly ISys_UserRepository _userRepository;
        private readonly IS_TeacherRepository _teacherRepository;
        private readonly IS_GradeRepository _gradeRepository;
        private readonly IN_SportsTestCategoryRepository _sportsTestCategoryRepository;
        private readonly IN_SportsTrainingCategoryRepository _sportsTrainingCategoryRepository;
        private readonly IN_HealthStandardsRepository _healthStandardsRepository;
        private readonly IN_SportsTestResultRepository _sportsTestResultRepository;
        [ActivatorUtilitiesConstructor]
        public IOTUserService(
            ISys_UserRepository repository,
            IS_TeacherRepository teacherRepository,
            IS_GradeRepository gradeRepository,
            IN_SportsTestCategoryRepository sportsTestCategoryRepository,
            IN_HealthStandardsRepository healthStandardsRepository,
            IN_SportsTestResultRepository sportsTestResultRepository,
            IN_SportsTrainingCategoryRepository sportsTrainingCategoryRepository)
        {
            _userRepository = repository;
            _teacherRepository = teacherRepository;
            _gradeRepository = gradeRepository;
            _sportsTestCategoryRepository = sportsTestCategoryRepository;
            _healthStandardsRepository = healthStandardsRepository;
            _sportsTestResultRepository = sportsTestResultRepository;
            _sportsTrainingCategoryRepository = sportsTrainingCategoryRepository;
        }

        public async Task<IOT_LoginInfoModel> Login(LoginInfo loginInfo, bool verificationCode = true)
        {
            var res = new IOT_LoginInfoModel();

            Sys_User user = await _userRepository.FindAsIQueryable(x => x.UserName == loginInfo.UserName).FirstOrDefaultAsync();

            if (user == null || loginInfo.Password.Trim() != (user.UserPwd ?? ""))
                throw new Exception("未找到用户信息");

            string token = JwtHelper.IssueJwt(new UserInfo()
            {
                User_Id = user.User_Id,
                UserName = user.UserName,
                Role_Id = user.Role_Id
            });

            res.Token = token;
            res.UserTrueName = user.UserTrueName;
            res.UserName = user.UserName;

            var school = await (from t in _teacherRepository.DbContext.Set<S_Teacher>()
                                join c in _teacherRepository.DbContext.Set<S_School>() on t.SchoolCode equals c.SchoolCode
                                where t.TeacherPhoneNo.Equals(user.PhoneNo)
                                select new { t, c })
                                .Select(x => new
                                {
                                    x.c.SchoolName,
                                    x.c.SchoolCode
                                })
                                .FirstOrDefaultAsync();
            res.SchoolName = school?.SchoolName;
            res.SchoolCode = school?.SchoolCode;

            return res;
        }

        public Task<WebResponseContent> ModifyPwd(string oldPwd, string newPwd)
        {
            throw new NotImplementedException();
        }

        public Task<WebResponseContent> ReplaceToken()
        {
            throw new NotImplementedException();
        }

        public async Task<List<IOT_GradeListModel>> GradePageList(IOT_GradeListParam paramDto)
        {
            var res = await (from s in _gradeRepository.DbContext.Set<S_School>()
                             join a in _gradeRepository.DbContext.Set<S_SchoolAssocGrade>() on s.SchoolCode equals a.SchoolCode
                             join g in _gradeRepository.DbContext.Set<S_Grade>() on a.GradeId equals g.Id
                             where s.SchoolCode.Equals(paramDto.SchoolCode)
                             select new { s, g })
                           .Select(x => new IOT_GradeListModel()
                           {
                               GradeId = x.g.Id,
                               GradeName = x.g.GradeName,
                               GradeState = 1,
                           })
                           .ToListAsync();

            //var res = await (
            //           from h in _gradeRepository.DbContext.Set<S_School>()
            //           join g in _gradeRepository.DbContext.Set<S_Grade>() on h.SchoolCode equals g.SchoolCode
            //           join c in _gradeRepository.DbContext.Set<S_Class>() on g.Id equals c.GradeId into classGroup
            //           from c in classGroup.DefaultIfEmpty()
            //           join s in _gradeRepository.DbContext.Set<S_Student>() on c.Id equals s.ClassId into studentGroup
            //           from s in studentGroup.DefaultIfEmpty()
            //           where h.SchoolCode.Equals(paramDto.SchoolCode)
            //           group new { c, s } by new { g.Id, g.GradeName } into groupedData
            //           select new IOT_GradeListModel()
            //           {
            //               GradeId = groupedData.Key.Id,
            //               GradeName = groupedData.Key.GradeName,
            //               GradeState = 1,
            //               TotalClass = groupedData.Select(x => x.c.Id).Distinct().Count(),
            //               TotalStudent = groupedData.Select(x => x.s.Id).Distinct().Count(),
            //               TotalTrainNumber = groupedData.Select(x => x.s.TotalTrainNumber).Sum(),
            //               TotalTrainTime = groupedData.Select(x => x.s.TotalTrainTime).Sum()
            //           }).OrderBy(x => x.GradeId).ToListAsync();


            //var res = await _gradeRepository.DbContext.Set<S_Grade>()
            //    .Where(x => x.SchoolCode.Equals(paramDto.SchoolCode))
            //    .Select(x => new IOT_GradeListModel()
            //    {
            //        GradeId = x.Id,
            //        GradeName = x.GradeName,
            //        GradeState = 1
            //    })
            //    .ToListAsync();

            return res;
        }

        public async Task<List<IOT_ClassListModel>> ClassPageList(IOT_ClassListParam paramDto)
        {
            var query = from c in _gradeRepository.DbContext.Set<S_Class>()
                        join g in _gradeRepository.DbContext.Set<S_Grade>() on c.GradeId equals g.Id
                        join a in _gradeRepository.DbContext.Set<S_ClassAssocTeacher>() on c.Id equals a.ClassId into associations
                        from association in associations.DefaultIfEmpty()
                        join t in _gradeRepository.DbContext.Set<S_Teacher>() on association.TeacherId equals t.Id into teachers
                        from t in teachers.DefaultIfEmpty()
                        where c.SchoolCode.Equals(paramDto.SchoolCode)
                        select new
                        {
                            c.Id,
                            c.ClassName,
                            c.GradeId,
                            g.GradeName,
                            TeacherId = t != null ? t.Id : (int?)null,
                            TeacherName = t != null ? t.TeacherName : null,
                            TeacherPhoneNo = t != null ? t.TeacherPhoneNo : null
                        };

            var groupedResult = await query
                .GroupBy(c => new { c.Id, c.ClassName, c.GradeId, c.GradeName })
                .Select(group => new IOT_ClassListModel
                {
                    ClassId = group.Key.Id,
                    ClassName = group.Key.ClassName,
                    GradeId = group.Key.GradeId,
                    GradeName = group.Key.GradeName,
                    Teachers = group
                        .Where(x => x.TeacherId.HasValue)
                        .Select(x => new IOT_TeacherModel
                        {
                            TeacherId = x.TeacherId,
                            TeacherName = x.TeacherName,
                            TeacherPhoneNo = x.TeacherPhoneNo
                        }).ToList()
                }).ToListAsync();

            return groupedResult;
        }

        public async Task<List<IOT_StudentListModel>> StudentPageList(IOT_StudentListParam paramDto)
        {
            var res = await (from s in _gradeRepository.DbContext.Set<S_Student>()
                             join c in _gradeRepository.DbContext.Set<S_Class>() on s.ClassId equals c.Id
                             join g in _gradeRepository.DbContext.Set<S_Grade>() on c.GradeId equals g.Id

                             where s.SchoolCode.Equals(paramDto.SchoolCode)

                             select new IOT_StudentListModel()
                             {
                                 StudentId = s.Id,
                                 StudentName = s.StudentName,
                                 StudentNo = s.StudentNo,
                                 Age = s.Age,
                                 ClassId = c.Id,
                                 ClassName = c.ClassName,
                                 GradeName = g.GradeName,
                                 Gender = (int)s.Sex,
                                 StudentState = (int)StudentStatus.Normal,
                                 TotalTrainNumber = s.TotalTrainNumber,
                                 TotalTrainTime = s.TotalTrainTime
                             }).ToListAsync();

            return res;
        }

        public async Task<List<IOT_TeacherListModel>> TeacherPageList(IOT_SchoolParam paramDto)
        {
            var res = await _gradeRepository.DbContext.Set<S_Teacher>()
                .Where(x => x.SchoolCode.Equals(paramDto.SchoolCode))
                .Join(
                    _gradeRepository.DbContext.Set<Sys_User>(),
                    teacher => teacher.TeacherPhoneNo,
                    user => user.PhoneNo,
                    (teacher, user) => new { teacher, user }
                )
                .Select(x => new IOT_TeacherListModel()
                {
                    TeacherId = x.teacher.Id,
                    TeacherName = x.teacher.TeacherName,
                    TeacherPhoneNo = x.teacher.TeacherPhoneNo,
                    TeacherState = (int)x.teacher.TeacherStatus,
                    Gender = (int)x.teacher.Sex,
                    TeacherPwd = x.user.UserPwd
                })
                .ToListAsync();

            return res;
        }

        public async Task<IOT_TeacherDetailsModel> TeacherDetails()
        {
            var user = await _userRepository.FindAsyncFirst(x => x.User_Id == UserContext.Current.UserId);

            if (user == null)
                return null;

            var res = await (from t in _teacherRepository.DbContext.Set<S_Teacher>()
                             join a in _teacherRepository.DbContext.Set<S_ClassAssocTeacher>() on t.Id equals a.TeacherId into assocTeachers
                             from at in assocTeachers.DefaultIfEmpty()
                             join s in _teacherRepository.DbContext.Set<S_Student>() on at.ClassId equals s.ClassId into students
                             from s in students.DefaultIfEmpty()
                             where t.TeacherPhoneNo == user.PhoneNo && t.SchoolCode.Equals(UserContext.Current.TenantId)
                             group new { t, at, s } by new { t.Id } into groupedData
                             select new IOT_TeacherDetailsModel()
                             {
                                 TeacherId = groupedData.Key.Id,
                                 TeacherPhoneNo = groupedData.Select(x => x.t.TeacherPhoneNo).FirstOrDefault(),
                                 TeacherName = groupedData.Select(x => x.t.TeacherName).FirstOrDefault(),
                                 Gender = (int)groupedData.Select(x => x.t.Sex).FirstOrDefault(),
                                 TotalStudentNumber = groupedData.Count(x => x.s.StudentNo != null),
                                 TotalClassNumber = groupedData.Select(x => x.at.ClassId).Distinct().Count(),
                                 TotalTrainNumber = groupedData.Sum(x => x.s.TotalTrainNumber),
                                 TotalTrainTime = groupedData.Sum(x => x.s.TotalTrainTime),
                                 TeacherState = (int)groupedData.Select(x => x.t.TeacherStatus).FirstOrDefault()
                             }).FirstOrDefaultAsync();
            return res;
        }

        public async Task<List<IOT_TrainTypeListModel>> TrainTypeList()
        {
            return await Task.FromResult(Tool.GetEnumDescriptions<IOT_TrainTypeListModel, TrainType>((id, description)
            => new IOT_TrainTypeListModel { Id = id, TrainTypeName = description }));
        }

        public async Task<List<IOT_CategoryListtModel>> CategoryList()
        {
            var res = await _sportsTestCategoryRepository.FindAsIQueryable(x => true).Select(x => new IOT_CategoryListtModel()
            {
                Id = x.Id,
                CategoryName = x.CategoryName
            }).ToListAsync();

            return res;
        }

        public async Task<List<IOT_ItemTypeModel>> ItemTypeList()
        {
            var res = await (from t in _sportsTestCategoryRepository.DbContext.Set<N_TrainingAssocCategory>()
                             join a in _sportsTrainingCategoryRepository.DbContext.Set<N_SportsTrainingCategory>() on t.CategoryValue equals a.CategoryValue
                             where t.ModeId == 2 && t.DataSource == DataSource.IOT
                             select new IOT_ItemTypeModel()
                             {
                                 Id = a.CategoryValue,
                                 ItemTypeName = a.CategoryName
                             }).ToListAsync();

            return res;
        }

        public async Task TankingLData(TankingDataParam paramDto)
        {
            if (paramDto == null || string.IsNullOrWhiteSpace(paramDto.Data))
                throw new Exception("参数错误");

            var classTrain = JsonSerializer.Deserialize<JsonClassTrainListEntity>(paramDto.Data);
            if (classTrain == null || classTrain.tankingList == null)
                throw new Exception("data参数解析失败");

            var entity = new I_TrainingData()
            {
                DataSource = DataSource.IOT,
                ClassId = paramDto.tc_id,
                TeacherId = paramDto.u_id,
                ItemType = paramDto.type,
                InsertTime = Convert.ToDateTime(paramDto.insertTime),
                EndTime = Convert.ToDateTime(paramDto.endTime),
                TotalNumber = paramDto.totalNumber,
                TtotalGroup = paramDto.totalGroup,
                TrainType = paramDto.trainType,
                ModeType = (int)Ai_ModeEnum.ClassRoomMode,
                ModelName = paramDto.modelName,
                GradeId = paramDto.grade,
                LimitNumber = paramDto.limitNumber,
                ClassScore = paramDto.classScore,
                BoyLevelHigh = Convert.ToDouble(paramDto.boyLevelHigh),
                BoyLevelLow = Convert.ToDouble(paramDto.boyLevelLow),
                BoyLevelMiddle = Convert.ToDouble(paramDto.boyLevelMiddle),
                GirlLevelHigh = Convert.ToDouble(paramDto.girlLevelHigh),
                GirlLevelLow = Convert.ToDouble(paramDto.girlLevelLow),
                GirlLevelMiddle = Convert.ToDouble(paramDto.girlLevelMiddle),
                SchoolCode = paramDto.sid,
                LimitTime = paramDto.limitTime,

                Level1 = classTrain.level1,
                Level2 = classTrain.level2,
                Level3 = classTrain.level3,
                Level4 = classTrain.level4,
                Level5 = classTrain.level5,
                Level6 = classTrain.level6,
                Level7 = classTrain.level7,
                Level8 = classTrain.level8,
                Level9 = classTrain.level9,
                Level10 = classTrain.level10,
                AvgEff = classTrain.avgEff,
                AvgNumMan = classTrain.avgNumMan,
                AvgNumWom = classTrain.avgNumWom,
                ClassAvgKcal = classTrain.classAvgKcal,
                ClassAvgTime = classTrain.classAvgTime,
                ClassDate = classTrain.classDate,
                ClassHightPer = classTrain.classHightPer,
                ClassLowNum = classTrain.classLowNum,
                ClassMaxNum = Convert.ToInt32(classTrain.classMaxNum),
                ClassMedian = Convert.ToInt32(classTrain.classMedian),
                ClassMinNum = Convert.ToInt32(classTrain.classMinNum),
                ClassName = classTrain.className,
                ClassNum = Convert.ToInt32(classTrain.classNum),
                ClassNumAvg = Convert.ToDouble(classTrain.classNumAvg),
                ClassTime = classTrain.classTime,
                ClassTimeMedian = classTrain.classTimeMedian,
                ClassTotal = classTrain.classTotal,
                ClassWellNum = classTrain.classWellNum,
                Distance = classTrain.distance,
                DistanceUseTime = classTrain.distanceUseTime,
                GradeName = "",
                MaxEff = classTrain.maxEff,
                MaxNumMan = classTrain.maxNumMan,
                MaxNumWom = classTrain.maxNumWom,
                MaxUseTime = classTrain.maxUseTime,
                MedianNumMan = classTrain.medianNumMan,
                MedianNumWom = classTrain.medianNumWom,
                MinEff = classTrain.minEff,
                TrainTimer = classTrain.trainTimer,
                MinNumMan = classTrain.minNumMan,
                MinUseTime = classTrain.minUseTime,
                MinNumWom = classTrain.minNumWom,
                ModelType = classTrain.modelType,
                Speed = classTrain.speed,
                StuName = classTrain.stuName,
                TotalRound = classTrain.totalRound,
                TotalTime = classTrain.totalTime,
                IsDisplay = true,

                TrainingTime = classTrain.trainingTime,
                KoTimeR = JsonSerializer.Serialize(classTrain.koTimeR),
                KoTimeY = JsonSerializer.Serialize(classTrain.koTimeY),
                TotalR = JsonSerializer.Serialize(classTrain.totalR),
                TotalY = JsonSerializer.Serialize(classTrain.totalY)
            };

            foreach (var data in classTrain.tankingList)
            {
                entity.TrainRankingData.Add(new I_TrainRanking()
                {
                    SchoolCode = paramDto.sid,
                    GradeId = paramDto.grade,
                    ClassId = paramDto.tc_id,
                    ClassName = classTrain.className,
                    StudentNo = data.studentId,
                    StudentName = data.name,
                    Gender = int.Parse(data.gender),
                    Efficiency = data.efficiency,
                    ErrorNumber = data.errorNumber,
                    HeartRatePercentage = data.heartRatePercentage,
                    JumpValue = data.jumpValue,
                    HighHeartRate = data.highHeartRate,
                    Kcal = data.kcal,
                    LowHeartRate = data.lowHeartRate,
                    ResultLevel = data.resultLevel,
                    SecondsNumber = data.secondsNumber,
                    SpeedTime = data.speedTime,
                    StuAgileSpeedTimeNumber = data.stuAgileSpeedTimeNumber,
                    IsDisplay = true

                });
            }


            //if (classTrain.trainGroupList != null)
            //{
            //    foreach (var trainGroup in classTrain.trainGroupList)
            //    {
            //        var stuList = new List<I_StuDetailInfoEntity>();

            //        foreach (var stu in trainGroup.stuList)
            //        {
            //            stuList.Add(new I_StuDetailInfoEntity()
            //            {
            //                ClassRanking = stu.ClassRanking,
            //                Efficiency = stu.Efficiency,
            //                GroupNumber = stu.GroupNumber,
            //                GroupRanking = stu.GroupRanking,
            //                IsGroup = stu.IsGroup,
            //                Kcal = stu.Kcal,
            //                Level = stu.Level,
            //                PowerMax = stu.PowerMax,
            //                PowerTotal = stu.PowerTotal,
            //                Speed = stu.Speed,
            //                SpeedTime = stu.SpeedTime,
            //                TotalNumber = stu.TotalNumber,
            //                UseTime = stu.UseTime
            //            });
            //        }

            //        entity.TrainGroupData.Add(new I_TrainGroup()
            //        {
            //            SchoolCode = paramDto.sid,
            //            AvgEff = trainGroup.avgEff,
            //            DevicesName = trainGroup.devicesName,
            //            GroupAvg = trainGroup.groupAvg,
            //            GroupAvgKcal = trainGroup.groupAvg,
            //            GroupAvgTime = trainGroup.groupAvgTime,
            //            GroupHigh = trainGroup.groupHigh,
            //            GroupLow = trainGroup.groupLow,
            //            GroupM = trainGroup.groupM,
            //            GroupMax = trainGroup.groupMax,
            //            GroupMedianNum = trainGroup.groupMedianNum,
            //            GroupMin = trainGroup.groupMin,
            //            GroupName = trainGroup.groupName,
            //            GroupSpeed = trainGroup.groupSpeed,
            //            GroupSpeedAvgTime = trainGroup.groupSpeedAvgTime,
            //            GroupSpeedCompleteNum = trainGroup.groupSpeedCompleteNum,
            //            GroupSpeedCompletePre = trainGroup.groupSpeedCompletePre,
            //            GroupSpeedMaxime = trainGroup.groupSpeedMaxime,
            //            GroupSpeedMedianTime = trainGroup.groupSpeedMedianTime,
            //            GroupSpeedMinTime = trainGroup.groupSpeedMinTime,
            //            GroupSpeedTotalTime = trainGroup.groupSpeedTotalTime,
            //            GroupTimeMedian = trainGroup.groupTimeMedian,
            //            GroupTotalNum = trainGroup.groupTotalNum,
            //            GroupUseTime = trainGroup.groupUseTime,
            //            IsGroup = trainGroup.isGroup,
            //            Level1 = trainGroup.level1,
            //            Level2 = trainGroup.level2,
            //            Level3 = trainGroup.level3,
            //            Level4 = trainGroup.level4,
            //            Level5 = trainGroup.level5,
            //            Level6 = trainGroup.level6,
            //            Level7 = trainGroup.level7,
            //            Level8 = trainGroup.level8,
            //            Level9 = trainGroup.level9,
            //            Level10 = trainGroup.level10,
            //            StuName = trainGroup.stuName,
            //            MaxEff = trainGroup.maxEff,
            //            MinEff = trainGroup.minEff,
            //            MaxUseTime = trainGroup.maxUseTime,
            //            MinUseTime = trainGroup.minUseTime,
            //            SecondsNumber = trainGroup.secondsNumber,
            //            StuList = stuList
            //        });
            //    }
            //}

            await _gradeRepository.DbContext.Set<I_TrainingData>().AddRangeAsync(entity);
            await _gradeRepository.SaveChangesAsync();
        }

        public async Task SportsTestData(SportsTestDataParam paramDto)
        {
            if (paramDto == null || paramDto.Data == null)
                throw new Exception("参数错误");

            var sportsTestValueEntinys = new List<N_SportsTestValue>();

            var distinctCategoryTypes = new List<string>()
            {
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.BMI),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.MeterRun_1000),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.MeterRun_800),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.Sit_And_Reach),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.VitalCapacity),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.OneMinuteJumpRope),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.ShuttleRun_50x8),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.MeterRun_50),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.Pull_Up),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.StandingLongJump),
                Enum.GetName(typeof(SportsTestItemType), SportsTestItemType.Pull_Up)
            };

            var healthStandards = await _healthStandardsRepository.FindAsync(x => distinctCategoryTypes.Contains(x.CategoryEnum));

            var sportsTestEntitys = new List<I_SportsTestData>();

            var nowTime = DateTime.Now;

            foreach (var data in paramDto.Data)
            {
                double bmi = (data.height.HasValue && data.weight.HasValue && data.height.Value > 0)
                    ? Math.Round(data.weight.Value / Math.Pow(data.height.Value / 100.0, 2), 1, MidpointRounding.AwayFromZero)
                    : 0;

                data.bmi = bmi;

                sportsTestEntitys.Add(new I_SportsTestData()
                {
                    ClassId = data.classId,
                    ClassName = data.className,
                    Gender = data.studentGender,
                    GradeId = data.gradeId,
                    GradeName = data.gradeName,
                    Hectometer = data.hectometer,
                    Height = data.height,
                    Bmi = bmi,
                    Kilometer = data.kilometer,
                    Pliable = data.pliable,
                    Pulmonary = data.pulmonary,
                    Chinning = data.chinning,
                    Rope = data.rope,
                    SchoolCode = data.schoolId,
                    SchoolName = data.schoolName,
                    ScoreTime = string.IsNullOrWhiteSpace(data.scoreTime) ? DateTime.Now : Convert.ToDateTime(data.scoreTime),
                    Speedeight = data.speedeight,
                    Speed = data.speed,
                    Situp = data.situp,
                    Standing = data.standing,
                    StudentName = data.studentName,
                    StudentNo = data.studenNumber,
                    Weight = data.weight,
                    TeacherName = data.teacherName,
                    StudenNumber = data.studenNumber,
                    TeacherId = data.teacherId,
                    CreateDate = nowTime
                });

                var categoryValues = new List<(Func<SportsTestData, double?> GetValue, SportsTestItemType Category)>
                    {
                        (d => d.hectometer, SportsTestItemType.MeterRun_800),
                        (d => d.bmi, SportsTestItemType.BMI),
                        (d => d.chinning, SportsTestItemType.Pull_Up),
                        (d => d.kilometer, SportsTestItemType.MeterRun_1000),
                        (d => d.pliable, SportsTestItemType.Sit_And_Reach),
                        (d => d.pulmonary, SportsTestItemType.VitalCapacity),
                        (d => d.rope, SportsTestItemType.OneMinuteJumpRope),
                        (d => d.speedeight, SportsTestItemType.ShuttleRun_50x8),
                        (d => d.speed, SportsTestItemType.MeterRun_50),
                        (d => d.situp, SportsTestItemType.Pull_Up),
                        (d => d.standing, SportsTestItemType.StandingLongJump)
                    };

                foreach (var (getValue, category) in categoryValues)
                {
                    AddSportsTestValueEntity(getValue(data), category, data, sportsTestValueEntinys, healthStandards, nowTime);
                }
            }

            try
            {

                await _gradeRepository.DbContext.Set<I_SportsTestData>().AddRangeAsync(sportsTestEntitys);

                await _sportsTestResultRepository.AddRangeAsync(sportsTestValueEntinys);

                await _gradeRepository.SaveChangesAsync();

            }
            catch (Exception e)
            {

                throw;
            }
        }
        private void AddSportsTestValueEntity(double? value, SportsTestItemType SportsTestItemType, SportsTestData data, List<N_SportsTestValue> sportsTestValueEntinys, List<N_HealthStandards> healthStandards, DateTime nowTime)
        {
            if (value.HasValue && value > 0)
            {
                var sportsTestValueEntity = new N_SportsTestValue();
                string categoryEnum = Enum.GetName(typeof(SportsTestItemType), SportsTestItemType);

                var standard = healthStandards.Where(x =>
                    x.CategoryEnum.Equals(categoryEnum) &&
                    x.GradeId == data.gradeId &&
                    x.Sex == (SexType)data.studentGender &&
                    value >= x.MinValue &&
                    value < x.MaxValue
                ).FirstOrDefault();

                if (standard != null)
                {
                    sportsTestValueEntity.Score = standard.Score;
                    sportsTestValueEntity.Rank = standard.Rank;
                }

                sportsTestValueEntity.Height = data.height != null ? (float)data.height : 0f;
                sportsTestValueEntity.Weight = data.weight != null ? (float)data.weight : 0f;

                sportsTestValueEntity.SchoolCode = data.schoolId;
                sportsTestValueEntity.DataSource = DataSource.IOT;
                sportsTestValueEntity.CategoryValue = (int)SportsTestItemType;
                sportsTestValueEntity.CategoryEnum = categoryEnum;
                sportsTestValueEntity.GradeId = data.gradeId;
                sportsTestValueEntity.GradeName = data.gradeName;
                sportsTestValueEntity.ClassId = data.classId;
                sportsTestValueEntity.ClassName = data.className;
                sportsTestValueEntity.TeacherId = data.teacherId;
                sportsTestValueEntity.TeacherName = data.teacherName;
                sportsTestValueEntity.StudentNo = data.studenNumber;
                sportsTestValueEntity.StudentName = data.studentName;
                sportsTestValueEntity.Value = (float)value;
                sportsTestValueEntity.Creator = UserContext.Current.UserId;
                sportsTestValueEntity.CreateDate = nowTime;
                sportsTestValueEntity.IsDisplay = true;
                sportsTestValueEntity.ScoreTime = string.IsNullOrWhiteSpace(data.scoreTime) ? DateTime.Now : Convert.ToDateTime(data.scoreTime);
                sportsTestValueEntity.AdditionalScore = sportsTestValueEntity.Score == 100 ? 20 : 0;

                SemesterDto semesterDto = new SemesterDto();
                sportsTestValueEntity.Year = semesterDto.Year;
                sportsTestValueEntity.Semester = semesterDto.Semester;

                sportsTestValueEntinys.Add(sportsTestValueEntity);
            }
        }
    }
}