using AutoMapper;
using EFCore.BulkExtensions;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
using OpenCvSharp;
using System.Threading;
using VOL.Business.IRepositories;
using VOL.Business.IServices.School;
using VOL.Core.CacheManager;
using VOL.Core.Configuration;
using VOL.Core.Extensions.AutofacManager;
using VOL.Core.ManageUser;
using VOL.Core.Utilities;
using VOL.Entity.DomainModels;
using VOL.Entity.DomainModels.Business.People;
using VOL.Entity.Enum;
using VOL.Model;
using VOL.Model.Norm.Response;
using VOL.Model.School.Request;
using VOL.Model.School.Response;
using VOL.System.IRepositories;
using VOL.System.Repositories;
using static Dapper.SqlMapper;
using static System.Formats.Asn1.AsnWriter;

namespace VOL.Business.Services.School
{
    public class S_SchoolService : IS_SchoolService, IDependency
    {
        #region 初始化 
        private readonly IMapper _mapper;
        private readonly ICacheService _cacheService;
        private readonly IS_SchoolRepository _schoolRepository;
        private readonly IS_SchoolNatureAssocGradeRepository _natureAssocGradeRepository;
        private readonly ISys_UserRepository _userRepository;
        private readonly IS_GradeRepository _gradeRepository;

        [ActivatorUtilitiesConstructor]
        public S_SchoolService(IMapper mapper,
             ICacheService cacheService,
             IS_SchoolRepository schoolRepository,
             IS_SchoolNatureAssocGradeRepository natureAssocGradeRepository,
             ISys_UserRepository userRepository,
             IS_GradeRepository gradeRepository)
        {
            _mapper = mapper;
            _cacheService = cacheService;
            _schoolRepository = schoolRepository;
            _natureAssocGradeRepository = natureAssocGradeRepository;
            _userRepository = userRepository;
            _gradeRepository = gradeRepository;
        }
        #endregion

        public async Task<PageDataDto<SchoolPageListModel>> GetSchoolPageList(SchoolPageListParam paramDto)
        {
            var res = new PageDataDto<SchoolPageListModel>();

            var query = from s in _schoolRepository.DbContext.Set<S_School>()
                        join u in _userRepository.DbContext.Set<Sys_User>()
                            on s.SchoolCode equals u.SchoolCode
                        where u.Role_Id == 2 || u.Role_Id == 4
                        select new SchoolPageListModel()
                        {
                            Id = s.Id,
                            SchoolCode = s.SchoolCode,
                            SchoolName = s.SchoolName,
                            Area = s.Area,
                            City = s.City,
                            Province = s.Province,
                            SchoolNatureId = s.SchoolNatureId,
                            CreateDate = s.CreateDate,
                            Status = u.Enable,
                            UserName = u.UserName,
                            UserTrueName = u.UserTrueName,
                            PhoneNo = u.PhoneNo,
                            SchoolType = s.SchoolType
                        };

            if (!string.IsNullOrWhiteSpace(paramDto.SchoolName))
            {
                query = query.Where(x => x.SchoolName.Equals(paramDto.SchoolName));
            }

            if (!string.IsNullOrWhiteSpace(paramDto.SchoolCode))
            {
                query = query.Where(x => x.SchoolCode.Equals(paramDto.SchoolCode));
            }

            if (!string.IsNullOrWhiteSpace(paramDto.UserTrueName))
            {
                query = query.Where(x => x.UserTrueName.Equals(paramDto.UserTrueName));
            }

            if (!string.IsNullOrWhiteSpace(paramDto.PhoneNo))
            {
                query = query.Where(x => x.PhoneNo.Equals(paramDto.PhoneNo));
            }

            if (paramDto.Status > 0)
            {
                query = query.Where(x => x.Status == (int)paramDto.Status);
            }

            if (paramDto.SchoolType > 0)
            {
                query = query.Where(x => x.SchoolType == paramDto.SchoolType);
            }

            res.Total = await query.CountAsync();

            var list = await query.OrderByDescending(x => x.Id)
                 .Skip((paramDto.PageIndex - 1) * paramDto.PageSize)
                 .Take(paramDto.PageSize)
                 .ToListAsync();
            res.Datas = list;

            return res;
        }

        public async Task<bool> DeviceCodeIsExists(string code)
        {
            var deviceExists = _schoolRepository.Exists<Ai_DeviceAssocSchool>(x => x.Code == code);

            return deviceExists;
        }

