using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using System.Collections.Generic;
using System.Security.Cryptography;
using VOL.Entity.DomainModels.XinWei;
using YD_XinWei.Api.Context;
using YD_XinWei.Api.Services.Interface;
using YD_XinWei.Api.SmartSportsEntitys;
using YD_XinWei.Api.Utilities;
using YD_XinWei.Commons.Dto.Common;
using YD_XinWei.Commons.Dto.HomeWork;
using YD_XinWei.Commons.Dto.Open;
using YD_XinWei.Commons.Dto.School;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace YD_XinWei.Api.Services.Impl
{
    /// <summary>
    /// 服务实现
    /// </summary>
    public class XinWeiService : IXinWeiService
    {
        public SmartSportsContext _sportsContext;
        private readonly IMapper _mapper;

        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="sportsContext"></param>
        /// <param name="mapper"></param>
        public XinWeiService(SmartSportsContext sportsContext, IMapper mapper)
        {
            _sportsContext = sportsContext;
            _mapper = mapper;
        }

        /// <summary>
        /// 获取设备信息
        /// </summary>
        /// <param name="deviceSerial"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<DeviceInfoDto> DeviceInfo(string deviceSerial)
        {
            var deviceInfo = await _sportsContext.XW_Device.FirstOrDefaultAsync(x => x.DeviceSerial == deviceSerial);
            var res = _mapper.Map<DeviceInfoDto>(deviceInfo);
            return res;
        }

        /// <summary>
        /// 项目模式
        /// </summary>
        /// <returns></returns>
        public async Task<List<ProjectModeDto>> SportsModelTypeList()
        {
            var res = await _sportsContext.XW_ProjectMode.Select(x => new ProjectModeDto()
            {
                Id = x.Id,
                ProjectKind = x.ProjectKind,
                Name = x.Name
            }).ToListAsync();

            return res;
        }

        /// <summary>
        /// 体育项目
        /// </summary>
        /// <param name="orgId">学校Id</param>
        /// <returns></returns>

        public async Task<List<TestingProjectDto>> OrgSportsProjectList(int orgId)
        {
            var res = await _sportsContext.XW_TestingProject.Where(x => x.OrgId == orgId).Select(x => new TestingProjectDto()
            {
                ProjectId = x.ProjectId,
                IsOpen = x.IsOpen,
                IsShow = x.IsShow,
                ProjectName = x.ProjectName

            }).ToListAsync();

            return res;
        }

        /// <summary>
        /// 获取学生信息
        /// </summary>
        /// <param name="orgId">学校Id</param>
        /// <returns></returns>
        public async Task<List<StudentInfoDto>> MinimumOfStudentInfoList(int orgId)
        {
            string schoolCode = await _sportsContext.School.Where(x => x.Id == orgId).Select(x => x.SchoolCode).FirstAsync();

            var res = await (from s in _sportsContext.Student
                             join c in _sportsContext.Class on s.ClassId equals c.Id
                             join g in _sportsContext.Grade on c.GradeId equals g.Id
                             where s.SchoolCode == schoolCode
                             select new StudentInfoDto()
                             {
                                 Id = s.Id,
                                 OrgId = orgId,
                                 UserId = s.Id,
                                 StudentNo = s.StudentNo,
                                 Name = s.StudentName,
                                 Sex = s.Sex == 1 ? "男" : "女",
                                 ClassId = c.Id,
                                 GradeId = g.Id,
                                 RuleGradeId = g.Id,
                                 ClassName = c.ClassName,
                                 GradeName = g.GradeName,
                                 CardNo = new List<string>()
                             }).ToListAsync();

            return res;
        }

        /// <summary>
        /// 获取名单列表
        /// </summary>
        /// <param name="orgId"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<List<SportsRosterDto>> SportsRosterList(int orgId, int userId = 0)
        {
            string schoolCode = await _sportsContext.School.Where(x => x.Id == orgId).Select(x => x.SchoolCode).FirstAsync();
            var studentList = await _sportsContext.Student.Where(x => x.SchoolCode == schoolCode).ToListAsync();

            var list = await (from c in _sportsContext.Class
                              join g in _sportsContext.Grade on c.GradeId equals g.Id
                              where c.SchoolCode == schoolCode
                              select new SportsRosterDto()
                              {
                                  Id = c.Id,
                                  OrgId = orgId,
                                  Name = c.ClassName,
                                  GradeId = g.Id,
                                  RuleGradeId = g.Id,
                                  GradeName = g.GradeName,
                                  Status = 1,
                                  Type = 1
                              }).ToListAsync();


            foreach (var item in list)
            {
                var stuList = studentList.Where(x => x.ClassId == item.Id).ToList();
                List<SportsRosterStudentDto> sportList = new List<SportsRosterStudentDto>();

                foreach (var sport in stuList)
                {
                    sportList.Add(new SportsRosterStudentDto()
                    {
                        Id = sport.Id,
                        GroupName = item.Name,
                        ClassId = item.Id,
                        ClassName = item.Name,
                        GradeId = item.GradeId,
                        GradeName = item.GradeName,
                        OrgId = orgId,
                        Sex = sport.Sex,
                        UserName = sport.StudentName,
                        StudentNo = sport.StudentNo,
                        UserId = sport.Id,
                        GroupOrder = 1,
                        RosterId = 1,
                    });
                }

                item.RosterGroupList.Add(new SportsRosterGroupDto()
                {
                    GroupName = item.Name,
                    RosterStudentList = sportList
                });
            }

            return list;
        }

        /// <summary>
        /// 获取人脸信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<FaceListOfDevicePageDto> FaceListOfDevicePage(FaceListOfDeviceDto dto)
        {
            string schoolCode = await _sportsContext.School.Where(x => x.Id == dto.OrgId).Select(x => x.SchoolCode).FirstAsync();

            var total = await _sportsContext.Student.CountAsync(x => x.SchoolCode == schoolCode && !string.IsNullOrWhiteSpace(x.Photo));

            var list = await _sportsContext.Student
                .Where(x => x.SchoolCode == schoolCode && !string.IsNullOrWhiteSpace(x.Photo))
                .Select(s => new DeviceUserFaceVo()
                {
                    FaceId = s.StudentNo,
                    FaceType = 1,
                    FaceUrl = s.Photo,
                    PersonId = s.StudentNo,
                    UserId = s.Id
                })
                .Skip((dto.PageNo - 1) * dto.PageSize)
                .Take(dto.PageSize)
                .ToListAsync();

            return new FaceListOfDevicePageDto()
            {
                Total = total,
                PageNum = dto.PageNo,
                PageSize = dto.PageSize,
                Pages = (int)Math.Ceiling((double)total / dto.PageSize),
                List = list
            };
        }

        /// <summary>
        /// 获取训练评分规则
        /// </summary>
        /// <param name="orgId">学校Id</param>
        /// <returns></returns>
        public async Task<List<ScoreRuleDto>> ScoreRules(int orgId)
        {
            var scoreRules = await _sportsContext.HealthStandards.ToListAsync();
            var projects = await _sportsContext.XW_TestingProject.ToListAsync();
            var projectModels = await _sportsContext.XW_ProjectMode.ToListAsync();

            var scoreRuleItemsByType = scoreRules
                .GroupBy(x => x.CategoryEnum)
                .ToDictionary(g => g.Key, g => g.ToList());

            List<ScoreRuleDto> res = new List<ScoreRuleDto>();

            foreach (var projectModel in projectModels)
            {
                var project = projects.FirstOrDefault(x => x.ProjectId == projectModel.ProjectKind);
                if (project == null) continue; // Skip if project doesn't exist

                var scoreRuleTypes = projectModel.CategoryEnum.Split(',');
                var scoreRuleItems = scoreRuleTypes.SelectMany(type => scoreRuleItemsByType.GetValueOrDefault(type, new List<N_HealthStandards>())).ToList();

                var groupedItemsData = scoreRuleItems.GroupBy(x => x.GradeId).ToList();

                foreach (var grouped in groupedItemsData)
                {
                    var maleItems = grouped.Where(x => x.Sex == 1).ToList();
                    var femaleItems = grouped.Where(x => x.Sex == 2).ToList();

                    var maleMax = maleItems.DefaultIfEmpty().Max(x => x?.MaxValue ?? 0);
                    var maleMin = maleItems.DefaultIfEmpty().Max(x => x?.MinValue ?? 0);
                    var maleMaxScore = maleItems.DefaultIfEmpty().Max(x => x?.Score ?? 0);

                    var femaleMax = femaleItems.DefaultIfEmpty().Max(x => x?.MaxValue ?? 0);
                    var femaleMin = femaleItems.DefaultIfEmpty().Max(x => x?.MinValue ?? 0);
                    var femaleMaxScore = femaleItems.DefaultIfEmpty().Max(x => x?.Score ?? 0);

                    ScoreRuleDto scoreRuleDto = new ScoreRuleDto
                    {
                        GradeId = grouped.Key,
                        OrgId = orgId,
                        ProjectKind = project.ProjectId,
                        ProjectName = project.ProjectName,
                        ModelType = projectModel.Id,
                        RuleType = 1,
                        ProjectId = project.ProjectId,
                        Items = grouped.Select(item => new ScoreRuleItemDto
                        {
                            Id = item.Id,
                            Sex = item.Sex,
                            Name = "1",
                            Score = item.Score,
                            Max = item.MaxValue,
                            Min = item.MinValue
                        }).ToList()
                    };

                    scoreRuleDto.Pluses = new List<ScoreRulePlusDto>
            {
                new ScoreRulePlusDto()
                {
                    Id = grouped.FirstOrDefault()?.Id ?? 0,
                    Sex = 1,
                    Max = maleMax,
                    Min = maleMin,
                    MaxScore = maleMaxScore,
                    Score = maleMaxScore
                },
                new ScoreRulePlusDto()
                {
                    Id = grouped.FirstOrDefault()?.Id ?? 0,
                    Sex = 2,
                    Max = femaleMax,
                    Min = femaleMin,
                    MaxScore = femaleMaxScore,
                    Score = femaleMaxScore
                }
            };

                    scoreRuleDto.ScoreScopes = new List<ScoreScope>
            {
                new ScoreScope()
                {
                    Gender = 1,
                    MaxScore = maleMaxScore,
                    MaxCount = maleMax
                },
                new ScoreScope()
                {
                    Gender = 2,
                    MaxScore = femaleMaxScore,
                    MaxCount = femaleMax
                }
            };

                    res.Add(scoreRuleDto);
                }
            }

            return res;
        }

        /// <summary>
        /// 新增训练
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<TrainDto> AddTrain(AddTrainDto dto)
        {
            var entity = _mapper.Map<XW_SportsTestData>(dto);

            Console.WriteLine(JsonConvert.SerializeObject(entity));

            if (entity != null)
            {
                await _sportsContext.XW_SportsTestData.AddAsync(entity);

                try
                {
                    await _sportsContext.SaveChangesAsync();

                    var res = _mapper.Map<TrainDto>(entity);

                    Console.WriteLine("新增成功");

                    return res;
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message + "/n" + e.InnerException);
                }

            }

            return null;
        }

        /// <summary>
        /// 年级排名
        /// </summary>
        /// <param name="studentId"></param>
        /// <param name="trainId"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public Task<GradeRankingVo> GradeRankingGet(int studentId, int trainId)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 全部历史记录
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<TrainHistoryResponseDto> HistoryGet(HistoryGetDto dto)
        {
            var res = new TrainHistoryResponseDto();

            var trainList = await _sportsContext.XW_SportsTestData
                .Where(x =>
                    x.OrgId == dto.OrgId &&
                    x.ProjectKind == Convert.ToInt32(dto.ProjectKind) &&
                    x.ModelType == dto.ModelType)
                .ToListAsync();

            if (trainList == null || !trainList.Any())
                return res;

            var trainIds = trainList.Select(t => t.Id).ToList();

            var query = _sportsContext.XW_TrainStudents
                .Where(x => trainIds.Contains(x.XW_SportsTestDataId))
                .AsQueryable();

            // 动态排序
            if (!string.IsNullOrEmpty(dto.OrderByColumn))
            {
                bool isAsc = dto.IsAsc?.ToLower() == "asc";
                query = isAsc
                    ? query.OrderBy(x => EF.Property<object>(x, dto.OrderByColumn))
                    : query.OrderByDescending(x => EF.Property<object>(x, dto.OrderByColumn));
            }
            else
            {
                query = query.OrderByDescending(x => x.Id); // 默认排序
            }

            var total = await query.CountAsync();

            var list = await query
                .Skip((dto.PageNo - 1) * dto.PageSize)
                .Take(dto.PageSize)
                .Select(x => new TrainHistoryVo()
                {
                    TrainStudentId = x.Id,
                    ClassName = x.ClassName,
                    CreateTime = x.CreateTime,
                    Achievement = x.Achievement.ToString(),
                    Rating = x.Rating.ToString(),
                    Score = x.Score.ToString(),
                    Sex = x.Sex.ToString(),
                    StudentName = x.StudentName,
                    TouristFlag = false,
                    DoubleFlag = false,
                })
                .ToListAsync();

            res.Total = total;
            res.Rows = list;

            return res;
        }



        /// <summary>
        /// 历史记录详细
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<TrainAnalusisVo> TrainAnalysisHistoryDetail(HistoryDetailRequestDto dto)
        {
            var res = await _sportsContext.XW_TrainStudents.Where(x => x.Id == dto.TrainStudentId).Include(x => x.TrainViolationsBO).Select(x => new TrainAnalusisVo()
            {
                Achievement = x.Achievement.ToString(),
                ClassName = x.ClassName,
                GradeRanking = x.Ranking.ToString(),
                HeadImgUrl = "",
                ProjectName = "",
                Rating = x.Rating.ToString(),
                Score = x.Score.ToString(),
                Sex = x.Sex.ToString(),
                StudentName = x.StudentName,
                Times = x.ErrorCount.ToString(),
                ViolationsNumber = x.TrainViolationsBO.Count(),
                TrainViolationsVo = x.TrainViolationsBO.Select(x => new TrainViolationsVo()
                {
                    CreateTime = x.TrainTime,
                    TrainTime = x.TrainTime,
                    PicUrl = x.PicUrl,
                    ViolationId = x.ViolationId,
                    ViolationName = "",
                }).ToList(),

            }).FirstOrDefaultAsync();

            return res;
        }

        /// <summary>
        /// 个人历史记录-历史成绩
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<TrainHistoryPersonVo> HistoryPersonGet(HistoryPersonGetDto dto)
        {
            var trainList = await _sportsContext.XW_SportsTestData
                .Where(x =>
                    x.OrgId == dto.OrgId &&
                    x.ProjectKind == Convert.ToInt32(dto.ProjectKind) &&
                    x.ModelType == dto.ModelType)
                .ToListAsync();

            var trainIds = trainList.Select(t => t.Id).ToList();

            var studentResults = await _sportsContext.XW_TrainStudents.Where(x => trainIds.Contains(x.XW_SportsTestDataId))
                .Select(x => new
                {
                    x.ClassName,
                    x.StudentId,
                    x.StudentName,
                    x.GradeId,
                    x.Sex,
                    x.Score,
                    x.CreateTime
                }).ToListAsync();

            var student = studentResults.FirstOrDefault(x => x.StudentId == dto.StudentId);

            if (student == null)
            {
                return new TrainHistoryPersonVo();
            }

            var rankedResults = studentResults.Where(x => x.GradeId == student.GradeId)
                    .OrderByDescending(x => x.Score)
                    .Select((x, index) => new { x, Rank = index + 1 })
                    .ToList();

            var monthList = studentResults.Where(x => DateTime.TryParse(x.CreateTime, out var date) && date.Year == DateTime.Now.Year && date.Month == DateTime.Now.Month).ToList();
            var monthRankedResults = studentResults.Where(x => x.GradeId == student.GradeId)
                .OrderByDescending(x => x.Score)
                .Select((x, index) => new { x, Rank = index + 1 })
                .ToList();


            var res = new TrainHistoryPersonVo()
            {
                ClassName = student.ClassName,
                HeadImgUrl = "",
                Sex = student.Sex?.ToString() ?? "无数据",
                StudentName = student.StudentName,
                HistoryBestScore = studentResults.Max(x => x.Score)?.ToString() ?? "无数据",
                HistoryRanking = rankedResults.FirstOrDefault(x => x.x.Score == student.Score)?.Rank.ToString() ?? "-1",
                MonthBestScore = monthList.Max(x => x.Score)?.ToString() ?? "无数据",
                MonthRanking = monthRankedResults.FirstOrDefault(x => x.x.Score == student.Score)?.Rank.ToString() ?? "-1"
            };

            return res;
        }

        /// <summary>
        /// 个人历史记录-记录列表
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<TableDataPersonAnalysisVo> HistoryPersonListGet(HistoryPersonListDto dto)
        {
            var res = new TableDataPersonAnalysisVo();

            var trainList = await _sportsContext.XW_SportsTestData
                .Where(x =>
                    x.OrgId == dto.OrgId &&
                    x.ProjectKind == Convert.ToInt32(dto.ProjectKind) &&
                    x.ModelType == dto.ModelType)
                .ToListAsync();

            if (trainList == null || !trainList.Any())
                return res;

            var trainIds = trainList.Select(t => t.Id).ToList();

            var query = _sportsContext.XW_TrainStudents
                .Where(x => trainIds.Contains(x.XW_SportsTestDataId) && x.StudentId == dto.StudentId)
                .AsQueryable();

            // 动态排序
            if (!string.IsNullOrEmpty(dto.OrderByColumn))
            {
                bool isAsc = dto.IsAsc?.ToLower() == "asc";
                query = isAsc
                    ? query.OrderBy(x => EF.Property<object>(x, dto.OrderByColumn))
                    : query.OrderByDescending(x => EF.Property<object>(x, dto.OrderByColumn));
            }
            else
            {
                query = query.OrderByDescending(x => x.Id); // 默认排序
            }

            var total = await query.CountAsync();

            var list = await query
                .Skip((dto.PageNo - 1) * dto.PageSize)
                .Take(dto.PageSize)
                .Select(x => new PersonAnalysisVo()
                {
                    TrainStudentId = x.StudentId,
                    ClassName = x.ClassName,
                    CreateTime = x.CreateTime,
                    Achievement = x.Achievement.ToString(),
                    Rating = x.Rating.ToString(),
                    Score = x.Score.ToString(),
                    Sex = x.Sex.ToString(),
                    StudentName = x.StudentName,
                    DoubleFlag = false,
                })
                .ToListAsync();

            res.Total = total;
            res.Rows = list;

            return res;
        }

        /// <summary>
        /// 成绩榜-年级列表
        /// </summary>
        /// <param name="orgId"></param>
        /// <returns></returns>
        public async Task<List<GradeVo>> GetGradeListByOrg(int orgId)
        {
            string schoolCode = await _sportsContext.School.Where(x => x.Id == orgId).Select(x => x.SchoolCode).FirstAsync();

            var res = await (from s in _sportsContext.SchoolAssocGrade
                             join g in _sportsContext.Grade on s.GradeId equals g.Id
                             where s.SchoolCode == schoolCode
                             select new GradeVo()
                             {
                                 GradeId = g.Id,
                                 GradeName = g.GradeName
                             }).ToListAsync();

            return res;
        }

        /// <summary>
        /// 成绩榜-年级列表
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public Task<ScoreRankingVo> ScoreRanking(ScoreRankingDto dto)
        {
            throw new NotImplementedException();
        }
    }
}