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)
        {
            var total = await _sportsContext.Student.CountAsync();

            string schoolCode = await _sportsContext.School.Where(x => x.Id == dto.OrgId).Select(x => x.SchoolCode).FirstAsync();

            var list = await _sportsContext.Student
                .Where(x => x.SchoolCode == schoolCode)
                .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,
                Pages = 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 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();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message + "/n" + e.InnerException);
                }

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