using FreeSql;

using LiveForum.Code.Base;
using LiveForum.Code.JwtInfrastructure;
using LiveForum.IService.Flowers;
using LiveForum.IService.Messages;
using LiveForum.IService.Others;
using LiveForum.Model;
using LiveForum.Model.Dto.Flowers;
using LiveForum.Model.Dto.Messages;

using System;
using System.Linq;
using System.Threading.Tasks;

using TencentCloud.Tbm.V20180129.Models;

namespace LiveForum.Service.Flowers
{
    /// <summary>
    /// 送花服务实现
    /// </summary>
    public class FlowersService : IFlowersService
    {
        private readonly JwtUserInfoModel _userInfoModel;
        private readonly IFreeSql _fsql;
        private readonly IBaseRepository<T_FlowerRecordsInfo> _flowerRecordsInfoRepository;
        private readonly IBaseRepository<T_FlowerRecords> _flowerRecordsRepository;
        private readonly IBaseRepository<T_Streamers> _streamersRepository;
        private readonly IBaseRepository<T_Posts> _postsRepository;
        private readonly IMessagePublisher _messagePublisher;
        private readonly IFlowerService _flowerService;
        private readonly IAntiAddictionService _antiAddictionService;
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userInfoModel">JWT用户信息模型</param>
        /// <param name="fsql">FreeSql实例</param>
        /// <param name="flowerRecordsInfoRepository">送花详细记录仓储</param>
        /// <param name="flowerRecordsRepository">送花月度汇总仓储</param>
        /// <param name="streamersRepository">主播仓储</param>
        /// <param name="postsRepository">帖子仓储</param>
        /// <param name="messagePublisher">消息发布器</param>
        /// <param name="flowerService">送花服务</param>
        public FlowersService(
            JwtUserInfoModel userInfoModel,
            IFreeSql fsql,
            IBaseRepository<T_FlowerRecordsInfo> flowerRecordsInfoRepository,
            IBaseRepository<T_FlowerRecords> flowerRecordsRepository,
            IBaseRepository<T_Streamers> streamersRepository,
            IBaseRepository<T_Posts> postsRepository,
            IMessagePublisher messagePublisher,
            IFlowerService flowerService,
            IAntiAddictionService antiAddictionService
            )
        {
            _userInfoModel = userInfoModel;
            _fsql = fsql;
            _flowerRecordsInfoRepository = flowerRecordsInfoRepository;
            _flowerRecordsRepository = flowerRecordsRepository;
            _streamersRepository = streamersRepository;
            _postsRepository = postsRepository;
            _messagePublisher = messagePublisher;
            _flowerService = flowerService;
            _antiAddictionService = antiAddictionService;
        }

        /// <summary>
        /// 送花
        /// </summary>
        /// <param name="request">请求参数</param>
        /// <returns></returns>
        public async Task<BaseResponse<SendFlowerRespDto>> SendFlower(SendFlowerReq request)
        {
            try
            {
                var currentUserId = (long)_userInfoModel.UserId;

                // 防沉迷校验
                if (await _antiAddictionService.IsRestrictedAsync("Flower"))
                {
                    return new BaseResponse<SendFlowerRespDto>(ResponseCode.Error, "防沉迷时间内无法操作");
                }

                // 1. 验证目标是否存在并获取接收者ID
                long? receiverId = null;
                if (request.TargetType == "Streamer")
                {
                    var streamer = await _streamersRepository.Select
                        .Where(s => s.Id == request.TargetId)
                        .FirstAsync();
                    if (streamer == null)
                    {
                        return new BaseResponse<SendFlowerRespDto>(ResponseCode.Error, "主播不存在");
                    }
                }
                else if (request.TargetType == "Post")
                {
                    var post = await _postsRepository.Select
                        .Where(p => p.Id == request.TargetId && !p.IsDeleted)
                        .FirstAsync();
                    if (post == null)
                    {
                        return new BaseResponse<SendFlowerRespDto>(ResponseCode.Error, "帖子不存在");
                    }
                    receiverId = post.UserId;
                }
                else
                {
                    return new BaseResponse<SendFlowerRespDto>(ResponseCode.Error, "无效的目标类型");
                }

                // 2. 检查1小时限制
                var canSend = await _flowerService.CanSendFlowerAsync(currentUserId, request.TargetType, request.TargetId);
                if (!canSend)
                {
                    return new BaseResponse<SendFlowerRespDto>(ResponseCode.Error, "每小时只能赠送1次");
                }

                // 3. 执行送花操作（Redis+队列）
                await _flowerService.SendFlowerAsync(currentUserId, request.TargetType, request.TargetId, receiverId ?? 0);

                // 4. 获取最新花数
                var flowerCount = await _flowerService.GetFlowerCountAsync(request.TargetType, request.TargetId);

                // 5. 发送送花消息（如果是帖子且不是自己的帖子）
                if (request.TargetType == "Post" && receiverId.HasValue && receiverId.Value != currentUserId)
                {
                    try
                    {
                        var post = await _postsRepository.Select
                            .Where(p => p.Id == request.TargetId)
                            .FirstAsync();

                        if (post != null)
                        {
                            await _messagePublisher.SendLikeMessageAsync(
                                triggerId: currentUserId,
                                receiverId: receiverId.Value,
                                contentType: 3, // 送花类型
                                contentId: post.Id,
                                postTitle: post.Title,
                                commentContent: null
                            );
                        }
                    }
                    catch (Exception ex)
                    {
                        // 记录日志但不影响送花操作
                        Console.WriteLine($"发送送花消息失败: {ex.Message}");
                    }
                }

                // 6. 返回成功响应
                return new BaseResponse<SendFlowerRespDto>("送花成功！", new SendFlowerRespDto
                {
                    FlowerCount = flowerCount
                });
            }
            catch (Exception ex)
            {
                return new BaseResponse<SendFlowerRespDto>(ResponseCode.Error, "系统出错");
            }
        }
    }
}