using System.Collections.Generic;
using Omika.App.Services;
using Omika.Core.Constants;
using Xunit;

namespace Omika.Tests.Mobile;

/// <summary>
/// Accès à l'envoi d'email INTERNE selon la préférence de messagerie.
///
/// <para>
/// Un collaborateur dont la messagerie par défaut est EXTERNE envoie ses courriels
/// depuis sa propre application : le droit <c>A.EMAIL.*</c> ne suffit donc pas, le
/// composeur interne de l'application ne doit pas lui être proposé (ni à l'entrée
/// de la page, ni sur les boutons d'email). La règle est portée par le service de
/// droits, seul point consulté par les vues et le garde de navigation.
/// </para>
/// </summary>
public class PermissionServiceMessagerieTests
{
    private static PermissionService Service(bool droitEnvoiEmail, bool messagerieExterne)
    {
        var service = new PermissionService();
        service.SetRights(new Dictionary<string, bool>
        {
            [MobilePermissionKeys.EnvoiEmail] = droitEnvoiEmail
        });
        service.SetMessagerieExterne(messagerieExterne);
        return service;
    }

    /// <summary>Messagerie interne + droit : l'envoi depuis l'application est possible.</summary>
    [Fact]
    public void MessagerieInterne_AvecDroit_PeutEnvoyerEmail()
    {
        PermissionService service = Service(droitEnvoiEmail: true, messagerieExterne: false);

        Assert.True(service.PeutEnvoyerEmail);
        Assert.False(service.MessagerieExterne);
    }

    /// <summary>
    /// Messagerie externe : l'envoi interne est refusé même avec le droit — c'est
    /// la préférence du collaborateur qui prime (envoi depuis sa messagerie).
    /// </summary>
    [Fact]
    public void MessagerieExterne_MemeAvecDroit_RefuseLEnvoiInterne()
    {
        PermissionService service = Service(droitEnvoiEmail: true, messagerieExterne: true);

        Assert.True(service.MessagerieExterne);
        Assert.False(service.PeutEnvoyerEmail);
    }

    /// <summary>Messagerie interne sans le droit : refusé (règle inchangée).</summary>
    [Fact]
    public void MessagerieInterne_SansDroit_RefuseLEnvoiInterne()
    {
        PermissionService service = Service(droitEnvoiEmail: false, messagerieExterne: false);

        Assert.False(service.PeutEnvoyerEmail);
    }

    /// <summary>
    /// COMPOSER reste possible en messagerie externe : l'utilisateur rédige dans
    /// Omika (modèle, brouillon) puis envoie depuis sa propre messagerie. Le droit
    /// d'envoi suffit, la préférence de messagerie ne prive pas du composeur.
    /// </summary>
    [Fact]
    public void MessagerieExterne_AvecDroit_PeutComposerEmail()
    {
        PermissionService service = Service(droitEnvoiEmail: true, messagerieExterne: true);

        Assert.True(service.PeutComposerEmail);
    }

    /// <summary>Composer sans le droit d'envoi reste refusé, quel que soit le choix.</summary>
    [Theory]
    [InlineData(false)]
    [InlineData(true)]
    public void SansDroit_PeutComposerEmailRefuse(bool messagerieExterne)
    {
        PermissionService service = Service(droitEnvoiEmail: false, messagerieExterne);

        Assert.False(service.PeutComposerEmail);
    }
}