using Microsoft.AspNetCore.Authorization;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Org.BouncyCastle.Asn1.Ocsp;
using Shentun.Peis.Enums;
using Shentun.Peis.Models;
using Shentun.Peis.PlugIns;
using Shentun.Peis.PrintReports;
using Shentun.Peis.SysParmValues;
using Shentun.Utilities;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Domain.Entities;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Domain.Services;

namespace Shentun.Peis.LisRequests
{
    public class LisRequestManager : DomainService
    {
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemRepository;
        private readonly IRepository<SampleGroup, Guid> _sampleGroupRepository;
        private readonly IRepository<SampleGroupDetail> _sampleGroupDetailRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly IRepository<ItemType, Guid> _itemTypeRepository;
        private readonly IRepository<SysParmValue> _sysParmValueRepository;
        private readonly IRepository<PrimarykeyBuilder> _primarykeyBuilderRepository;
        private readonly IRepository<LisRequest, Guid> _lisRequestRepository;
        private readonly IRepository<ThirdInterface, Guid> _thirdInterfaceRepository;
        private readonly SysParmValueManager _sysParmValueManager;
        public LisRequestManager(
            IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<RegisterCheckAsbitem, Guid> registerCheckAsbitemRepository,
              IRepository<SampleGroup, Guid> sampleGroupRepository,
            IRepository<SampleGroupDetail> sampleGroupDetailRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<ItemType, Guid> itemTypeRepository,
            IRepository<SysParmValue> sysParmValueRepository,
               IRepository<PrimarykeyBuilder> primarykeyBuilderRepository,
            IRepository<LisRequest, Guid> lisRequestRepository,
            SysParmValueManager sysParmValueManager,
            IRepository<ThirdInterface, Guid> thirdInterfaceRepository
            )
        {
            _patientRegisterRepository = patientRegisterRepository;
            _registerCheckRepository = registerCheckRepository;
            this._registerCheckAsbitemRepository = registerCheckAsbitemRepository;
            this._sampleGroupRepository = sampleGroupRepository;
            this._sampleGroupDetailRepository = sampleGroupDetailRepository;
            this._sysParmValueRepository = sysParmValueRepository;
            this._primarykeyBuilderRepository = primarykeyBuilderRepository;
            this._lisRequestRepository = lisRequestRepository;
            _sysParmValueManager = sysParmValueManager;
            _thirdInterfaceRepository = thirdInterfaceRepository;
            _asbitemRepository = asbitemRepository;
            _itemTypeRepository = itemTypeRepository;
        }


        /// <summary>
        /// 生成检验申请单
        /// </summary>
        /// <param name="patientRegisterId">人员登记ID</param>
        /// <returns></returns>
        public async Task<List<LisRequest>> SetLisRequestAsync(Guid patientRegisterId)
        {
            var sampleGroups = await _sampleGroupRepository.GetListAsync();
            var _sampleGroupDetail = await _sampleGroupDetailRepository.GetListAsync();
            var patientRegisterRequests = (
                       from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                       join registerCheck in await _registerCheckRepository.GetQueryableAsync()
                       on patientRegister.Id equals registerCheck.PatientRegisterId
                       join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
                       on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                       join asbitem in await _asbitemRepository.GetQueryableAsync()
                       on registerCheckAsbitem.AsbitemId equals asbitem.Id
                       join itemType in await _itemTypeRepository.GetQueryableAsync()
                       on asbitem.ItemTypeId equals itemType.Id
                       where patientRegister.Id == patientRegisterId
                       && patientRegister.CompleteFlag != PatientRegisterCompleteFlag.PreRegistration
                       && patientRegister.CompleteFlag != PatientRegisterCompleteFlag.SumCheck
                       && patientRegister.CompleteFlag != PatientRegisterCompleteFlag.Audit
                       &&  itemType.CheckTypeFlag == CheckTypeFlag.Laboratory
                       && registerCheck.CompleteFlag == RegisterCheckCompleteFlag.UnChecked
                       select new
                       {
                           patientRegister,
                           registerCheckAsbitem
                       }).ToList();
            if(!patientRegisterRequests.Any())
            {
                return null;
            }
            var patientRegisterFirst = patientRegisterRequests.First().patientRegister;
            var registerCheckAsbitems = patientRegisterRequests.Select(o => o.registerCheckAsbitem)
                    .Where(o => o.PatientRegisterId == patientRegisterFirst.Id).Distinct().ToList();

            SetLisRequest(patientRegisterFirst, registerCheckAsbitems, sampleGroups, _sampleGroupDetail
                  , out var updateRegisterCheckAsbitems, out var createLisRequests);
            await _lisRequestRepository.InsertManyAsync(createLisRequests, true);
            await _registerCheckAsbitemRepository.UpdateManyAsync(updateRegisterCheckAsbitems, true);
            return createLisRequests;
        }

