using LCU.API.Internal.Operations.IncentiveApi.Configuration;
using LCU.API.Internal.Operations.IncentiveApi.Models.DataTransfer;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.API.Internal.Operations.IncentiveApi.Models;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;

namespace LCU.API.Internal.Operations.IncentiveApi.Services;

public class SettingsService : ISettingsService
{
    private readonly ReportConfiguration _reportConfig;
    private readonly IRoleMappingRepository _roleMappingRepository;
    private readonly IUnitOfWork _unitOfWork;

    public SettingsService(
        ReportConfiguration reportConfig,
        IRoleMappingRepository roleMappingRepository,
        IUnitOfWork unitOfWork
    )
    {
        _reportConfig = reportConfig;
        _roleMappingRepository = roleMappingRepository;
        _unitOfWork = unitOfWork;
    }

    public async Task<RoleMapping> SaveRoleMappingAsync(RoleMappingUpdateRequest roleMappingUpdateRequest)
    {
        var existingRoleMapping = await _roleMappingRepository.GetRoleMappingByIdAsync(roleMappingUpdateRequest.Id);
        existingRoleMapping.ApplicationRole = Role.DetermineRoleOrDefault(roleMappingUpdateRequest.ApplicationRole);
        await _roleMappingRepository.UpdateRoleMapping(existingRoleMapping);
        await _unitOfWork.CompleteAsync();
        return existingRoleMapping;
    }

    public async Task SaveRoleMappingRangeAsync(IEnumerable<RoleMapping> roleMapping)
    {
        await _roleMappingRepository.SaveRoleMappingRangeAsync(roleMapping.ToList());
        await _unitOfWork.CompleteAsync();
    }

    public async Task SaveNewUnknownRoleMappingRangeAsync(IEnumerable<string> unknownRoles)
    {
        var existingBusinessRoles = await _roleMappingRepository.GetAllRoleMappingsAsync();
        var newRoles = unknownRoles.Where(x => existingBusinessRoles.All(e => !string.Equals(e.BusinessRole, x, StringComparison.InvariantCultureIgnoreCase)));
        await _roleMappingRepository.SaveNewRoleMappingRangeAsync(newRoles.Select(
                role => new RoleMapping { ApplicationRole = Role.MISSING_ROLE, BusinessRole = role })
            .ToList());
        await _unitOfWork.CompleteAsync();
    }

    public async Task<IEnumerable<RoleMapping>> GetRoleMappingsAsync()
    {
        var roleMappings = await _roleMappingRepository.GetAllRoleMappingsAsync();
        return roleMappings ?? new List<RoleMapping>();
    }

    public async Task<List<ReportSettings>> GetAuthorizedReportSettings(AppUser appUser)
    {
        var authorizedReports = new List<ReportSettings>();
        foreach (var reportSettings in _reportConfig.ReportConfigs)
        {
            if (appUser.UserHasPermission(reportSettings.RequiredPermissionCode))
            {
                authorizedReports.Add(reportSettings);
            }
        }

        return await Task.FromResult(authorizedReports);
    }
}