using FellowOakDicom.Network;
using FellowOakDicom;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using IRaCIS.Core.SCP.Service;
using IRaCIS.Core.Domain.Models;
using IRaCIS.Core.Infra.EFCore;
using Medallion.Threading;
using IRaCIS.Core.Domain.Share;
using Serilog;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion.Internal;
using Microsoft.Extensions.Options;
using System.Data;
using FellowOakDicom.Imaging;
using SharpCompress.Common;
using SixLabors.ImageSharp.Formats.Jpeg;
using IRaCIS.Core.Infrastructure;

namespace IRaCIS.Core.SCP.Service
{
    /// <summary>
    /// 后台托管服务的方式运行
    /// </summary>
    //public class CStoreSCPHostedService : IHostedService
    //{
    //    private readonly ILogger<CStoreSCPHostedService> _logger;
    //    private readonly IDicomServerFactory _dicomServerFactory;
    //    private IDicomServer? _server;

    //    public CStoreSCPHostedService(ILogger<CStoreSCPHostedService> logger, IDicomServerFactory dicomServerFactory)
    //    {
    //        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
    //        _dicomServerFactory = dicomServerFactory ?? throw new ArgumentNullException(nameof(dicomServerFactory));
    //    }

    //    public async Task StartAsync(CancellationToken cancellationToken)
    //    {
    //        _logger.LogInformation("Starting DICOM server");
    //        _server = _dicomServerFactory.Create<CStoreSCPService>(104);
    //        _logger.LogInformation("DICOM server is running");
    //    }

    //    public Task StopAsync(CancellationToken cancellationToken)
    //    {
    //        if (_server != null)
    //        {
    //            _server.Stop();
    //            _server.Dispose();
    //            _server = null;
    //        }
    //        return Task.CompletedTask;
    //    }
    //}
    public class DicomSCPServiceOption
    {
        public List<string> CalledAEList { get; set; }

        public string ServerPort { get; set; }
    }




    public class CStoreSCPService : DicomService, IDicomServiceProvider, IDicomCStoreProvider, IDicomCEchoProvider
    {
        private IServiceProvider _serviceProvider { get; set; }

        private List<Guid> _SCPStudyIdList { get; set; } = new List<Guid>();

        private SCPImageUpload _upload { get; set; }


        private static readonly DicomTransferSyntax[] _acceptedTransferSyntaxes = new DicomTransferSyntax[]
        {
               DicomTransferSyntax.ExplicitVRLittleEndian,
               DicomTransferSyntax.ExplicitVRBigEndian,
               DicomTransferSyntax.ImplicitVRLittleEndian
        };

        private static readonly DicomTransferSyntax[] _acceptedImageTransferSyntaxes = new DicomTransferSyntax[]
        {
               // Lossless
               DicomTransferSyntax.JPEGLSLossless,
               DicomTransferSyntax.JPEG2000Lossless,
               DicomTransferSyntax.JPEGProcess14SV1,
               DicomTransferSyntax.JPEGProcess14,
               DicomTransferSyntax.RLELossless,
               // Lossy
               DicomTransferSyntax.JPEGLSNearLossless,
               DicomTransferSyntax.JPEG2000Lossy,
               DicomTransferSyntax.JPEGProcess1,
               DicomTransferSyntax.JPEGProcess2_4,
               // Uncompressed
               DicomTransferSyntax.ExplicitVRLittleEndian,
               DicomTransferSyntax.ExplicitVRBigEndian,
               DicomTransferSyntax.ImplicitVRLittleEndian
        };


        public CStoreSCPService(INetworkStream stream, Encoding fallbackEncoding, Microsoft.Extensions.Logging.ILogger log, DicomServiceDependencies dependencies)
            : base(stream, fallbackEncoding, log, dependencies)
        {
        }




