using dy.net.model.dto;
using dy.net.model.entity;
using dy.net.model.response;
using dy.net.utils;
using Microsoft.AspNetCore.WebUtilities;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using Serilog;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using dy.net.storage;

namespace dy.net.service
{
    public class DouyinHttpClientService : IDisposable
    {
        private readonly IHttpClientFactory _clientFactory;
        private readonly MediaStorageRouter _storageRouter;
        private readonly Func<TimeSpan, CancellationToken, Task> _delayAsync;
        private const int TransientRequestRetryCount = 2;
        private const int MediaNetworkRetryCount = 2;
        private readonly JsonSerializerSettings _jsonSettings=new JsonSerializerSettings
            {
                NullValueHandling = NullValueHandling.Ignore,
                MissingMemberHandling = MissingMemberHandling.Ignore
            };
        private bool _disposedValue;

        public DouyinHttpClientService(IHttpClientFactory clientFactory, MediaStorageRouter storageRouter)
            : this(clientFactory, storageRouter, Task.Delay)
        {
        }

        internal DouyinHttpClientService(
            IHttpClientFactory clientFactory,
            MediaStorageRouter storageRouter,
            Func<TimeSpan, CancellationToken, Task> delayAsync)
        {
            _clientFactory = clientFactory;
            _storageRouter = storageRouter;
            _delayAsync = delayAsync ?? Task.Delay;
        }

        /// <summary>
        /// 异步获取HTTP响应消息（优化版）
        /// </summary>
        private async Task<HttpResponseMessage> GetHttpResponseMessage(
            HttpMethod httpMethod,
            string requestUrl,
            Dictionary<string, string> requestParameters,
            string refererValue,
            string cookie)
        {
            string fullUrl = requestUrl;
            if (requestParameters != null && requestParameters.Count > 0)
            {
                fullUrl = QueryHelpers.AddQueryString(
                    requestUrl,
                    requestParameters.ToDictionary(
                        kv => kv.Key,
                        kv => new StringValues(kv.Value)
                    )
                );
            }

            var httpClient = _clientFactory.CreateClient(DouyinRequestParamManager.DY_HTTP_CLIENT);
            for (var attempt = 0; ; attempt++)
            {
                using var requestMessage = new HttpRequestMessage(httpMethod, fullUrl);
                if (!string.IsNullOrEmpty(refererValue) && Uri.IsWellFormedUriString(refererValue, UriKind.Absolute))
                    requestMessage.Headers.Referrer = new Uri(refererValue);
                if (!string.IsNullOrEmpty(cookie))
                    requestMessage.Headers.TryAddWithoutValidation("Cookie", cookie);

                try
                {
                    var response = await httpClient.SendAsync(requestMessage);
                    if (!IsTransientStatus(response.StatusCode) || attempt >= TransientRequestRetryCount)
                        return response;
                    var status = (int)response.StatusCode;
                    response.Dispose();
                    await DelayTransientRetryAsync(attempt + 1, CancellationToken.None);
                    Log.Warning("抖音接口暂时返回 HTTP {Status}，正在进行第 {Retry}/{MaxRetry} 次有限重试",
                        status, attempt + 1, TransientRequestRetryCount);
                }
                catch (Exception ex) when (IsTransientRequestFailure(ex) && attempt < TransientRequestRetryCount)
                {
                    Log.Warning("抖音接口连接失败，正在进行第 {Retry}/{MaxRetry} 次有限重试：{Reason}",
                        attempt + 1, TransientRequestRetryCount, ex.GetBaseException().Message);
                    await DelayTransientRetryAsync(attempt + 1, CancellationToken.None);
                }
            }
        }

        private static bool IsTransientStatus(HttpStatusCode status) =>
            status == HttpStatusCode.RequestTimeout || (int)status >= 500;

        private static bool IsTransientRequestFailure(Exception error) =>
            error is HttpRequestException or TimeoutException or TaskCanceledException;

        private Task DelayTransientRetryAsync(int retryNumber, CancellationToken cancellationToken)
        {
            var exponential = retryNumber <= 1 ? 1 : 3;
            var jitter = Random.Shared.Next(0, 401);
            return _delayAsync(TimeSpan.FromMilliseconds(exponential * 1000 + jitter), cancellationToken);
        }

        #region 收藏夹相关方法（保留原有逻辑，仅优化资源释放）
        public async Task<DouyinVideoInfoResponse> SyncCollectVideos(string cursor, string count, string cookie)
        {
            if (string.IsNullOrWhiteSpace(cursor))
                throw new ArgumentException($"“{nameof(cursor)}”不能为 null 或空。", nameof(cursor));
            if (string.IsNullOrWhiteSpace(count))
                throw new ArgumentException($"“{nameof(count)}”不能为 null 或空。", nameof(count));
            if (string.IsNullOrWhiteSpace(cookie))
                throw new ArgumentException($"“{nameof(cookie)}”不能为 null 或空。", nameof(cookie));

            try
            {
                var requestUrl = "/aweme/v1/web/aweme/listcollection";
                var refererValue = "https://www.douyin.com";

                var requestParameters = DouyinRequestParamManager.DouyinCollectParams;
                requestParameters["cursor"] = cursor;
                requestParameters["count"] = count;

                using var response = await GetHttpResponseMessage(HttpMethod.Post, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinVideoInfoResponse>(jsonReader);
                    if (model == null)
                        Log.Error($"SyncCollectVideos fail, data is null");
                    return model;
                    
                }
                else
                {
                    Log.Error($"SyncCollectVideos fail: {response.StatusCode}");
                    return null;
                }
            }
            catch (Exception ex)
            {
                Log.Error($"SyncCollectVideos error: {ex.Message}", ex);
                return null;
            }
        }

