WingAIDiagnosisService/Service/AIDiagnosisService.cs

using WingServerCommon.Service;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.Enum;
using WingServerCommon.Config;
using WingServerCommon.Config.Parameters;
using WingAIDiagnosisService.Carotid.Utilities;
using Vinno.vCloud.Common.Vid2;
using WingAIDiagnosisService.Manage;
using WingAIDiagnosisService.Carotid;
using Newtonsoft.Json;
using AI.DiagSystem;
using WingServerCommon.Log;
using System.IO;
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;
using AI.Common;
using System.Threading;
using AI.Common.Log;
using SkiaSharp;
using System.Net.Http;
using System.Net;
using WingInterfaceLibrary.Request.Storage;
using WingInterfaceLibrary.Result.AIDiagnosis;
using WingInterfaceLibrary.Request.AIDiagnosis;
using WingInterfaceLibrary.DTO.Record;
using WingInterfaceLibrary.DTO.Comment;
using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;
using System.Net.Http.Headers;

namespace WingAIDiagnosisService.Service
{
    /// <summary>
    /// AI诊断服务
    /// </summary>
    public partial class AIDiagnosisService : JsonRpcService, IAIDiagnosisService
    {
        private EnumPerformance _workerLevel = EnumPerformance.Medium;
        private int _batchImageSize = 16;
        private int _sleepTime = 400;
        private readonly string _tempFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DiagnosisTemp");
        private AIDiagSystem _diagSystem;
        private AILesionCompareUtils _lesionCompareUtil;
        private RecognizeCarotidType _recognizeCarotidType = new RecognizeCarotidType();
        //识别左右颈是否初始化成功
        private static bool _recognizeCarotidTypeCanBeUse = false;
        static HttpClient _httpClient = new HttpClient();
        private IAuthenticationService _authenticationService;
        private IStorageService _storageService;

        /// <summary>
        /// Init service
        /// </summary>
        public override void Load(JsonRpcClientPool jsonRpcClientPool)
        {
            base.Load(jsonRpcClientPool);
            _authenticationService = GetProxy<IAuthenticationService>();
            _storageService = GetProxy<IStorageService>();
            _workerLevel = (EnumPerformance)ConfigurationManager.GetParammeter<IntParameter>("AI", "WorkerLevel").Value;
            _batchImageSize = ConfigurationManager.GetParammeter<IntParameter>("AI", "BatchImageSize").Value;
            _httpClient.Timeout = TimeSpan.FromMinutes(15);
            InitAISystem();
            //初始化识别左右颈
            _recognizeCarotidTypeCanBeUse = _recognizeCarotidType.Initialization();
        }

        private void InitAISystem()
        {
            var modeFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Networks");
            _diagSystem = new AIDiagSystem(_workerLevel, modeFilePath, EnumInferWorkName.Default, false, true, true);
            if (_diagSystem != null)
            {
                _diagSystem.NotifyError += AIdiagSystem_NotifyError;
                _diagSystem.NotifyLog += AIdiagSystem_NotifyLog;
            }
            _lesionCompareUtil = new AILesionCompareUtils();
        }

        /// <summary>
        /// 查询杏聆荟支持的AI模块
        /// </summary>
        /// <param name="request">查询杏聆荟支持的AI模块请求实体</param>
        /// <returns></returns>
        /// <show>false</show>
        public async Task<IList<string>> FindDiagnosisModulesAsync(TokenRequest request)
        {
            try
            {
                var moduleNames = AIDiagSystem.GetValidModuleNamesForVclound() ?? new List<EnumAIModuleNames>();
                var resultData = moduleNames.Select(x => x.ToString()).ToList();
                return await Task.FromResult(resultData);
            }
            catch (Exception)
            {
                return new List<string>();
            }
        }

