//--------------------------------------------------------------------
//     此代码由T4模板自动生成  byzhouhang 20210918
//	   生成时间 2022-08-12 14:07:20 
//     对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//--------------------------------------------------------------------

using IRaCIS.Core.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Infra.EFCore.Common;

namespace IRaCIS.Core.Application.Service
{
    /// <summary>
    /// 器官服务层
    /// </summary>	
    [ApiExplorerSettings(GroupName = "Reading")]
    public class OrganInfoService : BaseService, IOrganInfoService
    {

        private readonly IRepository<OrganInfo> _organInfoRepository;
        private readonly IRepository<OrganTrialInfo> _organTrialInfoRepository;

        public OrganInfoService(
            IRepository<OrganInfo> organInfoRepository,
            IRepository<OrganTrialInfo> organTrialInfoRepository
            )
        {
            _organInfoRepository = organInfoRepository;
            this._organTrialInfoRepository = organTrialInfoRepository;
        }


        /// <summary>
        /// 获取系统器官信息
        /// </summary>
        /// <param name="inQuery"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<OrganInfoView>> GetOrganInfoList(OrganInfoQuery inQuery)
        {
            var organInfoQueryable = _organInfoRepository
            .WhereIf(!inQuery.TypeName.IsNullOrEmpty(),x=>x.TypeName==inQuery.TypeName)
            .ProjectTo<OrganInfoView>(_mapper.ConfigurationProvider);
            return await organInfoQueryable.ToListAsync();
        }


        /// <summary>
        /// 新增或修改系统器官数据
        /// </summary>
        /// <param name="addOrEditOrganInfo"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateOrganInfo(OrganInfoAddOrEdit addOrEditOrganInfo)
        {
            var entity = await _organInfoRepository.InsertOrUpdateAsync(addOrEditOrganInfo, true);
            return ResponseOutput.Ok(entity.Id.ToString());
        }


        /// <summary>
        /// 删除系统器官
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpDelete("{Id:guid}")]
        public async Task<IResponseOutput> DeleteOrganInfo(Guid Id)
        {
            var success = await _organInfoRepository.DeleteFromQueryAsync(t => t.Id == Id, true);
            return ResponseOutput.Ok();
        }


        /// <summary>
        /// 批量添加项目器官
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<IResponseOutput> BatchAddTrialOrgan(BatchAddTrialOrganInDto inDto)
        {
            await _organTrialInfoRepository.BatchDeleteNoTrackingAsync(t => t.TrialId==inDto.TrialId&&t.OrganType == inDto.OrganType);

            List<OrganTrialInfo> organTrialInfos = inDto.OrganIds.Select(x => new OrganTrialInfo()
            {
                OrganInfoId=x,
                TrialId=inDto.TrialId,
                OrganType=inDto.OrganType,
            }).ToList();


            await _organTrialInfoRepository.AddRangeAsync(organTrialInfos);

            await _organInfoRepository.SaveChangesAsync();

            return ResponseOutput.Ok();
        }

        /// <summary>
        /// 删除系统器官
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpDelete("{Id:guid}")]
        public async Task<IResponseOutput> DeleteTrialOrganInfo(Guid Id)
        {
            var success = await _organTrialInfoRepository.DeleteFromQueryAsync(t => t.Id == Id, true);
            return ResponseOutput.Ok();
        }


        /// <summary>
        /// 获取项目器官信息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetTrialOrganListOutDto>> GetTrialOrganList(GetTrialOrganListInDto inDto)
        {
            var organInfoQueryable = from data in _organInfoRepository.Where(x => x.OrganType == inDto.OrganType)
                                     join trialData in _organTrialInfoRepository.Where(x => x.TrialId == inDto.TrialId && x.OrganType == inDto.OrganType)
                                     on data.Id equals trialData.OrganInfoId
                                     select new GetTrialOrganListOutDto()
                                     {
                                         Id = trialData.Id,
                                         Part = data.Part,
                                         TULAT = data.TULAT,
                                         TULOC = data.TULOC,
                                         TypeName = data.TypeName,
                                         Remark= data.Remark,
                                         OrganType=data.OrganType,
                                     };


            return await organInfoQueryable.ToListAsync();
        }



        /// <summary>
        /// 获取项目勾选器官信息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetTrialCheckOrganList>> GetTrialCheckOrganList(GetTrialOrganListInDto inDto)
        {
            var organInfoQueryable = from data in _organInfoRepository.Where(x => x.OrganType == inDto.OrganType)
                                     join trialData in _organTrialInfoRepository.Where(x => x.TrialId == inDto.TrialId && x.OrganType == inDto.OrganType)
                                     on data.Id equals trialData.OrganInfoId into jtemp
                                     from leftjoin in jtemp.DefaultIfEmpty()
                                     select new GetTrialCheckOrganList()
                                     {
                                         Id = data.Id,
                                         Part = data.Part,
                                         TULAT = data.TULAT,
                                         TULOC = data.TULOC,
                                         TypeName = data.TypeName,
                                         IsCheckd= leftjoin!=null,
                                         Remark = data.Remark,

                                     };


            return await organInfoQueryable.ToListAsync();
        }

    }
}