using Aliyun.OSS;
using Aliyun.OSS.Util;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Infrastructure;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Newtonsoft.Json.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace IRaCIS.Core.Application.Helper;

public static class FileStoreHelper
{

    /// <summary>
    /// 上传文件到OOS
    /// </summary>
    /// <param name="filePath">本地文件路径</param>
    /// <param name="oosPath">OOS路径例如(test/test)</param>
    /// <param name="isDeleteOriginalFile">是否删除本地文件</param>
    /// <returns>返回文件路径</returns>
    /// <exception cref="BusinessValidationFailedException"></exception>
    public static string UploadOOS(string filePath,string oosPath, bool isDeleteOriginalFile)
    {
        var config = new ConfigurationBuilder()
                      .AddEnvironmentVariables()
                      .Build();

        var enviromentName = config["ASPNETCORE_ENVIRONMENT"];

        var configuration = new ConfigurationBuilder()
          .AddJsonFile($"appsettings.{enviromentName}.json")
          .Build();

        var endpoint = configuration.GetSection("AliyunOSS:endpoint").Value;
        // yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1（杭州）为例，Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。

        // 阿里云账号AccessKey拥有所有API的访问权限，风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维，请登录RAM控制台创建RAM用户。
        var accessKeyId = configuration.GetSection("AliyunOSS:accessKeyId").Value;
        var accessKeySecret = configuration.GetSection("AliyunOSS:accessKeySecret").Value;
        // 填写Bucket名称，例如examplebucket。
        var bucketName = configuration.GetSection("AliyunOSS:bucketName").Value;
        // 填写Object完整路径，完整路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。

        var fileNameList = filePath.Split('\\').ToList();
        var fileName = fileNameList[fileNameList.Count() - 1];
        if (oosPath != string.Empty)
        {
            fileName = oosPath + "/" + fileName;
        }
        var objectName = fileName;
        // 填写本地文件完整路径，例如D:\\localpath\\examplefile.txt。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。
        var localFilename = filePath;
        // 创建OSSClient实例。
        var client = new OssClient(endpoint, accessKeyId, accessKeySecret);
        try
        {
            // 上传文件。
            var result = client.PutObject(bucketName, objectName, localFilename);
            var expiration = DateTime.Now.AddYears(1);
            var url = client.GeneratePresignedUri(bucketName, objectName, expiration).ToString();
            if (File.Exists(filePath)&& isDeleteOriginalFile)
            {
                // 删除文件
                File.Delete(filePath);
            }
            return url;
        }
        catch (Exception ex)
        {
            throw new BusinessValidationFailedException("上传异常!");

        }
    }

    private static ObjectMetadata BuildCallbackMetadata(string callbackUrl, string callbackBody)
    {
        string callbackHeaderBuilder = new CallbackHeaderBuilder(callbackUrl, callbackBody).Build();
        string CallbackVariableHeaderBuilder = new CallbackVariableHeaderBuilder().
            AddCallbackVariable("x:var1", "x:value1").AddCallbackVariable("x:var2", "x:value2").Build();
        var metadata = new ObjectMetadata();
        metadata.AddHeader(HttpHeaders.Callback, callbackHeaderBuilder);
        metadata.AddHeader(HttpHeaders.CallbackVar, CallbackVariableHeaderBuilder);
        return metadata;
    }

    private static string GetCallbackResponse(PutObjectResult putObjectResult)
    {
        string callbackResponse = null;
        using (var stream = putObjectResult.ResponseStream)
        {
            var buffer = new byte[4 * 1024];
            var bytesRead = stream.Read(buffer, 0, buffer.Length);
            callbackResponse = Encoding.Default.GetString(buffer, 0, bytesRead);
        }
        return callbackResponse;
    }

