RequestBuilder.cs

using System.Net.Sockets;
using System.Text;

namespace HttpParser;

public static class RequestBuilder
{
    private static readonly string _boundary = "----WebKitFormBoundary" + DateTime.Now.Ticks.ToString("x");
    
    public static string SendRequest(HttpRequest request)
    {
        using (var client = new TcpClient())
        {
            client.Connect(request.Host, request.Port);
            using (var stream = client.GetStream())
            using (var reader = new StreamReader(stream))
            using (var writer = new StreamWriter(stream) { AutoFlush = true })
            {
                // Строим полный путь с параметрами
                var fullPath = BuildPathWithQuery(request);
                
                // Строим тело запроса и определяем Content-Type
                var (requestBody, contentType) = BuildRequestBody(request);
                
                // Собираем полный запрос
                var httpRequest = BuildHttpRequest(request, fullPath, requestBody, contentType);

                // Отправляем
                writer.Write(httpRequest);
                
                // Читаем ответ
                var response = reader.ReadToEnd();
                return response;
            }
        }
    }
    
    private static string BuildPathWithQuery(HttpRequest request)
    {
        var path = request.Path;
        
        if (request.QueryParameters.Any())
        {
            var queryString = string.Join("&", 
                request.QueryParameters.Select(kvp => 
                    $"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value)}"));
            path += "?" + queryString;
        }
        
        return path;
    }
    
    private static (string body, string contentType) BuildRequestBody(HttpRequest request)
    {
        // Если есть явно заданное тело - в данном случае такого не бывает
        if (!string.IsNullOrEmpty(request.Body))
        {
            var contentType = request.UseJson ? "application/json" : "text/plain";
            return (request.Body, contentType);
        }
        
        // Multipart/form-data (формы с файлами)
        if (request.UseMultipartFormData && (request.FormData.Any() || request.Files.Any()))
        {
            return (BuildMultipartFormData(request), $"multipart/form-data; boundary={_boundary}");
        }
        
        // application/x-www-form-urlencoded (простые формы)
        if (request.UseFormData && request.FormData.Any())
        {
            var formBody = string.Join("&", 
                request.FormData.Select(kvp => 
                    $"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value)}"));
            return (formBody, "application/x-www-form-urlencoded");
        }
        
        // Пустое тело для GET
        return (string.Empty, "application/x-www-form-urlencoded");
    }
    
    private static string BuildMultipartFormData(HttpRequest request)
    {
        var bodyBuilder = new StringBuilder();
        
        // Добавляем обычные поля формы
        foreach (var field in request.FormData)
        {
            bodyBuilder.AppendLine($"--{_boundary}");
            bodyBuilder.AppendLine($"Content-Disposition: form-data; name=\"{field.Key}\"");
            bodyBuilder.AppendLine();
            bodyBuilder.AppendLine(field.Value);
        }
        
        // Добавляем файлы
        foreach (var file in request.Files)
        {
            bodyBuilder.AppendLine($"--{_boundary}");
            bodyBuilder.AppendLine($"Content-Disposition: form-data; name=\"{file.FieldName}\"; filename=\"{file.FileName}\"");
            bodyBuilder.AppendLine($"Content-Type: {file.ContentType}");
            bodyBuilder.AppendLine();
            
            Encoding utf8NoBom = new UTF8Encoding(false);
            bodyBuilder.AppendLine(utf8NoBom.GetString(file.Content));
        }
        
        bodyBuilder.AppendLine($"--{_boundary}--");
        
        return bodyBuilder.ToString();
    }
    
    private static string BuildHttpRequest(HttpRequest request, string fullPath, string body, string contentType)
    {
        var requestBuilder = new StringBuilder();
        
        // Стартовая строка
        requestBuilder.AppendLine($"{request.Method.ToUpper()} {fullPath} {request.Protocol}");
        
        // Обязательные заголовки
        requestBuilder.AppendLine($"Host: {request.Host}");
        
        // Cookie
        if (request.Cookies.Any())
        {
            var cookies = string.Join("; ", 
                request.Cookies.Select(kvp => $"{kvp.Key}={kvp.Value}"));
            requestBuilder.AppendLine($"Cookie: {cookies}");
        }
        
        // Content-Type (если есть тело)
        if (!string.IsNullOrEmpty(contentType))
        {
            requestBuilder.AppendLine($"Content-Type: {contentType}");
        }
        
        // Content-Length (если есть тело)
        if (!string.IsNullOrEmpty(body))
        {
            Encoding utf8NoBom = new UTF8Encoding(false);
            var contentLength = utf8NoBom.GetByteCount(body);
            requestBuilder.AppendLine($"Content-Length: {contentLength}");
        }
        else
        {
            requestBuilder.AppendLine($"Content-Length: {0}");
        }
        
        // Пользовательские заголовки
        foreach (var header in request.Headers)
        {
            requestBuilder.AppendLine($"{header.Key}: {header.Value}");
        }
        
        // Пустая строка - конец заголовков
        requestBuilder.AppendLine();
        
        // Тело запроса
        if (!string.IsNullOrEmpty(body))
        {
            requestBuilder.Append(body);
        }
        
        return requestBuilder.ToString();
    }
}