        public async Task<DouyinCollectListResponse> SyncCollectFolderList(string cookie, string cursor)
        {
            if (string.IsNullOrWhiteSpace(cookie))
            {
                Log.Error("cookie为空，无法获取收藏夹列表 ");
                return null;
            }

            try
            {
                var requestUrl = "/aweme/v1/web/collects/list";
                var refererValue = "https://www.douyin.com/user/self?from_tab_name=main&showSubTab=favorite_folder&showTab=favorite_collection";

                var requestParameters = DouyinRequestParamManager.DouyinCollectListParams;
                requestParameters["count"] = "10";
                requestParameters["cursor"] = cursor;

                using var response = await GetHttpResponseMessage(HttpMethod.Get, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinCollectListResponse>(jsonReader);
                    if (model == null)
                        Log.Error($"SyncCollectFolderList fail, data is null");
                    return model;
                }
                else
                {
                    Log.Error("SyncCollectFolderList ,{StatusCode}", response.StatusCode);
                    return null;
                }
            }
            catch (Exception ex)
            {
                Log.Error("SyncCollectFolderList ,{error}", ex);
                return null;
            }
        }

        public async Task<DouyinVideoInfoResponse> SyncCollectVideosByCollectId(string cursor, string count, string cookie, string collectsId)
        {
            if (string.IsNullOrWhiteSpace(collectsId))
                throw new ArgumentException($"“{nameof(collectsId)}”不能为 null 或空。", nameof(collectsId));
            if (string.IsNullOrWhiteSpace(cursor))
                throw new ArgumentException($"“{nameof(cursor)}”不能为 null 或空。", nameof(cursor));
            if (string.IsNullOrWhiteSpace(count))
                throw new ArgumentException($"“{nameof(count)}”不能为 null 或空。", nameof(count));
            if (string.IsNullOrWhiteSpace(cookie))
                throw new ArgumentException($"“{nameof(cookie)}”不能为 null 或空。", nameof(cookie));

            try
            {
                var requestUrl = "/aweme/v1/web/collects/video/list";
                var refererValue = "https://www.douyin.com/user/self?from_tab_name=main&showSubTab=favorite_folder&showTab=favorite_collection";

                var requestParameters = DouyinRequestParamManager.DouyinFolderCollectParams;
                requestParameters["cursor"] = cursor;
                requestParameters["count"] = "15";
                requestParameters["collects_id"] = collectsId;

                using var response = await GetHttpResponseMessage(HttpMethod.Get, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinVideoInfoResponse>(jsonReader);
                    if (model == null)
                        Log.Error($"SyncCollectVideosByCollectId fail: data is null");
                    return model;
                }
                else
                {
                    Log.Error($"SyncCollectVideosByCollectId fail: {response.StatusCode}");
                    return null;
                }
            }
            catch (Exception ex)
            {
                Log.Error($"SyncCollectVideosByCollectId error: {ex.Message}", ex);
                return null;
            }
        }
        #endregion

        #region 合集相关方法
        public async Task<DouyinMixListResponse> SyncMixList(string cookie, string cursor)
        {
            if (string.IsNullOrWhiteSpace(cookie))
            {
                Log.Error("cookie为空，无法获取收藏夹列表 ");
                return null;
            }

            try
            {
                var requestUrl = "/aweme/v1/web/mix/listcollection";
                var refererValue = "https://www.douyin.com/user/self?";

                var requestParameters = DouyinRequestParamManager.DouyinMixListParams;
                requestParameters["count"] = "10";
                requestParameters["cursor"] = cursor;

                using var response = await GetHttpResponseMessage(HttpMethod.Get, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinMixListResponse>(jsonReader);
                    if (model == null)
                        Log.Error($"SyncMixList fail, data is null");
                    return model;
                }
                else
                {
                    Log.Error($"SyncMixList : {response.StatusCode}");
                    return null;
                }
            }
            catch (Exception ex)
            {
                Log.Error("SyncMixList ,{error}", ex);
                return null;
            }
        }