    //处理文件名  压缩包，或者目录类的  会带上相对路径
    public static (string TrustedFileNameForFileStorage, string RealName) GetStoreFileName(string fileName,bool isChangeToPdfFormat=false)
    {

        //带目录层级，需要后端处理前端的路径
        if (fileName.Contains("\\"))
        {
            fileName = fileName.Split("\\").Last();
        }

        if (fileName.Contains("/"))
        {
            fileName = fileName.Split("/").Last();
        }

        var matchResult = Regex.Match(fileName, @"[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}");

        //如果有guid 
        if (matchResult.Success)
        {
            fileName = fileName.Replace($"{matchResult.Value}", "");
        }


        var trustedFileNameForFileStorage = string.Empty;

        if (isChangeToPdfFormat==false)
        {
            trustedFileNameForFileStorage= Path.GetFileNameWithoutExtension(fileName) + Guid.NewGuid().ToString()+Path.GetExtension(fileName) ;

        }
        else
        {
            trustedFileNameForFileStorage= Path.GetFileNameWithoutExtension(fileName) + Guid.NewGuid().ToString() + ".pdf";
        }

        return (trustedFileNameForFileStorage, fileName);
    }

    //API  vue  部署目录
    public static string GetIRaCISRootPath(IWebHostEnvironment _hostEnvironment)
    {
        string parentDirectory = Path.GetFullPath(Path.Combine(_hostEnvironment.ContentRootPath, ".."));     

        return parentDirectory;

    }


    //获取环境存储根目录
    public static string GetIRaCISRootDataFolder(IWebHostEnvironment _hostEnvironment)
    {
        var rootPath = GetIRaCISRootPath(_hostEnvironment);

        var rootFolder = Path.Combine(rootPath, StaticData.Folder.IRaCISDataFolder);

        return rootFolder;
    }

