using AutoMapper;
using Microsoft.EntityFrameworkCore;
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.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="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.IDCard,
                    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.Where(x => x.CategoryEnum == "Pull_Up").ToArrayAsync();
            var groupedData = scoreRules.GroupBy(x => x.GradeId).ToList();

            var result = groupedData.Select(group => new ScoreRuleDto
            {
                GradeId = group.Key,
                ProjectKind = 2,
                ProjectName = "引体向上",
                MarkType = 1,
                ModelType = 16,
                OrgId = orgId,
                ProjectRuleId = 6,
                RuleType = 1,
                ProjectId = 6,
                Items = group.Select(item => new ScoreRuleItemDto
                {
                    Id = item.Id,
                    Sex = item.Sex,
                    Name = $"{item.GradeId}",
                    Score = item.Score,
                    Max = item.MaxValue,
                    Min = item.MinValue
                }).ToList(),
                Pluses = new List<ScoreRulePlusDto>
    {
        new ScoreRulePlusDto()
        {
            Id = 6,
            Sex = 1,
            Max = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.MaxValue),
            Min = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.MinValue),
            MaxScore = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.Score),
            Score = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.Score)
        },
        new ScoreRulePlusDto()
        {
            Id = 6,
            Sex = 2,
            Max = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.MaxValue),
            Min = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.MinValue),
            MaxScore = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.Score),
            Score = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.Score)
        }
    },
                ScoreScopes = new List<ScoreScope>
    {
        new ScoreScope()
        {
            Gender = 1,
            MaxScore = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.Score),
            MaxCount = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.MaxValue)
        },
        new ScoreScope()
        {
            Gender = 2,
            MaxScore = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.Score),
            MaxCount = group.Where(x => x.Sex == 1).DefaultIfEmpty().Max(x => x.MaxValue)
        }
    }
            }).ToList();

            return result;
        }

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

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