using Data.SeaHavenIndustries;
using Microsoft.AspNetCore.Identity;
using SeaHaven.DataServices.Interfaces;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Interfaces;

namespace SeaHaven.Services.Implementation
{
    public class CommonService : ICommonService
    {
        private readonly ICommonDataService _dataService;
        private readonly UserManager<ApplicationUser> _userManager;

        public CommonService(ICommonDataService dataService, UserManager<ApplicationUser> userManager)
        {
            _dataService = dataService;
            _userManager = userManager;
        }

        public async Task<PagedUsersResult> GetUsersPagedAsync(string? search, int page, int pageSize, CancellationToken cancellationToken)
        {
            var (paginatedUsers, totalCount) = await _dataService.GetUsersPagedAsync(page, pageSize, search ?? "", cancellationToken);

            var filteredUsers = new List<UserListItemDTO>();

            foreach (var user in paginatedUsers)
            {
                var roles = await _userManager.GetRolesAsync(user);
                if (!roles.Contains("Admin"))
                {
                    filteredUsers.Add(new UserListItemDTO
                    {
                        RoleName = roles.Count() > 0 ? roles.First() : "",
                        Email = user.Email,
                        UserName = user.FirstName,
                        Date = user.CreatedDate?.Date.ToString(),
                        Status = user.UniqueName,
                        Id = user.Id
                    });
                }
            }

            var totalPages = (int)Math.Ceiling(totalCount / (double)pageSize);

            return new PagedUsersResult
            {
                Users = filteredUsers,
                PageNumber = page,
                PageSize = pageSize,
                TotalCount = totalCount,
                TotalPages = totalPages
            };
        }

        public async Task<IEnumerable<RoleListItemDTO>> GetRolesAsync(CancellationToken cancellationToken)
        {
            var names = await _dataService.GetRoleNamesAsync(cancellationToken);
            return names.Select(name => new RoleListItemDTO { Id = name, Name = name });
        }

        public async Task<IEnumerable<SiteNameDTO>> GetSiteNamesAsync(CancellationToken cancellationToken)
        {
            var sites = await _dataService.GetSiteNamesAsync(cancellationToken);
            return sites.Select(n => new SiteNameDTO { Id = n.Id, Name = n.Name, Title = n.Title });
        }

        public async Task<IEnumerable<ContactListItemDTO>> GetContactsAsync(CancellationToken cancellationToken)
        {
            var contacts = await _dataService.GetContactsAsync(cancellationToken);
            return contacts.Select(n => new ContactListItemDTO
            {
                Id = n.Id,
                Name = (n.FirstName + " " + n.LastName).Trim(),
                Email = n.Email,
                Phone = n.PhoneNumber
            });
        }

        public async Task<IEnumerable<CategoryListItemDTO>> GetCategoriesAsync(CancellationToken cancellationToken)
        {
            var categories = await _dataService.GetCategoriesAsync(cancellationToken);
            return categories.Select(s => new CategoryListItemDTO { Id = s.Id, Name = s.Name });
        }
    }
}