package com.fs.live.service.impl;

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.Collections;
import java.util.Date;
import java.util.List;

import com.alibaba.fastjson.JSON;

import com.fs.common.core.domain.R;
import com.fs.common.core.redis.RedisCache;
import com.fs.live.domain.Live;
import com.fs.live.domain.LiveAutoTask;
import com.fs.live.domain.LiveLotteryConf;
import com.fs.live.domain.LiveRedConf;
import com.fs.live.mapper.*;
import com.fs.live.param.LiveLotteryProduct;
import com.fs.live.service.ILiveAutoTaskService;
import com.fs.live.service.ILiveGoodsService;
import com.fs.live.vo.LiveGoodsVo;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 直播间自动化任务配置Service业务层处理
 *
 * @author fs
 * @date 2025-08-29
 */
@Service
public class LiveAutoTaskServiceImpl implements ILiveAutoTaskService {

    @Autowired
    private LiveMapper liveMapper;
    @Autowired
    private ILiveGoodsService goodsService;
    @Autowired
    private RedisCache redisCache;
    @Autowired
    private LiveAutoTaskMapper baseMapper;

    @Autowired
    private LiveRedConfMapper liveRedConfMapper;
    @Autowired
    private LiveLotteryConfMapper liveLotteryConfMapper;
    @Autowired
    private LiveLotteryProductConfMapper lotteryProductConfMapper;

    /**
     * 查询直播间自动化任务配置
     *
     * @param id 直播间自动化任务配置主键
     * @return 直播间自动化任务配置
     */
    @Override
    public LiveAutoTask selectLiveAutoTaskById(Long id)
    {
        return baseMapper.selectLiveAutoTaskById(id);
    }

    /**
     * 查询直播间自动化任务配置列表
     *
     * @param liveAutoTask 直播间自动化任务配置
     * @return 直播间自动化任务配置
     */
    @Override
    public List<LiveAutoTask> selectLiveAutoTaskList(LiveAutoTask liveAutoTask)
    {
        return baseMapper.selectLiveAutoTaskList(liveAutoTask);
    }