    //根据相对路径  获取具体文件物理地址
    public static string GetPhysicalFilePath(IWebHostEnvironment _hostEnvironment, string relativePath)
    {
        var rootPath = GetIRaCISRootPath(_hostEnvironment);

        var physicalFilePath = Path.Combine(rootPath, relativePath.TrimStart('/'));

        return physicalFilePath;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="_hostEnvironment"></param>
    /// <param name="_clinicalDataTrialSetRepository"></param>
    /// <param name="id"></param>
    /// <returns></returns>
    /// <exception cref="BusinessValidationFailedException"></exception>
    public static async Task<(string PhysicalPath, string FileName)> GetSystemClinicalPathAsync(IWebHostEnvironment _hostEnvironment, IRepository<ClinicalDataSystemSet> _clinicalDataTrialSetRepository, Guid id)
    {
        var systemClinicalData = await _clinicalDataTrialSetRepository.FirstOrDefaultAsync(t => t.Id == id);

        if (systemClinicalData == null || systemClinicalData.Path == string.Empty)
        {
                //---数据库没有找到对应的数据模板文件,请联系系统运维人员。
            throw new BusinessValidationFailedException(StaticData.International("FileStore_TemplateFileNotFound"));
        }

        var filePath = FileStoreHelper.GetPhysicalFilePath(_hostEnvironment, systemClinicalData.Path);

        if (!System.IO.File.Exists(filePath))
        {
                //---数据模板文件存储路径上未找对应文件,请联系系统运维人员。
            throw new BusinessValidationFailedException(StaticData.International("FileStore_TemplateFileStoragePathInvalid"));
        }

        return (filePath, systemClinicalData.FileName);
    }


    /// <summary>
    /// 
    /// </summary>
    /// <param name="_hostEnvironment"></param>
    /// <param name="_clinicalDataTrialSetRepository"></param>
    /// <param name="id"></param>
    /// <returns></returns>
    /// <exception cref="BusinessValidationFailedException"></exception>
    public static async Task<(string PhysicalPath, string FileName)> GetTrialClinicalPathAsync(IWebHostEnvironment _hostEnvironment, IRepository<ClinicalDataTrialSet> _clinicalDataTrialSetRepository, Guid id)
    {
        var trialClinicalData = await _clinicalDataTrialSetRepository.FirstOrDefaultAsync(t => t.Id == id);

        if (trialClinicalData == null|| trialClinicalData.Path==string.Empty)
        {
                //---数据库没有找到对应的数据模板文件,请联系系统运维人员。
            throw new BusinessValidationFailedException(StaticData.International("FileStore_TemplateFileNotFound"));
        }

        var filePath = FileStoreHelper.GetPhysicalFilePath(_hostEnvironment, trialClinicalData.Path);

        if (!System.IO.File.Exists(filePath))
        {
                //---数据模板文件存储路径上未找对应文件,请联系系统运维人员。
            throw new BusinessValidationFailedException(StaticData.International("FileStore_TemplateFileStoragePathInvalid"));
        }

        return (filePath, trialClinicalData.FileName);
    }


    //通过编码获取通用文档具体物理路径  

    public static async Task<(string PhysicalPath, string FileName)> GetCommonDocPhysicalFilePathAsync(IWebHostEnvironment _hostEnvironment, IRepository<CommonDocument> _commonDocumentRepository, string code)
    {
        var doc = await _commonDocumentRepository.FirstOrDefaultAsync(t => t.Code == code);

        if (doc == null)
        {
                //---数据库没有找到对应的数据模板文件,请联系系统运维人员。
            throw new BusinessValidationFailedException(StaticData.International("FileStore_TemplateFileNotFound"));
        }

        var filePath = FileStoreHelper.GetPhysicalFilePath(_hostEnvironment, doc.Path);

        if (!System.IO.File.Exists(filePath))
        {
                //---数据模板文件存储路径上未找对应文件,请联系系统运维人员。
            throw new BusinessValidationFailedException(StaticData.International("FileStore_TemplateFileStoragePathInvalid"));
        }

        return (filePath, doc.Name.Trim('/'));
    }


    /// <summary>
    /// 写文件导到磁盘
    /// </summary>
    /// <param name="stream">流</param>
    /// <param name="path">文件保存路径</param>
    /// <returns></returns>
    public static async Task<int> WriteFileAsync(System.IO.Stream stream, string path)
    {
        const int FILE_WRITE_SIZE = 84975;//写出缓冲区大小
        int writeCount = 0;
        using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Write, FILE_WRITE_SIZE, true))
        {
            byte[] byteArr = new byte[FILE_WRITE_SIZE];
            int readCount = 0;
            while ((readCount = await stream.ReadAsync(byteArr, 0, byteArr.Length)) > 0)
            {
                await fileStream.WriteAsync(byteArr, 0, readCount);
                writeCount += readCount;
            }
        }
        return writeCount;
    }

    // 获取项目签名文档存放路径

    public static (string PhysicalPath, string RelativePath) GetTrialSignDocPath(IWebHostEnvironment _hostEnvironment, Guid trialId, string fileName)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        //文件类型路径处理
        var uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), StaticData.Folder.SignDocumentFolder);
        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);

        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{StaticData.Folder.SignDocumentFolder}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }

    // 获取系统签名文档存放路径
    public static (string PhysicalPath, string RelativePath) GetSystemSignDocPath(IWebHostEnvironment _hostEnvironment, string fileName)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);


        //文件类型路径处理
        var uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.SystemDataFolder, StaticData.Folder.SignDocumentFolder);
        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);


        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);

        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.SystemDataFolder}/{ StaticData.Folder.SignDocumentFolder}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }

    #region 修改后留存


    public static (string PhysicalPath, string RelativePath) GetSystemFileUploadPath(IWebHostEnvironment _hostEnvironment, string templateFolderName, string fileName)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        //文件类型路径处理
        var uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.SystemDataFolder, templateFolderName);
        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);


        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.SystemDataFolder}/{templateFolderName}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }

    public static (string PhysicalPath, string RelativePath) GetOtherFileUploadPath(IWebHostEnvironment _hostEnvironment, string templateFolderName, string fileName)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        //文件类型路径处理
        var uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.OtherDataFolder, templateFolderName);
        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);


        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.OtherDataFolder}/{templateFolderName}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }


    #endregion





    // 获取通用文档存放路径（excel模板 ）

    public static (string PhysicalPath, string RelativePath) GetCommonDocPath(IWebHostEnvironment _hostEnvironment, string fileName)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        //文件类型路径处理
        var uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.SystemDataFolder, StaticData.Folder.DataTemplate);
        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);


        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.SystemDataFolder}/{StaticData.Folder.DataTemplate}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }

    //获取系统通知文档存放路径

    public static (string PhysicalPath, string RelativePath) GetSystemNoticePath(IWebHostEnvironment _hostEnvironment, string fileName)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        //文件类型路径处理
        var uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.SystemDataFolder, StaticData.Folder.NoticeAttachment);
        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);


        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);



        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.SystemDataFolder}/{StaticData.Folder.NoticeAttachment}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }

    // 获取一致性核查路径
    public static (string PhysicalPath, string RelativePath) GetTrialCheckFilePath(IWebHostEnvironment _hostEnvironment, string fileName,Guid trialId)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        //上传根路径
        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), StaticData.Folder.UploadEDCData);

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);


        //存放核对表
        var (trustedFileNameForFileStorage, realFileName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{StaticData.Folder.UploadEDCData}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }

    //获取 中心调研用户路径

    public static (string PhysicalPath, string RelativePath) GetTrialSiteSurveyFilePath(IWebHostEnvironment _hostEnvironment, string fileName, Guid trialId)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        //上传根路径
        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), StaticData.Folder.UploadSiteSurveyData);

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);


        var (trustedFileNameForFileStorage, realFileName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{StaticData.Folder.UploadSiteSurveyData}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }


    public static (string PhysicalPath, string RelativePath, string FileRealName) GetClinicalTemplatePath(IWebHostEnvironment _hostEnvironment, string fileName,Guid trialId)
    {
      
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, "ClinicalTemplate", trialId.ToString(), StaticData.Folder.TreatmenthistoryFolder);

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/ClinicalTemplate/{trialId}/{StaticData.Folder.TreatmenthistoryFolder}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath, fileRealName);

    }


    public  static (string PhysicalPath, string RelativePath, string FileRealName) GetReadClinicalDataPath(IWebHostEnvironment _hostEnvironment, string fileName, Guid trialId, Guid siteId, Guid subjectId, Guid readingId)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), siteId.ToString(), subjectId.ToString(), StaticData.Folder.Reading, readingId.ToString());

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{siteId}/{subjectId}/{StaticData.Folder.Reading}/{readingId}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath, fileRealName);

    }

    //获取临床数据存放路径
    public static (string PhysicalPath, string RelativePath,string FileRealName) GetClinicalDataPath(IWebHostEnvironment _hostEnvironment, string fileName,Guid trialId,Guid siteId,Guid subjectId,Guid subjectVisitId)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(),siteId.ToString(), subjectId.ToString(), subjectVisitId.ToString(), StaticData.Folder.TreatmenthistoryFolder);

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{siteId}/{subjectId}/{subjectVisitId}/{StaticData.Folder.TreatmenthistoryFolder}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath, fileRealName);

    }


    public static (string PhysicalPath, string RelativePath, string FileRealName) GetClinicalDataPath(IWebHostEnvironment _hostEnvironment, string fileName, Guid trialId , Guid subjectId)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(),  subjectId.ToString(),  StaticData.Folder.TreatmenthistoryFolder);

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{subjectId}/{StaticData.Folder.TreatmenthistoryFolder}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath, fileRealName);

    }


    /// <summary>
    /// 上传截图
    /// </summary>
    /// <param name="_hostEnvironment"></param>
    /// <param name="fileName"></param>
    /// <param name="trialId"></param>
    /// <param name="siteid"></param>
    /// <param name="subjectId"></param>
    /// <returns></returns>
    public static (string PhysicalPath, string RelativePath, string FileRealName) GetUploadPrintscreenFilePath(IWebHostEnvironment _hostEnvironment, string fileName, Guid trialId, Guid siteid, Guid subjectId)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), siteid.ToString(), subjectId.ToString());

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{siteid}/{subjectId}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath, fileRealName);
    }


    /// <summary>
    /// 通用获取文件路径
    /// </summary>
    /// <param name="_hostEnvironment"></param>
    /// <param name="fileName"></param>
    /// <param name="trialId"></param>
    /// <param name="id"></param>
    /// <param name="type"></param>
    /// <returns></returns>
    public static (string PhysicalPath, string RelativePath, string FileRealName) GetFilePath(IWebHostEnvironment _hostEnvironment, string fileName, Guid trialId, Guid id,string type)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), id.ToString(), type);

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{id}/{type}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath, fileRealName);
    }

    public static (string PhysicalPath, string RelativePath, string FileRealName) GetMedicalReviewImage(IWebHostEnvironment _hostEnvironment, string fileName, Guid trialId, Guid taskMedicalReviewId)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), taskMedicalReviewId.ToString(), StaticData.Folder.MedicalReview);

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{taskMedicalReviewId}/{StaticData.Folder.MedicalReview}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath, fileRealName);
    }

    //获取非dicom文件存放路径
    public static (string PhysicalPath, string RelativePath, string FileRealName) GetNoneDicomFilePath(IWebHostEnvironment _hostEnvironment, string fileName, Guid trialId, Guid siteId, Guid subjectId, Guid subjectVisitId)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), siteId.ToString(), subjectId.ToString(), subjectVisitId.ToString(), StaticData.Folder.NoneDicomFolder);

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{siteId}/{subjectId}/{subjectVisitId}/{StaticData.Folder.NoneDicomFolder}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath, fileRealName);
    }

    // 获取 入组确认 PD 进展发送邮件Word|PDF 存放路径

    public static (string PhysicalPath, string RelativePath, string FileRealName) GetSubjectEnrollConfirmOrPDEmailPath(IWebHostEnvironment _hostEnvironment, string fileName, Guid trialId, Guid siteId, Guid subjectId,bool isChangeToPdfFormat=false)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        string uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), siteId.ToString(), subjectId.ToString());

        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);

        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName, isChangeToPdfFormat);


        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{siteId}/{subjectId}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath, fileRealName);
    }


    public static string GetSubjectVisitDicomFolderPhysicalPath(IWebHostEnvironment _hostEnvironment,Guid trialId, Guid siteId, Guid subjectId, Guid subjectVisitId)
    {
        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        return Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(), siteId.ToString(), subjectId.ToString(), subjectVisitId.ToString(), StaticData.Folder.DicomFolder);
    }

    public static (string PhysicalPath, string RelativePath) GetDicomInstanceFilePath(IWebHostEnvironment _hostEnvironment, Guid trialId, Guid siteId, Guid subjectId, Guid subjectVisitId, Guid studyId, Guid instanceId)
    {
        #region 切换存储前
        //var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);
        #endregion
        var rootPath = Path.Combine(FileStoreHelper.GetBestStoreDisk(_hostEnvironment), StaticData.Folder.IRaCISDataFolder) ;



        //加入访视层级  和Data
        var path = Path.Combine(rootPath, StaticData.Folder.TrialDataFolder, trialId.ToString(),
            siteId.ToString(), subjectId.ToString(), subjectVisitId.ToString(), StaticData.Folder.DicomFolder, studyId.ToString());

        if (!Directory.Exists(path))
        {
            Directory.CreateDirectory(path);
        }

        var physicalPath = Path.Combine(path, instanceId.ToString() );

        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{siteId}/{subjectId}/{subjectVisitId}/{StaticData.Folder.DicomFolder}/{studyId}/{instanceId}";

        //var physicalPath = Path.Combine(path, instanceId.ToString() + ".dcm");

        //var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.TrialDataFolder}/{trialId}/{siteId}/{subjectId}/{subjectVisitId}/{StaticData.Folder.DicomFolder}/{studyId}/{instanceId}.dcm";

        return (physicalPath, relativePath);
    }

    public static string GetBestStoreDisk(IWebHostEnvironment _hostEnvironment)
    {

        var json = File.ReadAllText( Path.Combine(_hostEnvironment.ContentRootPath, "appsettings.json"));

        JObject jsonObject = (JObject.Parse(json, new JsonLoadSettings() { CommentHandling = CommentHandling.Load })).IfNullThrowException();

        int switchingRatio = 80;

        try
        {
            switchingRatio = (int)jsonObject["IRaCISImageStore"]["SwitchingRatio"];
        }
        catch (Exception e)
        {

            //---解析Json文件配置出现问题
            throw new BusinessValidationFailedException(StaticData.International("SysMon_JsonConfig")  + e.Message);
        }

        //默认存储的路径
        var defaultStoreRootFolder = FileStoreHelper.GetIRaCISRootPath(_hostEnvironment);


        DriveInfo defaultDrive = new DriveInfo(Path.GetPathRoot(defaultStoreRootFolder));

        var drives = DriveInfo.GetDrives().Where(t => !t.Name.Contains("C") && !t.Name.Contains("c"))
                        .Where(d => d.DriveType == DriveType.Fixed && d.IsReady)
                        //剩余空间最多的
                        .OrderByDescending(d => d.AvailableFreeSpace)

                        //存储空间相同，则按照按照总空间从大到小排序
                        .ThenByDescending(d => d.TotalSize - d.TotalFreeSpace);

        var bestDrive = drives.FirstOrDefault();
        var bestStoreRootFolder = string.Empty;

        //仅仅只有C 盘
        if (bestDrive == null || ((double)(defaultDrive.TotalSize - defaultDrive.TotalFreeSpace) / defaultDrive.TotalSize) * 100 < switchingRatio)
        {
            bestStoreRootFolder = defaultStoreRootFolder;
        }
        else
        {
            bestStoreRootFolder = Path.Combine(bestDrive?.RootDirectory.FullName, _hostEnvironment.EnvironmentName);
        }

        if (!Directory.Exists(bestStoreRootFolder))
        {
            Directory.CreateDirectory(bestStoreRootFolder);
        }

        return bestStoreRootFolder;

    }




    // 获取医生通用文件存放路径

    public static (string PhysicalPath, string RelativePath) GetDoctorOrdinaryFilePath(IWebHostEnvironment _hostEnvironment, string fileName,Guid doctorId,string attachmentType)
    {

        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        //文件类型路径处理
        var uploadFolderPath = Path.Combine(rootPath, "UploadFile", doctorId.ToString(), attachmentType);
        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);


        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);



        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.UploadFileFolder}/{doctorId}/{attachmentType}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }

    public static (string PhysicalPath, string RelativePath) GetNonDoctorFilePath(IWebHostEnvironment _hostEnvironment, string fileName,  string attachmentType)
    {

        var rootPath = FileStoreHelper.GetIRaCISRootDataFolder(_hostEnvironment);

        //文件类型路径处理
        var uploadFolderPath = Path.Combine(rootPath, StaticData.Folder.UploadFileFolder, attachmentType);
        if (!Directory.Exists(uploadFolderPath)) Directory.CreateDirectory(uploadFolderPath);


        var (trustedFileNameForFileStorage, fileRealName) = FileStoreHelper.GetStoreFileName(fileName);



        var relativePath = $"/{StaticData.Folder.IRaCISDataFolder}/{StaticData.Folder.UploadFileFolder}/{attachmentType}/{trustedFileNameForFileStorage}";

        var serverFilePath = Path.Combine(uploadFolderPath, trustedFileNameForFileStorage);

        return (serverFilePath, relativePath);
    }

    

}