        public async Task<DouyinVideoInfoResponse> SyncMixViedosByMixId(string cursor, string count, string cookie, string mixId)
        {
            if (string.IsNullOrWhiteSpace(mixId))
                throw new ArgumentException($"“{nameof(mixId)}”不能为 null 或空。", nameof(mixId));
            if (string.IsNullOrWhiteSpace(cursor))
                throw new ArgumentException($"“{nameof(cursor)}”不能为 null 或空。", nameof(cursor));
            if (string.IsNullOrWhiteSpace(count))
                throw new ArgumentException($"“{nameof(count)}”不能为 null 或空。", nameof(count));
            if (string.IsNullOrWhiteSpace(cookie))
                throw new ArgumentException($"“{nameof(cookie)}”不能为 null 或空。", nameof(cookie));

            try
            {
                var requestUrl = "/aweme/v1/web/mix/aweme";
                var refererValue = "https://www.douyin.com/user/self?";

                var requestParameters = DouyinRequestParamManager.DouyinMixVideoParams;
                requestParameters["cursor"] = cursor;
                requestParameters["count"] = "15";
                requestParameters["mix_id"] = mixId;

                using var response = await GetHttpResponseMessage(HttpMethod.Get, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinVideoInfoResponse>(jsonReader);
                    if (model == null)
                        Log.Error($"SyncMixViedosByMixId fail:data is null");
                    return model;
                }
                else
                {
                    Log.Error($"SyncMixViedosByMixId fail: {response.StatusCode}");
                    return null;
                }
            }
            catch (Exception ex)
            {
                Log.Error($"SyncMixViedosByMixId error: {ex.Message}", ex);
                return null;
            }
        }
        #endregion

        #region 短剧相关方法
        public async Task<DouyinSeriesListResponse> SyncSeriesList(string cookie, string cursor)
        {
            if (string.IsNullOrWhiteSpace(cookie))
            {
                Log.Error("cookie为空，无法获取收藏夹列表 ");
                return null;
            }

            try
            {
                var requestUrl = "/aweme/v1/web/series/collections";
                var refererValue = "https://www.douyin.com/user/self?";

                var requestParameters = DouyinRequestParamManager.DouyinSeriesListParams;
                requestParameters["count"] = "15";
                requestParameters["cursor"] = cursor;

                using var response = await GetHttpResponseMessage(HttpMethod.Get, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinSeriesListResponse>(jsonReader);
                    if (model == null)
                        Log.Error($"SyncShortList fail, data is null");
                    return model;
                }
                else
                {
                    Log.Error($"SyncShortList fail: {response.StatusCode}");
                    return null;
                }
            }
            catch (Exception ex)
            {
                Log.Error("SyncShortList ,{error}", ex);
                return null;
            }
        }

        public async Task<DouyinVideoInfoResponse> SyncSeriesViedosByMSeriesId(string cursor, string count, string cookie, string seriesId)
        {
            if (string.IsNullOrWhiteSpace(seriesId))
                throw new ArgumentException($"“{nameof(seriesId)}”不能为 null 或空。", nameof(seriesId));
            if (string.IsNullOrWhiteSpace(cursor))
                throw new ArgumentException($"“{nameof(cursor)}”不能为 null 或空。", nameof(cursor));
            if (string.IsNullOrWhiteSpace(count))
                throw new ArgumentException($"“{nameof(count)}”不能为 null 或空。", nameof(count));
            if (string.IsNullOrWhiteSpace(cookie))
                throw new ArgumentException($"“{nameof(cookie)}”不能为 null 或空。", nameof(cookie));

            try
            {
                var requestUrl = "/aweme/v1/web/series/aweme";
                var refererValue = "https://www.douyin.com/user/self?";

                var requestParameters = DouyinRequestParamManager.DouyinSeriesVideosParams;
                requestParameters["cursor"] = cursor;
                requestParameters["count"] = count;
                requestParameters["series_id"] = seriesId;

                using var response = await GetHttpResponseMessage(HttpMethod.Get, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinVideoInfoResponse>(jsonReader);
                    if (model == null)
                        Log.Error($"SyncSeriesViedosByMSeriesId fail:data is null");
                    return model;
                }
                else
                {
                    Log.Error($"SyncSeriesViedosByMSeriesId fail: {response.StatusCode}");
                    return null;
                }
            }
            catch (Exception ex)
            {
                Log.Error($"SyncSeriesViedosByMSeriesId error: {ex.Message}", ex);
                return null;
            }
        }
        #endregion

        #region 喜欢/博主/关注相关方法
        public async Task<DouyinVideoInfoResponse> SyncFavoriteVideos(string count, string cursor, string secUserId, string cookie)
        {
            if (string.IsNullOrWhiteSpace(cursor))
                throw new ArgumentException($"“{nameof(cursor)}”不能为 null 或空。", nameof(cursor));
            if (string.IsNullOrWhiteSpace(count))
                throw new ArgumentException($"“{nameof(count)}”不能为 null 或空。", nameof(count));
            if (string.IsNullOrWhiteSpace(secUserId))
                throw new ArgumentException($"“{nameof(secUserId)}”不能为 null 或空。", nameof(secUserId));
            if (string.IsNullOrWhiteSpace(cookie))
                throw new ArgumentException($"“{nameof(cookie)}”不能为 null 或空。", nameof(cookie));

            try
            {
                var requestUrl = "/aweme/v1/web/aweme/favorite";
                var refererValue = "https://www.douyin.com/user/self?showTab=like";

                var requestParameters = DouyinRequestParamManager.DouyinFavoriteParams;
                requestParameters["max_cursor"] = cursor;
                requestParameters["sec_user_id"] = secUserId;
                requestParameters["count"] = count;

                using var response = await GetHttpResponseMessage(HttpMethod.Get, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinVideoInfoResponse>(jsonReader);
                    if (model == null)
                        Log.Error($"SyncFavoriteVideos fail, data is null");
                    return model;
                }
                else
                {
                    Log.Error($"SyncFavoriteVideos fail: {response.StatusCode}");
                    return null;
                }
            }
            catch (Exception ex)
            {
                Log.Error($"SyncFavoriteVideos error: {ex.Message}", ex);
                return null;
            }
        }

