using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Jellyfin.Data;
using Jellyfin.Data.Enums;
using Jellyfin.Database.Implementations.Entities;
using Jellyfin.Database.Implementations.Enums;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Dto;
using MediaBrowser.Model.Users;
using Moq;

namespace Jellyfin.Plugin.WatchedTogether.Tests;

/// <summary>
/// Sets up the <see cref="IUserManager"/> members whose signatures differ between Jellyfin 10.11
/// and 12, so the suites read the same whichever generation they are compiled against.
/// </summary>
internal static class UserManagerMockExtensions
{
    /// <summary>
    /// Routes <c>ChangePassword</c> to <paramref name="onChange"/> with the user the real server
    /// would act on: the instance handed in on 10.11, the stored row looked up by id on 12.
    /// </summary>
    /// <param name="mock">The user manager mock.</param>
    /// <param name="users">The users the mock knows about, used to resolve ids on 12.</param>
    /// <param name="onChange">The behaviour to run for the change.</param>
    public static void SetupChangePassword(
        this Mock<IUserManager> mock,
        List<User> users,
        Func<User, string, Task> onChange)
    {
#if JELLYFIN_12
        mock.Setup(m => m.ChangePassword(It.IsAny<Guid>(), It.IsAny<string>()))
            .Returns((Guid id, string password) =>
            {
                var user = users.Find(u => u.Id == id)
                    ?? throw new KeyNotFoundException($"No user with id {id}");
                return onChange(user, password);
            });
#else
        mock.Setup(m => m.ChangePassword(It.IsAny<User>(), It.IsAny<string>()))
            .Returns((User user, string password) => onChange(user, password));
#endif
    }

    /// <summary>
    /// Models the policy round trip the way Jellyfin's UserManager does it: <c>GetUserDto</c>
    /// projects the user's live fields into a <see cref="UserPolicy"/>, and
    /// <c>UpdatePolicyAsync</c> writes a policy back onto the user entity, so code that reads the
    /// user afterwards sees what was written.
    /// </summary>
    /// <param name="mock">The user manager mock.</param>
    /// <param name="users">The users the mock knows about.</param>
    public static void SetupPolicyRoundTrip(this Mock<IUserManager> mock, List<User> users)
    {
        mock.Setup(m => m.GetUserDto(It.IsAny<User>(), It.IsAny<string?>()))
            .Returns((User user, string? _) => new UserDto
            {
                Id = user.Id,
                Name = user.Username,
                Policy = new UserPolicy
                {
                    IsAdministrator = user.HasPermission(PermissionKind.IsAdministrator),
                    EnableAllFolders = user.HasPermission(PermissionKind.EnableAllFolders),
                    EnabledFolders = user.GetPreferenceValues<Guid>(PreferenceKind.EnabledFolders),
                    MaxParentalRating = user.MaxParentalRatingScore,
                    MaxParentalSubRating = user.MaxParentalRatingSubScore,
                    BlockUnratedItems = user.GetPreferenceValues<UnratedItem>(PreferenceKind.BlockUnratedItems),
                    BlockedTags = user.GetPreference(PreferenceKind.BlockedTags),
                    AllowedTags = user.GetPreference(PreferenceKind.AllowedTags),
                }
            });

        mock.Setup(m => m.UpdatePolicyAsync(It.IsAny<Guid>(), It.IsAny<UserPolicy>()))
            .Returns((Guid id, UserPolicy policy) =>
            {
                var user = users.Find(u => u.Id == id)
                    ?? throw new KeyNotFoundException($"No user with id {id}");

                user.SetPermission(PermissionKind.IsAdministrator, policy.IsAdministrator);
                user.SetPermission(PermissionKind.EnableAllFolders, policy.EnableAllFolders);
                user.SetPreference(PreferenceKind.EnabledFolders, policy.EnabledFolders ?? []);
                user.MaxParentalRatingScore = policy.MaxParentalRating;
                user.MaxParentalRatingSubScore = policy.MaxParentalSubRating;
                user.SetPreference(PreferenceKind.BlockUnratedItems, policy.BlockUnratedItems ?? []);
                user.SetPreference(PreferenceKind.BlockedTags, policy.BlockedTags ?? []);
                user.SetPreference(PreferenceKind.AllowedTags, policy.AllowedTags ?? []);
                return Task.CompletedTask;
            });
    }

    /// <summary>
    /// Sets a user's content restrictions directly, the way the user editor would.
    /// </summary>
    /// <param name="user">The user to restrict.</param>
    /// <param name="maxRating">The rating cap, or <c>null</c> for none.</param>
    /// <param name="maxSubRating">The sub-score cap at the rating cap.</param>
    /// <param name="blockUnrated">The unrated kinds to block.</param>
    /// <param name="blockedTags">The tags that hide an item.</param>
    /// <param name="allowedTags">The whitelist, or none for no whitelist.</param>
    /// <returns>The same user, for chaining.</returns>
    public static User Restrict(
        this User user,
        int? maxRating = null,
        int? maxSubRating = null,
        IEnumerable<UnratedItem>? blockUnrated = null,
        IEnumerable<string>? blockedTags = null,
        IEnumerable<string>? allowedTags = null)
    {
        user.MaxParentalRatingScore = maxRating;
        user.MaxParentalRatingSubScore = maxSubRating;
        user.SetPreference(PreferenceKind.BlockUnratedItems, (blockUnrated ?? []).ToArray());
        user.SetPreference(PreferenceKind.BlockedTags, (blockedTags ?? []).ToArray());
        user.SetPreference(PreferenceKind.AllowedTags, (allowedTags ?? []).ToArray());
        return user;
    }
}