package com.ruoyi.system.service.impl;

import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.NotificationRecords;
import com.ruoyi.common.core.domain.entity.Notifications;
import com.ruoyi.common.core.domain.entity.PushMsgInfo;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.config.UmengConfig;
import com.ruoyi.system.mapper.NotificationRecordsMapper;
import com.ruoyi.system.mapper.NotificationsMapper;
import com.ruoyi.system.mapper.ShopUserMapper;
import com.ruoyi.system.service.INotificationsService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 【请填写功能名称】Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-08-23
 */
@Transactional
@Service
public class NotificationsServiceImpl implements INotificationsService 
{
    private static final Logger log = LoggerFactory.getLogger(NotificationsServiceImpl.class);
    
    @Autowired
    private NotificationsMapper notificationsMapper;
    
    @Autowired
    private NotificationRecordsMapper notificationRecordsMapper;

    @Autowired
    private UmengConfig umengConfig;

    @Autowired
    private ShopUserMapper shopUserMapper;

    /**
     * 查询【请填写功能名称】
     * 
     * @param id 【请填写功能名称】主键
     * @return 【请填写功能名称】
     */
    @Override
    public Notifications selectNotificationsById(Long id)
    {
        return notificationsMapper.selectNotificationsById(id);
    }

    /**
     * 查询【请填写功能名称】列表
     * 
     * @param notifications 【请填写功能名称】
     * @return 【请填写功能名称】
     */
    @Override
    public List<Notifications> selectNotificationsList(Notifications notifications)
    {
        return notificationsMapper.selectNotificationsList(notifications);
    }

    /**
     * 新增【请填写功能名称】
     * 
     * @param notifications 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int insertNotifications(Notifications notifications)
    {
        notifications.setCreateTime(DateUtils.getNowDate());
        return notificationsMapper.insertNotifications(notifications);
    }

    /**
     * 修改【请填写功能名称】
     * 
     * @param notifications 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int updateNotifications(Notifications notifications)
    {
        return notificationsMapper.updateNotifications(notifications);
    }

    /**
     * 批量删除【请填写功能名称】
     * 
     * @param ids 需要删除的【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteNotificationsByIds(Long[] ids)
    {
        return notificationsMapper.deleteNotificationsByIds(ids);
    }

    /**
     * 删除【请填写功能名称】信息
     * 
     * @param id 【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteNotificationsById(Long id)
    {
        return notificationsMapper.deleteNotificationsById(id);
    }
    
    /**
     * 发布通知
     * 
     * @param id 通知ID
     * @return 结果
     */
    @Override
    @Transactional
    public AjaxResult publishNotification(Long id)
    {
        // 查询通知信息
        Notifications notification = notificationsMapper.selectNotificationsById(id);
        if (notification == null)
        {
            return AjaxResult.error("通知不存在");
        }
        
        // 查询该通知的所有记录
        NotificationRecords query = new NotificationRecords();
        query.setNotificationId(id);
        List<NotificationRecords> records = notificationRecordsMapper.selectNotificationRecordsList(query);

        List<Long> userIds = records.stream().map(NotificationRecords::getUserId).collect(Collectors.toList());

        if (records.isEmpty())
        {
            return AjaxResult.error("该通知没有绑定任何用户，请先绑定用户");
        }
        List<String> phones = shopUserMapper.selectPhoneShopUserByUserIds(userIds);
        // 当前时间
        Date now = DateUtils.getNowDate();
        int successCount = 0;
        int failCount = 0;


        sendNotificationToThirdParty(notification, phones);
        query.setStatus("sent");
        notificationRecordsMapper.updateNotificationRecords(query);

        // 遍历所有记录，进行发布
//        for (NotificationRecords record : records)
//        {
//            // 如果记录已经发送过，则不再创建新记录，只更新状态
//            boolean sendResult = sendNotificationToThirdParty(notification, record);
//            if ("sent".equals(record.getStatus()))
//            {
//                // 调用第三方接口发送通知
//
//                if (sendResult)
//                {
//                    successCount++;
//                }
//                else
//                {
//                    failCount++;
//                    // 更新失败原因
//                    record.setFailureReason("重新发送失败");
//                    notificationRecordsMapper.updateNotificationRecords(record);
//                }
//            }
//            else
//            {
//                // 调用第三方接口发送通知
//
//                if (sendResult)
//                {
//                    // 更新记录状态为已发送
//                    record.setStatus("sent");
//                    record.setSentTime(now);
//                    record.setUpdateTime(now);
//                    notificationRecordsMapper.updateNotificationRecords(record);
//                    successCount++;
//                }
//                else
//                {
//                    // 更新记录状态为发送失败
//                    record.setStatus("failed");
//                    record.setFailureReason("发送失败");
//                    record.setUpdateTime(now);
//                    notificationRecordsMapper.updateNotificationRecords(record);
//                    failCount++;
//                }
//            }
//        }
        
        // 更新通知状态为已发布
//        notification.setStatus("published");
//        notification.setPublishTime(now);
 //       notificationsMapper.updateNotifications(notification);
        
        return AjaxResult.success("通知发布完成，成功：" + successCount + "，失败：" + failCount);
    }
    
    /**
     * 调用第三方接口发送通知
     * 
     * @param notification 通知信息
     * @param record 通知记录
     * @return 发送结果
     */
    private boolean sendNotificationToThirdParty(Notifications notification, List<String>  phones)
    {
        try
        {
            // TODO: 实现调用第三方接口发送通知的逻辑
            // 这里是模拟实现，实际项目中需要根据具体的第三方接口进行调用
//            log.info("发送通知：通知ID={}, 用户ID={}, 标题={}, 内容={}",
//                    notification.getId(), record.getUserId(), notification.getTitle(), notification.getContent());
            //
            // 按照499个手机号一组进行分批处理
            for (int i = 0; i < phones.size(); i += 499) {
                int endIndex = Math.min(i + 499, phones.size());
                List<String> phoneBatch = phones.subList(i, endIndex);
                String phoneS = String.join(",", phoneBatch);
                PushMsgInfo pushMsgInfo = new PushMsgInfo();
                pushMsgInfo.setAlias(phoneS);
                pushMsgInfo.setTitle(notification.getTitle());
                pushMsgInfo.setText(notification.getContent());
                umengConfig.sendAndroidCustomizedcast(pushMsgInfo);
                umengConfig.sendIOSCustomizedcast(pushMsgInfo);
                log.info("发送通知批次 {}/{}, 本批次包含 {} 个手机号", 
                        (i / 499) + 1, (phones.size() + 498) / 499, phoneBatch.size());
            }
            // 模拟发送成功
            return true;
        }
        catch (Exception e)
        {
            log.error("发送通知失败：", e);
            return false;
        }
    }
}