    /**
     * 新增直播间自动化任务配置
     *
     * @param liveAutoTask 直播间自动化任务配置
     * @return 结果
     */
    @Override
    public R insertLiveAutoTask(LiveAutoTask liveAutoTask)
    {

        Live live = liveMapper.selectLiveByLiveId(liveAutoTask.getLiveId());
        if(live == null) return R.error("直播间不存在");
        //截取triggerValue 时分秒部分 ，然后根据查询出来的直播间开始时间计算出相对时间
        Date triggerValue = liveAutoTask.getTriggerValue();
        if (triggerValue == null) {
            return R.error("请设置触发时间");
        }
        Date now = new Date();
        // 获取直播间开始时间进行计算触发时间
        liveAutoTask.setTriggerValue(triggerValue);
        liveAutoTask.setAbsValue(getTriggerValue(triggerValue, live.getStartTime()));
        //如果触发时间小于当前时间 报错
        if (liveAutoTask.getAbsValue().before(now)) {return R.error("请勿设置触发时间小于当前时间");}

        // 根据触发时间 查看同一时间有没有相同的数据 1.直播间id 2.时间
        LiveAutoTask existTask = baseMapper.selectLiveAutoTaskByTriggerValue(liveAutoTask.getLiveId(), liveAutoTask.getTriggerValue());
        if(existTask != null) return R.error("该时间段有任务");


        liveAutoTask.setCreateTime(now);
        liveAutoTask.setUpdateTime(now);
        liveAutoTask.setTriggerType(2L);
        liveAutoTask.setFinishStatus(0L);
        if(liveAutoTask.getStatus() == null) liveAutoTask.setStatus(1L);
        if (liveAutoTask.getTaskType() == 1L) {
            // 商品
            LiveGoodsVo liveGoodsVo = goodsService.selectLiveGoodsVoByGoodsId(Long.valueOf(liveAutoTask.getContent()));
            if(liveGoodsVo == null) return R.error("商品不存在");
            liveAutoTask.setContent(JSON.toJSONString(liveGoodsVo));
            baseMapper.insertLiveAutoTask(liveAutoTask);
        }else if (liveAutoTask.getTaskType() == 2L) {
            // 红包
            LiveRedConf liveRedConf = liveRedConfMapper.selectLiveRedConfByRedId(Long.valueOf(liveAutoTask.getContent()));
            if(liveRedConf == null) return R.error("红包配置不存在");
            if(liveRedConf.getRedStatus() != 0L) return R.error("红包状态应该为：未发放");
            liveAutoTask.setContent(JSON.toJSONString(liveRedConf));
            baseMapper.insertLiveAutoTask(liveAutoTask);
        }else if (liveAutoTask.getTaskType() == 4L) {
            // 开启抽奖
            LiveLotteryConf liveLotteryConf = liveLotteryConfMapper.selectLiveLotteryConfByLotteryId(Long.valueOf(liveAutoTask.getContent()));
            if(liveLotteryConf == null) return R.error("抽奖配置不存在");
            if(!"0".equals(liveLotteryConf.getLotteryStatus())) return R.error("抽奖状态应该为：未开始");
            List<LiveLotteryProduct> prizes = lotteryProductConfMapper.selectLiveLotteryProductConfByLotteryId(liveLotteryConf.getLotteryId());
            if (prizes == null || prizes.isEmpty()) {
                return R.error("抽奖配置请先添加奖品");
            }
            liveAutoTask.setContent(JSON.toJSONString(liveLotteryConf));
            baseMapper.insertLiveAutoTask(liveAutoTask);
        } else if(liveAutoTask.getTaskType() != 3L){
            baseMapper.insertLiveAutoTask(liveAutoTask);

        } else {
            return R.error("任务类型错误");
        }


        if (live.getStatus() == 2 && liveAutoTask.getStatus() == 1L) {
            liveAutoTask.setUpdateTime(null);
            liveAutoTask.setCreateTime(null);
            redisCache.redisTemplate.opsForZSet().add("live:auto_task:" + live.getLiveId(), JSON.toJSONString(liveAutoTask),liveAutoTask.getAbsValue().getTime());
            redisCache.redisTemplate.expire("live:auto_task:" + live.getLiveId(), 30, java.util.concurrent.TimeUnit.MINUTES);
        }


        return R.ok();
    }

    /**
     * 复制新增直播间自动化任务配置
     *
     * @param liveAutoTask 直播间自动化任务配置
     * @return 结果
     */
    @Override
    public R copyInsertLiveAutoTask(LiveAutoTask liveAutoTask , Live live)
    {

        Date triggerValue = liveAutoTask.getTriggerValue();
        if (triggerValue == null) {
            return R.error("请设置触发时间");
        }
        Date now = new Date();
        // 获取直播间开始时间进行计算触发时间
        liveAutoTask.setTriggerValue(triggerValue);
        liveAutoTask.setAbsValue(getTriggerValue(triggerValue, live.getStartTime()));

        liveAutoTask.setCreateTime(now);
        liveAutoTask.setUpdateTime(now);
        liveAutoTask.setTriggerType(2L);
        liveAutoTask.setFinishStatus(0L);
        if(liveAutoTask.getStatus() == null) liveAutoTask.setStatus(1L);
        baseMapper.insertLiveAutoTask(liveAutoTask);

        if (live.getStatus() == 2 && liveAutoTask.getStatus() == 1L) {
            liveAutoTask.setUpdateTime(null);
            liveAutoTask.setCreateTime(null);
            redisCache.redisTemplate.opsForZSet().add("live:auto_task:" + live.getLiveId(), JSON.toJSONString(liveAutoTask),liveAutoTask.getAbsValue().getTime());
            redisCache.redisTemplate.expire("live:auto_task:" + live.getLiveId(), 30, java.util.concurrent.TimeUnit.MINUTES);
        }
        return R.ok();
    }

