using FreeSql;

using LiveForum.Code.Base;
using LiveForum.IService.Flowers;
using LiveForum.IService.Home;
using LiveForum.Model;
using LiveForum.Model.Dto.Home;

using Mapster;

using Microsoft.AspNetCore.Mvc.ViewFeatures;

namespace LiveForum.Service.Home
{
    /// <summary>
    /// 首页服务实现
    /// </summary>
    public class HomeService : IHomeService
    {
        private readonly IBaseRepository<T_Streamers> _streamersRepository;
        private readonly IBaseRepository<T_StreamerCategory> _streamerCategory;
        private readonly IFlowerService _flowerService;
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="streamersRepository">主播仓储</param>
        /// <param name="streamerCategory">主播分类仓储</param>
        /// <param name="flowerService">送花服务</param>
        public HomeService(
            IBaseRepository<T_Streamers> streamersRepository,
            IBaseRepository<T_StreamerCategory> streamerCategory,
            IFlowerService flowerService)
        {
            _streamersRepository = streamersRepository;
            _streamerCategory = streamerCategory;
            _flowerService = flowerService;
        }

        /// <summary>
        /// 获取首页主播榜单
        /// </summary>
        /// <param name="request">请求参数</param>
        /// <returns></returns>
        public async Task<BaseResponse<GetRankingsRespDto>> GetRankings(GetRankingsReq request)
        {
            try
            {
                // 1. 查询指定分类的主播，按送花数降序排序
                var list = await _streamersRepository.Select
                    .Where(s => s.IsEnabled && s.Category == request.Category)

                    .ToListAsync();

                // 2. 查询该分类的主播总数
                var total = await _streamersRepository.Select
                    .Where(s => s.IsEnabled && s.Category == request.Category)
                    .CountAsync();

                // 3. 批量从缓存获取最新花数
                var streamerIds = list.Select(s => (long)s.Id).ToList();
                var flowerCounts = await _flowerService.BatchGetFlowerCountAsync("Streamer", streamerIds);

                // 4. 添加排名序号并转换为DTO，使用缓存中的花数
                var rankingList = list.OrderByDescending(s => s.FlowerCount).ThenBy(it=>it.Nickname).ThenByDescending(it=>it.FollowerCount).Take(request.Limit).Select((s, index) => new StreamerRankingDto

                {
                    Id = s.Id,
                    Rank = s.Rank ?? 0,
                    StreamerId = s.StreamerId,
                    Nickname = s.Nickname,
                    Avatar = s.Avatar,
                    OnlineCount = s.OnlineCount,
                    IsLive = s.IsLive,
                    FlowerCount = flowerCounts.ContainsKey(s.Id) ? flowerCounts[s.Id] : s.FlowerCount,
                    FollowerCount = s.FollowerCount
                }).ToList();

                return new BaseResponse<GetRankingsRespDto>(new GetRankingsRespDto
                {
                    Total = (int)total,
                    List = rankingList
                });
            }
            catch (Exception ex)
            {
                return new BaseResponse<GetRankingsRespDto>(ResponseCode.Error, $"获取榜单失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 获取更多排行榜（分页）
        /// </summary>
        /// <param name="request">请求参数</param>
        /// <returns></returns>
        public async Task<BaseResponse<GetRankingsMoreRespDto>> GetRankingsMore(GetRankingsMoreReq request)
        {
            try
            {
                // 1. 查询该分类的主播总数
                var total = await _streamersRepository.Select
                    .Where(s => s.IsEnabled && s.Category == request.Category)
                    .CountAsync();

                // 2. 分页查询指定分类的主播，按送花数降序排序
                var list = await _streamersRepository.Select
                    .Where(s => s.IsEnabled && s.Category == request.Category)
                    .ToListAsync();

                // 3. 批量从缓存获取最新花数
                var streamerIds = list.Select(s => (long)s.Id).ToList();
                var flowerCounts = await _flowerService.BatchGetFlowerCountAsync("Streamer", streamerIds);

                // 4. 添加全局排名序号并转换为DTO，使用缓存中的花数
                var rankingList = list.Select((s, index) => new StreamerRankingDto
                {
                    Id = s.Id,
                    Rank = (request.Page - 1) * request.PageSize + index + 1,
                    StreamerId = s.StreamerId,
                    Nickname = s.Nickname,
                    Avatar = s.Avatar,
                    OnlineCount = s.OnlineCount,
                    IsLive = s.IsLive,
                    FlowerCount = flowerCounts.ContainsKey(s.Id) ? flowerCounts[s.Id] : s.FlowerCount,
                    FollowerCount = s.FollowerCount
                })
                    .OrderByDescending(s => s.FlowerCount).ThenBy(it => it.Nickname).ThenByDescending(it => it.FollowerCount)
                    .Skip((request.Page - 1) * request.PageSize)
                    .Take(request.PageSize)
                    .Select((it, index) =>
                    {
                        it.Rank = (request.Page - 1) * request.PageSize + index + 1;
                        return it;
                    })
                    .ToList();

                return new BaseResponse<GetRankingsMoreRespDto>(new GetRankingsMoreRespDto
                {
                    Page = request.Page,
                    PageSize = request.PageSize,
                    Total = (int)total,
                    List = rankingList
                });
            }
            catch (Exception ex)
            {
                return new BaseResponse<GetRankingsMoreRespDto>(ResponseCode.Error, $"获取更多排行失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 获取直播中主播列表（分页）
        /// </summary>
        /// <param name="request">请求参数</param>
        /// <returns></returns>
        public async Task<BaseResponse<GetLiveStreamersRespDto>> GetLiveStreamers(GetLiveStreamersReq request)
        {
            try
            {
                // 1. 查询直播中主播的总数
                var total = await _streamersRepository.Select
                    .Where(s => s.IsLive == true && s.IsEnabled)
                    .CountAsync();

                // 2. 分页查询正在直播的主播，按在线人数降序排序
                var list = await _streamersRepository.Select
                    .Where(s => s.IsLive == true && s.IsEnabled)
                    .OrderByDescending(s => s.FlowerCount)
                    .Page(request.Page, request.PageSize)
                    .ToListAsync();

                // 3. 转换为DTO
                var streamerList = list.Adapt<List<LiveStreamerDto>>();
                var streamerIds = streamerList.Select(s => (long)s.Id).ToList();
                var flowerCounts = await _flowerService.BatchGetFlowerCountAsync("Streamer", streamerIds);
                streamerList.ForEach(s =>
                {
                    s.FlowerCount = flowerCounts.ContainsKey(s.Id) ? flowerCounts[s.Id] : s.FlowerCount;
                });
                return new BaseResponse<GetLiveStreamersRespDto>(new GetLiveStreamersRespDto
                {
                    Page = request.Page,
                    PageSize = request.PageSize,
                    Total = (int)total,
                    List = streamerList
                });
            }
            catch (Exception ex)
            {
                return new BaseResponse<GetLiveStreamersRespDto>(ResponseCode.Error, $"获取直播中主播列表失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 获取主播榜单分类列表
        /// </summary>
        /// <returns></returns>
        public async Task<BaseResponseList<StreamerCategoryDto>> GetStreamerCategories()
        {
            var categories = await _streamerCategory.Select.NoTracking().Where(it => it.IsEnabled).ToListAsync<StreamerCategoryDto>();

            return await Task.FromResult(new BaseResponseList<StreamerCategoryDto>
            {
                Code = ResponseCode.Success,
                Data = categories
            });
        }
    }
}