        public void SetLisRequest(PatientRegister patientRegister,
                                           List<RegisterCheckAsbitem> registerCheckAsbitems,
                                           List<SampleGroup> sampleGroups,
                                           List<SampleGroupDetail> sampleGroupDetails,
                                           out List<RegisterCheckAsbitem> updateRegisterCheckAsbitems,
                                           out List<LisRequest> createLisRequests)
        {
            var registerCheckAsbitemLisList = new List<RegisterCheckAsbitemLis>();
            updateRegisterCheckAsbitems = new List<RegisterCheckAsbitem>();
            foreach (var registerCheckAsbitem in registerCheckAsbitems)
            {
                var sampleGroupDetail = sampleGroupDetails.Where(o => o.AsbitemId == registerCheckAsbitem.AsbitemId).FirstOrDefault();
                if (sampleGroupDetail != null)
                {
                    registerCheckAsbitemLisList.Add(new RegisterCheckAsbitemLis()
                    {
                        RegisterCheckAsbitemId = registerCheckAsbitem.Id,
                        SampleGroupId = sampleGroupDetail.SampleGroupId,
                        LisRequestId = registerCheckAsbitem.LisRequestId,
                    });
                }
            }
            //未设置的申请单设置到相同分组的已有申请单
            var noRequestCheckAsbitems = registerCheckAsbitems.Where(o => o.LisRequestId == null || o.LisRequestId == Guid.Empty).ToList();
            foreach (var registerCheckAsbitem in noRequestCheckAsbitems)
            {
                var registerCheckAsbitemLis = registerCheckAsbitemLisList.Where(o => o.RegisterCheckAsbitemId == registerCheckAsbitem.Id).SingleOrDefault();
                if (registerCheckAsbitemLis == null)
                {
                    continue;
                }
                var haveRegisterCheckAsbitemLis = registerCheckAsbitemLisList.Where(o => o.SampleGroupId == registerCheckAsbitemLis.SampleGroupId
                && o.LisRequestId != null && o.LisRequestId != Guid.Empty).FirstOrDefault();
                if (haveRegisterCheckAsbitemLis != null)
                {
                    registerCheckAsbitem.LisRequestId = haveRegisterCheckAsbitemLis.LisRequestId;
                    updateRegisterCheckAsbitems.Add(registerCheckAsbitem);
                }
            }
            //未设置的项目重新设置申请单
            noRequestCheckAsbitems = registerCheckAsbitems.Where(o => o.LisRequestId == null || o.LisRequestId == Guid.Empty).ToList();
            var noRequestLisList = registerCheckAsbitemLisList.Where(o => noRequestCheckAsbitems.Select(o => o.Id).Contains(o.RegisterCheckAsbitemId)).ToList();
            var sampleGroupids = noRequestLisList.Select(o => o.SampleGroupId).Distinct();
            createLisRequests = new List<LisRequest>();
            foreach (var sampleGroupid in sampleGroupids)
            {
                var sampleGroup = sampleGroups.Where(o => o.Id == sampleGroupid).Single();
                //var guid = GuidGenerator.Create();
                var lisRequest = new LisRequest(GuidGenerator.Create())
                {
                    IsPrint = 'N',
                    IsSignIn = 'N',
                    LisRequestNo = CreateLisRequestNo(patientRegister.MedicalCenterId).Result,
                    SampleContainerId = sampleGroup.SampleContainerId,
                    SampleTypeId = sampleGroup.SampleTypeId
                };
                createLisRequests.Add(lisRequest);
                foreach (var requestLis in noRequestLisList)
                {
                    if (requestLis.SampleGroupId == sampleGroupid)
                    {
                        requestLis.LisRequestId = lisRequest.Id;
                        var registerCheckAsbitem = noRequestCheckAsbitems.Where(o => o.Id == requestLis.RegisterCheckAsbitemId).Single();
                        registerCheckAsbitem.LisRequestId = lisRequest.Id;
                        updateRegisterCheckAsbitems.Add(registerCheckAsbitem);
                    }
                }
            }


        }


