// (c) Copyright Ascensio System SIA 2010-2022
//
// This program is a free software product.
// You can redistribute it and/or modify it under the terms
// of the GNU Affero General Public License (AGPL) version 3 as published by the Free Software
// Foundation. In accordance with Section 7(a) of the GNU AGPL its Section 15 shall be amended
// to the effect that Ascensio System SIA expressly excludes the warranty of non-infringement of
// any third-party rights.
//
// This program is distributed WITHOUT ANY WARRANTY, without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For details, see
// the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
//
// You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia, EU, LV-1021.
//
// The  interactive user interfaces in modified source and object code versions of the Program must
// display Appropriate Legal Notices, as required under Section 5 of the GNU AGPL version 3.
//
// Pursuant to Section 7(b) of the License you must retain the original Product logo when
// distributing the program. Pursuant to Section 7(e) we decline to grant you any rights under
// trademark law for use of our trademarks.
//
// All the Product's GUI elements, including illustrations and icon sets, as well as technical writing
// content are licensed under the terms of the Creative Commons Attribution-ShareAlike 4.0
// International. See the License terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode

using UnknownImageFormatException = SixLabors.ImageSharp.UnknownImageFormatException;

namespace ASC.Web.Core.WhiteLabel;

[Serializable]
public class TenantWhiteLabelSettings : ISettings<TenantWhiteLabelSettings>
{
    public const string DefaultLogoText = BaseWhiteLabelSettings.DefaultLogoText;

    #region Logos information: extension, isDefault, text for img auto generating

    public string LogoLightSmallExt { get; set; }

    [JsonPropertyName("DefaultLogoLightSmall")]
    public bool IsDefaultLogoLightSmall { get; set; }

    public string LogoDarkExt { get; set; }

    [JsonPropertyName("DefaultLogoDark")]
    public bool IsDefaultLogoDark { get; set; }

    public string LogoFaviconExt { get; set; }

    [JsonPropertyName("DefaultLogoFavicon")]
    public bool IsDefaultLogoFavicon { get; set; }

    public string LogoDocsEditorExt { get; set; }

    [JsonPropertyName("DefaultLogoDocsEditor")]
    public bool IsDefaultLogoDocsEditor { get; set; }

    public string LogoDocsEditorEmbedExt { get; set; }

    [JsonPropertyName("DefaultLogoDocsEditorEmbed")]
    public bool IsDefaultLogoDocsEditorEmbed { get; set; }

    public string LogoLeftMenuExt { get; set; }

    [JsonPropertyName("DefaultLogoLeftMenu")]
    public bool IsDefaultLogoLeftMenu { get; set; }

    public string LogoAboutPageExt { get; set; }

    [JsonPropertyName("DefaultLogoAboutPage")]
    public bool IsDefaultLogoAboutPage { get; set; }

    public string LogoText { get; set; }

    public string GetLogoText(SettingsManager settingsManager)
    {
        if (!string.IsNullOrEmpty(LogoText) && LogoText != DefaultLogoText)
        {
            return LogoText;
        }

        var partnerSettings = settingsManager.LoadForDefaultTenant<TenantWhiteLabelSettings>();
        return string.IsNullOrEmpty(partnerSettings.LogoText) ? DefaultLogoText : partnerSettings.LogoText;
    }

    public void SetLogoText(string val)
    {
        LogoText = val;
    }

    #endregion

    #region Logo available sizes

    public static readonly Size LogoLightSmallSize = new Size(422, 48);
    public static readonly Size LogoLoginPageSize = new Size(810, 92);
    public static readonly Size LogoFaviconSize = new Size(32, 32);
    public static readonly Size LogoDocsEditorSize = new Size(172, 40);
    public static readonly Size LogoDocsEditorEmbedSize = new Size(172, 40);
    public static readonly Size LogoLeftMenuSize = new Size(56, 56);
    public static readonly Size LogoAboutPageSize = new Size(810, 92);

