package com.ks.lucky.service.impl.remote;

import com.ks.lucky.exception.LuckyActivityAwardException;
import com.ks.lucky.exception.LuckyActivityException;
import com.ks.lucky.exception.LuckyActivityOpenException;
import com.ks.lucky.exception.LuckyMQException;
import com.ks.lucky.mapper.LuckyActivityMapper;
import com.ks.lucky.pojo.DO.LuckyActivity;
import com.ks.lucky.pojo.DO.LuckyActivityAwards;
import com.ks.lucky.pojo.DO.LuckyActivityOpenInfo;
import com.ks.lucky.pojo.DTO.ActivityMQMsg;
import com.ks.lucky.remote.service.LuckyActivityOpenService;
import com.ks.lucky.service.impl.*;
import com.ks.lucky.util.LuckyRunUtil;
import com.ks.lucky.util.mq.CMQManager;
import org.apache.dubbo.config.annotation.Service;
import org.omg.PortableServer.THREAD_POLICY_ID;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Service(version = "1.0")
public class LuckyActivityOpenServiceImpl implements LuckyActivityOpenService {

    @Resource
    private LuckyActivityAwardManager luckyActivityAwardManager;

    @Resource
    private LuckyActivityMapper luckyActivityMapper;

    @Resource
    private LuckyActivityOpenInfoManager luckyActivityOpenInfoManager;

    @Resource
    private LuckyActivityJoinManager luckyActivityJoinManager;

    @Resource
    private LuckyActivityAwardResultManager luckyActivityAwardResultManager;

    @Resource
    private LuckyActivityManager luckyActivityManager;


    /**
     * 是否可以开奖了
     *
     * @param activity
     * @return
     */
    private boolean canOpen(LuckyActivity activity) throws LuckyActivityException {
        long now = System.currentTimeMillis();
        if (activity.getState() != LuckyActivity.STATE_FINISH) {
            throw new LuckyActivityException(1, "活动尚未结束");
        }

        LuckyActivityOpenInfo openInfo = luckyActivityOpenInfoManager.getOpenInfo(activity.getId());

        //未达到最低开奖人数
        if (activity.getCurrentPersonCount() < openInfo.getMinPersonCount()) {
            throw new LuckyActivityException(2, "尚未达到最低开奖人数");
        }

        //到达最低开奖人数就开奖
        if (activity.getPreOpenTime() != null) {
            if (activity.getPreOpenTime().getTime() > now) {
                throw new LuckyActivityException(2, "尚未达到开奖时间");
            }
        }
        return true;
    }


    @Transactional(rollbackFor = Exception.class)
    @Override
    public void preOpenAward(Long activityId) throws LuckyActivityException, LuckyActivityOpenException, LuckyActivityAwardException {
        //判断活动状态
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        if (activity == null) {
            throw new LuckyActivityException(LuckyActivityException.CODE_NOT_EXIST, "活动不存在");
        }

        //判断是否达到开奖条件
        try {
            canOpen(activity);
        } catch (LuckyActivityException e) {
            throw new LuckyActivityOpenException(1, "尚未达到开奖条件");
        }
        //------------计算开奖-------------

        //获取奖项数据
        List<LuckyActivityAwards> awardsList = luckyActivityAwardManager.getAwardList(activityId);
        if (awardsList == null || awardsList.size() == 0) {
            throw new LuckyActivityAwardException(LuckyActivityAwardException.CODE_NOT_EXIST, "无奖项信息");
        }

        //获取用户数据
        Map<String, Integer> data = luckyActivityJoinManager.getJoinData(activityId);
        for (LuckyActivityAwards awards : awardsList) {
            //获取中奖用户ID
            Set<String> uids = LuckyRunUtil.compute(data, awards.getCount());
            //保存开奖结果
            luckyActivityAwardResultManager.addRecord(uids, awards.getActivityId(), awards.getId());
        }


        //更新状态
        LuckyActivity update = new LuckyActivity();
        update.setId(activityId);
        update.setState(LuckyActivity.STATE_PRE_OPENED);
        update.setStateRemarks("预开奖成功");
        update.setUpdateTime(new Date());
        luckyActivityMapper.updateByPrimaryKeySelective(update);
        //添加消息
        CMQManager.getInstance().addActivityMsg(new ActivityMQMsg(activityId, ActivityMQMsg.TYPE_OPEN_SHOW, new Date()));
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void showOpenAward(Long activityId) throws LuckyActivityException {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        if (activity.getState() != LuckyActivity.STATE_PRE_OPENED) {
            throw new LuckyActivityException(1, "尚未开奖");
        }

        LuckyActivity update = new LuckyActivity();
        update.setId(activityId);
        update.setUpdateTime(new Date());
        update.setState(LuckyActivity.STATE_OPENED);
        update.setStateRemarks("已开奖");
        luckyActivityMapper.updateByPrimaryKeySelective(update);

        //先设置所有记录未中奖
        luckyActivityJoinManager.setActivityAllJoinerUnDraw(activityId);
        //设置中奖用户状态为中奖
        luckyActivityJoinManager.setActivityDrawnJoinerState(activityId);

        luckyActivityAwardResultManager.setResultShow(activityId);
    }

    @Override
    public void reachMinPerson(Long activityId) throws LuckyActivityException {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKey(activityId);
        if (activity == null) {
            throw new LuckyActivityException(LuckyActivityException.CODE_NOT_EXIST, "活动不存在");
        }
        //如果未设置开奖时间，且活动正在进行，就判断是否达到最低人数
        if (activity.getPreOpenTime() == null) {
            if (activity.getState() == LuckyActivity.STATE_STARTED) {
                try {
                    luckyActivityManager.finishActivity(activityId, false, "达到最低开奖人数");
                } catch (LuckyMQException e) {
                    throw new LuckyActivityException(1, e.getMsg());
                }
            }
        }
    }


}