        /// <summary>
        /// 追加项目到检验单 如lisrequest内有项目完成体检或者弃检  不允许追加
        /// </summary>
        /// <param name="LisRequestId"></param>
        /// <param name="RegisterCheckAsbitemIds"></param>
        /// <returns></returns>
        public async Task AppendLisRequestAsync(Guid LisRequestId, List<Guid> RegisterCheckAsbitemIds)
        {
            //根据RegisterAsbitemId
            var registerCheckAsbitemInIdList = (await _registerCheckAsbitemRepository.GetQueryableAsync())
                 .Include(x => x.RegisterCheck)
                 .Include(x=>x.Asbitem)
                 .ThenInclude(x=>x.ItemType)
                 .Where(m => RegisterCheckAsbitemIds.Contains(m.Id)).ToList();
            foreach(var registerCheckAsbitem in  registerCheckAsbitemInIdList)
            {
                if(registerCheckAsbitem.Asbitem.ItemType.CheckTypeFlag != CheckTypeFlag.Laboratory)
                {
                    throw new UserFriendlyException($"{registerCheckAsbitem.Asbitem.DisplayName}不是检验项目");
                }
            }
            //根据LisRequestId
            var registerAsbitemInLisRequestIdList = (await _registerCheckAsbitemRepository.GetQueryableAsync())
                 .Include(x => x.RegisterCheck)
                 .Where(m => m.LisRequestId == LisRequestId).ToList();

            if (registerAsbitemInLisRequestIdList.Where(m => m.RegisterCheck.CompleteFlag != RegisterCheckCompleteFlag.UnChecked).Count() > 0)
            {
                //当前条码项目已完成体检或已弃检
                throw new UserFriendlyException("当前条码项目已完成体检或已弃检");
            }

            if (registerCheckAsbitemInIdList.Any())
            {
                registerCheckAsbitemInIdList.ForEach(f => f.LisRequestId = LisRequestId);

                await _registerCheckAsbitemRepository.UpdateManyAsync(registerCheckAsbitemInIdList);
            }
            else
            {
                throw new UserFriendlyException("RegisterAsbitem数据不存在");
            }

        }