        public async Task<DouyinVideoInfoResponse> SyncUpderPostVideos(string count, string cursor, string secUserId, string cookie)
        {
            if (string.IsNullOrWhiteSpace(cursor))
                throw new ArgumentException($"“{nameof(cursor)}”不能为 null 或空。", nameof(cursor));
            if (string.IsNullOrWhiteSpace(count))
                throw new ArgumentException($"“{nameof(count)}”不能为 null 或空。", nameof(count));
            if (string.IsNullOrWhiteSpace(secUserId))
                throw new ArgumentException($"“{nameof(secUserId)}”不能为 null 或空。", nameof(secUserId));
            if (string.IsNullOrWhiteSpace(cookie))
                throw new ArgumentException($"“{nameof(cookie)}”不能为 null 或空。", nameof(cookie));

            try
            {
                var requestUrl = "/aweme/v1/web/aweme/post";
                var refererValue = "https://www.douyin.com/user/";

                var requestParameters = DouyinRequestParamManager.DouyinUpderPostParams;
                requestParameters["max_cursor"] = cursor;
                requestParameters["sec_user_id"] = secUserId;
                requestParameters["count"] = count;

                using var response = await GetHttpResponseMessage(HttpMethod.Get, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinVideoInfoResponse>(jsonReader);
                    if (model == null)
                        throw new InvalidDataException("获取博主作品列表失败：响应内容为空或无法解析");
                    return model;
                }
                else
                {
                    throw new HttpRequestException(
                        $"获取博主作品列表失败：HTTP {(int)response.StatusCode} {response.StatusCode}",
                        null,
                        response.StatusCode);
                }
            }
            catch (Exception ex)
            {
                Log.Error($"SyncUpderPostVideos error: {ex.Message}", ex);
                throw;
            }
        }

        public async Task<DouyinFollowInfoResponse> SyncMyFollows(string count, string offset, string secUserId, string cookie)
        {
            if (string.IsNullOrWhiteSpace(offset))
                throw new ArgumentException($"“{nameof(offset)}”不能为 null 或空。", nameof(offset));
            if (string.IsNullOrWhiteSpace(count))
                throw new ArgumentException($"“{nameof(count)}”不能为 null 或空。", nameof(count));
            if (string.IsNullOrWhiteSpace(secUserId))
                throw new ArgumentException($"“{nameof(secUserId)}”不能为 null 或空。", nameof(secUserId));
            if (string.IsNullOrWhiteSpace(cookie))
                throw new ArgumentException($"“{nameof(cookie)}”不能为 null 或空。", nameof(cookie));

            try
            {
                var requestUrl = "/aweme/v1/web/user/following/list";
                var refererValue = "https://www.douyin.com/user/self?showTab=like";

                var requestParameters = DouyinRequestParamManager.DouyinMyFollowParams;
                requestParameters["sec_user_id"] = secUserId;
                requestParameters["count"] = count;
                requestParameters["offset"] = offset;

                using var response = await GetHttpResponseMessage(HttpMethod.Get, requestUrl, requestParameters, refererValue, cookie);
                if (response.IsSuccessStatusCode)
                {
                    using var stream = await response.Content.ReadAsStreamAsync();
                    using var reader = new StreamReader(stream);
                    using var jsonReader = new JsonTextReader(reader);
                    var model = JsonSerializer.Create(_jsonSettings).Deserialize<DouyinFollowInfoResponse>(jsonReader);
                    return model;
                }
                else
                {
                    Log.Error($"SyncMyFollows fail: {response.StatusCode}");
                    return null;
                }
            }
            catch (Exception ex)
            {
                Log.Error($"SyncMyFollows error: {ex.Message}", ex);
                // 优化：抛出前确保资源释放，使用包装异常保留原始堆栈
                throw new InvalidOperationException("获取关注列表失败", ex);
            }
        }
        #endregion

        #region Cookie检查
        public async Task<bool> CheckCookie(DouyinCookie douyinCookie)
        {
            if (douyinCookie == null || string.IsNullOrWhiteSpace(douyinCookie.Cookies))
                return false;

            try
            {
                if (!string.IsNullOrWhiteSpace(douyinCookie.SecUserId))
                {
                    var res = await SyncMyFollows("1", "10", douyinCookie.SecUserId, douyinCookie.Cookies);
                    return res != null && res.StatusCode == 0;
                }
                else
                {
                    var res = await SyncCollectVideos("0", "10", douyinCookie.Cookies);
                    return res != null && res.StatusCode == 0;
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex, "检查Cookie有效性失败");
                return false;
            }
        }
        #endregion

