using AutoMapper;
using IRaCIS.Application.ExpressionExtend;
using IRaCIS.Application.Interfaces;
using IRaCIS.Application.ViewModels;
using IRaCIS.Core.Application.Contracts.RequestAndResponse;
using IRaCIS.Infra.Data.ExpressionExtend;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using IRaCIS.Core.Domain.Interfaces;
using IRaCIS.Core.Domain.Models;

namespace IRaCIS.Application.Services.Pay
{
    public class ReviewerPayInfoService : IReviewerPayInfoService
    {
        private readonly IReviewerPayInfoRepository _doctorPayInfoRepository;
        private readonly IDoctorRepository _doctorRepository;
        private readonly IRankPriceRepository _rankPriceRepository;
        private readonly IHospitalRepository _hospitalRepository;
        private readonly IMapper _mapper;

        public ReviewerPayInfoService(IDoctorRepository doctorRepository, IReviewerPayInfoRepository doctorPayInfoRepository,
            IRankPriceRepository rankPriceRepository, IHospitalRepository hospitalRepository, IMapper mapper)
        {
            _doctorPayInfoRepository = doctorPayInfoRepository;
            _doctorRepository = doctorRepository;
            _rankPriceRepository = rankPriceRepository;
            _hospitalRepository = hospitalRepository;
            _mapper = mapper;
        }
        public IResponseOutput AddOrUpdateReviewerPayInfo(ReviewerPayInfoCommand addOrUpdateModel, Guid userId)
        {
            var success = false;
            var doctorPayInfoExistedItem = _doctorPayInfoRepository.FindSingleOrDefault(u => u.DoctorId == addOrUpdateModel.DoctorId);
            if (doctorPayInfoExistedItem == null)//insert
            {
                var doctorPayInfo = _mapper.Map<ReviewerPayInformation>(addOrUpdateModel);
                //doctorPayInfo.CreateTime = DateTime.Now;
                //doctorPayInfo.CreateUserId = userId;
                _doctorPayInfoRepository.Add(doctorPayInfo);
              
            }
            else//update
            {
                _doctorPayInfoRepository.Update(_mapper.Map(addOrUpdateModel, doctorPayInfoExistedItem));

            }
            success = _doctorPayInfoRepository.SaveChanges();
            return ResponseOutput.Result(success);
        }

        public PageOutput<DoctorPayInfoQueryListDTO> GetDoctorPayInfoList(DoctorPaymentInfoQueryDTO queryParam)
        {
            Expression<Func<Doctor, bool>> doctorLambda = x => true;
            if (queryParam.HospitalId != Guid.Empty && queryParam.HospitalId != null)
            {
                doctorLambda = doctorLambda.And(o => o.HospitalId == queryParam.HospitalId);
            }

            if (!string.IsNullOrEmpty(queryParam.SearchName))
            {
                var searchKeyword = queryParam.SearchName.Trim();
                doctorLambda = doctorLambda.And(u => u.ChineseName.Contains(searchKeyword)
                                                     || u.FirstName.Contains(searchKeyword) || u.LastName.Contains(searchKeyword));
            }

            var doctorQueryable = from doctor in _doctorRepository.GetAll().Where(doctorLambda)
                                  join hospitalItem in _hospitalRepository.GetAll() on doctor.HospitalId
                                      equals hospitalItem.Id
                                      into gt
                                  from hospital in gt.DefaultIfEmpty()
                                  join trialPayInfo in _doctorPayInfoRepository.Find()
                                  on doctor.Id equals trialPayInfo.DoctorId into payInfo
                                  from doctorPayInfo in payInfo.DefaultIfEmpty()
                                  join rankPrice in _rankPriceRepository.Find()
                                  on doctorPayInfo.RankId equals rankPrice.Id into rankPriceInfo
                                  from rankPrice in rankPriceInfo.DefaultIfEmpty()
                                  select new DoctorPayInfoQueryListDTO
                                  {
                                      //Id = doctorPayInfo.Id,
                                      DoctorId = doctor.Id,
                                      Code = doctor.Code,
                                      LastName = doctor.LastName,
                                      FirstName = doctor.FirstName,
                                      ChineseName = doctor.ChineseName,
                                      Phone = doctor.Phone,
                                      DoctorNameInBank = doctorPayInfo.DoctorNameInBank,
                                      IDCard = doctorPayInfo.IDCard,
                                      BankCardNumber = doctorPayInfo.BankCardNumber,
                                      BankName = doctorPayInfo.BankName,
                                      RankId = doctorPayInfo.RankId,
                                      RankName = rankPrice.RankName,
                                      Additional = doctorPayInfo.Additional,
                                      Hospital = hospital.HospitalName,
                                      CreateTime = doctor.CreateTime
                                  };
            var count = doctorQueryable.Count();
            var propName = string.IsNullOrWhiteSpace(queryParam.SortField) ? "Code" : queryParam.SortField;
            doctorQueryable = queryParam.Asc ? doctorQueryable.OrderBy(propName) : doctorQueryable.OrderByDescending(propName);
            doctorQueryable = doctorQueryable.Skip((queryParam.PageIndex - 1) * queryParam.PageSize)
                .Take(queryParam.PageSize);

            var trialList = doctorQueryable.ToList();
            return new PageOutput<DoctorPayInfoQueryListDTO>(queryParam.PageIndex, queryParam.PageSize, count, trialList);
            
        }

        public DoctorPayInfoQueryListDTO GetReviewerPayInfo(Guid doctorId)
        {
            var doctorQueryable = from doctor in _doctorRepository.Find(u => u.Id == doctorId)
                                  join trialPayInfo in _doctorPayInfoRepository.Find()
                                  on doctor.Id equals trialPayInfo.DoctorId into payInfo
                                  from doctorPayInfo in payInfo.DefaultIfEmpty()
                                  join rankPrice in _rankPriceRepository.Find()
                                  on doctorPayInfo.RankId equals rankPrice.Id into rankPriceInfo
                                  from rankPrice in rankPriceInfo.DefaultIfEmpty()
                                  select new DoctorPayInfoQueryListDTO
                                  {
                                      //Id = doctorPayInfo.Id,
                                      DoctorId = doctor.Id,
                                      Code = doctor.Code,
                                      LastName = doctor.LastName,
                                      FirstName = doctor.FirstName,
                                      ChineseName = doctor.ChineseName,
                                      Phone = doctor.Phone,
                                      DoctorNameInBank = doctorPayInfo.DoctorNameInBank,
                                      IDCard = doctorPayInfo.IDCard,
                                      BankCardNumber = doctorPayInfo.BankCardNumber,
                                      BankName = doctorPayInfo.BankName,
                                      RankId = doctorPayInfo.RankId,
                                      RankName = rankPrice.RankName,
                                      Additional = doctorPayInfo.Additional,
                                      CreateTime = doctor.CreateTime
                                  };

            return doctorQueryable.FirstOrDefault();
        }

        /// <summary>
        /// 根据rankId 获取ReviewerId，用于当Rank的单价信息改变时，触发费用计算
        /// </summary>
        /// <param name="rankId"></param>
        /// <returns></returns>
        public List<Guid> GetReviewerIdByRankId(Guid rankId)
        {
            return _doctorPayInfoRepository.Find(u => u.RankId == rankId).Select(u => u.DoctorId).ToList();
        }
    }
}