using Data.SeaHavenIndustries;
using Data.SeaHavenIndustries.Enums;
using Microsoft.EntityFrameworkCore;
using SeaHaven.DataServices.Dto;
using SeaHaven.DataServices.Interfaces;

namespace SeaHaven.DataServices.Implementation;

public sealed class TeamPermissionOverrideDataService : ITeamPermissionOverrideDataService
{
    private readonly ApplicationDbContext _context;

    public TeamPermissionOverrideDataService(ApplicationDbContext context)
    {
        _context = context;
    }

    public async Task<TeamPermissionUserData?> GetUserAsync(
        string userId,
        CancellationToken cancellationToken)
    {
        var userExists = await _context.Users
            .AsNoTracking()
            .AnyAsync(user => user.Id == userId, cancellationToken);

        if (!userExists)
            return null;

        var roleName = await (
            from userRole in _context.UserRoles.AsNoTracking()
            join role in _context.Roles.AsNoTracking()
                on userRole.RoleId equals role.Id
            where userRole.UserId == userId
            select role.Name)
            .FirstOrDefaultAsync(cancellationToken);

        var overrides = await _context.UserPermissionOverrides
            .AsNoTracking()
            .Where(permission => permission.UserId == userId)
            .ToDictionaryAsync(
                permission => permission.PermissionKey,
                permission => permission.State,
                StringComparer.OrdinalIgnoreCase,
                cancellationToken);

        return new TeamPermissionUserData
        {
            UserId = userId,
            RoleName = roleName,
            Overrides = overrides
        };
    }

    public async Task SetOverrideAsync(
        string userId,
        string permissionKey,
        UserPermissionState state,
        CancellationToken cancellationToken)
    {
        await SetOverridesAsync(
            userId,
            new Dictionary<string, UserPermissionState>(StringComparer.OrdinalIgnoreCase)
            {
                [permissionKey] = state
            },
            cancellationToken);
    }

    public async Task SetOverridesAsync(
        string userId,
        IReadOnlyDictionary<string, UserPermissionState> overrides,
        CancellationToken cancellationToken)
    {
        foreach (var pair in overrides)
        {
            var existing = await _context.UserPermissionOverrides
                .SingleOrDefaultAsync(
                    permission => permission.UserId == userId
                        && permission.PermissionKey == pair.Key,
                    cancellationToken);

            if (existing is null)
            {
                await _context.UserPermissionOverrides.AddAsync(
                    new UserPermissionOverride
                    {
                        UserId = userId,
                        PermissionKey = pair.Key,
                        State = pair.Value
                    },
                    cancellationToken);
            }
            else
            {
                existing.State = pair.Value;
            }
        }

        await _context.SaveChangesAsync(cancellationToken);
    }
}