using New_College.IServices;
using New_College.Model.Models;
using New_College.Services.BASE;
using New_College.IRepository.Base;
using System.Threading.Tasks;
using New_College.Model.ViewModels;
using New_College.Model;
using SqlSugar;
using System.Linq.Expressions;
using System;
using System.Linq;
using New_College.Common;
using New_College.IRepository;
using LinqKit;

namespace New_College.Services
{

    /// <summary>
    /// 填报数据整合
    /// </summary>
    public class D_PlanMajorDescServices : BaseServices<D_PlanMajorDesc>, ID_PlanMajorDescServices
    {
        private readonly IBaseRepository<D_PlanMajorDesc> _dal;
        private readonly ID_QualificationLineRepository _qualificationLineRepository;
        public D_PlanMajorDescServices(IBaseRepository<D_PlanMajorDesc> dal, ID_QualificationLineRepository d_QualificationLineRepository)
        {
            this._dal = dal;
            base.BaseDal = dal;
            _qualificationLineRepository = d_QualificationLineRepository;
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<AIGOPageModel<AIGOResponse>> GetAIGoList(OneSubmitGoRequest request)
        {
            var claim = request.SubjectClaim.Split(",", StringSplitOptions.RemoveEmptyEntries).ToList();

            var pagemodel = new AIGOPageModel<AIGOResponse>();
            int startscore = request.Score - 15;
            int endscore = request.Score + 15;
            int qyear = request.Year >= DateTime.Now.Year ? DateTime.Now.Year - 1 : 2022;
            Expression<Func<D_QualificationLine, bool>> expression = Expressionable.Create<D_QualificationLine>()
                  .And(c => c.Years == qyear)
                  .And(c => c.IsDelete == false)
                  .And(c => c.Location == request.Location)
                  .AndIF(!string.IsNullOrWhiteSpace(request.BatchName), c => c.BatchName.Equals(request.BatchName))
                  .AndIF(!string.IsNullOrWhiteSpace(request.Name), c => SqlFunc.Contains(c.UniversityName, request.Name))
                 .AndIF(!string.IsNullOrWhiteSpace(request.Province), c => SqlFunc.Contains(request.Province, c.AreaName))
                  .AndIF(!string.IsNullOrWhiteSpace(request.SchoolType), c => c.SubjectType == request.SchoolType)
                  .AndIF(request.Score > 0 && (request.EndScore <= endscore && request.StartScore >= startscore), c => SqlFunc.Between(c.LowScore, startscore, endscore))
                  .AndIF(request.EndScore > endscore || request.StartScore < startscore, c => SqlFunc.Between(c.LowScore, request.StartScore, request.EndScore))
                  .AndIF(request.Syl.HasValue && request.Syl == 1, c => c._SYL == "是")
                  .AndIF(request._211.HasValue && request._211 == 1, c => c._211 == "是")
                  .AndIF(request._985.HasValue && request._985 == 1, c => c._985 == "是")
                  .AndIF(!string.IsNullOrWhiteSpace(request.Ownership), c => c.Ownership == request.Ownership)
                  .AndIF(!string.IsNullOrWhiteSpace(request.Nature), c => c.Nature == request.Nature)
                 .ToExpression();
            var query = await _qualificationLineRepository.QueryPage(expression, request.PageIndex, request.PageSize, "  LowScoreRank desc ");

            //var majorarry = query.data.Select(c => c.Major).Distinct().ToArray();
            var universityarry = query.data.Select(c => c.UId).Distinct().ToArray();//
            Expression<Func<D_PlanMajorDesc, bool>> expression2 = Expressionable.Create<D_PlanMajorDesc>()
                  .And(c => c.IsDelete == false)
                  .And(c => c.Location == request.Location)
                  .AndIF(!string.IsNullOrWhiteSpace(request.Major), c => SqlFunc.Contains(c.Major, request.Major))
                  // .AndIF(!string.IsNullOrWhiteSpace(request.SubjectClaim), c => SqlFunc.Contains(c.SelectSubject, request.SubjectClaim)) //此条件不带
                  .AndIF(!string.IsNullOrWhiteSpace(request.SubjectClaim), c => SqlFunc.Contains(c.SelectSubject, claim[0]) || SqlFunc.Contains(c.SelectSubject, claim[1]) || SqlFunc.Contains(c.SelectSubject, claim[2]))
                  .AndIF(!string.IsNullOrWhiteSpace(request.BatchName), c => c.BatchName == request.BatchName)
                  .AndIF(!string.IsNullOrWhiteSpace(request.Province), c => SqlFunc.Contains(request.Province, c.AreaName))
                  .AndIF(!string.IsNullOrWhiteSpace(request.SchoolType), c => c.SchoolType == request.SchoolType)
                  .AndIF(request.Syl.HasValue && request.Syl == 1, c => c._SYL == "是")
                  .AndIF(request._211.HasValue && request._211 == 1, c => c._211 == "是")
                  .AndIF(request._985.HasValue && request._985 == 1, c => c._985 == "是")
                  .AndIF(!string.IsNullOrWhiteSpace(request.Ownership), c => c.Ownership == request.Ownership)
                  .AndIF(!string.IsNullOrWhiteSpace(request.Nature), c => c.Nature == request.Nature)
                  //.AndIF(majorarry.Any(), c => SqlFunc.ContainsArray(majorarry, c.Major))
                  .AndIF(universityarry.Any(), c => SqlFunc.ContainsArray(universityarry, c.UId))
                  .AndIF(request.EndScore > endscore || request.StartScore < startscore, c => SqlFunc.Between(c.LowScore, request.StartScore, request.EndScore))
                 .ToExpression();
            var list = (await _dal.Query(expression2)).Select(c => new D_PlanMajorDesc()
            {
                Major = c.Major,
                MajorCode = c.MajorCode,
                UniversityName = c.UniversityName,
                UId = c.UId,
                Years = c.Years,
                LowScore = c.LowScore,
                LowScoreRank = c.LowScoreRank,
                PlanCount = c.PlanCount,
                Id = c.Id
                // AcademicYear = c.Years.ToString()
            }).ToList();
            var responselist = query.data.Select(c => new AIGOResponse()
            {
                AreaName = c.AreaName,
                Rank = c.Rank.ToString(),
                _985 = c._985,
                _211 = c._211,
                _SYL = c._SYL,
                UniversityId = c.UId,
                UniversityName = c.UniversityName,
                UniversityCode = c.RecruitCode.ToString(),
                LowScoreRank = c.LowScoreRank,
                // SubjectClam = c.SelectSubject,
                Type = MajorPlanScoreTool.GetPlanScore(c.LowScore, request.Score),//冲稳保院校
                planCount = list.Where(w => w.Years == DateTime.Now.Year && w.UId == c.UId).Sum(c => c.PlanCount),
                iGoPlanMajorItems = list.Where(w => w.Years == DateTime.Now.Year && w.UId == c.UId).Select(t => new AIGoPlanMajorItem()
                {
                    PlanId = t.Id,
                    MajorCode = t.MajorCode,
                    fee = t.Free,
                    Major = t.Major,
                    MajorGroup = t.MajorGroup,
                    MajorRemark = t.Remark,
                    planCount = t.PlanCount,
                    SubjectClam = t.SelectSubject,
                    PlanItems = list.Where(ss => ss.UId == c.UId && ss.Major == t.Major).Select(k => new PlanItem()
                    {
                        PlanCount = k.PlanCount,
                        RankLine = k.LowScoreRank,
                        Scoreline = k.LowScoreRank,
                        Year = k.Years.ToString()
                    }).ToList()
                }).ToList(),

            }).OrderByDescending(c => c.Type).OrderBy(c => c.LowScoreRank).ToList();
            return new AIGOPageModel<AIGOResponse>()
            {
                data = responselist,
                c = responselist.Where(c => c.Type == 2).Count(),
                w = responselist.Where(c => c.Type == 1).Count(),
                b = responselist.Where(c => c.Type == 0).Count(),
                dataCount = query.dataCount,
                page = query.page,
                pageCount = query.pageCount,
                PageSize = query.PageSize
            };
        }



        /// <summary>
        /// 一键填报招生计划展示
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<PageModel<OneSubmitGoResponse>> GetPlanMajorList(OneSubmitGoRequest request)
        {

            request.PageSize = 96;//山东省


            var claim = request.SubjectClaim.Split(",", StringSplitOptions.RemoveEmptyEntries).ToList();
            var pagemodel = new PageModel<OneSubmitGoResponse>();
            Expression<Func<D_PlanMajorDesc, bool>> expression = Expressionable.Create<D_PlanMajorDesc>()
                  .And(c => c.IsDelete == false)
                  .And(c => c.Location == request.Location)
                  .AndIF(!string.IsNullOrWhiteSpace(request.SubjectClaim), c => SqlFunc.Contains(c.SelectSubject, claim[0]) || SqlFunc.Contains(c.SelectSubject, claim[1]) || SqlFunc.Contains(c.SelectSubject, claim[2]))
                  .AndIF(!string.IsNullOrWhiteSpace(request.Major), c => SqlFunc.Contains(c.Major, request.Major))
                  .AndIF(!string.IsNullOrWhiteSpace(request.BatchName), c => c.BatchName.Equals(request.BatchName))
                  .AndIF(!string.IsNullOrWhiteSpace(request.Province), c => SqlFunc.Contains(request.Province, c.AreaName))
                  .And(c => c.Years == request.Year)
                  .AndIF(!string.IsNullOrWhiteSpace(request.SchoolType), c => c.SchoolType == request.SchoolType)
                  .AndIF(request.Score > 0, c => SqlFunc.Between(c.LowScore, request.Score - 15, request.Score + 15))
                  .AndIF(request.Syl.HasValue && request.Syl == 1, c => c._SYL == "是")
                  .AndIF(request._211.HasValue && request._211 == 1, c => c._211 == "是")
                  .AndIF(request._985.HasValue && request._985 == 1, c => c._985 == "是")
                  .AndIF(!string.IsNullOrWhiteSpace(request.Ownership), c => c.Ownership == request.Ownership)
                  .AndIF(!string.IsNullOrWhiteSpace(request.Nature), c => c.Nature == request.Nature)
                 //.AndIF(request. > 0, c => SqlFunc.Between(c.LowScore, request.Score, request.Score)) 位次区间
                 .ToExpression();
            var query = await _dal.QueryPage(expression, request.PageIndex, request.PageSize, "  LowScoreRank desc ");

            var majorarry = query.data.Select(c => c.Major).Distinct().ToArray();
            var universityarry = query.data.Select(c => c.UId).Distinct().ToArray();//
            Expression<Func<D_PlanMajorDesc, bool>> expression2 = Expressionable.Create<D_PlanMajorDesc>()
                  .And(c => c.IsDelete == false)
                  .And(c => c.Location == request.Location)
                  .AndIF(!string.IsNullOrWhiteSpace(request.Major), c => SqlFunc.Contains(c.Major, request.Major))
                  // .AndIF(!string.IsNullOrWhiteSpace(request.SubjectClaim), c => SqlFunc.Contains(request.SubjectClaim, c.SelectSubject)) //此条件不带
                  .AndIF(!string.IsNullOrWhiteSpace(request.BatchName), c => c.BatchName == request.BatchName.Trim())
                  .AndIF(!string.IsNullOrWhiteSpace(request.Province), c => SqlFunc.Contains(request.Province, c.AreaName))
                  .AndIF(!string.IsNullOrWhiteSpace(request.SchoolType), c => c.SchoolType == request.SchoolType)
                  .AndIF(request.Syl.HasValue && request.Syl == 1, c => c._SYL == "是")
                  .AndIF(request._211.HasValue && request._211 == 1, c => c._211 == "是")
                  .AndIF(request._985.HasValue && request._985 == 1, c => c._985 == "是")
                  .AndIF(!string.IsNullOrWhiteSpace(request.Ownership), c => c.Ownership == request.Ownership)
                  .AndIF(!string.IsNullOrWhiteSpace(request.Nature), c => c.Nature == request.Nature)
                   .AndIF(majorarry.Any(), c => SqlFunc.ContainsArray(majorarry, c.Major))
                  .AndIF(universityarry.Any(), c => SqlFunc.ContainsArray(universityarry, c.UId))
                 //.AndIF(request. > 0, c => SqlFunc.Between(c.LowScore, request.Score, request.Score)) 位次区间
                 .ToExpression();
            var list = (await _dal.Query(expression2)).Select(c => new D_PlanMajorDesc()
            {
                Major = c.Major,
                MajorCode = c.MajorCode,
                UniversityName = c.UniversityName,
                UId = c.UId,
                Years = c.Years,
                LowScore = c.LowScore,
                LowScoreRank = c.LowScoreRank,
                PlanCount = c.PlanCount,
                // AcademicYear = c.Years.ToString()

            }).ToList();
            var responselist = query.data.Select(c => new OneSubmitGoResponse()
            {
                AreaName = c.AreaName,
                fee = c.Free,
                Major = c.Major,
                MajorGroup = c.MajorGroup,
                MajorRemark = c.Remark,
                planCount = c.PlanCount,
                Rank = c.Rank,
                _985 = c._985,
                _211 = c._211,
                _SYL = c._SYL,
                UniversityId = c.UId,
                UniversityName = c.UniversityName,
                SubjectClam = c.SelectSubject,
                Type = MajorPlanScoreTool.GetPlanScore(c.LowScore, request.Score),//还缺冲稳保
                PlanId = c.Id,
                UniversityCode = c.EnrollmentCode,
                MajorCode = c.MajorCode,
                LowScoreRank = c.LowScoreRank,
                PlanItems = list.Where(e => e.UId == c.UId && e.Major.Equals(c.Major)).Select(s => new PlanItem()
                {
                    PlanCount = s.PlanCount,
                    RankLine = s.LowScoreRank,
                    Scoreline = s.LowScore,
                    Year = s.Years.ToString()

                }).OrderByDescending(k => k.Year).ToList()
            }).OrderByDescending(c => c.Type).OrderBy(c => c.LowScoreRank).ToList();
            return new PageModel<OneSubmitGoResponse>()
            {
                data = responselist,
                dataCount = query.dataCount,
                page = query.page,
                pageCount = query.pageCount,
                PageSize = query.PageSize
            };
        }




    }
}