using Shentun.WebPeis.CustomerOrgs;
using Shentun.WebPeis.Enums;
using Shentun.WebPeis.Models;
using Shentun.WebPeis.Persons;
using Shentun.WebPeis.SysParmValues;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Domain.Services;
using Volo.Abp.Identity;

namespace Shentun.WebPeis.AppointPatientRegisters
{
    public class AppointPatientRegisterManager : DomainService
    {
        private readonly IRepository<CustomerOrg> _customerOrgRepository;
        private readonly IRepository<CustomerOrgGroup> _customerOrgGroupRepository;
        private readonly IRepository<CustomerOrgGroupDetail> _customerOrgGroupDetailRepository;
        private readonly IRepository<CustomerOrgRegister> _customerOrgRegisterRepository;
        private readonly IRepository<MedicalPackage> _medicalPackageRepository;
        private readonly IRepository<MedicalPackageDetail> _medicalPackageDetailRepository;
        private readonly IRepository<AppointPatientRegister> _repository;
        private readonly IRepository<IdentityUser> _identityUserRepository;
        private readonly IdentityUserManager _identityUserManager;
        private readonly IRepository<Nation> _nationRepository;
        private readonly SysParmValueManager _sysParmValueManager;
        private readonly IRepository<PrimarykeyBuilder> _primarykeyBuilderRepository;
        private readonly IRepository<Asbitem> _asbitemRepository;
        private readonly CustomerOrgManager _customerOrgManager;
        public AppointPatientRegisterManager(IRepository<AppointPatientRegister> repository,
            IRepository<IdentityUser> identityUserRepository,
            IdentityUserManager identityUserManager,
            IRepository<Nation> nationRepository,
            SysParmValueManager sysParmValueManager,
            IRepository<PrimarykeyBuilder> primarykeyBuilderRepository,
            IRepository<CustomerOrgGroup> customerOrgGroupRepository,
            IRepository<MedicalPackage> medicalPackageRepository,
            IRepository<CustomerOrg> customerOrgRepository,
            IRepository<CustomerOrgRegister> customerOrgRegisterRepository,
            IRepository<Asbitem> asbitemRepository,
            CustomerOrgManager customerOrgManager,
            IRepository<MedicalPackageDetail> medicalPackageDetailRepository,
            IRepository<CustomerOrgGroupDetail> customerOrgGroupDetailRepository
            )
        {
            _repository = repository;
            _identityUserRepository = identityUserRepository;
            _identityUserManager = identityUserManager;
            _nationRepository = nationRepository;
            _sysParmValueManager = sysParmValueManager;
            _primarykeyBuilderRepository = primarykeyBuilderRepository;
            _customerOrgGroupRepository = customerOrgGroupRepository;
            _medicalPackageRepository = medicalPackageRepository;
            _customerOrgRepository = customerOrgRepository;
            _customerOrgRegisterRepository = customerOrgRegisterRepository;
            _asbitemRepository = asbitemRepository;
            _customerOrgManager = customerOrgManager;
            _medicalPackageDetailRepository = medicalPackageDetailRepository;
            _customerOrgGroupDetailRepository = customerOrgGroupDetailRepository;
        }