    public static Size GetSize(WhiteLabelLogoTypeEnum type)
    {
        return type switch
        {
            WhiteLabelLogoTypeEnum.LightSmall => LogoLightSmallSize,
            WhiteLabelLogoTypeEnum.LoginPage => LogoLoginPageSize,
            WhiteLabelLogoTypeEnum.Favicon => LogoFaviconSize,
            WhiteLabelLogoTypeEnum.DocsEditor => LogoDocsEditorSize,
            WhiteLabelLogoTypeEnum.DocsEditorEmbed => LogoDocsEditorEmbedSize,
            WhiteLabelLogoTypeEnum.LeftMenu => LogoLeftMenuSize,
            WhiteLabelLogoTypeEnum.AboutPage => LogoAboutPageSize,
            _ => new Size(),
        };
    }

    #endregion

    #region ISettings Members

    public TenantWhiteLabelSettings GetDefault()
    {
        return new TenantWhiteLabelSettings
        {
            LogoLightSmallExt = null,
            LogoDarkExt = null,
            LogoFaviconExt = null,
            LogoDocsEditorExt = null,
            LogoDocsEditorEmbedExt = null,
            LogoLeftMenuExt = null,
            LogoAboutPageExt = null,

            IsDefaultLogoLightSmall = true,
            IsDefaultLogoDark = true,
            IsDefaultLogoFavicon = true,
            IsDefaultLogoDocsEditor = true,
            IsDefaultLogoDocsEditorEmbed = true,
            IsDefaultLogoLeftMenu = true,
            IsDefaultLogoAboutPage = true,

            LogoText = null
        };
    }
    #endregion

    [JsonIgnore]
    public Guid ID
    {
        get { return new Guid("{05d35540-c80b-4b17-9277-abd9e543bf93}"); }
    }

    #region Get/Set IsDefault and Extension

    internal bool GetIsDefault(WhiteLabelLogoTypeEnum type)
    {
        return type switch
        {
            WhiteLabelLogoTypeEnum.LightSmall => IsDefaultLogoLightSmall,
            WhiteLabelLogoTypeEnum.LoginPage => IsDefaultLogoDark,
            WhiteLabelLogoTypeEnum.Favicon => IsDefaultLogoFavicon,
            WhiteLabelLogoTypeEnum.DocsEditor => IsDefaultLogoDocsEditor,
            WhiteLabelLogoTypeEnum.DocsEditorEmbed => IsDefaultLogoDocsEditorEmbed,
            WhiteLabelLogoTypeEnum.LeftMenu => IsDefaultLogoLeftMenu,
            WhiteLabelLogoTypeEnum.AboutPage => IsDefaultLogoAboutPage,
            _ => true,
        };
    }

    internal void SetIsDefault(WhiteLabelLogoTypeEnum type, bool value)
    {
        switch (type)
        {
            case WhiteLabelLogoTypeEnum.LightSmall:
                IsDefaultLogoLightSmall = value;
                break;
            case WhiteLabelLogoTypeEnum.LoginPage:
                IsDefaultLogoDark = value;
                break;
            case WhiteLabelLogoTypeEnum.Favicon:
                IsDefaultLogoFavicon = value;
                break;
            case WhiteLabelLogoTypeEnum.DocsEditor:
                IsDefaultLogoDocsEditor = value;
                break;
            case WhiteLabelLogoTypeEnum.DocsEditorEmbed:
                IsDefaultLogoDocsEditorEmbed = value;
                break;
            case WhiteLabelLogoTypeEnum.LeftMenu:
                IsDefaultLogoLeftMenu = value;
                break;
            case WhiteLabelLogoTypeEnum.AboutPage:
                IsDefaultLogoAboutPage = value;
                break;
        }
    }

    internal string GetExt(WhiteLabelLogoTypeEnum type)
    {
        return type switch
        {
            WhiteLabelLogoTypeEnum.LightSmall => LogoLightSmallExt,
            WhiteLabelLogoTypeEnum.LoginPage => LogoDarkExt,
            WhiteLabelLogoTypeEnum.Favicon => LogoFaviconExt,
            WhiteLabelLogoTypeEnum.DocsEditor => LogoDocsEditorExt,
            WhiteLabelLogoTypeEnum.DocsEditorEmbed => LogoDocsEditorEmbedExt,
            WhiteLabelLogoTypeEnum.LeftMenu => LogoLeftMenuExt,
            WhiteLabelLogoTypeEnum.AboutPage => LogoAboutPageExt,
            _ => "",
        };
    }