        public async Task Add(AddSchoolParam paramDto)
        {
            var school_Entity = _mapper.Map<S_School>(paramDto);

            var maxId = await _schoolRepository.FindAsIQueryable(x => true).Select(x => x.SchoolCode).MaxAsync();
            string nextSchoolCode = Tool.IncrementId(maxId);
            school_Entity.SchoolCode = nextSchoolCode;
            school_Entity.CreateDate = DateTime.Now;
            school_Entity.Creator = UserContext.Current.UserId;

            var gradeEntityList = new List<S_SchoolAssocGrade>();

            if (paramDto.SchoolType == SchoolType.School)
            {
                var natureList = await _natureAssocGradeRepository.FindAsync(x => x.NatureId == paramDto.SchoolNatureId);
                if (natureList == null || natureList.Count == 0)
                    throw new Exception($"未找到学校性质:{paramDto.SchoolNatureId}");

                var user = await _userRepository.FindAsyncFirst(x => x.UserName == paramDto.UserName && x.Role_Id == 2);
                if (user != null)
                    throw new Exception($"用户名为{paramDto.UserName}的学校已存在");

                foreach (var nature in natureList)
                {
                    gradeEntityList.Add(new S_SchoolAssocGrade()
                    {
                        SchoolCode = nextSchoolCode,
                        GradeId = nature.GradeId
                    });
                }
            }
            else
            {
                var grade = await _gradeRepository.FindAsIQueryable(x => x.GradeName == "运动馆").FirstOrDefaultAsync();
                gradeEntityList.Add(new S_SchoolAssocGrade()
                {
                    SchoolCode = nextSchoolCode,
                    GradeId = grade?.Id ?? 0
                });
            }

            var userEntity = new Sys_User()
            {
                Role_Id = paramDto.SchoolType == SchoolType.School ? 2 : 4,
                RoleName = paramDto.SchoolType == SchoolType.School ? "学校" : "运动馆",
                SchoolCode = nextSchoolCode,
                Enable = 1,
                SchoolName = paramDto.SchoolName,
                UserName = paramDto.UserName,
                PhoneNo = paramDto.PhoneNo,
                UserPwd = AppSetting.OriginalPwd,
                UserTrueName = paramDto.UserTrueName,
            };

            var deviceAsocSchools = new List<Ai_DeviceAssocSchool>();

            foreach (var code in paramDto.DeviceCode)
            {
                if (!string.IsNullOrWhiteSpace(code))
                {
                    var deviceCodeIsExists = await this.DeviceCodeIsExists(code);
                    if (deviceCodeIsExists)
                    {
                        throw new Exception($"设备编号{code}已存在");
                    }
                    deviceAsocSchools.Add(new Ai_DeviceAssocSchool()
                    {
                        Code = code,
                        SchoolCode = nextSchoolCode
                    });
                }
            }

            using (var transaction = _schoolRepository.DbContext.Database.BeginTransaction())
            {
                try
                {
                    await _schoolRepository.AddAsync(school_Entity);
                    await _gradeRepository.DbContext.Set<S_SchoolAssocGrade>().AddRangeAsync(gradeEntityList);
                    await _gradeRepository.DbContext.Set<Ai_DeviceAssocSchool>().AddRangeAsync(deviceAsocSchools);
                    await _userRepository.AddAsync(userEntity);
                    await _schoolRepository.SaveChangesAsync();
                    // 提交事务
                    await transaction.CommitAsync();
                }
                catch (Exception ex)
                {
                    // 发生错误，回滚事务
                    await transaction.RollbackAsync();
                    throw new Exception(ex.Message);
                }
            }
        }

        public async Task<SchoolPageListModel> Details(string schoolCode)
        {
            var schoolModel = await (from s in _schoolRepository.DbContext.Set<S_School>()
                                     join u in _userRepository.DbContext.Set<Sys_User>()
                                         on s.SchoolCode equals u.SchoolCode
                                     where u.Role_Id == 2 && s.SchoolCode == schoolCode
                                     select new SchoolPageListModel()
                                     {
                                         Id = s.Id,
                                         SchoolCode = s.SchoolCode,
                                         SchoolName = s.SchoolName,
                                         Area = s.Area,
                                         City = s.City,
                                         Province = s.Province,
                                         SchoolNatureId = s.SchoolNatureId,
                                         CreateDate = s.CreateDate,
                                         Status = u.Enable,
                                         UserName = u.UserName,
                                         UserTrueName = u.UserTrueName,
                                         PhoneNo = u.PhoneNo
                                     }).FirstOrDefaultAsync();

            if (schoolModel != null)
            {
                var codes = await _gradeRepository.DbContext.Set<Ai_DeviceAssocSchool>().Where(x => x.SchoolCode == schoolCode)
                    .Select(x => x.Code)
                    .ToListAsync();

                schoolModel.DeviceCode = codes;
            }
            return schoolModel;
        }