        public Task OnReceiveAssociationRequestAsync(DicomAssociation association)
        {

            _upload = new SCPImageUpload() { StartTime = DateTime.Now, CallingAE = association.CallingAE, CalledAE = association.CalledAE, CallingAEIP = association.RemoteHost };


            Log.Logger.Warning($"接收到来自{association.CallingAE}的连接");

            _serviceProvider = (IServiceProvider)this.UserState;

            var option = _serviceProvider.GetService<IOptionsMonitor<DicomSCPServiceOption>>().CurrentValue;



            var calledAEList = option.CalledAEList;

            if (!calledAEList.Contains(association.CalledAE))

            //if (association.CalledAE != "STORESCP")
            {

                Log.Logger.Warning($"拒绝CalledAE:{association.CalledAE}的连接");

                return SendAssociationRejectAsync(
                    DicomRejectResult.Permanent,
                    DicomRejectSource.ServiceUser,
                    DicomRejectReason.CalledAENotRecognized);
            }

            foreach (var pc in association.PresentationContexts)
            {
                if (pc.AbstractSyntax == DicomUID.Verification)
                {
                    pc.AcceptTransferSyntaxes(_acceptedTransferSyntaxes);
                }
                else if (pc.AbstractSyntax.StorageCategory != DicomStorageCategory.None)
                {
                    pc.AcceptTransferSyntaxes(_acceptedImageTransferSyntaxes);
                }
            }

            return SendAssociationAcceptAsync(association);
        }


        public async Task OnReceiveAssociationReleaseRequestAsync()
        {
            await DataMaintenanceAsaync();

            //记录监控

            var _SCPImageUploadRepository = _serviceProvider.GetService<IRepository<SCPImageUpload>>();

            _upload.EndTime = DateTime.Now;
            _upload.StudyCount = _SCPStudyIdList.Count;

            await _SCPImageUploadRepository.AddAsync(_upload,true);

            await SendAssociationReleaseResponseAsync();
        }


        private async Task DataMaintenanceAsaync()
        {
            Log.Logger.Warning($"CallingAE:{Association.CallingAE} CalledAE:{Association.CalledAE}传输结束：开始维护数据，处理检查Modality 以及自动创建访视，绑定检查");

            //var patientStudyService = _serviceProvider.GetService<IPatientStudyService>();

            //await patientStudyService.AutoBindingPatientStudyVisitAsync(_SCPStudyIdList);

            //处理检查Modality
            var _dictionaryRepository = _serviceProvider.GetService<IRepository<Dictionary>>();
            var _seriesRepository = _serviceProvider.GetService<IRepository<SCPSeries>>();
            var _studyRepository = _serviceProvider.GetService<IRepository<SCPStudy>>();

            var dicModalityList = _dictionaryRepository.Where(t => t.Code == "Modality").SelectMany(t => t.ChildList.Select(c => c.Value)).ToList();
            var seriesModalityList = _seriesRepository.Where(t => _SCPStudyIdList.Contains(t.StudyId)).Select(t => new { SCPStudyId = t.StudyId, t.Modality }).ToList();

            foreach (var g in seriesModalityList.GroupBy(t => t.SCPStudyId))
            {
                var modality = string.Join('、', g.Select(t => t.Modality).Distinct().ToList());

                //特殊逻辑
                var modalityForEdit = dicModalityList.Contains(modality) ? modality : String.Empty;

                if (modality == "MR")
                {
                    modalityForEdit = "MRI";
                }

                if (modality == "PT")
                {
                    modalityForEdit = "PET";
                }
                if (modality == "PT、CT" || modality == "CT、PT")
                {
                    modalityForEdit = "PET-CT";
                }

                await _studyRepository.BatchUpdateNoTrackingAsync(t => t.Id == g.Key, u => new SCPStudy() { Modalities = modality, ModalityForEdit = modalityForEdit });

            }

            Log.Logger.Warning($"CallingAE:{Association.CallingAE} CalledAE:{Association.CalledAE}维护数据结束");
        }

        public void OnReceiveAbort(DicomAbortSource source, DicomAbortReason reason)
        {
            Log.Logger.Warning($"CallingAE:{Association.CallingAE} CalledAE:{Association.CalledAE}接收中断，中断原因：{source.ToString() + reason.ToString()}");
            /* nothing to do here */
        }


        public async void OnConnectionClosed(Exception exception)
        {
            /* nothing to do here */

            //奇怪的bug  上传的时候，用王捷修改的影像，会关闭，重新连接，导致检查id 丢失，然后状态不一致
            if (exception == null)
            {
                var _studyRepository = _serviceProvider.GetService<IRepository<SCPStudy>>();
                //将检查设置为传输结束
                await _studyRepository.BatchUpdateNoTrackingAsync(t => _SCPStudyIdList.Contains(t.Id), u => new SCPStudy() { IsUploadFinished = true });

                await _studyRepository.SaveChangesAndClearAllTrackingAsync();
            }

            Log.Logger.Warning($"连接关闭 {exception?.Message} {exception?.InnerException?.Message}");
        }