    internal void SetExt(WhiteLabelLogoTypeEnum type, string fileExt)
    {
        switch (type)
        {
            case WhiteLabelLogoTypeEnum.LightSmall:
                LogoLightSmallExt = fileExt;
                break;
            case WhiteLabelLogoTypeEnum.LoginPage:
                LogoDarkExt = fileExt;
                break;
            case WhiteLabelLogoTypeEnum.Favicon:
                LogoFaviconExt = fileExt;
                break;
            case WhiteLabelLogoTypeEnum.DocsEditor:
                LogoDocsEditorExt = fileExt;
                break;
            case WhiteLabelLogoTypeEnum.DocsEditorEmbed:
                LogoDocsEditorEmbedExt = fileExt;
                break;
            case WhiteLabelLogoTypeEnum.LeftMenu:
                LogoLeftMenuExt = fileExt;
                break;
            case WhiteLabelLogoTypeEnum.AboutPage:
                LogoAboutPageExt = fileExt;
                break;
        }
    }

    #endregion
}

[Scope]
public class TenantWhiteLabelSettingsHelper
{
    private const string ModuleName = "whitelabel";

    private readonly WebImageSupplier _webImageSupplier;
    private readonly UserPhotoManager _userPhotoManager;
    private readonly StorageFactory _storageFactory;
    private readonly WhiteLabelHelper _whiteLabelHelper;
    private readonly TenantManager _tenantManager;
    private readonly SettingsManager _settingsManager;
    private readonly ILogger<TenantWhiteLabelSettingsHelper> _log;

    public TenantWhiteLabelSettingsHelper(
        WebImageSupplier webImageSupplier,
        UserPhotoManager userPhotoManager,
        StorageFactory storageFactory,
        WhiteLabelHelper whiteLabelHelper,
        TenantManager tenantManager,
        SettingsManager settingsManager,
        ILogger<TenantWhiteLabelSettingsHelper> logger)
    {
        _webImageSupplier = webImageSupplier;
        _userPhotoManager = userPhotoManager;
        _storageFactory = storageFactory;
        _whiteLabelHelper = whiteLabelHelper;
        _tenantManager = tenantManager;
        _settingsManager = settingsManager;
        _log = logger;
    }

    #region Restore default

    public bool IsDefault(TenantWhiteLabelSettings tenantWhiteLabelSettings)
    {
        var defaultSettings = _settingsManager.GetDefault<TenantWhiteLabelSettings>();

        return tenantWhiteLabelSettings.LogoLightSmallExt == defaultSettings.LogoLightSmallExt &&
                tenantWhiteLabelSettings.LogoDarkExt == defaultSettings.LogoDarkExt &&
                tenantWhiteLabelSettings.LogoFaviconExt == defaultSettings.LogoFaviconExt &&
                tenantWhiteLabelSettings.LogoDocsEditorExt == defaultSettings.LogoDocsEditorExt &&
                tenantWhiteLabelSettings.LogoDocsEditorEmbedExt == defaultSettings.LogoDocsEditorEmbedExt &&
                tenantWhiteLabelSettings.LogoLeftMenuExt == defaultSettings.LogoLeftMenuExt &&
                tenantWhiteLabelSettings.LogoAboutPageExt == defaultSettings.LogoAboutPageExt &&

                tenantWhiteLabelSettings.IsDefaultLogoLightSmall == defaultSettings.IsDefaultLogoLightSmall &&
                tenantWhiteLabelSettings.IsDefaultLogoDark == defaultSettings.IsDefaultLogoDark &&
                tenantWhiteLabelSettings.IsDefaultLogoFavicon == defaultSettings.IsDefaultLogoFavicon &&
                tenantWhiteLabelSettings.IsDefaultLogoDocsEditor == defaultSettings.IsDefaultLogoDocsEditor &&
                tenantWhiteLabelSettings.IsDefaultLogoDocsEditorEmbed == defaultSettings.IsDefaultLogoDocsEditorEmbed &&
                tenantWhiteLabelSettings.IsDefaultLogoLeftMenu == defaultSettings.IsDefaultLogoLeftMenu &&
                tenantWhiteLabelSettings.IsDefaultLogoAboutPage == defaultSettings.IsDefaultLogoAboutPage &&

                tenantWhiteLabelSettings.LogoText == defaultSettings.LogoText;
    }

