using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Jellyfin.Database.Implementations.Entities;
using MediaBrowser.Controller.Library;

namespace Jellyfin.Plugin.WatchedTogether.Compat;

/// <summary>
/// Papers over the <see cref="IUserManager"/> differences between Jellyfin 10.11 and 12.
/// </summary>
/// <remarks>
/// <para>
/// Jellyfin 12 turned the <c>Users</c> and <c>UsersIds</c> properties into methods and made
/// <c>ChangePassword</c> take a user id instead of a user. The plugin is compiled once per server
/// generation (see the project file), and this is the only place that needs to know which one it
/// is building for, so the rest of the code reads the same either way.
/// </para>
/// <para>
/// Jellyfin 12 also dropped the in-memory user cache: every lookup returns a detached copy, and
/// <see cref="IUserManager.UpdateUserAsync"/> copies every column from the instance it is given.
/// Callers that mutate a user and save it must therefore work with a fresh copy, which is why
/// <see cref="ChangePasswordAsync"/> carries the stored hash back onto the caller's instance.
/// </para>
/// </remarks>
internal static class UserManagerCompat
{
    /// <summary>
    /// Gets every user on the server.
    /// </summary>
    /// <param name="userManager">The user manager.</param>
    /// <returns>All users.</returns>
    public static IEnumerable<User> GetAllUsers(this IUserManager userManager)
    {
        ArgumentNullException.ThrowIfNull(userManager);
#if JELLYFIN_12
        return userManager.GetUsers();
#else
        return userManager.Users;
#endif
    }

    /// <summary>
    /// Gets the id of every user on the server.
    /// </summary>
    /// <param name="userManager">The user manager.</param>
    /// <returns>All user ids.</returns>
    public static IEnumerable<Guid> GetAllUserIds(this IUserManager userManager)
    {
        ArgumentNullException.ThrowIfNull(userManager);
#if JELLYFIN_12
        return userManager.GetUsersIds();
#else
        return userManager.UsersIds;
#endif
    }

    /// <summary>
    /// Changes a user's password through the provider the user is currently assigned to.
    /// </summary>
    /// <param name="userManager">The user manager.</param>
    /// <param name="user">The user whose password to change.</param>
    /// <param name="newPassword">The new password.</param>
    /// <returns>A task representing the change.</returns>
    /// <remarks>
    /// On return <paramref name="user"/> carries the newly stored hash on both server generations,
    /// so a subsequent <see cref="IUserManager.UpdateUserAsync"/> with the same instance keeps it.
    /// </remarks>
    public static async Task ChangePasswordAsync(this IUserManager userManager, User user, string newPassword)
    {
        ArgumentNullException.ThrowIfNull(userManager);
        ArgumentNullException.ThrowIfNull(user);
#if JELLYFIN_12
        await userManager.ChangePassword(user.Id, newPassword).ConfigureAwait(false);

        // 12 loaded and saved its own copy; without this the caller's instance still says "no
        // password" and the next UpdateUserAsync would write that back over the stored hash.
        var stored = userManager.GetUserById(user.Id);
        if (stored is not null)
        {
            user.Password = stored.Password;
        }
#else
        await userManager.ChangePassword(user, newPassword).ConfigureAwait(false);
#endif
    }
}