using Omika.App.Local.Abstractions;
using Omika.App.Local.Models;
using Omika.App.Navigation;
using Omika.App.ViewModels;

namespace Omika.Tests.Mobile.Local;

/// <summary>
/// Tests du ViewModel Contacts d'une intervention : chargement local, états
/// liste / vide / erreur, ouverture du détail d'un contact et retour.
/// </summary>
public class InterventionContactsViewModelTests
{
    private sealed class FakeContactsService : IInterventionContactsService
    {
        public IReadOnlyList<InterventionContact> ItemsToReturn { get; set; } = [];
        public bool ThrowOnLoad { get; set; }

        public Task<IReadOnlyList<InterventionContact>> GetContactsForInterventionAsync(
            Guid interventionGuid, CancellationToken ct = default)
        {
            if (ThrowOnLoad)
            {
                throw new InvalidOperationException("Erreur de chargement");
            }
            return Task.FromResult(ItemsToReturn);
        }

        public Task<InterventionContact?> GetContactByIdAsync(Guid contactGuid, CancellationToken ct = default)
            => Task.FromResult<InterventionContact?>(null);

        public Task<IReadOnlyList<InterventionContact>> GetContactsDisponiblesAsync(Guid interventionGuid, CancellationToken ct = default)
            => Task.FromResult<IReadOnlyList<InterventionContact>>([]);
    }

    private static InterventionContact CreateContact(Guid id, string nom)
        => new()
        {
            ContactGuid = id,
            DisplayName = nom,
            LastName = nom,
            FirstName = nom
        };

    private readonly FakeContactsService _service = new();
    private readonly NavigationService _navigation = new();
    private readonly InterventionContactsViewModel _viewModel;

    public InterventionContactsViewModelTests()
    {
        _viewModel = new InterventionContactsViewModel(_service, _navigation);
    }

    [Fact]
    public async Task Load_ChargeLesContacts()
    {
        // Arrange
        Guid interventionId = Guid.NewGuid();
        Guid contactId = Guid.NewGuid();
        _service.ItemsToReturn = [CreateContact(contactId, "Alice Dupont")];

        // Act
        await _viewModel.LoadCommand.ExecuteAsync(interventionId);

        // Assert
        Assert.False(_viewModel.IsLoading);
        Assert.Null(_viewModel.ErrorMessage);
        Assert.Single(_viewModel.Contacts);
        Assert.Equal(contactId, _viewModel.Contacts[0].ContactGuid);
        Assert.True(_viewModel.HasContacts);
        Assert.False(_viewModel.IsEmpty);
        Assert.Equal(interventionId, _viewModel.InterventionGuid);
    }

    [Fact]
    public async Task Load_AucunContact_IsEmpty()
    {
        // Arrange
        _service.ItemsToReturn = [];

        // Act
        await _viewModel.LoadCommand.ExecuteAsync(Guid.NewGuid());

        // Assert
        Assert.Empty(_viewModel.Contacts);
        Assert.False(_viewModel.HasContacts);
        Assert.True(_viewModel.IsEmpty);
    }

    [Fact]
    public async Task Load_Erreur_MessageAffiché()
    {
        // Arrange
        _service.ThrowOnLoad = true;

        // Act
        await _viewModel.LoadCommand.ExecuteAsync(Guid.NewGuid());

        // Assert
        Assert.False(_viewModel.IsLoading);
        Assert.NotNull(_viewModel.ErrorMessage);
        Assert.Empty(_viewModel.Contacts);
        Assert.False(_viewModel.IsEmpty);
    }

    [Fact]
    public void OpenContact_NavigueVersLeDetail()
    {
        // Arrange
        Guid interventionId = Guid.NewGuid();
        Guid contactId = Guid.NewGuid();
        _viewModel.InterventionGuid = interventionId;
        var contact = CreateContact(contactId, "Alice Dupont");

        // Act
        _viewModel.OpenContactCommand.Execute(contact);

        // Assert : navigation vers le détail du contact avec le GUID public et le retour vers les contacts de l'intervention.
        Assert.Equal(AppPage.ContactDetail, _navigation.CurrentPage);
        var nav = Assert.IsType<DetailNavigation>(_navigation.CurrentParameter);
        Assert.Equal(contactId, nav.Id);
        Assert.Equal(AppPage.InterventionContacts, nav.ReturnContext.Page);
        Assert.Equal(interventionId, nav.ReturnContext.Parameter);

    }

    [Fact]
    public void OpenContact_Null_NeNaviguePas()
    {
        // Act
        _viewModel.OpenContactCommand.Execute(null);

        // Assert
        Assert.Equal(AppPage.Home, _navigation.CurrentPage);
    }

    [Fact]
    public void Back_RetourneALaFicheIntervention()
    {
        // Arrange
        Guid interventionId = Guid.NewGuid();
        _viewModel.InterventionGuid = interventionId;

        // Act
        _viewModel.BackCommand.Execute(null);

        // Assert
        Assert.Equal(AppPage.InterventionDetail, _navigation.CurrentPage);
        Assert.Equal(interventionId, _navigation.CurrentParameter);
    }
}