    public async Task RestoreDefault(TenantWhiteLabelSettings tenantWhiteLabelSettings, TenantLogoManager tenantLogoManager, int tenantId, IDataStore storage = null)
    {
        tenantWhiteLabelSettings.LogoLightSmallExt = null;
        tenantWhiteLabelSettings.LogoDarkExt = null;
        tenantWhiteLabelSettings.LogoFaviconExt = null;
        tenantWhiteLabelSettings.LogoDocsEditorExt = null;
        tenantWhiteLabelSettings.LogoDocsEditorEmbedExt = null;
        tenantWhiteLabelSettings.LogoLeftMenuExt = null;
        tenantWhiteLabelSettings.LogoAboutPageExt = null;

        tenantWhiteLabelSettings.IsDefaultLogoLightSmall = true;
        tenantWhiteLabelSettings.IsDefaultLogoDark = true;
        tenantWhiteLabelSettings.IsDefaultLogoFavicon = true;
        tenantWhiteLabelSettings.IsDefaultLogoDocsEditor = true;
        tenantWhiteLabelSettings.IsDefaultLogoDocsEditorEmbed = true;
        tenantWhiteLabelSettings.IsDefaultLogoLeftMenu = true;
        tenantWhiteLabelSettings.IsDefaultLogoAboutPage = true;

        tenantWhiteLabelSettings.SetLogoText(null);

        var store = storage ?? _storageFactory.GetStorage(tenantId, ModuleName);

        try
        {
            await store.DeleteFilesAsync("", "*", false);
        }
        catch (Exception e)
        {
            _log.ErrorRestoreDefault(e);
        }

        Save(tenantWhiteLabelSettings, tenantId, tenantLogoManager, true);
    }

    public async Task RestoreDefault(TenantWhiteLabelSettings tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum type)
    {
        if (!tenantWhiteLabelSettings.GetIsDefault(type))
        {
            try
            {
                tenantWhiteLabelSettings.SetIsDefault(type, true);
                var store = _storageFactory.GetStorage(_tenantManager.GetCurrentTenant().Id, ModuleName);
                await DeleteLogoFromStore(tenantWhiteLabelSettings, store, type, false);
                await DeleteLogoFromStore(tenantWhiteLabelSettings, store, type, true);
            }
            catch (Exception e)
            {
                _log.ErrorRestoreDefault(e);
            }
        }
    }

    #endregion

    #region Set logo

    public async Task SetLogo(TenantWhiteLabelSettings tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum type, string logoFileExt, byte[] data, bool dark, IDataStore storage = null)
    {
        var store = storage ?? _storageFactory.GetStorage(_tenantManager.GetCurrentTenant().Id, ModuleName);

        #region delete from storage if already exists

        var isAlreadyHaveBeenChanged = !tenantWhiteLabelSettings.GetIsDefault(type);

        if (isAlreadyHaveBeenChanged)
        {
            try
            {
                await DeleteLogoFromStore(tenantWhiteLabelSettings, store, type, dark);
            }
            catch (Exception e)
            {
                _log.ErrorSetLogo(e);
            }
        }
        #endregion

        using (var memory = new MemoryStream(data))
        {
            var logoFileName = BuildLogoFileName(type, logoFileExt, dark);

            memory.Seek(0, SeekOrigin.Begin);
            await store.SaveAsync(logoFileName, memory);
        }
    }

    public async Task SetLogo(TenantWhiteLabelSettings tenantWhiteLabelSettings, Dictionary<int, KeyValuePair<string, string>> logo, IDataStore storage = null)
    {
        foreach (var currentLogo in logo)
        {
            var currentLogoType = (WhiteLabelLogoTypeEnum)currentLogo.Key;

            byte[] darkData;
            string extDark;

            var (lightData, extLight) = await GetLogoData(currentLogo.Value.Key);

            if (currentLogo.Value.Key == currentLogo.Value.Value)
            {
                darkData = lightData;
                extDark = extLight;
            }
            else
            {
                (darkData, extDark) = await GetLogoData(currentLogo.Value.Value);
            }

            if (lightData == null && darkData == null)
            {
                return;
            }

            if (lightData != null)
            {
                await SetLogo(tenantWhiteLabelSettings, currentLogoType, extLight, lightData, false, storage);
            }

            if (darkData != null && CanBeDark(currentLogoType))
            {
                await SetLogo(tenantWhiteLabelSettings, currentLogoType, extDark, darkData, true, storage);
            }

            tenantWhiteLabelSettings.SetExt(currentLogoType, extLight);
            tenantWhiteLabelSettings.SetIsDefault(currentLogoType, false);
        }
    }