    private Date getTriggerValue( Date triggerValue, LocalDateTime liveStartTime) {
        LocalDateTime triggerDateTime = LocalDateTime.ofInstant(
                triggerValue.toInstant(),
                ZoneId.systemDefault()
        );
        LocalTime triggerTime = triggerDateTime.toLocalTime();
        LocalDateTime combinedTime = liveStartTime
                .plusHours(triggerTime.getHour())
                .plusMinutes(triggerTime.getMinute())
                .plusSeconds(triggerTime.getSecond());
        return Date.from(combinedTime.atZone(ZoneId.systemDefault()).toInstant());
    }

    /**
     * 修改直播间自动化任务配置
     *
     * @param liveAutoTask 直播间自动化任务配置
     * @return 结果
     */
    @Override
    public int updateLiveAutoTask(LiveAutoTask liveAutoTask)
    {
        LiveAutoTask existTask = baseMapper.selectLiveAutoTaskById(liveAutoTask.getId());
        redisCache.redisTemplate.opsForZSet().removeRangeByScore("live:auto_task:" + existTask.getLiveId(), existTask.getAbsValue().getTime(), existTask.getAbsValue().getTime());
        LiveGoodsVo liveGoodsVo = goodsService.selectLiveGoodsVoByGoodsId(Long.valueOf(liveAutoTask.getContent()));
        if(liveGoodsVo == null) return -1;
        liveAutoTask.setContent(JSON.toJSONString(liveGoodsVo));

        return baseMapper.updateLiveAutoTask(liveAutoTask);
    }

    /**
     * 批量删除直播间自动化任务配置
     *
     * @param ids 需要删除的直播间自动化任务配置主键
     * @return 结果
     */
    @Override
    public int deleteLiveAutoTaskByIds(Long[] ids)
    {
        return baseMapper.deleteLiveAutoTaskByIds(ids);
    }

    /**
     * 删除直播间自动化任务配置信息
     *
     * @param id 直播间自动化任务配置主键
     * @return 结果
     */
    @Override
    public int deleteLiveAutoTaskById(Long id)
    {
        return baseMapper.deleteLiveAutoTaskById(id);
    }

    @Override
    public List<LiveAutoTask> selectLiveAutoTaskByLiveId(Long existLiveId) {
        return  baseMapper.selectLiveAutoTaskByLiveId(existLiveId);
    }

    @Override
    public List<LiveAutoTask> selectNoActivedByLiveId(Long existLiveId, Date now) {
        return baseMapper.selectNoActivedByLiveId(existLiveId, now);
    }

    @Override
    public List<LiveAutoTask> selectLiveAutoTaskByLiveIds(List<Long> liveIdLists) {
        return baseMapper.selectLiveAutoTaskByLiveIds(liveIdLists, new Date());
    }

    @Override
    public void recalcLiveAutoTask(Live live) {

        if(live == null) return;
        // 目前只重算 推送商品 弹幕脚本
        List<LiveAutoTask> liveAutoTasks = baseMapper.recalcLiveAutoTaskQuery(live.getLiveId());
        Date now = new Date();
        for (LiveAutoTask liveAutoTask : liveAutoTasks) {
            liveAutoTask.setAbsValue(getTriggerValue(liveAutoTask.getTriggerValue(), live.getStartTime()));
            liveAutoTask.setUpdateTime(now);
            liveAutoTask.setFinishStatus(0L);
            baseMapper.updateLiveAutoTask(liveAutoTask);
        }
    }

    @Override
    public void finishLiveAutoTask(LiveAutoTask task) {
        baseMapper.finishLiveAutoTask(task);
    }

    @Override
    public List<LiveAutoTask> selectLiveAutoTaskBarrageList(LiveAutoTask liveAutoTask) {
        return baseMapper.selectLiveAutoTaskBarrageList(liveAutoTask);
    }

    @Override
    public void directInsertLiveAutoTask(LiveAutoTask liveAutoTask) {
        baseMapper.insertLiveAutoTask(liveAutoTask);
    }
}
