using AutoMapper;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using VOL.Business.IServices;
using VOL.Business.IServices.Norm;
using VOL.Business.IServices.School;
using VOL.Business.IServices.SportsHall;
using VOL.Business.Services.School;
using VOL.Core.CacheManager;
using VOL.Core.Extensions.AutofacManager;
using VOL.Core.ManageUser;
using VOL.Entity.DomainModels;
using VOL.Entity.Enum;
using VOL.Model;
using VOL.Model.IOT.Request;
using VOL.Model.SportsHall;
using VOL.System.IRepositories;
using VOL.System.Repositories;

namespace VOL.Business.Services.SportsHall
{
    /// <summary>
    /// 运动馆
    /// </summary>
    public class SportsHallService : ISportsHallService, IDependency
    {
        #region 初始化 
        private readonly IS_ClassRepository _classRepository;
        private readonly IS_GradeRepository _gradeRepository;
        private readonly IS_ClassAssocTeacherRepository _classAssocTeacherRepository;
        private readonly IS_StudentRepository _studentRepository;

        [ActivatorUtilitiesConstructor]
        public SportsHallService(IS_ClassRepository classRepository, IS_GradeRepository gradeRepository, IS_ClassAssocTeacherRepository classAssocTeacherRepository, IS_StudentRepository studentRepository)
        {
            _classRepository = classRepository;
            _gradeRepository = gradeRepository;
            _classAssocTeacherRepository = classAssocTeacherRepository;
            _studentRepository = studentRepository;
        }
        #endregion

        /// <summary>
        /// 新增班级
        /// </summary>
        /// <param name="paramDto"></param>
        /// <returns></returns>
        public async Task AddClass(AddSportsHallClassParam paramDto)
        {
            var tenantId = UserContext.Current.TenantId;

            var grade = await _gradeRepository.FindAsIQueryable(x => x.GradeName == "运动馆").Select(x => new { x.Id, x.GradeName }).FirstAsync();

            var exist = await _classRepository.ExistsAsync(x => x.SchoolCode == tenantId && x.ClassName == paramDto.ClassName && x.GradeId == grade.Id);
            if (exist)
                throw new Exception("班级名称已存在");

            var classEntity = new S_Class()
            {
                GradeId = grade.Id,
                GradeName = grade.GradeName,
                ClassName = paramDto.ClassName,
                Creator = UserContext.Current.UserId,
                SchoolCode = UserContext.Current.TenantId,
                CreateDate = DateTime.Now
            };

            using (var transaction = _classRepository.DbContext.Database.BeginTransaction())
            {
                try
                {
                    await _classRepository.AddAsync(classEntity);
                    await _classRepository.SaveChangesAsync();

                    int classId = classEntity.Id;

                    var classAssocTeacherList = new List<S_ClassAssocTeacher>();

                    paramDto.TeacherIds.ForEach(x =>
                    {
                        classAssocTeacherList.Add(new S_ClassAssocTeacher()
                        {
                            ClassId = classId,
                            TeacherId = x,
                            Creator = UserContext.Current.UserId,
                            CreateDate = DateTime.Now,
                            Modifier = UserContext.Current.UserId,
                            ModifyDate = DateTime.Now,
                        });
                    });

                    await _classAssocTeacherRepository.AddRangeAsync(classAssocTeacherList);

                    var students = await _studentRepository.FindAsync(x => paramDto.studentNoList.Contains(x.StudentNo));

                    foreach (var student in students)
                    {
                        student.ClassId = classId;

                        int index = paramDto.studentNoList.IndexOf(student.StudentNo);

                        student.OrderNo = index >= 0 ? index + 1 : 0;
                    }

                    _studentRepository.UpdateRange(students);
                    await _studentRepository.SaveChangesAsync();


                    // 提交事务
                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    // 发生错误，回滚事务
                    transaction.Rollback();
                    Console.WriteLine("事务回滚：" + ex.Message);
                }
            }
        }

        /// <summary>
        /// 更新班级
        /// </summary>
        /// <param name="paramDto"></param>
        /// <returns></returns>
        public async Task ModifyClass(ModifySportsHallClassParam paramDto)
        {
            var tenantId = UserContext.Current.TenantId;
            var classModel = await _classRepository.FindAsyncFirst(x => x.Id == paramDto.ClassId);

            var grade = await _gradeRepository.FindAsIQueryable(x => x.GradeName == "运动馆").Select(x => new { x.Id, x.GradeName }).FirstAsync();

            if (classModel == null)
                throw new ArgumentNullException("未找到要更新得数据");
            var exist = await _classRepository.ExistsAsync(
                x => x.SchoolCode == tenantId
                    && x.ClassName == paramDto.ClassName
                    && x.GradeId == grade.Id
                    && x.Id != paramDto.ClassId);
            if (exist)
                throw new Exception("班级名称已存在");


            classModel.ClassName = paramDto.ClassName;
            using (var transaction = _classRepository.DbContext.Database.BeginTransaction())
            {
                try
                {
                    _classRepository.Update(classModel);

                    var teacherList = await _classAssocTeacherRepository.FindAsync(x => x.ClassId == paramDto.ClassId);
                    _classAssocTeacherRepository.DbContext.RemoveRange(teacherList);

                    var classAssocTeacherList = new List<S_ClassAssocTeacher>();

                    paramDto.TeacherIds.ForEach(x =>
                    {
                        classAssocTeacherList.Add(new S_ClassAssocTeacher()
                        {
                            ClassId = paramDto.ClassId,
                            TeacherId = x,
                            Creator = UserContext.Current.UserId,
                            CreateDate = DateTime.Now,
                            Modifier = UserContext.Current.UserId,
                            ModifyDate = DateTime.Now,
                        });
                    });

                    await _classAssocTeacherRepository.AddRangeAsync(classAssocTeacherList);

                    var oldStudents = await _studentRepository.FindAsync(x => x.ClassId == classModel.Id);
                    var newStudents = await _studentRepository.FindAsync(x => paramDto.studentNoList.Contains(x.StudentNo));

                    var allStudents = oldStudents.UnionBy(newStudents, s => s.Id).ToList();

                    foreach (var student in allStudents)
                    {
                        if (paramDto.studentNoList.Contains(student.StudentNo))
                        {
                            student.ClassId = classModel.Id;
                            student.OrderNo = paramDto.studentNoList.IndexOf(student.StudentNo) + 1;
                        }
                        else
                        {
                            student.ClassId = 0; 
                            student.OrderNo = 0;
                        }
                    }

                    _studentRepository.UpdateRange(allStudents);
                    await _classRepository.SaveChangesAsync();

                    transaction.Commit();
                }
                catch (Exception ex)
                {
                    // 发生错误，回滚事务
                    transaction.Rollback();
                    Console.WriteLine("事务回滚：" + ex.Message);
                }
            }
        }
    }
}