        public async Task<AppointPatientRegister> CreateAsync(AppointPatientRegister entity)
        {
            await Verify(entity);

            entity.AppointPatientRegisterId = GuidGenerator.Create();
            entity.CompleteFlag = AppointPatientRegisterCompleteFlag.Appoint;
            entity.IsCharge = 'N';
            foreach (var appointRegisterAsbitem in entity.AppointRegisterAsbitems)
            {
                appointRegisterAsbitem.AppointPatientRegisterId = entity.AppointPatientRegisterId;
            }
            return entity;
        }
        private async Task Verify(AppointPatientRegister entity)
        {
            Check.NotNull<Guid>(entity.PersonId, "人员ID");
            Check.NotNull<Guid>(entity.MedicalCenterId, "体检中心");
            Check.NotDefaultOrNull<Guid>(entity.CustomerOrgId, "单位");
            Check.NotNull<DateTime>(entity.AppointDate, "体检日期");
            if(entity.AppointDate < DateTime.Now.Date)
            {
                throw new UserFriendlyException("预约日期不能小于当前日期");
            }
            if (entity.PregnantFlag != PregnantFlag.None && entity.PregnantFlag != PregnantFlag.PreparePregnancy 
                && entity.PregnantFlag != PregnantFlag.Pregnancy)
            {
                throw new UserFriendlyException("备孕标志错误");
            }

            if (entity.CustomerOrgGroupId != Guid.Empty && entity.CustomerOrgGroupId != null)
            {
                if ((await _customerOrgGroupRepository.GetQueryableAsync()).
                     Where(o => o.CustomerOrgRegisterId == entity.CustomerOrgRegisterId &&
                     o.CustomerOrgGroupId == entity.CustomerOrgGroupId).Count() == 0)
                {
                    throw new UserFriendlyException("单位分组ID不存在");
                }
            }

            if (entity.MedicalPackageId != Guid.Empty && entity.MedicalPackageId != null)
            {
                if ((await _medicalPackageRepository.GetQueryableAsync()).
                     Where(o => o.MedicalPackageId == entity.MedicalPackageId).Count() == 0)
                {
                    throw new UserFriendlyException("套餐ID不存在");
                }
            }

            var customerOrg = await _customerOrgRepository.FindAsync(o => o.CustomerOrgId == entity.CustomerOrgId);
            if (customerOrg == null)
            {
                throw new UserFriendlyException("客户单位ID不存在");
            }

            if (customerOrg.CustomerOrgId == GuidFlag.PersonCustomerOrgId)
            {
                if (entity.CustomerOrgGroupId != Guid.Empty && entity.CustomerOrgGroupId != null)
                {
                    throw new UserFriendlyException("个人体检不能选单位分组");
                }
            }
            else
            {
                if (entity.MedicalPackageId != Guid.Empty && entity.MedicalPackageId != null)
                {
                    throw new UserFriendlyException("单位体检不能选套餐");
                }
                if(entity.PatientRegisterId == null || entity.PatientRegisterId == Guid.Empty)
                {
                    throw new UserFriendlyException("团检预约必须有人员备案登记编号");
                }

            }

            var customerOrgRegister = await _customerOrgRegisterRepository.FindAsync(o => o.CustomerOrgRegisterId == entity.CustomerOrgRegisterId);
            if (customerOrgRegister == null)
            {
                throw new UserFriendlyException("客户登记单位次数不存在");
            }
            if (customerOrgRegister.CustomerOrgId != customerOrg.CustomerOrgId)
            {
                var topCustomerOrg = await _customerOrgManager.GetTopCustomerOrgAsync(customerOrg.CustomerOrgId);
                var topCustomerOrgRegisterOrg = await _customerOrgManager.GetTopCustomerOrgAsync(customerOrgRegister.CustomerOrgId);
                if (topCustomerOrg.CustomerOrgId != topCustomerOrgRegisterOrg.CustomerOrgId)
                {
                    throw new UserFriendlyException("登记单位和登记单位体检次数不一致");
                }
            }

            if (entity.AppointRegisterAsbitems == null || !entity.AppointRegisterAsbitems.Any())
            {
                throw new UserFriendlyException("必须预约组合项目");
            }
            if (entity.MedicalPackageId != null)  
            {
               var medicalPackageDetails = await _medicalPackageDetailRepository.GetListAsync(o=>o.MedicalPackageId == entity.MedicalPackageId);
                medicalPackageDetails.ForEach(o =>
                {
                    if (!entity.AppointRegisterAsbitems.Where(x=>x.AsbitemId == o.AsbitemId).Any())
                    {
                        throw new UserFriendlyException("套餐项目不能取消");
                    }
                });
            }
          
            if (entity.CustomerOrgGroupId != null)
            {
                var customerOrgGroupDetails = await _customerOrgGroupDetailRepository
                    .GetListAsync(o => o.CustomerOrgGroupId == entity.CustomerOrgGroupId);
                customerOrgGroupDetails.ForEach(o =>
                {
                    if (!entity.AppointRegisterAsbitems.Where(x => x.AsbitemId == o.AsbitemId).Any())
                    {
                        throw new UserFriendlyException("单位分组项目不能取消");
                    }
                });

                foreach(var asbitem in  entity.AppointRegisterAsbitems)
                {
                    decimal addMoney = 0;
                    var customerOrgGroupDetail = customerOrgGroupDetails.Where(o => o.AsbitemId == asbitem.AsbitemId).FirstOrDefault();
                    if(customerOrgGroupDetail != null)
                    {
                        addMoney += customerOrgGroupDetail.Price;
                    }

                    if(addMoney > 0)
                    {
                        var customerOrgGroup = await _customerOrgGroupRepository.GetAsync(o => o.CustomerOrgGroupId == entity.CustomerOrgGroupId);
                        if(addMoney > customerOrgGroup.CanAddMoney)
                        {
                            throw new UserFriendlyException($"自选的单位支付金额能超过{customerOrgGroup.CanAddMoney}元");
                        }
                    }
                }
            }



            var asbitems = await _asbitemRepository.GetListAsync();
            foreach (var appointRegisterAsbitem in entity.AppointRegisterAsbitems)
            {
                var asbitem = asbitems.Where(o => o.AsbitemId == appointRegisterAsbitem.AsbitemId).Single();
                appointRegisterAsbitem.StandardPrice = asbitem.Price;
                if (appointRegisterAsbitem.ChargePrice < 0)
                {
                    throw new UserFriendlyException($"{asbitem.AsbitemName}价格不能小于0");
                }
                if (appointRegisterAsbitem.ChargePrice > 10000)
                {
                    throw new UserFriendlyException($"{asbitem.AsbitemName}价格不能大于10000");
                }
                if (appointRegisterAsbitem.Amount < 1)
                {
                    throw new UserFriendlyException($"{asbitem.AsbitemName}数量不能小于1");
                }
                if (customerOrg.CustomerOrgId == GuidFlag.PersonCustomerOrgId)
                {
                    appointRegisterAsbitem.PayTypeFlag = PayTypeFlag.PersonPay;
                    
                }
                else
                {
                    //在这里要判断属于分组的免费，不属于分组的自费
                    if (appointRegisterAsbitem.PayTypeFlag != PayTypeFlag.PersonPay &&
                    appointRegisterAsbitem.PayTypeFlag != PayTypeFlag.OrgPay)
                    {
                        throw new UserFriendlyException($"{asbitem.AsbitemName}支付类别错误");
                    }
                }

                appointRegisterAsbitem.IsCharge = 'N';
            }

            var appoentPatientRegisters = await _repository.GetListAsync(o => o.PersonId == entity.PersonId &&
             o.AppointDate >= DateTime.Now.Date && o.CompleteFlag != AppointPatientRegisterCompleteFlag.CancelAppoint);
            if(appoentPatientRegisters.Count >= 1)
            {
                throw new UserFriendlyException("已有今天及之后的预约订单，必须先取消订单才能重新预约");
            }

        }
    }
}