        /// <summary>
        /// 追加项目到检验单 生成新的条码号
        /// </summary>
        /// <param name="LisRequestId"></param>
        /// <param name="registerCheckAsbitemIds"></param>
        /// <returns></returns>
        public async Task<List<LisRequest>> AddLisRequestAsync(List<Guid> registerCheckAsbitemIds)
        {
            List<LisRequest> lisRequests = new List<LisRequest>();
            //根据RegisterAsbitem表ID 查找登记的组合项目
            var registerCheckAsbitemeList = (await _registerCheckAsbitemRepository.GetQueryableAsync())
                .Include(x => x.Asbitem)
                .ThenInclude(x => x.ItemType)
                .Include(x => x.PatientRegister)
                .Where(m => registerCheckAsbitemIds.Contains(m.Id))
                .ToList();
            if(!registerCheckAsbitemeList.Any())
            {
                return null;
            }
            foreach (var registerCheckAsbitem in registerCheckAsbitemeList)
            {
                if (registerCheckAsbitem.Asbitem.ItemType.CheckTypeFlag != CheckTypeFlag.Laboratory)
                {
                    throw new UserFriendlyException($"{registerCheckAsbitem.Asbitem.DisplayName}不是检验项目");
                }
            }
            var sampleGroups = await _sampleGroupRepository.GetListAsync();
            var _sampleGroupDetail = await _sampleGroupDetailRepository.GetListAsync();
            var patientRegisterFirst = registerCheckAsbitemeList.First().PatientRegister;

            SetLisRequest(patientRegisterFirst, registerCheckAsbitemeList, sampleGroups, _sampleGroupDetail
                 , out var updateRegisterCheckAsbitems, out var createLisRequests);
            await _lisRequestRepository.InsertManyAsync(createLisRequests, true);
            await _registerCheckAsbitemRepository.UpdateManyAsync(updateRegisterCheckAsbitems, true);
            //if (registerCheckAsbitemeList.Any())
            //{

            //    //根据登记的组合ID 查找组合项目对应的条码分组
            //    var sampleGroupDetailList = await _sampleGroupDetailRepository.GetListAsync(m => registerCheckAsbitemeList.Select(s => s.AsbitemId).Contains(m.AsbitemId));
            //    if (sampleGroupDetailList.Any())
            //    {
            //        //查找条码分组信息  根据条码分组ID
            //        var sampleGroupList = (await _sampleGroupRepository.GetQueryableAsync())
            //            .Include(x => x.SampleContainer)
            //            .Include(x => x.SampleType)
            //            .Where(m => sampleGroupDetailList.Select(s => s.SampleGroupId).Contains(m.Id)).ToList();

            //        foreach (var sampleGroup in sampleGroupList)
            //        {
            //            //根据条码分组生成，一个条码分组生成一个检验单
            //            #region 生成检验申请单

            //            var lisRequestEnt = new LisRequest
            //            {
            //                IsPrint = 'N',
            //                IsSignIn = 'N',
            //                LisRequestNo = await CreateLisRequestNo(registerCheckAsbitemeList.FirstOrDefault().PatientRegister.MedicalCenterId),
            //                SampleContainerId = sampleGroup.SampleContainerId,
            //                SampleTypeId = sampleGroup.SampleTypeId
            //            };

            //            //生成检验申请单的新实体
            //            var lisRequestEnt_New = await _lisRequestRepository.InsertAsync(lisRequestEnt, true);

            //            lisRequests.Add(lisRequestEnt_New);

            //            #region 修改RegisterAsbitem表 LisRequestId 

            //            //当前条码分组ID绑定的组合项目
            //            var AsbitemIds = sampleGroupDetailList.Where(m => m.SampleGroupId == sampleGroup.Id).Select(s => s.AsbitemId);

            //            //获取需要更新的RegisterCheckAsbitem数据
            //            var registerAsbitemeList_Update = await _registerCheckAsbitemRepository.GetListAsync(
            //                f => registerCheckAsbitemIds.Contains(f.Id) && AsbitemIds.Contains(f.AsbitemId));
            //            if (registerAsbitemeList_Update.Any())
            //            {
            //                //更新LisRequestId
            //                registerAsbitemeList_Update.ForEach(m => m.LisRequestId = lisRequestEnt_New.Id);
            //                await _registerCheckAsbitemRepository.UpdateManyAsync(registerAsbitemeList_Update);
            //            }

            //            #endregion

            //            #endregion
            //        }
            //    }
            //}

            return createLisRequests;
        }