        #region 下载相关
        public Task<MediaDownloadResult> DownloadAsync(
           string videoUrl,
           string savePath,
           string cookie,
           List<string> otherUrls = null,
           CancellationToken cancellationToken = default,
           TimeSpan? streamTimeout = null,
           int maxRetryCount = 12,
           TimeSpan? initialRetryDelay = null)
        {
            var urls = BuildCandidateUrls(videoUrl, otherUrls, maxRetryCount);
            return DownloadCandidatesAsync(
                urls,
                savePath,
                cookie,
                cancellationToken,
                streamTimeout ?? TimeSpan.FromSeconds(60),
                initialRetryDelay ?? TimeSpan.FromSeconds(1),
                async (response, actualPath, timeout, token) =>
                {
                    await WriteLocalAsync(response, actualPath, timeout, token);
                });
        }

        /// <summary>
        /// 将抖音媒体写入指定存储。远端存储负责安全中转和最终提交，
        /// 不会先落入永久本地媒体目录。
        /// </summary>
        public async Task<MediaDownloadResult> DownloadToStorageAsync(
            StorageType storageType,
            string mediaUrl,
            string savePath,
            string cookie,
            List<string> otherUrls = null,
            CancellationToken cancellationToken = default,
            int maxRetryCount = 12,
            IMediaStorage storageOverride = null)
        {
            if (storageType == StorageType.Local)
                return await DownloadAsync(mediaUrl, savePath, cookie, otherUrls, cancellationToken, maxRetryCount: maxRetryCount);
            var storage = storageOverride ?? _storageRouter.Resolve(storageType);
            if (storage.StorageType != storageType)
                throw new InvalidOperationException("指定的媒体存储与目标存储类型不一致");
            if (storage is ICanonicalMediaStorage canonicalStorage)
                savePath = await canonicalStorage.CanonicalizePathAsync(savePath, false, cancellationToken);
            var urls = BuildCandidateUrls(mediaUrl, otherUrls, maxRetryCount);
            return await DownloadCandidatesAsync(
                urls,
                savePath,
                cookie,
                cancellationToken,
                TimeSpan.FromSeconds(60),
                TimeSpan.FromSeconds(1),
                async (response, actualPath, _, token) =>
                {
                    try
                    {
                        await using var responseStream = await response.Content.ReadAsStreamAsync(token);
                        await storage.WriteAsync(
                            actualPath,
                            responseStream,
                            response.Content.Headers.ContentLength,
                            response.Content.Headers.ContentType?.MediaType,
                            token);
                    }
                    catch (OperationCanceledException) when (token.IsCancellationRequested) { throw; }
                    catch (MediaIntegrityException) { throw; }
                    catch (Exception ex)
                    {
                        throw new MediaStorageException($"{storageType} 媒体写入失败：{actualPath}", ex);
                    }
                });
        }

