using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Shentun.Peis.Enums;
using Shentun.Peis.Models;
using Shentun.Peis.PatientRegisters;
using Shentun.Peis.SumSuggestionContents;
using Shentun.Peis.SumSummaryContents;
using Shentun.Peis.SumSummaryHeaders;
using Shentun.Peis.SysParmValues;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;

namespace Shentun.Peis.SumSuggestionHeaders
{
    /// <summary>
    /// 总检诊台建议
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class SumSuggestionHeaderAppService : ApplicationService
    {
        private readonly IRepository<SumSuggestionHeader, Guid> _sumSuggestionHeaderRepository;
        private readonly IRepository<SumSuggestionContent, Guid> _sumSuggestionContentRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<SumDiagnosis> _sumDiagnosisRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<Diagnosis, Guid> _diagnosisRepository;
        private readonly SumSummaryHeaderManager _sumSummaryHeaderManager;
        private readonly SysParmValueManager _sysParmValueManager;
        public SumSuggestionHeaderAppService(
            IRepository<SumSuggestionHeader, Guid> sumSuggestionHeaderRepository,
            IRepository<SumSuggestionContent, Guid> sumSuggestionContentRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<SumDiagnosis> sumDiagnosisRepository,
            IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<Diagnosis, Guid> diagnosisRepository,
            SumSummaryHeaderManager sumSummaryHeaderManager,
            SysParmValueManager sysParmValueManager
            )
        {
            this._sumSuggestionHeaderRepository = sumSuggestionHeaderRepository;
            this._sumSuggestionContentRepository = sumSuggestionContentRepository;
            this._registerCheckRepository = registerCheckRepository;
            this._sumDiagnosisRepository = sumDiagnosisRepository;
            _patientRegisterRepository = patientRegisterRepository;
            _sumSummaryHeaderManager = sumSummaryHeaderManager;
            _diagnosisRepository = diagnosisRepository;
            _sysParmValueManager = sysParmValueManager;
        }


        /// <summary>
        /// 获取人员总检诊台建议 （如还未录入，获取医生诊台录入的建议）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/sumsuggestionheader/GetSumSuggestionList")]
        public async Task<List<SumSuggestionDto>> GetSumSuggestionListAsync(PatientRegisterSumInputDto input)
        {
            if (input is null)
            {
                throw new UserFriendlyException("input参数不能为空");
            }

            List<SumSuggestionDto> msg = new List<SumSuggestionDto>();

            var patientRegister = await _patientRegisterRepository.GetAsync(input.PatientRegisterId);
            var query = from sumSuggestionHeader in await _sumSuggestionHeaderRepository.GetQueryableAsync()
                        join sumDiagnosis in await _sumDiagnosisRepository.GetQueryableAsync()
                        on new { sumSuggestionHeader.PatientRegisterId, sumSuggestionHeader.Id } equals new { sumDiagnosis.PatientRegisterId, Id = sumDiagnosis.SumSuggestionHeaderId } into bb
                        from sumDiagnosisHaveEmpty in bb.DefaultIfEmpty()
                        join diagnosis in await _diagnosisRepository.GetQueryableAsync()
                        on sumDiagnosisHaveEmpty.DiagnosisId equals diagnosis.Id into diagnosisTemp
                        from diagnosisHaveEmpty in diagnosisTemp.DefaultIfEmpty()
                        join sumSuggestionContent in await _sumSuggestionContentRepository.GetQueryableAsync()
                        on sumSuggestionHeader.Id equals sumSuggestionContent.SumSuggestionHeaderId into cc
                        from sumSuggestionContentHaveEmpty in cc.DefaultIfEmpty()
                        where (sumSuggestionHeader.PatientRegisterId == input.PatientRegisterId)
                        orderby sumSuggestionHeader.DisplayOrder ascending, sumSuggestionContentHaveEmpty.DisplayOrder ascending
                        select new
                        {
                            sumSuggestionHeader,
                            sumDiagnosisHaveEmpty,
                            diagnosisHaveEmpty,
                            sumSuggestionContentHaveEmpty
                        };


            if (patientRegister.CompleteFlag == PatientRegisterCompleteFlag.SumCheck || input.IsGetExistData == "Y")
            {
                msg = query.GroupBy(g => g.sumSuggestionHeader.Id).Select(s => new SumSuggestionDto
                {
                    SuggestionTitle = s.FirstOrDefault().sumSuggestionHeader.SuggestionTitle,
                    SuggestionFlag = s.FirstOrDefault().sumSuggestionHeader.SuggestionFlag,
                    DisplayOrder = s.FirstOrDefault().sumSuggestionHeader.DisplayOrder,
                    DiagnosisIds = s.Where(o => o.sumDiagnosisHaveEmpty != null).
                    Select(x => x.sumDiagnosisHaveEmpty.DiagnosisId).Distinct().ToList(),
                    DiagnosisNames = s.Where(m => m.diagnosisHaveEmpty != null).Select(x => x.diagnosisHaveEmpty.DisplayName).Distinct().ToList(),
                    MedicalInterpretations = s.Where(m => m.sumSuggestionContentHaveEmpty != null &&
                     m.sumSuggestionContentHaveEmpty.SuggestionType == SuggestionTypeFlag.MedicalInterpretation).
                    Select(sa => new SumSuggestionContentData
                    {
                        DisplayOrder = sa.sumSuggestionContentHaveEmpty.DisplayOrder,
                        SuggestionContent = sa.sumSuggestionContentHaveEmpty.SuggestionContent,
                    }).OrderBy(o => o.DisplayOrder).Distinct().ToList(),
                    CommonReasons = s.Where(m => m.sumSuggestionContentHaveEmpty != null &&
                    m.sumSuggestionContentHaveEmpty.SuggestionType == SuggestionTypeFlag.CommonReasons).
                    Select(sa => new SumSuggestionContentData
                    {
                        DisplayOrder = sa.sumSuggestionContentHaveEmpty.DisplayOrder,
                        SuggestionContent = sa.sumSuggestionContentHaveEmpty.SuggestionContent,
                    }).OrderBy(o => o.DisplayOrder).Distinct().ToList(),
                    HealthGuidances = s.Where(m => m.sumSuggestionContentHaveEmpty != null &&
                    m.sumSuggestionContentHaveEmpty.SuggestionType == SuggestionTypeFlag.HealthGuidance).
                    Select(sa => new SumSuggestionContentData
                    {
                        DisplayOrder = sa.sumSuggestionContentHaveEmpty.DisplayOrder,
                        SuggestionContent = sa.sumSuggestionContentHaveEmpty.SuggestionContent,
                    }).OrderBy(o => o.DisplayOrder).Distinct().ToList(),

                }).OrderBy(o => o.DisplayOrder).ToList();
            }
            else
            {
                //没有值的情况
                var checklist = await _sumSummaryHeaderManager.GetSumSummarysByDoctorCheck(input.PatientRegisterId);
                //获取所有综述
                var registerCheckSummaries = new List<string>();
                foreach (var registerCheck in checklist)
                {

                    foreach (var registerCheckSummary in registerCheck.RegisterCheckSummaries)
                    {
                        registerCheckSummaries.Add(registerCheckSummary.Summary);
                    }

                }
                //根据综述生成建议
                var diagnosis = (await _diagnosisRepository.GetQueryableAsync()).Include(o => o.Suggestions).ToList();

                foreach (var registerCheckSummary in registerCheckSummaries)
                {
                    var matchDiagnosisList = diagnosis.Where(o => registerCheckSummary.Contains(o.DisplayName)).ToList();
                    var matchDiagnosis = matchDiagnosisList.OrderByDescending(o => o.DisplayName.Length).FirstOrDefault();
                    if (matchDiagnosis != null)
                    {
                        if (msg.Where(o => o.SuggestionTitle == matchDiagnosis.DisplayName).Count() > 0)
                        {
                            continue;
                        }
                        var sumSuggestionDto = new SumSuggestionDto()
                        {
                            SuggestionTitle = matchDiagnosis.DisplayName,
                            SuggestionFlag = null,
                            DisplayOrder = 0,
                            DiagnosisIds = new List<Guid>() { matchDiagnosis.Id },
                            DiagnosisNames = new List<string>() { matchDiagnosis.DisplayName },
                            MedicalInterpretations = matchDiagnosis.Suggestions.
                            Where(o => o.SuggestionType == SuggestionTypeFlag.MedicalInterpretation)
                            .OrderBy(o => o.DisplayOrder)
                            .Select(x => new SumSuggestionContentData()
                            {
                                SuggestionContent = x.SuggestionContent,
                                DisplayOrder = x.DisplayOrder,
                            }
                             ).ToList(),
                            CommonReasons = matchDiagnosis.Suggestions.
                            Where(o => o.SuggestionType == SuggestionTypeFlag.CommonReasons)
                            .OrderBy(o => o.DisplayOrder)
                            .Select(x => new SumSuggestionContentData()
                            {
                                SuggestionContent = x.SuggestionContent,
                                DisplayOrder = x.DisplayOrder,
                            }
                             ).ToList(),
                            HealthGuidances = matchDiagnosis.Suggestions.
                            Where(o => o.SuggestionType == SuggestionTypeFlag.HealthGuidance)
                            .OrderBy(o => o.DisplayOrder)
                            .Select(x => new SumSuggestionContentData()
                            {
                                SuggestionContent = x.SuggestionContent,
                                DisplayOrder = x.DisplayOrder,
                            }
                             ).ToList()
                        };
                        msg.Add(sumSuggestionDto);
                    }

                }
                var summaryCheckDefaultSuggestionHeader = await _sysParmValueManager.
               GetSysParmValueAsync(patientRegister.MedicalCenterId,
               "summary_check_default_suggestion_header");
                if (!msg.Any())
                {
                    msg.Add(new SumSuggestionDto()
                    {
                        SuggestionTitle = summaryCheckDefaultSuggestionHeader,
                        SuggestionFlag = null,
                        DisplayOrder = 0,
                        DiagnosisIds = null,
                        DiagnosisNames = null
                    });
                }

            }
            return msg;
        }


        /// <summary>
        /// 批量插入总诊台建议
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/sumsuggestionheader/createsumsuggestion")]
        public async Task CreateSumSuggestionAsync(List<CreateSumSuggestionHeaderOrContentDto> input)
        {
            throw new UserFriendlyException("禁止使用");
            if (input.Any())
            {

                //先删除总诊头跟内容
                await _sumSuggestionHeaderRepository.DeleteAsync(m => m.PatientRegisterId == input.FirstOrDefault().PatientRegisterId, true);

                //删除对应的诊断数据
                await _sumDiagnosisRepository.DeleteAsync(m => m.PatientRegisterId == input.FirstOrDefault().PatientRegisterId, true);

                foreach (var item in input)
                {
                    #region 插入SumSuggestionHeader
                    SumSuggestionHeader sumSuggestionHeaderEnt = new SumSuggestionHeader
                    {
                        DisplayOrder = input.IndexOf(item) + 1,
                        PatientRegisterId = item.PatientRegisterId,
                        SuggestionFlag = null,
                        SuggestionTitle = item.SuggestionTitle
                    };

                    var sumSuggestionHeaderEnt_New = await _sumSuggestionHeaderRepository.InsertAsync(sumSuggestionHeaderEnt, true);

                    if (sumSuggestionHeaderEnt_New != null)
                    {

                        #region 插入SumDiagnosis
                        if (item.DiagnosisId != null && item.DiagnosisId != Guid.Empty)
                        {

                            SumDiagnosis sumDiagnosis = new SumDiagnosis
                            {
                                DiagnosisId = item.DiagnosisId.Value,
                                DisplayOrder = input.IndexOf(item) + 1,
                                PatientRegisterId = item.PatientRegisterId,
                                SumSuggestionHeaderId = sumSuggestionHeaderEnt_New.Id
                            };

                            await _sumDiagnosisRepository.InsertAsync(sumDiagnosis);
                        }
                        #endregion

                        #region 插入SumSuggestionContent
                        List<SumSuggestionContent> sumSuggestionContentList = new List<SumSuggestionContent>();
                        foreach (var item2 in item.Details)
                        {
                            SumSuggestionContent sumSuggestionContentEnt = new SumSuggestionContent
                            {
                                DisplayOrder = item.Details.IndexOf(item2) + 1,
                                SuggestionContent = item2.SuggestionContent,
                                SumSuggestionHeaderId = sumSuggestionHeaderEnt_New.Id
                            };

                            sumSuggestionContentList.Add(sumSuggestionContentEnt);
                        }

                        await _sumSuggestionContentRepository.InsertManyAsync(sumSuggestionContentList);
                        #endregion
                    }
                    #endregion
                }
            }
        }



        /// <summary>
        /// 清空总诊台建议内容
        /// </summary>
        /// <param name="PatientRegisterId"></param>
        /// <returns></returns>
        [HttpPost("api/app/sumsuggestionheader/deletesumsuggestionmany")]
        public async Task DeleteSumSuggestionManyAsync(Guid PatientRegisterId)
        {
            if (PatientRegisterId != Guid.Empty)
            {
                await _sumSuggestionHeaderRepository.DeleteAsync(d => d.PatientRegisterId == PatientRegisterId);
                //删除对应的诊断数据
                await _sumDiagnosisRepository.DeleteAsync(m => m.PatientRegisterId == PatientRegisterId);
            }
            else
            {
                throw new UserFriendlyException("请求参数有误");
            }
        }
    }
}