        public async Task SendThirdLisRequestAsync(Guid id)
        {
           //var patientRegisterEntity = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
           // join registerCheck in await _registerCheckRepository.GetQueryableAsync()
           // on patientRegister.Id equals registerCheck.PatientRegisterId
           // join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
           // on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
           // join lisRequest in await _lisRequestRepository.GetQueryableAsync()
           // on  registerCheckAsbitem.LisRequestId equals  lisRequest.Id  
           // where lisRequest.Id == id
           // select new
           // {
           //     patientRegister
           // }).ToList().FirstOrDefault();
           // if(patientRegisterEntity == null)
           // {
           //     return;
           // }
            var thirdInterfaces = (await _thirdInterfaceRepository.GetListAsync(o => o.ThirdInterfaceType == ThirdInterfaceTypeFlag.LisRequest 
                             ))
                                   .OrderBy(o => o.DisplayOrder).ToList();
            foreach (var thirdInterface in thirdInterfaces)
            {
                var lisRequestPluginsInput = new LisRequestPlugInsInput()
                {
                    LisRequestId = id
                };

                var parmValue = thirdInterface.ParmValue;
                var configurationBuilder = new ConfigurationBuilder()
                   .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
                var config = configurationBuilder.Build();
                var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
                var className = config.GetSection("Interface").GetSection("ClassName").Value;
                object[] objects = new object[] { lisRequestPluginsInput };
                var LisRequestPluginsOut = await ReflectionHelper.InvokeAsync<LisRequestPlugInsOut>(assemblyName, className, parmValue, "SendRequestAsync", objects);
            }
        }



