using IRaCIS.Core.Application.Helper;
using IRaCIS.Core.Domain.Share;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.StaticFiles;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.FileProviders.Physical;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Hosting.Internal;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Microsoft.VisualBasic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

namespace IRaCIS.Core.API
{


    public class MultiDiskStaticFilesMiddleware
    {
        private readonly RequestDelegate _next;
        private readonly IWebHostEnvironment _hostingEnv;
        private readonly StaticFileOptions _options;
        private readonly ILoggerFactory _loggerFactory;

        private string iRaCISDefaultDataFolder = string.Empty;

        public MultiDiskStaticFilesMiddleware(RequestDelegate next, IWebHostEnvironment hostingEnv, StaticFileOptions options, ILoggerFactory loggerFactory)
        {
            _next = next;
            _hostingEnv = hostingEnv;
            _options = options;
            _loggerFactory = loggerFactory;

            iRaCISDefaultDataFolder = FileStoreHelper.GetIRaCISRootDataFolder(_hostingEnv);

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

        public async Task Invoke(HttpContext context)
        {
            var path = context.Request.Path.Value;
            var isIRacisFile = path.StartsWith($"/{StaticData.Folder.IRaCISDataFolder}");

            var isDicomFile = path.Contains($"{StaticData.Folder.DicomFolder}");

            var defaultFileProvider = new PhysicalFileProvider(iRaCISDefaultDataFolder);
            var staticFileOptions = new StaticFileOptions
            {
                FileProvider = defaultFileProvider,
                RequestPath = $"/{StaticData.Folder.IRaCISDataFolder}",
                ServeUnknownFileTypes = true,
                DefaultContentType = "application/octet-stream"
            };

            var defaultRoot = Path.GetPathRoot(iRaCISDefaultDataFolder);

            //先从默认里面去找
            if (isIRacisFile)
            {
                if (defaultFileProvider.GetFileInfo(context.Request.Path).Exists)
                {
                    var staticFileMiddleware = new StaticFileMiddleware(_next, _hostingEnv, Options.Create(staticFileOptions), _loggerFactory);
                    await staticFileMiddleware.Invoke(context);
                    return;
                }
            }

            //没找到  
            //dicom影像，从多个文件夹尝试，因为会存在切换磁盘
            if (isDicomFile)
            {
                var disks = GetDisks().Where(t=>!t.Contains(defaultRoot));


                foreach (var item in disks)
                {
                    var otherFileStoreFolder = Path.Combine(item, _hostingEnv.EnvironmentName);
                 
                    var otherFileProvider= new PhysicalFileProvider(otherFileStoreFolder);

                    var otherStaticFileOptions = new StaticFileOptions
                    {
                        FileProvider = otherFileProvider,
                        RequestPath = $"/{StaticData.Folder.IRaCISDataFolder}",
                        ServeUnknownFileTypes = true,
                        DefaultContentType = "application/octet-stream"
                    };

                    if (otherFileProvider.GetFileInfo(context.Request.Path).Exists)
                    {
                        var staticFileMiddleware = new StaticFileMiddleware(_next, _hostingEnv, Options.Create(staticFileOptions), _loggerFactory);
                        await staticFileMiddleware.Invoke(context);
                        return;
                    }
                }
            }
   

            // 如果所有磁盘都不存在所请求的文件，则将请求传递给下一个中间件组件。
            await _next.Invoke(context);
        }



        private string[] GetDisks()
        {
            // 获取系统中所有可用的磁盘
            return DriveInfo.GetDrives()
                .Where(d => d.IsReady && d.DriveType == DriveType.Fixed).Where(t => !t.Name.Contains("C") && !t.Name.Contains("c"))
                .Select(d => d.RootDirectory.FullName)
                .ToArray();
        }


        //private static string GetContentType(string path)
        //{
        //    var provider = new FileExtensionContentTypeProvider();
        //    if (!provider.TryGetContentType(path, out var contentType))
        //    {
        //        contentType = "application/octet-stream";
        //    }

        //    return contentType;
        //}

        //private async Task ServeFileAsync(HttpContext context, IFileInfo fileInfo)
        //{
        //    var response = context.Response;
        //    response.ContentType = GetContentType(fileInfo.PhysicalPath);

        //    using (var fileStream = fileInfo.CreateReadStream())
        //    {
        //        await fileStream.CopyToAsync(response.Body);
        //    }
        //}
    }


}