using WingServerCommon.Service;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.Request.RemedicalAISelected;
using System.Threading.Tasks;
using System.Linq;
// using WingServerCommon.Log;
using System.IO;
using System;
using System.Net.Http;
using System.Net;
using System.Collections.Generic;
using WingInterfaceLibrary.Request.Examine;
using Vinno.IUS.Common.Media.FFmpeg.Video;
using Vinno.IUS.Common.Media.FFmpeg.Video.Codecs;
using SkiaSharp;
using Vinno.IUS.Common.Media.FFmpeg.Settings;
using System.Diagnostics;
using Logger = WingServerCommon.Log.Logger;
using System.Text;
using Newtonsoft.Json;
using WingAIDiagnosisService.URMManage;

namespace WingAIDiagnosisService.Service
{
    /// <summary>
    /// URM分析服务
    /// </summary>
    public partial class AIDiagnosisService : JsonRpcService, IAIDiagnosisService
    {
        private readonly string _urmTempFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "URMTemp");

        /// <summary>
        /// URM分析
        /// </summary>
        /// <param name="request">URM分析请求实体</param>
        /// <returns>URM分析分析结果</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMAnalysisResult> URMAnalysisAsync(URMAnalysisRequest request)
        {
            return null;
        }

        /// <summary>
        /// URM分析V2
        /// </summary>
        /// <param name="request">URM分析V2请求实体</param>
        /// <returns>URM分析分析结果V2</returns>
        /// <value></value>
        /// <errorCodes></errorCodes>
        public async Task<URMAnalysisV2Result> URMAnalysisV2Async(URMAnalysisV2Request request)
        {
            DeleteExpiredFolders(DateTime.Now.AddDays(-1));
            var remedicalCode = request.RemedicalCode;
            var customizedStartFrame = request.CustomizedStartFrame != null ? request.CustomizedStartFrame.ToString() : string.Empty;
            var customizedEndFrame = request.CustomizedEndFrame != null ? request.CustomizedEndFrame.ToString() : string.Empty;
            var pos = $"{request.X},{request.Y},{request.Width},{request.Height},{customizedStartFrame},{customizedEndFrame}";
            Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async start, remedicalCode:{remedicalCode}, Pos:{pos}");

            var currentFolder = string.Empty;
            var resultData = new URMAnalysisV2Result { URMAnalysisDetails = new List<ImgItem>() };
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == 0);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    var converImageUrl = remedical?.TerminalImages?.CoverImageUrl;
                    if (!string.IsNullOrWhiteSpace(fileToken) && !string.IsNullOrWhiteSpace(converImageUrl))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async, remedicalCode:{remedicalCode}, fileToken:{fileToken}, converImageUrl:{converImageUrl}");
                        currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialName = Path.GetFileName(fileToken);
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        var converName = Path.GetFileName(converImageUrl);
                        var converFile = Path.Combine(currentFolder, converName);
                        if (!File.Exists(converFile))
                        {
                            await DownloadToLocalAsync(converImageUrl, converFile);
                        }
                        DeleteTempFiles(currentFolder, new List<string> { origialFile, converFile });
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var urmParamers = remedical.UrmParameters;
                            if (urmParamers != null && urmParamers.Any())
                            {
                                Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async URMAnalysisProcess start, remedicalCode:{remedicalCode}");
                                urmParamers.TryAdd("startX", request.X.ToString());
                                urmParamers.TryAdd("startY", request.Y.ToString());
                                urmParamers.TryAdd("width", request.Width.ToString());
                                urmParamers.TryAdd("height", request.Height.ToString());
                                urmParamers.TryAdd("CustomizedStartFrame", request.CustomizedStartFrame == null ? "" : request.CustomizedStartFrame.ToString());
                                urmParamers.TryAdd("CustomizedEndFrame", request.CustomizedEndFrame == null ? "" : request.CustomizedEndFrame.ToString());
                                urmParamers.TryAdd("RoiXPercent", request.RoiXPercent.ToString());
                                urmParamers.TryAdd("RoiYPercent", request.RoiYPercent.ToString());
                                urmParamers.TryAdd("RoiWPercent", request.RoiWPercent.ToString());
                                urmParamers.TryAdd("RoiHPercent", request.RoiHPercent.ToString());
                                // 开始URM分析
                                var result = DoURMAnalysisV2(remedicalCode, origialFile, converFile, currentFolder, urmParamers);
                                if (result != null)
                                {
                                    resultData.IsSuccess = true;
                                    resultData.UrmPosition = pos;
                                    resultData.URMSrcWidth = result.URMSrcWidth;
                                    resultData.URMSrcHeight = result.URMSrcHeight;
                                    resultData.URMRes = result.URMRes;
                                    await InitURMAnalysisDetails(resultData, fileToken, currentFolder, origialRemedicalInfo, result.ConverImageUrl);
                                }
                            }
                        }
                        else
                        {
                            Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisV2Async failed, remedicalCode:{remedicalCode}, origialFile not existed");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisV2Async error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            finally
            {
                try
                {
                    // if (Directory.Exists(currentFolder))
                    // {
                    //     Directory.Delete(currentFolder, true);
                    // }
                }
                catch { }
            }
            Logger.WriteLineInfo($"AIDiagnosisService URMAnalysisV2Async finished, remedicalCode:{remedicalCode}, result:{resultData.IsSuccess}");
            return resultData;
        }

        /// <summary>
        /// 测量项SRCurvature计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetSRCurvatureResult> GetSRCurvatureAsync(GetSRCurvatureRequest request)
        {
            DeleteExpiredFolders(DateTime.Now.AddHours(-6));

            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetSRCurvatureAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService GetSRCurvatureAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {request.StartPointX} {request.StartPointY} {request.EndPointX} {request.EndPointY}";
                            var result = DoURMeasure<GetSRCurvatureResult>("GetSRCurvature", remedicalCode, arguments);
                            return result;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetSRCurvatureAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// 测量项SRRoiDensity计算
        /// </summary>
        /// <param name="request"></param>
        /// /// <returns></returns>
        public async Task<GetSRRoiVelResult> GetSRRoiVelAsync(GetSRRoiVelRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetSRRoiVelAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService GetSRRoiVelAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {request.StartPointX} {request.StartPointY} {request.EndPointX} {request.EndPointY}";
                            var output = DoURMeasure<double>("GetSRRoiVel", remedicalCode, arguments);
                            return new GetSRRoiVelResult
                            {
                                Output = output,
                            };
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetSRRoiVelAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// 测量项SRRoiFractalDim计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetSRRoiFractalDimResult> GetSRRoiFractalDimAsync(GetSRRoiFractalDimRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetSRRoiFractalDimAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService GetSRRoiFractalDimAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {request.StartPointX} {request.StartPointY} {request.EndPointX} {request.EndPointY}";
                            var output = DoURMeasure<double>("GetSRRoiFractalDim", remedicalCode, arguments);
                            return new GetSRRoiFractalDimResult
                            {
                                Output = output,
                            };
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetSRRoiFractalDimAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// 测量项SRRoiDensity Trace计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetSRTraceVelResult> GetSRTraceVelAsync(GetSRTraceVelRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetSRTraceVelAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            var inputPointPath = Path.Combine(currentFolder, $"{Guid.NewGuid():N}.txt");
                            File.WriteAllText(inputPointPath, JsonConvert.SerializeObject(request.InputPoints ?? new List<UrmPoint>()));

                            Logger.WriteLineInfo($"AIDiagnosisService GetSRTraceVelAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {inputPointPath}";
                            var output = DoURMeasure<double>("GetSRTraceVel", remedicalCode, arguments);
                            return new GetSRTraceVelResult
                            {
                                Output = output,
                            };
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetSRTraceVelAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// 测量项SRTraceFD计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetSRTraceFractalDimResult> GetSRTraceFractalDimAsync(GetSRTraceFractalDimRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetSRTraceFractalDimAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            var inputPointPath = Path.Combine(currentFolder, $"{Guid.NewGuid():N}.txt");
                            File.WriteAllText(inputPointPath, JsonConvert.SerializeObject(request.InputPoints ?? new List<UrmPoint>()));

                            Logger.WriteLineInfo($"AIDiagnosisService GetSRTraceFractalDimAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {inputPointPath}";
                            var output = DoURMeasure<double>("GetSRTraceFractalDim", remedicalCode, arguments);
                            return new GetSRTraceFractalDimResult
                            {
                                Output = output,
                            };
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetSRTraceFractalDimAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// 测量项SRLoactionVel计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetSRLoactionVelResult> GetSRLoactionVelAsync(GetSRLoactionVelRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetSRLoactionVelAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService GetSRLoactionVelAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {request.StartPointX} {request.StartPointY}";
                            var output = DoURMeasure<double>("GetSRLoactionVel", remedicalCode, arguments);
                            return new GetSRLoactionVelResult
                            {
                                Output = output,
                            };
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetSRLoactionVelAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// 测量项SRRoiVel计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetSRRoiSpeedResult> GetSRRoiSpeedAsync(GetSRRoiSpeedRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetSRRoiSpeedAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService GetSRRoiSpeedAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {request.StartPointX} {request.StartPointY} {request.EndPointX} {request.EndPointY}";
                            var output = DoURMeasure<double>("GetSRRoiSpeed", remedicalCode, arguments);
                            return new GetSRRoiSpeedResult
                            {
                                Output = output,
                            };
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetSRRoiSpeedAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// 测量项URMDensityMeasure计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetURMDenMeasureResult> GetURMDenMeasureAsync(GetURMDenMeasureRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetURMDenMeasureAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService GetURMDenMeasureAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {request.StartPointX} {request.StartPointY} {request.EndPointX} {request.EndPointY} {request.AreaScaler}";
                            var output = DoURMeasure<GetURMDenMeasureResult>("GetURMDenMeasureResult", remedicalCode, arguments);
                            return output;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetURMDenMeasureAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// 测量项URMVelMeasure计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetURMVelMeasureResult> GetURMVelMeasureAsync(GetURMVelMeasureRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetURMVelMeasureAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService GetURMVelMeasureAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {request.StartPointX} {request.StartPointY} {request.EndPointX} {request.EndPointY} {request.AreaScaler}";
                            var output = DoURMeasure<GetURMVelMeasureResult>("GetURMVelMeasureResult", remedicalCode, arguments);
                            return output;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetURMVelMeasureAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// 测量项URMVessMeasure计算
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetUrmVessMeasureResult> GetUrmVessMeasureAsync(GetUrmVessMeasureRequest request)
        {
            var remedicalCode = request.RemedicalCode;
            try
            {
                if (!string.IsNullOrWhiteSpace(remedicalCode))
                {
                    var remedical = await _remedicalDBService.GetRemedicalByCodeAsync(remedicalCode, false);
                    var origialRemedicalInfo = remedical?.ImgList?.FirstOrDefault(x => x.ImgType == request.MeasureMode);
                    var fileToken = origialRemedicalInfo?.FileToken ?? string.Empty;
                    if (!string.IsNullOrWhiteSpace(fileToken))
                    {
                        Logger.WriteLineInfo($"AIDiagnosisService GetUrmVessMeasureAsync, remedicalCode:{remedicalCode}, fileToken:{fileToken}");
                        var origialName = Path.GetFileName(fileToken);
                        var currentFolder = Path.Combine(_urmTempFolder, remedicalCode);
                        if (!Directory.Exists(currentFolder))
                        {
                            Directory.CreateDirectory(currentFolder);
                        }
                        var origialFile = Path.Combine(currentFolder, origialName);
                        if (!File.Exists(origialFile))
                        {
                            await DownloadToLocalAsync(fileToken, origialFile);
                        }
                        if (File.Exists(origialFile))
                        {
                            Logger.WriteLineInfo($"AIDiagnosisService GetUrmVessMeasureAsync download success, remedicalCode:{remedicalCode}, fileToken:{fileToken}, localFile:{origialFile}");
                            var arguments = $"{currentFolder} {origialFile} {request.DataWidth} {request.DataHeight} {request.StartPointX} {request.StartPointY} {request.EndPointX} {request.EndPointY} {request.AreaScaler} {request.CmLength}";
                            var output = DoURMeasure<GetUrmVessMeasureResult>("GetUrmVessMeasureResult", remedicalCode, arguments);
                            return output;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService GetUrmVessMeasureAsync error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return null;
        }

        /// <summary>
        /// Converter Report
        /// </summary>
        /// <param name="converterParm">ReportConverter.exe param</param>
        private bool DoURMAnalysis(string origialFile, string pos, string outputFolder, Dictionary<string, string> urmParamers)
        {
            try
            {
                // var urmFolder2 = $"\"UrmDatapath\":\"{origialFile}\",\"VecLens\":\"{GetValue(urmParamers, "VecLens")}\",\"Mlas\":\"{GetValue(urmParamers, "Mlas")}\",\"VectorStartForMid\":\"{GetValue(urmParamers, "VectorStartForMid")}\",\"FramesGot\":\"{GetValue(urmParamers, "FramesGot")}\",\"CenterFrequencyMHz\":\"{GetValue(urmParamers, "CenterFrequencyMHz")}\",\"Prf\":\"{GetValue(urmParamers, "Prf")}\",\"Angles\":\"{GetValue(urmParamers, "Angles")}\",\"SupersonicSpeed\":\"{GetValue(urmParamers, "SupersonicSpeed")}\",\"PulseNum\":\"{GetValue(urmParamers, "VectorStartForMid")}\",\"FrequencyMin\":\"{GetValue(urmParamers, "FrequencyMin")}\",\"FMUint\":\"{GetValue(urmParamers, "FMUint")}\",\"FrameRateDisplay\":\"{GetValue(urmParamers, "FrameRateDisplay")}\",\"FDUnit\":\"{GetValue(urmParamers, "FDUnit")}\",\"ScaleOfPixel_x\":\"{GetValue(urmParamers, "ScaleOfPixel_x")}\",\"ScaleOfPixel_y\":\"{GetValue(urmParamers, "ScaleOfPixel_y")}\",\"ULMCount\":\"{GetValue(urmParamers, "ULMCount")}\",\"PacketsNum\":\"{GetValue(urmParamers, "PacketsNum")}\",\"Res\":\"{GetValue(urmParamers, "Res")}\",\"MaxLinkingDistance\":\"{GetValue(urmParamers, "MaxLinkingDistance")}\",\"MinLength\":\"{GetValue(urmParamers, "MinLength")}\",\"MaxGapClosing\":\"{GetValue(urmParamers, "MaxGapClosing")}\",\"LocMethod\":\"{GetValue(urmParamers, "LocMethod")}\",\"ButterCuttofFreqLow\":\"{GetValue(urmParamers, "ButterCuttofFreqLow")}\",\"NLocalMax\":\"{GetValue(urmParamers, "NLocalMax")}\",\"SVDCutoffLow\":\"{GetValue(urmParamers, "SVDCutoffLow")}\",\"Fwhm\":\"{GetValue(urmParamers, "Fwhm")}\",\"MOCOYN\":\"{GetValue(urmParamers, "MOCOYN")}\",\"MOCOLevel\":\"{GetValue(urmParamers, "MOCOLevel")}\",\"MOCOThresh1\":\"{GetValue(urmParamers, "MOCOThresh1")}\",\"MOCOThresh2\":\"{GetValue(urmParamers, "MOCOThresh2")}\",\"MOCOThresh3\":\"{GetValue(urmParamers, "MOCOThresh3")}\",\"LocaFixmethod\":\"{GetValue(urmParamers, "LocaFixmethod")}\",\"LocFixThresh\":\"{GetValue(urmParamers, "LocFixThresh")}\",\"RefNum\":\"{GetValue(urmParamers, "RefNum")}\",\"MotionCorrThresh\":\"{GetValue(urmParamers, "MotionCorrThresh")}\",\"Pos\":\" {pos} \",\"FilterDeci\":\"{GetValue(urmParamers, "FilterDeci")}\",\"PSFNum\":\"{GetValue(urmParamers, "PSFNum")}\",\"PSFCorr\":\"{GetValue(urmParamers, "PSFCorr")}\",\"Depth\":\"{GetValue(urmParamers, "Depth")}\",\"X0\":\"{GetValue(urmParamers, "X0")}\",\"Z0\":\"{GetValue(urmParamers, "Z0")}\",\"ProbeType\":\"{GetValue(urmParamers, "ProbeType")}\",\"Decifactorx\":\"{GetValue(urmParamers, "Decifactorx")}\",\"Decifactory\":\"{GetValue(urmParamers, "Decifactory")}\",\"SizeScan\":\"{GetValue(urmParamers, "SizeScan")}\",\"MotionAngleThresh\":\"{GetValue(urmParamers, "MotionAngleThresh")}\",\"TrackInterpFactor\":\"{GetValue(urmParamers, "TrackInterpFactor")}\"";
                StringBuilder urmFolder = new StringBuilder();
                urmFolder.Append($"\"{origialFile}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "VecLens")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "Mlas")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "VectorStartForMid")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "FramesGot")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "CenterFrequencyMHz")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "Prf")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "Angles")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "SupersonicSpeed")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "PulseNum")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "FrequencyMin")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "FMUint")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "FrameRateDisplay")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "FDUnit")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "ScaleOfPixel_x")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "ScaleOfPixel_y")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "ULMCount")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "PacketsNum")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "Res")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MaxLinkingDistance")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MinLength")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MaxGapClosing")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "LocMethod")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "ButterCuttofFreqLow")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "NLocalMax")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "SVDCutoffLow")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "Fwhm")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MOCOYN")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MOCOLevel")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MOCOThresh1")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MOCOThresh2")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MOCOThresh3")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "LocaFixmethod")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "LocFixThresh")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "RefNum")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MotionCorrThresh")}\";");
                urmFolder.Append($"\"{pos}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "FilterDeci")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "PSFNum")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "PSFCorr")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "Depth")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "X0")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "Z0")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "ProbeType")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "Decifactorx")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "Decifactory")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "SizeScan")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "MotionAngleThresh")}\";");
                urmFolder.Append($"\"{GetValue(urmParamers, "TrackInterpFactor")}\"");

                var arguments = $"URMAnalysis {outputFolder} {urmFolder.ToString()}";
                var exeFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "URM");
                var exePath = Path.Combine(exeFolder, "URMAnalysis.exe");

                var psi = new ProcessStartInfo(exePath, arguments)
                {
                    Verb = "runas",
                    RedirectStandardOutput = true,
                    UseShellExecute = false,
                };
                using (var process = Process.Start(psi))
                {
                    if (process != null)
                    {
                        // string output = process.StandardOutput.ReadToEnd();
                        process.WaitForExit();
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService DoURMAnalysis error, ex:{ex}");
            }
            return false;
        }

        private URMAnalysisV2Result DoURMAnalysisV2(string remedicalCode, string origialFile, string converFile, string outputFolder, Dictionary<string, string> urmParamers)
        {
            try
            {
                StringBuilder arguments = new StringBuilder();
                arguments.Append($"URMAnalysis ");
                arguments.Append($"{outputFolder} ");
                arguments.Append($"{converFile} ");

                arguments.Append($"{origialFile};");
                arguments.Append($"{GetValue(urmParamers, "familyName")};");
                arguments.Append($"{GetValue(urmParamers, "typeInfo")};");
                arguments.Append($"{GetValue(urmParamers, "nativeId")};");
                arguments.Append($"{GetValue(urmParamers, "VecLens")};");
                arguments.Append($"{GetValue(urmParamers, "Mlas")};");
                arguments.Append($"{GetValue(urmParamers, "FramesGot")};");
                arguments.Append($"{GetValue(urmParamers, "CenterFrequencyMhz")};");
                arguments.Append($"{GetValue(urmParamers, "SupersonicSpeed")};");
                arguments.Append($"{GetValue(urmParamers, "FrequencyMin")};");
                arguments.Append($"{GetValue(urmParamers, "FrameRateDisplay")};");
                arguments.Append($"{GetValue(urmParamers, "Depth")};");
                arguments.Append($"{GetValue(urmParamers, "X0")};");
                arguments.Append($"{GetValue(urmParamers, "Z0")};");
                arguments.Append($"{GetValue(urmParamers, "ProbeType")};");
                arguments.Append($"{GetValue(urmParamers, "ScaleOfPixel_x")};");
                arguments.Append($"{GetValue(urmParamers, "ScaleOfPixel_y")};");
                arguments.Append($"{GetValue(urmParamers, "section")};");
                arguments.Append($"{GetValue(urmParamers, "MOCOYN")};");
                arguments.Append($"{GetValue(urmParamers, "MidProc_DeciFactor")};");
                arguments.Append($"{GetValue(urmParamers, "VectorStartForMid")};");
                arguments.Append($"{GetValue(urmParamers, "isliner")};");

                arguments.Append($"{GetValue(urmParamers, "startX")};");
                arguments.Append($"{GetValue(urmParamers, "startY")};");
                arguments.Append($"{GetValue(urmParamers, "width")};");
                arguments.Append($"{GetValue(urmParamers, "height")};");
                arguments.Append($"{GetValue(urmParamers, "CustomizedStartFrame")};");
                arguments.Append($"{GetValue(urmParamers, "CustomizedEndFrame")};");
                arguments.Append($"{GetValue(urmParamers, "RoiXPercent")};");
                arguments.Append($"{GetValue(urmParamers, "RoiYPercent")};");
                arguments.Append($"{GetValue(urmParamers, "RoiWPercent")};");
                arguments.Append($"{GetValue(urmParamers, "RoiHPercent")};");

                return new URMAnalysisManager().DoURMAnalysis(arguments.ToString().Split(" "));

                // var exeFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "URM", "net6.0");
                // // exeFolder = Path.Combine(@"D:\WingProjects\URMDemo\URMAnalysis\bin\Debug\net6.0");
                // var exePath = Path.Combine(exeFolder, "URMAnalysis.exe");
                // var psi = new ProcessStartInfo(exePath, arguments.ToString())
                // {
                //     Verb = "runas",
                //     RedirectStandardOutput = true,
                //     UseShellExecute = false,
                // };
                // using (var process = Process.Start(psi))
                // {
                //     if (process != null)
                //     {
                //         process.WaitForExit();
                //     }
                // }
                // var urmResultFile = Path.Combine(outputFolder, "urmResult.txt");
                // if (File.Exists(urmResultFile))
                // {
                //     var output = File.ReadAllText(urmResultFile);
                //     if (!string.IsNullOrWhiteSpace(output))
                //     {
                //         return JsonConvert.DeserializeObject<TResult>(output);
                //     }
                // }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService DoURMAnalysisV2 error, remedicalCode:{remedicalCode}, ex:{ex}");
            }
            return default;
        }

        private TResult DoURMeasure<TResult>(string measureType, string remedicalCode, string arguments)
        {
            try
            {
                arguments = measureType + " " + arguments;
                var exeFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "URM");
                var exePath = Path.Combine(exeFolder, "URMAnalysis.exe");

                var psi = new ProcessStartInfo(exePath, arguments)
                {
                    Verb = "runas",
                    RedirectStandardOutput = true,
                    UseShellExecute = false,
                };
                var output = string.Empty;
                using (var process = Process.Start(psi))
                {
                    if (process != null)
                    {
                        output = process.StandardOutput.ReadToEnd();
                        process.WaitForExit();
                    }
                }
                return JsonConvert.DeserializeObject<TResult>(output);
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService DoURMeasure error, remedicalCode:{remedicalCode}, measureType:{measureType}, ex:{ex}");
            }
            return default;
        }

        private string GetValue(Dictionary<string, string> urmParamers, string key)
        {
            if (urmParamers.ContainsKey(key))
            {
                var value = urmParamers[key];
                return string.IsNullOrWhiteSpace(value) ? "0" : value;
            }
            return "0";
        }

        private async Task InitURMAnalysisDetails(URMAnalysisV2Result resultData, string originalUrl, string currentFolder, ImgItem originalRemedicalInfo, string converImagePath)
        {
            var orginal = new ImgItem
            {
                ImgType = 0,
                FileToken = originalUrl,
                FileSize = originalRemedicalInfo.FileSize,
                CoverImgUrl = originalRemedicalInfo.CoverImgUrl,
                PreviewFileUrl = originalRemedicalInfo.PreviewFileUrl,
            };
            if (File.Exists(converImagePath))
            {
                var fileName = Path.GetFileName(converImagePath);
                var fileInfo = await UploadFileWithSizeAsync(converImagePath, fileName);
                orginal.CoverImgUrl = fileInfo.Item1;
                orginal.PreviewFileUrl = fileInfo.Item1;
            }
            resultData.URMAnalysisDetails.Add(orginal);
            var files = Directory.GetFiles(currentFolder);
            foreach (var file in files)
            {
                var fileName = Path.GetFileName(file);
                if (fileName.Contains(".bin"))
                {
                    var imgType = 0;
                    if (fileName.Contains("srcDenArray.bin"))
                    {
                        imgType = 10;
                    }
                    else if (fileName.Contains("srcDirArray.bin"))
                    {
                        imgType = 11;
                    }
                    else if (fileName.Contains("srcVelArray.bin"))
                    {
                        imgType = 12;
                    }
                    else if (fileName.Contains("srcAngleArray.bin"))
                    {
                        imgType = 13;
                    }
                    else if (fileName.Contains("srcMaskArray.bin"))
                    {
                        imgType = 14;
                    }
                    else if (fileName.Contains("URMPoints.bin"))
                    {
                        imgType = 15;
                    }
                    else if (fileName.Contains("URMPointNums.bin"))
                    {
                        imgType = 16;
                    }
                    else
                    {
                        continue;
                    }
                    var fileInfo = await UploadFileWithSizeAsync(file, fileName);
                    resultData.URMAnalysisDetails.Add(new ImgItem
                    {
                        ImgType = imgType,
                        FileToken = fileInfo.Item1,
                        FileSize = fileInfo.Item2,
                    });
                }
            }
        }

        private async Task InitURMVideo(URMAnalysisResult resultData, string currentFolder)
        {
            var mp4FileInfos = ImagesToMP4(currentFolder);
            await Task.Delay(1000 * 5);
            if (!string.IsNullOrWhiteSpace(mp4FileInfos.Item1))
            {
                if (File.Exists(mp4FileInfos.Item1))
                {
                    var converImageUrl = await UploadFileAsync(mp4FileInfos.Item1, Path.GetFileName(mp4FileInfos.Item1));
                    if (File.Exists(mp4FileInfos.Item2))
                    {
                        var mp4ImgItem = new ImgItem
                        {
                            ImgType = 4,
                            CoverImgUrl = converImageUrl,
                            PreviewFileUrl = converImageUrl,
                        };
                        var mp4Path = mp4FileInfos.Item2;
                        var mp4Info = await UploadFileWithSizeAsync(mp4Path, Path.GetFileName(mp4Path));
                        mp4ImgItem.FileToken = mp4Info.Item1;
                        mp4ImgItem.FileSize = mp4Info.Item2;
                        resultData.URMAnalysisDetails.Add(mp4ImgItem);
                    }
                }
            }
        }

        private Tuple<int, int> GetRatioByName(string fileName)
        {
            try
            {
                if (fileName.Contains("_"))
                {
                    var index = fileName.LastIndexOf("_");
                    var value = fileName.Substring(index + 1).Replace(".png", "");
                    if (value.Contains("x"))
                    {
                        var infos = value.Split("x");
                        if (int.TryParse(infos[0], out int width) && int.TryParse(infos[1], out int height))
                        {
                            return new Tuple<int, int>(width, height);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync GetRatioByName ex:{ex}");
            }
            return new Tuple<int, int>(0, 0);
        }

        private Tuple<string, string> ImagesToMP4(string currentFolder)
        {
            try
            {
                var files = Directory.GetFiles(Path.Combine(currentFolder, "avi"))?.OrderBy(x =>
                {
                    var start = x.IndexOf("avi_") + 4;
                    var end = x.IndexOf("_output");
                    if (!int.TryParse(x.Substring(start, end - start), out int index))
                    {
                        index = 0;
                    }
                    return index;
                });
                if (files?.Any() ?? false)
                {
                    var mp4Path = Path.Combine(currentFolder, $"{Guid.NewGuid()}.mp4");
                    var firstFile = files.FirstOrDefault();

                    var width = 0;
                    var height = 0;
                    using (SKBitmap bitmap = SKBitmap.Decode(firstFile))
                    {
                        width = bitmap.Width;
                        height = bitmap.Height;
                    }

                    var frameRate = 30;
                    var setting = new FFmpegSettings();
                    var writeArgs = new FFmpegVideoWriterArgs(mp4Path, width, height)
                    {
                        FrameRate = frameRate,
                        VideoCodec = FFmpegVideoCodec.X264
                    };
                    using (var videoWriter = new FFmpegVideoWriter(writeArgs, setting, null))
                    {
                        foreach (var avi in files)
                        {
                            using (SKBitmap bitmap = SKBitmap.Decode(avi))
                            {
                                if (bitmap != null)
                                {
                                    try
                                    {
                                        if (bitmap.Bytes != null && bitmap.Bytes.Length > 0 && bitmap.Width > 0 && bitmap.Height > 0)
                                        {
                                            var frame = new BitmapFrame(bitmap.Width, bitmap.Height, bitmap.Bytes);
                                            videoWriter.WriteFrame(frame);
                                        }
                                    }
                                    catch (Exception exception)
                                    {
                                        Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync ImagesToMP4 WriteFrame ex:{exception}");
                                    }
                                }
                            }
                        }
                    }
                    return new Tuple<string, string>(firstFile, mp4Path);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync ImagesToMP4 ex:{ex}");
            }
            return new Tuple<string, string>("", "");
        }

        private async Task<bool> DownloadToLocalAsync(string fileUrl, string localFile)
        {
            try
            {
                if (fileUrl.Contains("FlyinsonoStorage"))
                {
                    // 自建存储
                    var infos = fileUrl.Split("FlyinsonoStorage");
                    var sourceFilePath = Path.Combine(_storageDirectory, infos[1].Trim('/'));
                    if (File.Exists(sourceFilePath))
                    {
                        File.Copy(sourceFilePath, localFile);
                        return true;
                    }
                }
                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)
                {
                    byte[] bytes = await _httpClient.GetByteArrayAsync(fileUrl);
                    File.WriteAllBytes(localFile, bytes);
                    return true;
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService URMAnalysisAsync, fileToken:{fileUrl}, ex:{ex}");
            }
            return false;
        }

        private void DeleteExpiredFolders(DateTime time)
        {
            if (Directory.Exists(_urmTempFolder))
            {
                DirectoryInfo theFolder = new DirectoryInfo(_urmTempFolder);
                DirectoryInfo[] dics = theFolder.GetDirectories();
                foreach (var item in dics)
                {
                    if (item.CreationTime < time)
                    {
                        Directory.Delete(item.FullName, true);
                    }
                }
            }
        }

        private void DeleteTempFiles(string currentFolder, List<string> expectFiles)
        {
            try
            {
                var files = Directory.GetFiles(currentFolder);
                if (files?.Any() ?? false)
                {
                    foreach (var file in files)
                    {
                        if (expectFiles == null || !expectFiles.Any(x => x == file))
                        {
                            File.Delete(file);
                        }
                    }
                }
                var aviFolder = Path.Combine(currentFolder, "avi");
                if (Directory.Exists(aviFolder))
                {
                    Directory.Delete(aviFolder, true);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"AIDiagnosisService DeleteTempFiles failed, currentFolder:{currentFolder}, ex:{ex}");
            }
        }

    }
}