In case, someone want to use this approach the code is:

The middleware class:

public class SetUserLanguageOnStartupMiddleware {

private readonly IUmbracoContextFactory _umbracoContextFactory;
private readonly IVariationContextAccessor _variationContextAccessor;
private readonly IDomainService _domainService;
private readonly RequestDelegate _next;
private readonly ILocalizationService _localizationService;

public SetUserLanguageOnStartupMiddleware(IUmbracoContextFactory umbracoContextFactory, IVariationContextAccessor variationContextAccessor, IDomainService domainService, RequestDelegate next,
    ILocalizationService localizationService)
{
    _umbracoContextFactory = umbracoContextFactory;
    _variationContextAccessor = variationContextAccessor;
    _domainService = domainService;
    _next = next;
    _localizationService = localizationService;
}

public async Task InvokeAsync(HttpContext context)
{
    //Cookie wchich inform us if user's language has been checked
    string cookieValue = context.Request.Cookies[PublicConstants.CookieCultureExamined];

    if (string.IsNullOrWhiteSpace(cookieValue))
    {
        ArgumentNullException.ThrowIfNull(context);

        HttpRequest request = context.Request;
        string UrlAddress = request.Path.Value.ToLower();

        //Get the Current Culture. We are using Domains, because CultureInfo.CurrentCulture.Name is always the Default Language of RequestLocalizationOptions
        string CurrentCultureName = CultureInfo.CurrentCulture.Name;
        IEnumerable<IDomain> Domains = _domainService.GetAll(true);
        foreach (IDomain Domain in Domains)
        {
            if (UrlAddress.StartsWith(Domain.DomainName + "/") && Domain.DomainName != "/")
            {
                CurrentCultureName = Domain.LanguageIsoCode;
                //Domain Name (Language) must be removed from UrlAddress, otherwise GetByRoute is not working
                UrlAddress = UrlAddress.ReplaceFirst(Domain.DomainName + "/", "/");
                break;
            }
        }

        //Prefered language of user
        ILanguage UmbracoLanguageToUse = GetUmbracoLanguageToUse(request);

        //Inform cookie that user's language has been checked
        CookieOptions cookieOptions = new() { Expires = DateTime.Now.AddDays(1) };
        context.Response.Cookies.Append(PublicConstants.CookieCultureExamined, "yes", cookieOptions);

        //In case, where prefered culture of user is different than current culture
        if (UmbracoLanguageToUse.CultureInfo.Name != CurrentCultureName)
        {
             _variationContextAccessor.VariationContext ??= new VariationContext(CurrentCultureName);
            var umbracoContextReference = _umbracoContextFactory.EnsureUmbracoContext();
            IUmbracoContext umbracoContext = umbracoContextReference.UmbracoContext;
            IPublishedContent CurrentPage = umbracoContext?.Content.GetByRoute(UrlAddress);
            //IPublishedContent CurrentPageB = umbracoContext?.Content.GetByRoute(UrlAddress, culture: CurrentCultureName.ToLower());

            if(CurrentPage != null)
            {
                string UriByLanguage = GetUriOfPublishedContent(CurrentPage, UmbracoLanguageToUse);
                if (!string.IsNullOrEmpty(UriByLanguage))
                    context.Response.Redirect(UriByLanguage);
            }
        }
    }

    await _next(context);
}

/// <summary>
/// Get Language (UmbracoLanguages) that user prefers
/// </summary>
private ILanguage GetUmbracoLanguageToUse(HttpRequest request)
{
    //Get browser's cultures
    string[] browserLanguages = request.GetTypedHeaders()
                   .AcceptLanguage
                   ?.OrderByDescending(x => x.Quality ?? 1) // Quality defines priority from 0 to 1, where 1 is the highest.
                   .Select(x => x.Value.ToString())
                   .ToArray() ?? Array.Empty<string>();

    IEnumerable<ILanguage> UmbracoLanguages = _localizationService.GetAllLanguages();

    if (UmbracoLanguages != null && browserLanguages != null)
    {
        //Check if any culture that application uses exists in browser's cultures
        foreach (string browserLanguage in browserLanguages)
        {
            foreach (ILanguage UmbracoLanguage in UmbracoLanguages)
            {
                if (UmbracoLanguage.CultureInfo.Name.ToLower() == browserLanguage.ToLower())
                    return UmbracoLanguage;
                else if (!string.IsNullOrEmpty(UmbracoLanguage.CultureInfo.Parent.Name) && UmbracoLanguage.CultureInfo.Parent.Name.ToLower() == browserLanguage.ToLower())
                    return UmbracoLanguage;
            }
        }
    }

    return null;
}

/// <summary>
/// Get Uri of Page by Language
/// </summary>
/// <param name="publishedContent">PublishedContent of page</param>
/// <param name="UmbracoLanguage">Language to search</param>
private string GetUriOfPublishedContent(IPublishedContent publishedContent, ILanguage UmbracoLanguage)
{
    string res = string.Empty;

    string LanguageUri = publishedContent.Url(UmbracoLanguage.CultureInfo.Name, mode: UrlMode.Default);
    if (LanguageUri.StartsWith("/"))
        res = LanguageUri;
    else
    {
        string FallbackUri = string.Empty;
        if (UmbracoLanguage.FallbackLanguageId != null)
        {
            ILanguage FallbackLanguage = _localizationService.GetLanguageById(UmbracoLanguage.FallbackLanguageId.Value);
            FallbackUri = publishedContent.Url(FallbackLanguage.CultureInfo.Name, mode: UrlMode.Default);
        }
        if (FallbackUri.StartsWith("/"))
            res = FallbackUri;
        else
        {
            string DefaultUri = string.Empty;
            int? DefaultLanguageId = _localizationService.GetDefaultLanguageId();
            if (DefaultLanguageId != null)
            {
                ILanguage DefaulLanguage = _localizationService.GetLanguageById(DefaultLanguageId.Value);
                DefaultUri = publishedContent.Url(DefaulLanguage.CultureInfo.Name, mode: UrlMode.Default);
                if (DefaultUri.StartsWith("/"))
                    res = DefaultUri;
            }
        }
    }

    return res;
}

}

Extension for IApplication:

public static class IApplicationExtensions
{
    public static IApplicationBuilder SetUserLanguageOnStartup(this IApplicationBuilder app)
    {
        return app.UseMiddleware<SetUserLanguageOnStartupMiddleware>();
    }
}

and in Startup.cs

app.SetUserLanguageOnStartup();

before app.UseUmbraco()