        /// <summary>
        /// 图像诊断
        /// </summary>
        /// <param name="request">图像诊断请求实体</param>
        /// <returns>图像诊断结果</returns>
        /// <show>false</show>
        public async Task<DiagnosisImageResult> DiagnosisImageAsync(DiagnosisImageRequest request)
        {
            try
            {
                var localFile = await DownloadAsync(request.FileToken);
                if (File.Exists(localFile))
                {
                    if (_diagSystem == null)
                    {
                        InitAISystem();
                    }
                    using (var imageData = new VinnoImageData(localFile, OperationMode.Open))
                    {
                        if (DiagnosisHelper.IsCarotid(imageData))
                        {
                            if (imageData.ImageCount > DiagnosisHelper.CarotidMinImageCounts)
                            {
                                //颈动脉
                                var result = await CarotidDiagnosis(imageData);
                                var resultData = new DiagnosisImageResult()
                                {
                                    CarotidResult = result
                                };
                                return resultData;
                            }
                        }
                        else
                        {
                            //乳腺、肝脏
                            var results = NormalDiagnosis(imageData);
                            var diagnosisResults = results.Select(x => new AIDiagnosisPerImageModel(x.Key, x.Value)).ToList();
                            var diagnosisResult = Newtonsoft.Json.JsonConvert.DeserializeObject<List<AIDiagnosisPerImageDTO>>(Newtonsoft.Json.JsonConvert.SerializeObject(diagnosisResults));
                            var resultData = new DiagnosisImageResult()
                            {
                                DiagnosisConclusion = (DiagnosisConclusionEnum)GetDiagnosisConclusion(diagnosisResults),
                                DiagnosisResult = diagnosisResult,
                                DiagnosisOrgans = GetDiagnosisOrgans(diagnosisResult),
                            };
                            return resultData;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"DiagnosisImageAsync err {ex}");
            }
            return new DiagnosisImageResult();
        }
        /// <summary>
        /// 生成AI报告
        /// </summary>
        /// <param name="request">生成AI报告请求实体</param>
        /// <returns></returns>
        /// <show>false</show>
        public async Task<DiagnosisReportResult> DiagnosisReportAsync(DiagnosisReportRequest request)
        {
            try
            {
                var manager = await CreateDiagnosisManagerAsync(request);
                var reportPerImages = manager.GetReportResults();
                var diagnosisConclusion = GetDiagnosisConclusion(reportPerImages);

                var diagnosisResult = new List<DiagnosisPerImageDTO>();
                foreach (var item in reportPerImages)
                {
                    var aiFileToken = await UploadFileAsync(item.AILocalImagePath, Path.GetFileName(item.AILocalImagePath));
                    var perImageResult = Newtonsoft.Json.JsonConvert.DeserializeObject<DiagnosisPerImageDTO>(Newtonsoft.Json.JsonConvert.SerializeObject(item));
                    perImageResult.RemedicalCode = item.RemedicalCode;
                    perImageResult.DataType = (RemedicalFileDataTypeEnum)item.DataType;
                    perImageResult.Pixel = item.Pixel;
                    perImageResult.AIFileToken = aiFileToken;
                    diagnosisResult.Add(perImageResult);

                }
                return new DiagnosisReportResult
                {
                    DiagnosisConclusion = (DiagnosisConclusionEnum)diagnosisConclusion,
                    DiagnosisResult = diagnosisResult,
                };
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIService DiagnosisReport err, {ex}");
            }
            return new DiagnosisReportResult();
        }

        private async Task<BaseDiagnosis> CreateDiagnosisManagerAsync(DiagnosisReportRequest request)
        {
            var recordResults = new List<DiagnosisPerImageModel>();
            foreach (var remedical in request.RemedicalList)
            {
                foreach (var perImage in remedical.DiagnosisResult)
                {
                    var localFile = await DownloadAsync(remedical.FileToken);
                    if (File.Exists((localFile)))
                    {
                        var diagnosisPerImage = new DiagnosisPerImageModel();
                        diagnosisPerImage.RemedicalCode = remedical.RemedicalCode;
                        diagnosisPerImage.DataType = (WingAIDiagnosisService.Manage.DataType)remedical.DataType;
                        diagnosisPerImage.LocalVidPath = localFile;
                        diagnosisPerImage.Index = perImage.Index;
                        diagnosisPerImage.PriorityScore = perImage.PriorityScore;
                        var diagnosisResults = Newtonsoft.Json.JsonConvert.DeserializeObject<List<WingAIDiagnosisService.Manage.AIDiagnosisResultPerOrgan>>(Newtonsoft.Json.JsonConvert.SerializeObject(perImage.DiagResultsForEachOrgan));
                        diagnosisPerImage.DiagResultsForEachOrgan = diagnosisResults;
                        recordResults.Add(diagnosisPerImage);
                    }
                }
            }
            switch (request.Organ)
            {
                case DiagnosisOrganEnum.Breast:
                    return new BreastDiagnosis(recordResults, request.Organ);
                case DiagnosisOrganEnum.Liver:
                    return new LiverDiagnosis(recordResults, request.Organ);
                default:
                    throw new Exception($"not support organ type:{request.Organ.ToString()}");
            }
        }

        private async Task<CarotidResultDTO> CarotidDiagnosis(VinnoImageData imageData)
        {
            var resampleInputData = new ResampleInputData();
            resampleInputData.SurfaceFilePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.SurfaceFileSuffix);
            resampleInputData.MdlFilePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.ModelFileSuffix);
            resampleInputData.MdlZipFilePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.ZipFileSuffix);
            resampleInputData.BaseAIImagePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.JPGFileSuffix);
            resampleInputData.PlaqueAIImagePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.JPGFileSuffix);
            resampleInputData.YShapeAIImagePath = DiagnosisHelper.GetCacheFilePath(DiagnosisHelper.JPGFileSuffix);
            var resampleResult = TryResample(imageData, resampleInputData);
            if (resampleResult.ResampleErrorCode == ResampleErrorCode.Success)
            {
                var carotidAIImageTokens = new List<CarotidAIImage>();

                if (resampleResult.CarotidAIMeasureResult.IsYImageSuccess)
                {
                    var fileUrl = await UploadFileAsync(resampleInputData.YShapeAIImagePath, Path.GetFileName(resampleInputData.YShapeAIImagePath));
                    if (!string.IsNullOrWhiteSpace(fileUrl))
                    {
                        carotidAIImageTokens.Add(new CarotidAIImage() { AIImageToken = fileUrl, AIImageType = CarotidAIImageType.YShape });
                    }
                    File.Delete(resampleInputData.YShapeAIImagePath);
                }

                if (resampleResult.CarotidAIMeasureResult.IntimaResult.IsSuccess)
                {
                    var fileUrl = await UploadFileAsync(resampleInputData.BaseAIImagePath, Path.GetFileName(resampleInputData.BaseAIImagePath));
                    if (!string.IsNullOrWhiteSpace(fileUrl))
                    {
                        carotidAIImageTokens.Add(new CarotidAIImage() { AIImageToken = fileUrl, AIImageType = CarotidAIImageType.Base });
                    }
                    File.Delete(resampleInputData.BaseAIImagePath);
                }

                if (resampleResult.CarotidAIMeasureResult.PlaqueResult.IsSuccess && resampleResult.CarotidAIMeasureResult.PlaqueResult.PlaqueCountType != WingAIDiagnosisService.Carotid.Utilities.DetectPlaque.PlaqueCountType.NoPlaque)
                {
                    var fileUrl = await UploadFileAsync(resampleInputData.PlaqueAIImagePath, Path.GetFileName(resampleInputData.PlaqueAIImagePath));
                    if (!string.IsNullOrWhiteSpace(fileUrl))
                    {
                        carotidAIImageTokens.Add(new CarotidAIImage() { AIImageToken = fileUrl, AIImageType = CarotidAIImageType.Plaque });
                    }
                    File.Delete(resampleInputData.PlaqueAIImagePath);
                }
                var surfaceImageList = new List<string>();
                if (!string.IsNullOrWhiteSpace(resampleInputData.SurfaceFilePath) && File.Exists(resampleInputData.SurfaceFilePath))
                {
                    surfaceImageList = await SurfaceFile(resampleInputData.SurfaceFilePath);
                    var fileUrl = await UploadFileAsync(resampleInputData.SurfaceFilePath, Path.GetFileName(resampleInputData.SurfaceFilePath));
                    File.Delete(resampleInputData.SurfaceFilePath);
                    resampleInputData.SurfaceFilePath = fileUrl;
                }
                if (!string.IsNullOrWhiteSpace(resampleInputData.MdlFilePath) && File.Exists(resampleInputData.MdlFilePath))
                {
                    var fileUrl = await UploadFileAsync(resampleInputData.MdlFilePath, Path.GetFileName(resampleInputData.MdlFilePath));
                    File.Delete(resampleInputData.MdlFilePath);
                    resampleInputData.MdlFilePath = fileUrl;
                }

                var result = new CarotidResultDTO
                {
                    CarotidScanType = (CarotidScanTypeEnum)resampleInputData.ScanType,
                    CarotidScanDirection = (CarotidScanDirectionEnum)resampleInputData.CarotidScanDirection,
                    SurfaceFile = resampleInputData.SurfaceFilePath,
                    MdlFile = resampleInputData.MdlFilePath,
                    MeasureImageFiles = carotidAIImageTokens.Select(x => new MeasureImageFileDTO { ImageType = (CarotidAIImageTypeEnum)x.AIImageType, ImageFile = x.AIImageToken }).ToList(),
                    MeasureResult = JsonConvert.SerializeObject(resampleResult.CarotidAIMeasureResult),
                    SurfaceImageList = surfaceImageList,

                };
                return result;
            }
            return null;
        }

        private ResampleResult TryResample(VinnoImageData vinnoImageData, ResampleInputData resampleInputData)
        {
            float scanDistance = 7;
            ResampleResult resampleResult = new ResampleResult(ResampleErrorCode.Fail);
            var vinnoExtendedData = VinnoCarotidExtendedData.FromBytes(vinnoImageData.ExtendedData);
            CarotidScanType scanType = CarotidScanType.CarotidLeft;
            CarotidScanDirection direction = CarotidScanDirection.TopToBottom;
            if (vinnoExtendedData != null)
            {
                // Should be 6~9cm normally.
                //scanDistance = vinnoExtendedData.ScanDistance;
                scanType = vinnoExtendedData.CarotidType == CarotidType.Left ? CarotidScanType.CarotidLeft : CarotidScanType.CarotidRight;
                direction = vinnoExtendedData.CarotidDirection == CarotidDirection.BottomToTop ? CarotidScanDirection.BottomToTop
                    : CarotidScanDirection.TopToBottom;
            }
            else
            {
                //This is a walkaround : vid's first frame is black image or depth coordinate is not in the right place.
                var middleCount = vinnoImageData.ImageCount / 2;
                var vinnoImage = vinnoImageData.GetImage(middleCount);
                var imageBuffer = vinnoImage.ImageData;
                if (_recognizeCarotidTypeCanBeUse)
                {
                    //转成彩色图像
                    using var img = new Mat();
                    CvInvoke.Imdecode(imageBuffer, ImreadModes.Color, img);
                    using var image = img.ToImage<Bgr, byte>();
                    //识别左右颈信息
                    scanType = _recognizeCarotidType.RecognizeType(image);
                }
            }
            resampleInputData.ScanDistance = scanDistance;
            resampleInputData.ScanType = scanType;
            resampleInputData.CarotidScanDirection = direction;
            resampleResult = ResampleModel.Instance.Resample(vinnoImageData, resampleInputData, _workerLevel);
            return resampleResult;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="filePath"></param>
        private async Task<List<string>> SurfaceFile(string filePath)
        {
            var fileUrls = new List<string>();
            using (var stream = new FileStream(filePath, FileMode.Open))
            {
                var reader = new Carotid3DStreamReader(stream);
                var width = reader.ReadInt();
                var height = reader.ReadInt();
                var depth = reader.ReadInt();
                var physicalData = VinnoCarotid3DPhysicalData.FromBytes(reader.ReadBytes());
                var imageCount = reader.ReadInt();
                var fileName = $"{Guid.NewGuid():N}";
                for (var i = 0; i < imageCount; i++)
                {
                    var readBytes = reader.ReadBytes();
                    if (readBytes.Any())
                    {
                        using var img = new Mat();
                        CvInvoke.Imdecode(readBytes, ImreadModes.Color, img);
                        var buf = new Emgu.CV.Util.VectorOfByte();
                        using var image = img.ToImage<Gray, byte>();
                        CvInvoke.Imencode(".jpg", image, buf, new KeyValuePair<ImwriteFlags, int>(ImwriteFlags.JpegQuality, 80));
                        var jpgByte = buf.ToArray();
                        var localPath = Path.Combine(_tempFolder, $"{fileName}_{i + 1}.jpg");
                        File.WriteAllBytes(localPath, jpgByte);
                        var fileUrl = await UploadFileAsync(localPath, Path.GetFileName(localPath));
                        fileUrls.Add(fileUrl);
                        File.Delete(localPath);
                    }
                }
            }
            return fileUrls;
        }

        private SKBitmap CreateBitmap(VinnoImage vinnoImage)
        {
            try
            {
                return SKBitmap.Decode(vinnoImage.ImageData);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Create skbitmap by VinnoImage error:{ex}");
            }

            return null;
        }

        private EnumColorType MapTo(SKColorType sKColor)
        {
            switch (sKColor)
            {
                case SKColorType.Rgba8888:
                    return EnumColorType.Rgba;
                case SKColorType.Rgb888x:
                    return EnumColorType.Rgba;
                case SKColorType.Bgra8888:
                    return EnumColorType.Bgra;
                case SKColorType.Gray8:
                    return EnumColorType.Gray8;

            }
            throw new Exception($"AIService not support color type:{sKColor}");
        }

        private void AIdiagSystem_NotifyError(object sender, ErrorEventArgs e)
        {
            Logger.WriteLineError("AIdiagSystem_NotifyError:" + e.GetException());
        }

        private void AIdiagSystem_NotifyLog(object sender, LogEventArgs e)
        {
            if (e != null && !string.IsNullOrEmpty(e.Msg))
            {
                switch (e.LogType)
                {
                    case EnumLogType.InfoLog:
                        Logger.WriteLineInfo($"AIdiagSystem_NotifyLog:{e.Msg}");
                        break;
                    case EnumLogType.ErrorLog:
                        Logger.WriteLineError($"AIdiagSystem_NotifyLog:{e.Msg}");
                        break;
                    case EnumLogType.WarnLog:
                        Logger.WriteLineWarn($"AIdiagSystem_NotifyLog:{e.Msg}");
                        break;
                    case EnumLogType.FatalLog:
                        Logger.WriteLineError($"AIdiagSystem_NotifyLog:{e.Msg}");
                        break;
                    default:
                        Logger.WriteLineInfo(e.Msg);
                        break;
                }
            }
        }

        private DiagnosisConclusion GetDiagnosisConclusion<T>(List<T> results) where T : AIDiagnosisPerImageModel
        {
            var diagnosisConclusions = new List<DiagnosisConclusion>();
            foreach (var imageResult in results)
            {
                foreach (var diagnosisResult in imageResult.DiagResultsForEachOrgan)
                {
                    var benignLabels = new List<int>();
                    var malignantLabels = new List<int>();
                    if (diagnosisResult.Organ == DiagnosisOrganEnum.Breast)
                    {
                        benignLabels = new List<int> { 1, 2, 3 };
                        malignantLabels = new List<int> { 4, 5, 6, 7 };
                    }
                    else if (diagnosisResult.Organ == DiagnosisOrganEnum.Liver)
                    {
                        benignLabels = new List<int> { 1, 2, 3, 5, 6, 7, 8 };
                        malignantLabels = new List<int> { 4 };
                    }
                    var labels = diagnosisResult.DetectedObjects.Select(x => x.Label);
                    if (labels.Contains(0))
                    {
                        diagnosisConclusions.Add(DiagnosisConclusion.NoObviousLesion);
                    }
                    if (labels.Intersect(benignLabels).Any())
                    {
                        diagnosisConclusions.Add(DiagnosisConclusion.Benign);
                    }
                    if (labels.Intersect(malignantLabels).Any())
                    {
                        diagnosisConclusions.Add(DiagnosisConclusion.Malignant);
                    }
                }
            }
            var containsBenign = diagnosisConclusions.Contains(DiagnosisConclusion.Benign);
            var containsMalignant = diagnosisConclusions.Contains(DiagnosisConclusion.Malignant);
            var containsNoObviousLesion = diagnosisConclusions.Contains(DiagnosisConclusion.NoObviousLesion);
            if (containsBenign && containsMalignant)
            {
                return DiagnosisConclusion.BenignAndMalignant;
            }
            else if (containsBenign)
            {
                return DiagnosisConclusion.Benign;
            }
            else if (containsMalignant)
            {
                return DiagnosisConclusion.Malignant;
            }
            else if (containsNoObviousLesion)
            {
                return DiagnosisConclusion.NoObviousLesion;
            }
            else
            {
                return DiagnosisConclusion.Unrecognized;
            }
        }

        private List<DiagnosisOrganEnum> GetDiagnosisOrgans(List<AIDiagnosisPerImageDTO> results)
        {
            var diagnosisOrgans = new List<DiagnosisOrganEnum>();
            foreach (var imageResult in results)
            {
                foreach (var diagnosisResult in imageResult.DiagResultsForEachOrgan)
                {
                    var organName = Enum.GetName(typeof(DiagnosisOrganEnum), (int)diagnosisResult.Organ);
                    if (!string.IsNullOrWhiteSpace(organName))
                    {
                        diagnosisOrgans.Add((DiagnosisOrganEnum)diagnosisResult.Organ);
                    }
                }
            }
            return diagnosisOrgans.Distinct().ToList();
        }

        private Dictionary<int, AIDiagResultPerImg> NormalDiagnosis(VinnoImageData imageData)
        {
            var images = new List<RawImage>();
            var results = new Dictionary<int, AIDiagResultPerImg>();
            try
            {
                var totalCount = imageData.ImageCount;
                for (var i = 0; i < totalCount; i++)
                {
                    var image = imageData.GetImage(i);
                    var bitmap = CreateBitmap(image);
                    if (bitmap != null)
                    {
                        images.Add(new RawImage(bitmap.Bytes, bitmap.Width, bitmap.Height, MapTo(bitmap.ColorType)));
                    }
                }
                if (images.Count > 0)
                {
                    var excuteCount = images.Count / _batchImageSize;
                    var remainderCount = images.Count % _batchImageSize;
                    var diagId = _diagSystem.StartEvalutationOfMultipleImageBatches(images.Count);
                    for (var j = 0; j < excuteCount; j++)
                    {
                        var excuteImages = images.GetRange(j * _batchImageSize, _batchImageSize);
                        _diagSystem.PushOneBatchOfImagesAsync(diagId, excuteImages);
                        Thread.Sleep(_sleepTime);
                    }

                    if (remainderCount > 0)
                    {
                        var excuteImages = images.GetRange(excuteCount * _batchImageSize, remainderCount);
                        _diagSystem.PushOneBatchOfImagesAsync(diagId, excuteImages);
                    }
                    results = _diagSystem.GetEvaluationsOfPushedMultipleImageBatches(diagId);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIService NormalDiagnosis err, {ex}");
            }
            finally
            {
                foreach (var image in images)
                {
                    image?.Dispose();
                }
            }
            return results;
        }

        /// <summary>下载文件</summary>
        /// <param name="fileUrl"></param>
        /// <returns></returns>
        private async Task<string> DownloadAsync(string fileUrl)
        {
            try
            {
                if (string.IsNullOrEmpty(fileUrl))
                {
                    return string.Empty;
                }
                if (!Directory.Exists(_tempFolder))
                {
                    Directory.CreateDirectory(_tempFolder);
                }
                var fileName = Path.GetFileName(fileUrl);
                var tempFile = Path.Combine(_tempFolder, fileName);
                if (File.Exists(tempFile))
                {
                    return tempFile;
                }
                long fileSize = 0;
                using (var request = new HttpRequestMessage())
                {
                    request.RequestUri = new Uri(fileUrl);
                    request.Method = HttpMethod.Get;
                    var response = await _httpClient.SendAsync(request);

                    if (response != null && response.StatusCode == HttpStatusCode.OK)
                    {
                        var contentLength = response.Content.Headers.ContentLength;
                        fileSize = contentLength == null ? 0 : contentLength.Value;
                    }
                }
                if (fileSize <= 0)
                {
                    throw new NotSupportedException($"fileSize is {fileSize}");
                }
                byte[] bytes = await _httpClient.GetByteArrayAsync(fileUrl);
                File.WriteAllBytes(tempFile, bytes);
                return tempFile;
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"DiagnosisService download file err, url: {fileUrl}, {ex}");
            }
            finally
            {
                Logger.WriteLineInfo($"download file:{fileUrl}");
            }
            return string.Empty;
        }

        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="fileName"></param>
        /// <returns></returns>
        private async Task<string> UploadFileAsync(string filePath, string fileName)
        {
            var fileToken = "";
            using (var fileStream = new FileStream(filePath, FileMode.Open))
            {
                var size = fileStream.Length;

                byte[] buffer = new byte[fileStream.Length];
                fileStream.Read(buffer, 0, buffer.Length);
                fileToken = await DoUploadFile(fileName, buffer);
            }
            return fileToken;
        }

        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="fileData"></param>
        /// <returns></returns>
        async Task<string> DoUploadFile(string fileName, byte[] fileData)
        {
            var requestHeads = new Dictionary<string, string>();
            var defaultToken = await _authenticationService.GetServerDefaultTokenAsync();
            var authorizationRet = await _storageService.GetAuthorizationAsync(
                new FileServiceRequest
                {
                    Token = defaultToken,
                    FileName = fileName,
                });
            requestHeads.Add("Authorization", authorizationRet.Authorization);
            var fileUrl = authorizationRet.StorageUrl;
            Logger.WriteLineInfo($"DoUploadFile fileUrl:{fileUrl}");
            using (var request = new HttpRequestMessage())
            {
                var fileExtension = Path.GetExtension(fileName);
                var mimeType = FileHelper.GetMimeType(fileExtension);
                var contentType = MediaTypeHeaderValue.Parse(mimeType);
                using (UploadContent content = new UploadContent(fileData, contentType))
                {
                    request.RequestUri = new Uri(fileUrl);
                    request.Method = HttpMethod.Put;
                    request.Content = content;
                    foreach (var head in requestHeads)
                    {
                        request.Headers.TryAddWithoutValidation(head.Key, head.Value);
                    }
                    var result = await ExecuteRequest(request);
                    if (!result)
                    {
                        throw new Exception("Upload file failed!");
                    }
                }
            }
            return fileUrl;
        }

        private UploadFileTypeEnum GetUploadFileType(string fileName)
        {
            if (fileName.EndsWith(".vid"))
            {
                return UploadFileTypeEnum.VID;
            }
            else if (fileName.EndsWith(".jpg"))
            {
                return UploadFileTypeEnum.JPG;
            }
            else
            {
                return UploadFileTypeEnum.MP4;
            }
        }

        /// <summary>
        /// 执行请求
        /// </summary>
        /// <param name="httpRequestMessage"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public async Task<bool> ExecuteRequest(HttpRequestMessage httpRequestMessage)
        {
            try
            {
                var response = await _httpClient.SendAsync(httpRequestMessage);
                if (response != null && response.StatusCode == HttpStatusCode.OK)
                {
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}