        /// <summary>
        /// 生成检验申请单条码号(规则，先找体检中心的配置，如未找到，就直接使用全局的)
        /// 模式（0 日期+尾号   1.顺序递增）
        /// </summary>
        /// <param name="medicalCenterId">体检中心ID</param>
        /// <returns></returns>
        private async Task<string> CreateLisRequestNo(Guid medicalCenterId)
        {
            string LisRequestNo = "";  //条码号

            //List<SysParmValue> spvlist = await _sysParmValueRepository.GetListAsync();

            //var spv_tjzx = spvlist.Where(m => m.MedicalCenterId == medicalCenterId); //体检中心配置
            //var spv_global = spvlist.Where(m => m.MedicalCenterId == Guid.Empty);  //全局配置

            string lis_request_no_rule_coding = "0";  // 模式（0 日期+尾号   1.顺序递增）
            string lis_request_no_rule_tail_len = "4";  //尾号长度
            string lis_request_no_rule_prefix = "T"; //前缀
            lis_request_no_rule_coding = await _sysParmValueManager.GetSysParmValueAsync(medicalCenterId, "lis_request_no_rule_coding");
            lis_request_no_rule_tail_len = await _sysParmValueManager.GetSysParmValueAsync(medicalCenterId, "lis_request_no_rule_tail_len");
            lis_request_no_rule_prefix = await _sysParmValueManager.GetSysParmValueAsync(medicalCenterId, "lis_request_no_rule_prefix");
            if (string.IsNullOrWhiteSpace(lis_request_no_rule_coding))
            {
                throw new UserFriendlyException("LIS编码方式不能为空");
            }
            if (string.IsNullOrWhiteSpace(lis_request_no_rule_tail_len))
            {
                throw new UserFriendlyException("LIS编码尾号长度不能为空");
            }
            int tailLen = 0;
            if (!int.TryParse(lis_request_no_rule_tail_len, out tailLen))
            {
                throw new UserFriendlyException("LIS编码尾号长度不能为空");
            }
            if (tailLen < 3)
            {
                throw new UserFriendlyException("LIS编码尾号长度至少为3位");
            }
            if (string.IsNullOrWhiteSpace(lis_request_no_rule_prefix))
            {
                lis_request_no_rule_prefix = "";
            }
            var primarykeyBuilderEnt = await _primarykeyBuilderRepository.FirstOrDefaultAsync(f => f.PrimarykeyBuilderId == "lis_request_no");




            string maxnum = "1";
            string date = DateTime.Now.ToString("yyMMdd");// 当天

            if (lis_request_no_rule_coding == "0")
            {
                //日期+尾号    
                #region 模式0  日期+尾号

                if (primarykeyBuilderEnt != null)
                {
                    if (primarykeyBuilderEnt.DateString != date)
                    {
                        //新的日期  为1  maxnum
                        primarykeyBuilderEnt.DateString = date;
                        maxnum = "1";
                    }
                    else
                    {
                        maxnum = (Convert.ToInt32(primarykeyBuilderEnt.SerialNo) + 1).ToString();
                    }
                  
                   
                    primarykeyBuilderEnt.SerialNo = maxnum; //更新新的序列号

                    LisRequestNo = lis_request_no_rule_prefix + date + maxnum.PadLeft(Convert.ToInt32(lis_request_no_rule_tail_len), '0');

                    await _primarykeyBuilderRepository.UpdateAsync(primarykeyBuilderEnt);
                }
                else
                {
                    //初始写入

                    LisRequestNo = lis_request_no_rule_prefix + date + maxnum.PadLeft(Convert.ToInt32(lis_request_no_rule_tail_len), '0');

                    primarykeyBuilderEnt = new PrimarykeyBuilder
                    {
                        PrimarykeyBuilderId = "lis_request_no",
                        DateString = date,
                        SerialNo = maxnum
                    };

                    await _primarykeyBuilderRepository.InsertAsync(primarykeyBuilderEnt,true);
                }
                #endregion
            }
            else
            {
                //模式1  顺序递增   

                #region 模式1  顺序递增

                if (primarykeyBuilderEnt != null)
                {
                    maxnum = (Convert.ToInt32(primarykeyBuilderEnt.SerialNo) + 1).ToString();
                    primarykeyBuilderEnt.SerialNo = maxnum;  //更新num
                    await _primarykeyBuilderRepository.UpdateAsync(primarykeyBuilderEnt);
                }
                else
                {
                    //初始写入

                    primarykeyBuilderEnt = new PrimarykeyBuilder
                    {
                        PrimarykeyBuilderId = "lis_request_no",
                        DateString = "",
                        SerialNo = maxnum
                    };

                    await _primarykeyBuilderRepository.InsertAsync(primarykeyBuilderEnt,true);
                }


                LisRequestNo = lis_request_no_rule_prefix + maxnum.PadLeft(Convert.ToInt32(lis_request_no_rule_tail_len), '0');
                #endregion

            }

            return LisRequestNo;

        }

        private class RegisterCheckAsbitemLis
        {
            public Guid RegisterCheckAsbitemId { get; set; }
            public Guid SampleGroupId { get; set; }
            public Guid? LisRequestId { get; set; }
        }
        //private async Task<LisRequestPlugInsOut> InvokeAsync(string assemblyName, string className, string classConstructorArg, string methodName, object[] args = null)
        //{
        //    Assembly assembly = Assembly.Load(assemblyName);
        //    Type type = assembly.GetType(className);
        //    // 创建类的实例
        //    object instance = Activator.CreateInstance(type, classConstructorArg);
        //    // 获取方法信息
        //    MethodInfo method = type.GetMethod(methodName);
        //    // 调用方法,如果方法需要参数，可以传入对应的参数数组，例如: new object[] { arg1, arg2 }
        //    LisRequestPlugInsOut returnValue;
        //    var isAsync = (method.ReturnType == typeof(Task) ||
        //        (method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(Task<>)));
        //    if (isAsync)
        //    {
        //        // 使用反射调用方法

        //        //object returnValue = method.Invoke(instance, args);
        //        returnValue = await (Task<LisRequestPlugInsOut>)method.Invoke(instance, args);
        //    }
        //    else
        //    {
        //        returnValue = (LisRequestPlugInsOut)method.Invoke(instance, args);

        //    }
        //    return returnValue;
        //}
    }
}