    private async Task<(byte[], string)> GetLogoData(string logo)
    {
        var supportedFormats = new[]
        {
            new {
                    mime = "image/jpeg",
                    ext = "jpg"
                },
            new {
                    mime = "image/png",
                    ext = "png"
                },
            new {
                    mime = "image/svg+xml",
                    ext = "svg"
                }
        };

        string ext = null;

        if (!string.IsNullOrEmpty(logo))
        {
            byte[] data;
            var format = supportedFormats.FirstOrDefault(r => logo.StartsWith($"data:{r.mime};base64,"));
            if (format == null)
            {
                var fileName = Path.GetFileName(logo);
                ext = fileName.Split('.').Last();
                data = await _userPhotoManager.GetTempPhotoData(fileName);
                try
                {
                    await _userPhotoManager.RemoveTempPhoto(fileName);
                }
                catch (Exception ex)
                {
                    _log.ErrorSetLogo(ex);
                }
            }
            else
            {
                ext = format.ext;
                var xB64 = logo.Substring($"data:{format.mime};base64,".Length); // Get the Base64 string
                data = Convert.FromBase64String(xB64); // Convert the Base64 string to binary data
            }

            return (data, ext);
        }
        else
        {
            return (null, ext);
        }
    }

    public async Task SetLogoFromStream(TenantWhiteLabelSettings tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum type, string fileExt, Stream fileStream, Stream fileDarkStream, IDataStore storage = null)
    {
        var lightData = GetData(fileStream);
        var darkData = GetData(fileDarkStream);

        if (tenantWhiteLabelSettings.GetIsDefault(type))
        {
            if (lightData == null)
            {
                lightData = darkData;
            }
            if (darkData == null)
            {
                darkData = lightData;
            }

        }

        if ((lightData == null || darkData == null)
            && tenantWhiteLabelSettings.GetExt(type) != fileExt
            && CanBeDark(type))
        {
            throw new InvalidOperationException("current logos and downloaded logo have different extention");
        }

        if (lightData != null)
        {
            await SetLogo(tenantWhiteLabelSettings, type, fileExt, lightData, false, storage);
        }
        if (darkData != null && CanBeDark(type))
        {
            await SetLogo(tenantWhiteLabelSettings, type, fileExt, darkData, true, storage);
        }

        tenantWhiteLabelSettings.SetExt(type, fileExt);
        tenantWhiteLabelSettings.SetIsDefault(type, false);
    }

    private byte[] GetData(Stream stream)
    {
        if (stream != null)
        {
            using (var memoryStream = new MemoryStream())
            {
                stream.CopyTo(memoryStream);
                return memoryStream.ToArray();
            }
        }
        return null;
    }

    #endregion

    #region Get logo path

    public async Task<string> GetAbsoluteLogoPath(TenantWhiteLabelSettings tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum type, bool dark = false)
    {
        if (tenantWhiteLabelSettings.GetIsDefault(type))
        {
            return await GetAbsoluteDefaultLogoPath(type, dark);
        }

        return await GetAbsoluteStorageLogoPath(tenantWhiteLabelSettings, type, dark);
    }

    private async Task<string> GetAbsoluteStorageLogoPath(TenantWhiteLabelSettings tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum type, bool dark)
    {
        var store = _storageFactory.GetStorage(_tenantManager.GetCurrentTenant().Id, ModuleName);
        var fileName = BuildLogoFileName(type, tenantWhiteLabelSettings.GetExt(type), dark);

        if (await store.IsFileAsync(fileName))
        {
            return (await store.GetUriAsync(fileName)).ToString();
        }
        return await GetAbsoluteDefaultLogoPath(type, dark);
    }

