Полностью переписанное api

YandexMusic.API/Requests/Common/YRequestBuilder.cs

@@ -1,38 +1,39 @@
 using System.Collections.Specialized;
 using System.Net;
 using System.Net.Http.Headers;
-using System.Reflection;
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
 using System.Web;
 using YandexMusic.API.Common;
-using YandexMusic.API.Extensions;
-using YandexMusic.API.Requests.Common.Attributes;
 
 namespace YandexMusic.API.Requests.Common;
 
-/// <summary>Базовый строитель HTTP-запросов к API Яндекс.Музыки.</summary>
-/// <typeparam name="TResponse">Тип ответа.</typeparam>
+/// <summary>Базовый строитель HTTP-запросов.</summary>
 /// <typeparam name="TParams">Тип параметров запроса.</typeparam>
-public abstract class YRequestBuilder<TResponse, TParams>
+public abstract class YRequestBuilder<TParams>
 {
-    private readonly YRequestAttribute _requestInfo;
-    private Dictionary<string, string> _substitutions = null!;
+    /// <summary>HTTP-метод (GET, POST и т.д.).</summary>
+    protected abstract string Method { get; }
+
+    /// <summary>Базовый URL (например, "https://api.music.yandex.net").</summary>
+    protected abstract string BaseUrl { get; }
+
+    /// <summary>Шаблон пути (может содержать плейсхолдеры вида {id}).</summary>
+    protected abstract string PathTemplate { get; }
+
     private readonly JsonSerializerOptions _jsonOptions;
 
-    protected readonly YandexMusicApi api;
-    protected readonly AuthStorage storage;
-    protected string device;
+    /// <summary>Основной экземпляр API.</summary>
+    protected YandexMusicApi Api { get; }
 
-    protected YRequestBuilder(YandexMusicApi yandex, AuthStorage auth)
+    /// <summary>Хранилище авторизации (сокращение для Api.Storage).</summary>
+    protected AuthStorage Storage => Api.Storage;
+
+    protected YRequestBuilder(YandexMusicApi api)
     {
-        _requestInfo = GetType().GetCustomAttribute<YRequestAttribute>()
-            ?? throw new NotImplementedException($"Отсутствует атрибут {nameof(YRequestAttribute)}");
-        api = yandex;
-        storage = auth;
-        device = $"os=CSharp; os_version=; manufacturer=FrigaT; model=Yandex Music API; clid=; device_id={storage.DeviceId}; uuid=random";
-
+        Api = api;
         _jsonOptions = new JsonSerializerOptions
         {
             PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
@@ -41,57 +42,91 @@ public abstract class YRequestBuilder<TResponse, TParams>
         };
     }
 
-    private Uri BuildUri(TParams tuple)
+    private string FullUrl => $"{BaseUrl.TrimEnd('/')}/{PathTemplate.TrimStart('/')}";
+
+    private Uri BuildUri(TParams parameters, Dictionary<string, string> substitutions)
     {
-        var queryParams = GetQueryParams(tuple);
+        var queryParams = GetQueryParams(parameters);
         var modifiedParams = HttpUtility.ParseQueryString(string.Empty);
         foreach (string? key in queryParams)
             if (key != null)
-                modifiedParams[key] = ReplaceSubs(queryParams[key]!);
-        var endpoint = ReplaceSubs(_requestInfo.Url);
+                modifiedParams[key] = ReplaceSubs(queryParams[key]!, substitutions);
+        var endpoint = ReplaceSubs(FullUrl, substitutions);
         var builder = new UriBuilder(endpoint) { Query = modifiedParams.ToString() ?? string.Empty };
         return builder.Uri;
     }
 
-    private HttpRequestMessage CreateMessage(TParams tuple)
+    private HttpRequestMessage CreateMessage(TParams parameters, Dictionary<string, string> substitutions)
     {
         var msg = new HttpRequestMessage
         {
-            RequestUri = BuildUri(tuple),
-            Method = new HttpMethod(_requestInfo.Method),
-            Content = GetContent(tuple)
+            RequestUri = BuildUri(parameters, substitutions),
+            Method = new HttpMethod(Method),
+            Content = GetContent(parameters)
         };
-        msg.Headers.TryAddWithoutValidation(HttpRequestHeader.AcceptCharset.GetName(), Encoding.UTF8.WebName);
-        msg.Headers.TryAddWithoutValidation(HttpRequestHeader.AcceptEncoding.GetName(), "gzip");
-        if (!string.IsNullOrEmpty(storage.Token))
-            msg.Headers.TryAddWithoutValidation(HttpRequestHeader.Authorization.GetName(), $"OAuth {storage.Token}");
+        msg.Headers.TryAddWithoutValidation(GetHeaderName(HttpRequestHeader.AcceptCharset), Encoding.UTF8.WebName);
+        msg.Headers.TryAddWithoutValidation(GetHeaderName(HttpRequestHeader.AcceptEncoding), "gzip");
+        if (!string.IsNullOrEmpty(Storage.Token))
+            msg.Headers.TryAddWithoutValidation(GetHeaderName(HttpRequestHeader.Authorization), $"OAuth {Storage.Token}");
         SetCustomHeaders(msg.Headers);
         return msg;
     }
 
-    protected string ReplaceSubs(string str)
+    // Вспомогательный метод: преобразование HttpRequestHeader в строку (как было в HttpRequestHeaderExtensions)
+    private static string GetHeaderName(HttpRequestHeader header)
     {
-        var subs = str.GetMatches(@"\{.+?\}");
+        return SplitByCapitalLetter(header.ToString(), "-");
+    }
+
+    // Вспомогательный метод: разбиение строки по заглавным буквам (из StringExtensions)
+    private static string SplitByCapitalLetter(string str, string delimiter)
+    {
+        var matches = Regex.Matches(str, @"([A-Z]+)(?=([A-Z][a-z]|$)) | [A-Z][a-z].+?(?=([A-Z]|$))", RegexOptions.IgnorePatternWhitespace);
+        return string.Join(delimiter, matches.Cast<Match>().Select(m => m.Value));
+    }
+
+    // Вспомогательный метод: замена всех вхождений регулярного выражения (из StringExtensions)
+    private static string ReplaceRegex(string input, string pattern, string replacement, RegexOptions options = RegexOptions.IgnoreCase)
+    {
+        return string.IsNullOrEmpty(input) ? string.Empty : Regex.Replace(input, pattern, replacement, options);
+    }
+
+    // Вспомогательный метод: получение совпадений по регулярному выражению (из StringExtensions)
+    private static string[] GetMatches(string input, string pattern, RegexOptions options = RegexOptions.IgnoreCase)
+    {
+        if (string.IsNullOrEmpty(input) || !Regex.IsMatch(input, pattern, options))
+            return Array.Empty<string>();
+        return Regex.Matches(input, pattern, options)
+            .Cast<Match>()
+            .Select(m => m.Value)
+            .ToArray();
+    }
+
+    private string ReplaceSubs(string str, Dictionary<string, string> substitutions)
+    {
+        var subs = GetMatches(str, @"\{.+?\}");
         foreach (var s in subs)
         {
-            var key = s.ReplaceRegex(@"[\{\}]", string.Empty);
-            if (!_substitutions.TryGetValue(key, out var value))
+            var key = ReplaceRegex(s, @"[\{\}]", string.Empty);
+            if (!substitutions.TryGetValue(key, out var value))
                 throw new Exception($"Не найдена подстановка {s}");
             str = str.Replace(s, value);
         }
         return str;
     }
 
-    protected virtual Dictionary<string, string> GetSubstitutions(TParams tuple) => [];
-    protected virtual NameValueCollection GetQueryParams(TParams tuple) => [];
-    protected virtual HttpContent? GetContent(TParams tuple) => null;
+    protected virtual Dictionary<string, string> GetSubstitutions(TParams parameters) => [];
+    protected virtual NameValueCollection GetQueryParams(TParams parameters) => [];
+    protected virtual HttpContent? GetContent(TParams parameters) => null;
     protected virtual void SetCustomHeaders(HttpRequestHeaders headers) { }
+
     protected string SerializeJson(object data) => JsonSerializer.Serialize(data, _jsonOptions);
 
-    internal YRequest<TResponse> Build(TParams tuple)
+    /// <summary>Выполняет запрос и возвращает десериализованный ответ.</summary>
+    public async Task<HttpResponseMessage?> ExecuteRawAsync(TParams parameters)
     {
-        _substitutions = GetSubstitutions(tuple);
-        var msg = CreateMessage(tuple);
-        return new YRequest<TResponse>(msg, api, storage);
+        var substitutions = GetSubstitutions(parameters);
+        using var msg = CreateMessage(parameters, substitutions);
+        return await Api.HttpClient.SendAsync(msg);
     }
 }