        private async Task<MediaDownloadResult> DownloadCandidatesAsync(
            IReadOnlyList<Uri> urls,
            string savePath,
            string cookie,
            CancellationToken cancellationToken,
            TimeSpan streamTimeout,
            TimeSpan retryDelay,
            Func<HttpResponseMessage, string, TimeSpan, CancellationToken, Task> writeAsync)
        {
            if (urls.Count == 0)
                return Failure(MediaDownloadFailureKind.SourceUnavailable, savePath, null, null, 0, null, "没有有效的媒体下载地址。");

            var client = _clientFactory.CreateClient(DouyinRequestParamManager.DY_HTTP_CLIENT_DOWN);
            MediaDownloadResult lastFailure = null;
            var forbiddenCount = 0;
            var attempted = 0;

            foreach (var source in urls)
            {
                attempted++;
                var networkRetry = 0;
                var rateLimitRetry = 0;
                while (true)
                {
                    HttpResponseMessage response = null;
                    Uri finalUri = source;
                    try
                    {
                        (response, finalUri) = await SendWithSafeRedirectsAsync(client, source, cookie, cancellationToken);
                        var status = (int)response.StatusCode;
                        var host = SafeHost(finalUri);

                        if (response.StatusCode == HttpStatusCode.Unauthorized)
                            return Failure(MediaDownloadFailureKind.SourceUnauthorized, savePath, status, host, attempted, null,
                                "抖音媒体请求返回 401，需要重新授权。");

                        if (response.StatusCode == HttpStatusCode.Forbidden)
                        {
                            forbiddenCount++;
                            lastFailure = Failure(MediaDownloadFailureKind.SourceForbidden, savePath, status, host, attempted, null,
                                "抖音媒体来源拒绝访问（403）。");
                            break;
                        }

                        if (response.StatusCode is HttpStatusCode.NotFound or HttpStatusCode.Gone)
                        {
                            lastFailure = Failure(MediaDownloadFailureKind.SourceNotFound, savePath, status, host, attempted, null,
                                $"媒体来源返回 {status}，作品可能已下架或链接已失效。");
                            break;
                        }

                        if ((int)response.StatusCode == 429)
                        {
                            var retryAt = GetRetryAfter(response);
                            if (rateLimitRetry++ == 0)
                            {
                                var wait = retryAt.HasValue ? retryAt.Value - DateTime.UtcNow : TimeSpan.FromSeconds(5);
                                if (wait < TimeSpan.Zero) wait = TimeSpan.Zero;
                                if (wait > TimeSpan.FromSeconds(60)) wait = TimeSpan.FromSeconds(60);
                                await _delayAsync(wait, cancellationToken);
                                continue;
                            }
                            return Failure(MediaDownloadFailureKind.SourceRateLimited, savePath, status, host, attempted, retryAt,
                                "抖音媒体来源请求过于频繁（429），已进入冷却等待。");
                        }

                        if ((int)response.StatusCode >= 500)
                        {
                            if (networkRetry < MediaNetworkRetryCount)
                            {
                                networkRetry++;
                                await DelayMediaRetryAsync(retryDelay, networkRetry, cancellationToken);
                                continue;
                            }
                            lastFailure = Failure(MediaDownloadFailureKind.SourceUnavailable, savePath, status, host, attempted, null,
                                $"媒体来源暂时不可用（{status}）。");
                            break;
                        }

                        if (!response.IsSuccessStatusCode)
                        {
                            lastFailure = Failure(MediaDownloadFailureKind.SourceUnavailable, savePath, status, host, attempted, null,
                                $"媒体来源请求失败（{status}）。");
                            break;
                        }

                        var mediaType = response.Content.Headers.ContentType?.MediaType;
                        if (IsObviousNonMedia(mediaType))
                        {
                            lastFailure = Failure(MediaDownloadFailureKind.SourceInvalidContent, savePath, status, host, attempted, null,
                                $"媒体来源返回了非媒体内容（{mediaType}）。");
                            break;
                        }
                        if (response.Content.Headers.ContentLength == 0)
                        {
                            lastFailure = Failure(MediaDownloadFailureKind.IntegrityCheckFailed, savePath, status, host, attempted, null,
                                "媒体来源返回空内容。");
                            break;
                        }

                        var actualPath = DetectActualSavePath(savePath, mediaType);
                        await writeAsync(response, actualPath, streamTimeout, cancellationToken);
                        return MediaDownloadResult.Succeeded(actualPath, host, attempted);
                    }
                    catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
                    {
                        CleanupIncompleteFile(savePath);
                        return Failure(MediaDownloadFailureKind.Cancelled, savePath, null, SafeHost(finalUri), attempted, null, "媒体下载已取消。");
                    }
                    catch (MediaStorageException ex)
                    {
                        CleanupIncompleteFile(savePath);
                        Log.Error(ex, "媒体存储写入失败：{Path}", savePath);
                        return Failure(MediaDownloadFailureKind.StorageUnavailable, savePath, null, SafeHost(finalUri), attempted, null,
                            DescribeStorageFailure(ex));
                    }
                    catch (MediaIntegrityException ex)
                    {
                        CleanupIncompleteFile(savePath);
                        lastFailure = Failure(MediaDownloadFailureKind.IntegrityCheckFailed, savePath, null, SafeHost(finalUri), attempted, null, ex.Message);
                        break;
                    }
                    catch (MediaSourceException ex)
                    {
                        lastFailure = Failure(ex.FailureKind, savePath, ex.StatusCode, ex.SourceHost, attempted, ex.RetryAfter, ex.Message);
                        break;
                    }
                    catch (Exception ex) when (ex is HttpRequestException or TimeoutException or TaskCanceledException or IOException)
                    {
                        if (networkRetry < MediaNetworkRetryCount)
                        {
                            networkRetry++;
                            await DelayMediaRetryAsync(retryDelay, networkRetry, cancellationToken);
                            continue;
                        }
                        lastFailure = Failure(MediaDownloadFailureKind.SourceUnavailable, savePath, null, SafeHost(finalUri), attempted, null,
                            "连接媒体来源失败。");
                        break;
                    }
                    finally
                    {
                        response?.Dispose();
                    }
                }
            }

            if (forbiddenCount == attempted && attempted > 0)
                lastFailure = Failure(MediaDownloadFailureKind.SourceForbidden, savePath, 403, lastFailure?.SourceHost,
                    attempted, null, $"全部 {attempted} 个候选媒体地址均返回 403。");
            else if (lastFailure?.FailureKind == MediaDownloadFailureKind.SourceForbidden)
                lastFailure = Failure(MediaDownloadFailureKind.SourceUnavailable, savePath, null, lastFailure.SourceHost,
                    attempted, null, "候选媒体地址返回了多种来源错误。");

            lastFailure ??= Failure(MediaDownloadFailureKind.SourceUnavailable, savePath, null, null, attempted, null, "所有候选媒体地址均不可用。");
            if (lastFailure.FailureKind == MediaDownloadFailureKind.SourceForbidden)
                Log.Warning("抖音媒体来源被拒绝：Host={SourceHost}, Status={Status}, Candidates={Candidates}",
                    lastFailure.SourceHost, lastFailure.HttpStatusCode, lastFailure.AttemptedUrlCount);
            else
                Log.Warning("媒体来源下载失败：Host={SourceHost}, Status={Status}, Kind={Kind}, Candidates={Candidates}",
                    lastFailure.SourceHost, lastFailure.HttpStatusCode, lastFailure.FailureKind, lastFailure.AttemptedUrlCount);
            return lastFailure;
        }