        public async Task Modify(AddSchoolParam paramDto)
        {
            var schoolModel = await _schoolRepository.FindAsyncFirst(x => x.SchoolCode.Equals(paramDto.SchoolCode));
            schoolModel.SchoolNatureId = schoolModel.SchoolNatureId;
            schoolModel.SchoolName = schoolModel.SchoolName;
            schoolModel.SchoolCode = schoolModel.SchoolCode;
            schoolModel.Area = schoolModel.Area;
            schoolModel.City = schoolModel.City;
            schoolModel.Province = schoolModel.Province;
            schoolModel.ModifyDate = DateTime.Now;
            schoolModel.Modifier = UserContext.Current.UserId;

            var user = await _userRepository.FindAsyncFirst(x => x.UserName == paramDto.UserName && x.Role_Id == 2);
            if (user == null)
                throw new Exception($"未找到用户名为{paramDto.UserName}的学校");

            user.PhoneNo = paramDto.PhoneNo;
            user.UserName = paramDto.UserName;
            user.UserTrueName = paramDto.UserTrueName;

            var delDeviceAssocSchools = await _gradeRepository.DbContext.Set<Ai_DeviceAssocSchool>().Where(x => x.SchoolCode == schoolModel.SchoolCode).ToListAsync();

            var addDeviceAssocSchools = new List<Ai_DeviceAssocSchool>();

            foreach (var code in paramDto.DeviceCode)
            {
                if (!string.IsNullOrWhiteSpace(code))
                {
                    if (!delDeviceAssocSchools.Select(c => c.Code).Contains(code))
                    {
                        var deviceCodeIsExists = await this.DeviceCodeIsExists(code);
                        if (deviceCodeIsExists)
                        {
                            throw new Exception($"设备编号{code}已存在");
                        }
                    }
                    addDeviceAssocSchools.Add(new Ai_DeviceAssocSchool()
                    {
                        Code = code,
                        SchoolCode = schoolModel.SchoolCode
                    });
                }
            }

            using (var transaction = _schoolRepository.DbContext.Database.BeginTransaction())
            {
                try
                {
                    _gradeRepository.DbContext.Set<Ai_DeviceAssocSchool>().RemoveRange(delDeviceAssocSchools);

                    _schoolRepository.Update(schoolModel);
                    _userRepository.Update(user);
                    await _gradeRepository.DbContext.Set<Ai_DeviceAssocSchool>().AddRangeAsync(addDeviceAssocSchools);
                    await _schoolRepository.SaveChangesAsync();
                    // 提交事务
                    await transaction.CommitAsync();
                }
                catch (Exception ex)
                {
                    // 发生错误，回滚事务
                    await transaction.RollbackAsync();
                    throw new Exception(ex.Message);
                }
            }
        }

        public async Task ModifyStatus(SchoolStatusParam paramDto)
        {
            var user = await _userRepository.FindAsyncFirst(x => x.SchoolCode == paramDto.SchoolCode);
            if (user == null)
                throw new Exception("未找到更新数据");

            user.Enable = (int)paramDto.Status;
            _userRepository.Update(user);
            await _userRepository.SaveChangesAsync();
        }

        public async Task UpdatePwd(SchoolParam paramDto)
        {
            var user = await _userRepository.FindAsyncFirst(x => x.SchoolCode == paramDto.SchoolCode);
            if (user == null)
                throw new Exception("未找到更新数据");

            user.UserPwd = AppSetting.OriginalPwd;

            _userRepository.Update(user);
            await _userRepository.SaveChangesAsync();
        }

        public async Task<bool> UserNameIsExists(string userName)
        {
            var userExists = await _userRepository.ExistsAsync(x => x.UserName == userName);
            return userExists;
        }


        public async Task<List<SchoolNatureListModel>> GetSchoolNatureList()
        {
            var res = await _schoolRepository.DbContext.Set<S_SchoolNature>().Select(s => new SchoolNatureListModel()
            {
                Id = s.Id,
                Name = s.NatureName

            }).ToListAsync();

            return res;
        }
    }
}