    public async Task<string> GetAbsoluteDefaultLogoPath(WhiteLabelLogoTypeEnum type, bool dark)
    {
        var partnerLogoPath = await GetPartnerStorageLogoPath(type, dark);
        if (!string.IsNullOrEmpty(partnerLogoPath))
        {
            return partnerLogoPath;
        }

        var ext = type switch
        {
            WhiteLabelLogoTypeEnum.Favicon => "ico",
            _ => "svg"
        };

        return _webImageSupplier.GetAbsoluteWebPath($"logo/" + BuildLogoFileName(type, ext, dark));
    }

    private async Task<string> GetPartnerStorageLogoPath(WhiteLabelLogoTypeEnum type, bool dark)
    {
        var partnerSettings = _settingsManager.LoadForDefaultTenant<TenantWhiteLabelSettings>();

        if (partnerSettings.GetIsDefault(type))
        {
            return null;
        }

        var partnerStorage = _storageFactory.GetStorage(null, "static_partnerdata");

        if (partnerStorage == null)
        {
            return null;
        }

        var logoPath = BuildLogoFileName(type, partnerSettings.GetExt(type), dark);

        return (await partnerStorage.IsFileAsync(logoPath)) ? (await partnerStorage.GetUriAsync(logoPath)).ToString() : null;
    }

    #endregion

    #region Get Whitelabel Logo Stream

    /// <summary>
    /// Get logo stream or null in case of default whitelabel
    /// </summary>
    public async Task<Stream> GetWhitelabelLogoData(TenantWhiteLabelSettings tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum type, bool dark = false)
    {
        if (tenantWhiteLabelSettings.GetIsDefault(type))
        {
            return await GetPartnerStorageLogoData(type, dark);
        }

        return await GetStorageLogoData(tenantWhiteLabelSettings, type, dark);
    }

    private async Task<Stream> GetStorageLogoData(TenantWhiteLabelSettings tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum type, bool dark)
    {
        var storage = _storageFactory.GetStorage(_tenantManager.GetCurrentTenant().Id, ModuleName);

        if (storage == null)
        {
            return null;
        }

        var fileName = BuildLogoFileName(type, tenantWhiteLabelSettings.GetExt(type), dark);

        return await storage.IsFileAsync(fileName) ? await storage.GetReadStreamAsync(fileName) : null;
    }

    private async Task<Stream> GetPartnerStorageLogoData(WhiteLabelLogoTypeEnum type, bool dark)
    {
        var partnerSettings = _settingsManager.LoadForDefaultTenant<TenantWhiteLabelSettings>();

        if (partnerSettings.GetIsDefault(type))
        {
            return null;
        }

        var partnerStorage = _storageFactory.GetStorage(null, "static_partnerdata");

        if (partnerStorage == null)
        {
            return null;
        }

        var fileName = BuildLogoFileName(type, partnerSettings.GetExt(type), dark);

        return await partnerStorage.IsFileAsync(fileName) ? await partnerStorage.GetReadStreamAsync(fileName) : null;
    }

    #endregion

    public static string BuildLogoFileName(WhiteLabelLogoTypeEnum type, string fileExt, bool dark)
    {
        if (CanBeDark(type))
        {
            return $"{(dark ? "dark_" : "")}{type.ToString().ToLowerInvariant()}.{fileExt}";
        }

        return $"{type.ToString().ToLowerInvariant()}.{fileExt}";
    }

    public static Size GetSize(WhiteLabelLogoTypeEnum type)
    {
        return type switch
        {
            WhiteLabelLogoTypeEnum.LightSmall => TenantWhiteLabelSettings.LogoLightSmallSize,
            WhiteLabelLogoTypeEnum.LoginPage => TenantWhiteLabelSettings.LogoLoginPageSize,
            WhiteLabelLogoTypeEnum.Favicon => TenantWhiteLabelSettings.LogoFaviconSize,
            WhiteLabelLogoTypeEnum.DocsEditor => TenantWhiteLabelSettings.LogoDocsEditorSize,
            WhiteLabelLogoTypeEnum.DocsEditorEmbed => TenantWhiteLabelSettings.LogoDocsEditorEmbedSize,
            WhiteLabelLogoTypeEnum.LeftMenu => TenantWhiteLabelSettings.LogoLeftMenuSize,
            WhiteLabelLogoTypeEnum.AboutPage => TenantWhiteLabelSettings.LogoAboutPageSize,
            _ => new Size(0, 0),
        };
    }