        private Task DelayMediaRetryAsync(TimeSpan baseDelay, int retryNumber, CancellationToken cancellationToken)
        {
            var multiplier = Math.Pow(2, Math.Max(0, retryNumber - 1));
            var milliseconds = Math.Min(5000, Math.Max(100, baseDelay.TotalMilliseconds * multiplier));
            milliseconds += Random.Shared.Next(0, 251);
            return _delayAsync(TimeSpan.FromMilliseconds(milliseconds), cancellationToken);
        }

        private static List<Uri> BuildCandidateUrls(string primary, IEnumerable<string> alternatives, int limit)
        {
            var result = new List<Uri>();
            var seen = new HashSet<string>(StringComparer.Ordinal);
            foreach (var value in new[] { primary }.Concat(alternatives ?? Enumerable.Empty<string>()))
            {
                if (result.Count >= Math.Clamp(limit, 1, 12)) break;
                if (!Uri.TryCreate(value, UriKind.Absolute, out var uri) || (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)) continue;
                if (seen.Add(uri.AbsoluteUri)) result.Add(uri);
            }
            return result;
        }

        internal static string DescribeStorageFailure(MediaStorageException error)
        {
            if (error == null) return "媒体存储写入失败。";
            var message = error.Message?.Trim();
            var reason = error.GetBaseException()?.Message?.Trim();
            if (string.IsNullOrWhiteSpace(message)) message = "媒体存储写入失败。";
            if (string.IsNullOrWhiteSpace(reason) || string.Equals(message, reason, StringComparison.Ordinal))
                return message;
            return $"{message}；原因：{reason}";
        }

        private static async Task<(HttpResponseMessage Response, Uri FinalUri)> SendWithSafeRedirectsAsync(
            HttpClient client,
            Uri initialUri,
            string cookie,
            CancellationToken cancellationToken)
        {
            var current = initialUri;
            for (var redirect = 0; redirect <= 5; redirect++)
            {
                using var request = new HttpRequestMessage(HttpMethod.Get, current);
                if (!string.IsNullOrWhiteSpace(cookie) && IsDouyinHost(current.Host))
                    request.Headers.TryAddWithoutValidation("Cookie", cookie);
                var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
                if (!IsRedirect(response.StatusCode)) return (response, current);

                var location = response.Headers.Location;
                response.Dispose();
                if (location == null)
                    throw new MediaSourceException(MediaDownloadFailureKind.SourceUnavailable, "媒体来源返回了无目标地址的跳转。",
                        (int)response.StatusCode, SafeHost(current));
                if (redirect == 5)
                    throw new MediaSourceException(MediaDownloadFailureKind.SourceUnavailable, "媒体来源跳转次数超过 5 次。",
                        (int)response.StatusCode, SafeHost(current));
                current = location.IsAbsoluteUri ? location : new Uri(current, location);
                if (current.Scheme != Uri.UriSchemeHttp && current.Scheme != Uri.UriSchemeHttps)
                    throw new MediaSourceException(MediaDownloadFailureKind.SourceUnavailable, "媒体来源返回了不安全的跳转协议。",
                        sourceHost: SafeHost(current));
            }
            throw new MediaSourceException(MediaDownloadFailureKind.SourceUnavailable, "媒体来源跳转失败。", sourceHost: SafeHost(current));
        }