        public async Task<DicomCStoreResponse> OnCStoreRequestAsync(DicomCStoreRequest request)
        {

            string studyInstanceUid = request.Dataset.GetString(DicomTag.StudyInstanceUID);
            string seriesInstanceUid = request.Dataset.GetString(DicomTag.SeriesInstanceUID);
            string sopInstanceUid = request.Dataset.GetString(DicomTag.SOPInstanceUID);

            Guid seriesId = IdentifierHelper.CreateGuid(studyInstanceUid, seriesInstanceUid);
            Guid instanceId = IdentifierHelper.CreateGuid(studyInstanceUid, seriesInstanceUid, sopInstanceUid);


            var ossService = _serviceProvider.GetService<IOSSService>();
            var dicomArchiveService = _serviceProvider.GetService<IDicomArchiveService>();
            var _seriesRepository = _serviceProvider.GetService<IRepository<SCPSeries>>();

            var _distributedLockProvider = _serviceProvider.GetService<IDistributedLockProvider>();

            var storeRelativePath = string.Empty;
            var ossFolderPath = $"Dicom/{studyInstanceUid}";


            long fileSize = 0;
            try
            {

                using (MemoryStream ms = new MemoryStream())
                {
                    await request.File.SaveAsync(ms);

                    //irc 从路径最后一截取Guid
                    storeRelativePath = await ossService.UploadToOSSAsync(ms, ossFolderPath, instanceId.ToString(), false);

                    fileSize = ms.Length;
                }

                Log.Logger.Information($"CallingAE:{Association.CallingAE} CalledAE:{Association.CalledAE} {request.SOPInstanceUID} 上传完成 ");

            }
            catch (Exception ec)
            {
                Log.Logger.Warning($"CallingAE:{Association.CallingAE} CalledAE:{Association.CalledAE} 上传异常 {ec.Message}");
            }



            var @lock = _distributedLockProvider.CreateLock($"{studyInstanceUid}");

            using (await @lock.AcquireAsync())
            {
                try
                {
                    var scpStudyId = await dicomArchiveService.ArchiveDicomFileAsync(request.Dataset, storeRelativePath, Association.CallingAE, Association.CalledAE);

                    if (!_SCPStudyIdList.Contains(scpStudyId))
                    {
                        _SCPStudyIdList.Add(scpStudyId);
                    }

                    var series = await _seriesRepository.FindAsync(seriesId);

                    //没有缩略图
                    if (series != null && string.IsNullOrEmpty(series.ImageResizePath))
                    {

                        // 生成缩略图
                        using (var memoryStream = new MemoryStream())
                        {
                            DicomImage image = new DicomImage(request.Dataset);

                            var sharpimage = image.RenderImage().AsSharpImage();
                            sharpimage.Save(memoryStream, new JpegEncoder());

                            // 上传缩略图到 OSS

                            var seriesPath = await ossService.UploadToOSSAsync(memoryStream, ossFolderPath, seriesId.ToString() + ".preview.jpg", false);

                            Console.WriteLine(seriesPath + "  Id:  " + seriesId);

                            series.ImageResizePath = seriesPath;



                            //await _seriesRepository.BatchUpdateNoTrackingAsync(t => t.Id == seriesId, u => new SCPSeries() { ImageResizePath = seriesPath });


                        }
                    }

                    await _seriesRepository.SaveChangesAsync();
                }
                catch (Exception ex)
                {

                    Log.Logger.Warning($"CallingAE:{Association.CallingAE} CalledAE:{Association.CalledAE} 传输处理异常：{ex.ToString()}");

                }

            }



            //监控信息设置
            _upload.FileCount++;
            _upload.FileSize= _upload.FileSize+ fileSize;
            return new DicomCStoreResponse(request, DicomStatus.Success);
        }


        public Task OnCStoreRequestExceptionAsync(string tempFileName, Exception e)
        {
            // let library handle logging and error response
            return Task.CompletedTask;
        }


        public Task<DicomCEchoResponse> OnCEchoRequestAsync(DicomCEchoRequest request)
        {
            return Task.FromResult(new DicomCEchoResponse(request, DicomStatus.Success));
        }

    }
}