    private static async Task ResizeLogo(string fileName, byte[] data, long maxFileSize, Size size, IDataStore store)
    {
        //Resize synchronously
        if (data == null || data.Length <= 0)
        {
            throw new UnknownImageFormatException("data null");
        }

        if (maxFileSize != -1 && data.Length > maxFileSize)
        {
            throw new ImageWeightLimitException();
        }

        try
        {
            using var stream = new MemoryStream(data);
            using var img = Image.Load(stream);

            if (size != img.Size)
            {
                using var img2 = CommonPhotoManager.DoThumbnail(img, size, false, true, false);
                data = CommonPhotoManager.SaveToBytes(img2);
            }
            else
            {
                data = CommonPhotoManager.SaveToBytes(img);
            }

            //fileExt = CommonPhotoManager.GetImgFormatName(imgFormat);

            using var stream2 = new MemoryStream(data);
            await store.SaveAsync(fileName, stream2);
        }
        catch (ArgumentException error)
        {
            throw new UnknownImageFormatException(error.Message);
        }
    }

    #region Save for Resource replacement

    private static readonly List<int> _appliedTenants = new List<int>();

    public void Apply(TenantWhiteLabelSettings tenantWhiteLabelSettings, int tenantId)
    {
        if (_appliedTenants.Contains(tenantId))
        {
            return;
        }

        SetNewLogoText(tenantWhiteLabelSettings, tenantId);

        if (!_appliedTenants.Contains(tenantId))
        {
            _appliedTenants.Add(tenantId);
        }
    }

    public void Save(TenantWhiteLabelSettings tenantWhiteLabelSettings, int tenantId, TenantLogoManager tenantLogoManager, bool restore = false)
    {
        _settingsManager.Save(tenantWhiteLabelSettings, tenantId);

        if (tenantId == Tenant.DefaultTenant)
        {
            _appliedTenants.Clear();
        }
        else
        {
            SetNewLogoText(tenantWhiteLabelSettings, tenantId, restore);
            tenantLogoManager.RemoveMailLogoDataFromCache();
        }
    }

    private void SetNewLogoText(TenantWhiteLabelSettings tenantWhiteLabelSettings, int tenantId, bool restore = false)
    {
        _whiteLabelHelper.DefaultLogoText = TenantWhiteLabelSettings.DefaultLogoText;
        var partnerSettings = _settingsManager.LoadForDefaultTenant<TenantWhiteLabelSettings>();

        if (restore && string.IsNullOrEmpty(partnerSettings.GetLogoText(_settingsManager)))
        {
            _whiteLabelHelper.RestoreOldText(tenantId);
        }
        else
        {
            _whiteLabelHelper.SetNewText(tenantId, tenantWhiteLabelSettings.GetLogoText(_settingsManager));
        }
    }

    #endregion

    #region Delete from Store

    private async Task DeleteLogoFromStore(TenantWhiteLabelSettings tenantWhiteLabelSettings, IDataStore store, WhiteLabelLogoTypeEnum type, bool dark)
    {
        await DeleteLogoFromStoreByGeneral(tenantWhiteLabelSettings, store, type, dark);
    }

    private async Task DeleteLogoFromStoreByGeneral(TenantWhiteLabelSettings tenantWhiteLabelSettings, IDataStore store, WhiteLabelLogoTypeEnum type, bool dark)
    {
        var fileExt = tenantWhiteLabelSettings.GetExt(type);
        var logo = BuildLogoFileName(type, fileExt, dark);
        if (await store.IsFileAsync(logo))
        {
            await store.DeleteAsync(logo);
        }
    }

    #endregion

    private static bool CanBeDark(WhiteLabelLogoTypeEnum type)
    {
        return type switch
        {
            WhiteLabelLogoTypeEnum.Favicon => false,
            WhiteLabelLogoTypeEnum.DocsEditor => false,
            WhiteLabelLogoTypeEnum.DocsEditorEmbed => false,
            _ => true,
        };
    }
}