        private static async Task WriteLocalAsync(
            HttpResponseMessage response,
            string actualSavePath,
            TimeSpan streamTimeout,
            CancellationToken cancellationToken)
        {
            var directory = Path.GetDirectoryName(actualSavePath);
            FileStream fileStream = null;
            try
            {
                try
                {
                    if (!string.IsNullOrWhiteSpace(directory)) Directory.CreateDirectory(directory);
                    CleanupIncompleteFile(actualSavePath);
                    fileStream = new FileStream(actualSavePath, FileMode.CreateNew, FileAccess.Write, FileShare.None,
                        81920, FileOptions.Asynchronous | FileOptions.SequentialScan);
                }
                catch (Exception ex) when (ex is UnauthorizedAccessException or IOException)
                {
                    throw new MediaStorageException($"本地媒体写入失败：{actualSavePath}", ex);
                }

                Stream responseStream;
                try { responseStream = await response.Content.ReadAsStreamAsync(cancellationToken); }
                catch (Exception ex) when (ex is HttpRequestException or IOException)
                {
                    throw new MediaSourceException(MediaDownloadFailureKind.SourceUnavailable, "读取媒体来源响应失败。",
                        sourceHost: SafeHost(response.RequestMessage?.RequestUri), innerException: ex);
                }
                await using var ownedResponseStream = responseStream;
                var buffer = System.Buffers.ArrayPool<byte>.Shared.Rent(81920);
                long totalRead = 0;
                var lastActivity = DateTime.UtcNow;
                try
                {
                    int read;
                    while (true)
                    {
                        try { read = await responseStream.ReadAsync(buffer.AsMemory(0, buffer.Length), cancellationToken); }
                        catch (Exception ex) when (ex is HttpRequestException or IOException)
                        {
                            throw new MediaSourceException(MediaDownloadFailureKind.SourceUnavailable, "读取媒体来源响应失败。",
                                sourceHost: SafeHost(response.RequestMessage?.RequestUri), innerException: ex);
                        }
                        if (read <= 0) break;
                        if (DateTime.UtcNow - lastActivity > streamTimeout)
                            throw new MediaSourceException(MediaDownloadFailureKind.SourceUnavailable,
                                $"媒体流超过 {streamTimeout.TotalSeconds:0} 秒没有数据。");
                        try { await fileStream.WriteAsync(buffer.AsMemory(0, read), cancellationToken); }
                        catch (Exception ex) when (ex is UnauthorizedAccessException or IOException)
                        {
                            throw new MediaStorageException($"本地媒体写入失败：{actualSavePath}", ex);
                        }
                        totalRead += read;
                        lastActivity = DateTime.UtcNow;
                    }
                    try { await fileStream.FlushAsync(cancellationToken); }
                    catch (Exception ex) when (ex is UnauthorizedAccessException or IOException)
                    {
                        throw new MediaStorageException($"本地媒体写入失败：{actualSavePath}", ex);
                    }
                }
                finally
                {
                    System.Buffers.ArrayPool<byte>.Shared.Return(buffer);
                }
                if (totalRead <= 0) throw new MediaIntegrityException("下载内容为空。");
                var expected = response.Content.Headers.ContentLength;
                if (expected.HasValue && expected.Value != totalRead)
                    throw new MediaIntegrityException($"下载长度不一致：期望 {expected.Value}，实际 {totalRead}。");
            }
            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
            catch (MediaSourceException) { CleanupIncompleteFile(actualSavePath); throw; }
            catch (MediaIntegrityException) { CleanupIncompleteFile(actualSavePath); throw; }
            catch (MediaStorageException) { CleanupIncompleteFile(actualSavePath); throw; }
            finally { if (fileStream != null) await fileStream.DisposeAsync(); }
        }

        private static string DetectActualSavePath(string savePath, string mediaType)
        {
            if (!Path.GetExtension(savePath).Equals(".mp3", StringComparison.OrdinalIgnoreCase)) return savePath;
            if (mediaType?.Contains("audio/mp4", StringComparison.OrdinalIgnoreCase) == true
                || mediaType?.Contains("audio/m4a", StringComparison.OrdinalIgnoreCase) == true)
                return Path.ChangeExtension(savePath, ".m4a");
            if (mediaType?.Contains("video/mp4", StringComparison.OrdinalIgnoreCase) == true)
                return Path.ChangeExtension(savePath, ".mp4");
            return savePath;
        }

        private static bool IsObviousNonMedia(string mediaType) =>
            !string.IsNullOrWhiteSpace(mediaType)
            && (mediaType.StartsWith("text/html", StringComparison.OrdinalIgnoreCase)
                || mediaType.Contains("json", StringComparison.OrdinalIgnoreCase));

        private static bool IsDouyinHost(string host) =>
            string.Equals(host, "douyin.com", StringComparison.OrdinalIgnoreCase)
            || host.EndsWith(".douyin.com", StringComparison.OrdinalIgnoreCase);

        private static bool IsRedirect(HttpStatusCode code) => code is
            HttpStatusCode.MovedPermanently or HttpStatusCode.Redirect or HttpStatusCode.RedirectMethod
            or HttpStatusCode.TemporaryRedirect or HttpStatusCode.PermanentRedirect;

        private static string SafeHost(Uri uri) => uri?.IsAbsoluteUri == true ? uri.IdnHost : null;

        private static DateTime? GetRetryAfter(HttpResponseMessage response)
        {
            var value = response.Headers.RetryAfter;
            if (value?.Date.HasValue == true) return value.Date.Value.UtcDateTime;
            if (value?.Delta.HasValue == true) return DateTime.UtcNow.Add(value.Delta.Value);
            return DateTime.UtcNow.AddMinutes(15);
        }

        private static MediaDownloadResult Failure(
            MediaDownloadFailureKind kind,
            string savePath,
            int? status,
            string host,
            int attempted,
            DateTime? retryAfter,
            string message) => new()
        {
            Success = false,
            ActualSavePath = savePath,
            FailureKind = kind,
            HttpStatusCode = status,
            SourceHost = host,
            AttemptedUrlCount = attempted,
            RetryAfter = retryAfter,
            Message = message
        };

        private static void CleanupIncompleteFile(string savePath)
        {
            if (File.Exists(savePath))
            {
                try
                {
                    File.Delete(savePath);
                }
                catch (IOException ex)
                {
                    Log.Error(ex, $"清理无效文件失败：{savePath}（可能被占用）");
                }
            }
        }
        #endregion

        #region IDisposable 实现（优化版）
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposedValue)
            {
                if (disposing)
                {
                    // 释放托管资源：仅清理本类创建的托管资源（此处无）
                }

                // 释放非托管资源：本类无非托管资源
                // 优化：移除强制GC调用，让GC自动管理

                _disposedValue = true;
            }
        }

        public void Dispose()
        {
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
        #endregion
    }
}