ThreeGamesBackEnd/games/src/main/java/com/api/games/service/impl/PushLogServiceImpl.java

package com.api.games.service.impl;

import com.api.common.JSONUtils;
import com.api.common.UtilFun;
import com.api.config.ConstUser;
import com.api.core.response.Result;
import com.api.core.response.ResultGenerator;
import com.api.core.service.AbstractService;
import com.api.games.dao.*;
import com.api.games.model.*;
import com.api.games.result.GameInfoResult;
import com.api.games.service.PushLogService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;


/**
 * Created by wanghuiwen on 2020/02/27.
 */
@Service
@Transactional
public class PushLogServiceImpl extends AbstractService<PushLog> implements PushLogService {
    @Resource
    private PushLogMapper pushLogMapper;

    @Resource
    private GameConfigMapper gameConfigMapper;

    @Resource
    private UserConfigMapper userConfigMapper;

    @Resource
    private GamePlayTimeMapper gamePlayTimeMapper;

    @Resource
    private GameLogMapper gameLogMapper;

    private SimpleDateFormat simpleDateFormatScale = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private SimpleDateFormat simpleDateFormatGameConfig = new SimpleDateFormat("HH:mm");

    @Override
    public void deleteByUid(long userId) {
        pushLogMapper.deleteByUid(userId);
    }

    @Override
    public Result list(String search, String ordermap, Integer page, Integer size) {
        Map<String, Object> params = JSONUtils.json2map(search);
        Map<String, Object> order = JSONUtils.json2map(ordermap);

        for (String key : order.keySet()) {
            if (order.get(key) != null && order.get(key).equals("ascending")) order.put(key, "asc");
            if (order.get(key) != null && order.get(key).equals("descending")) order.put(key, "desc");
        }
        PageHelper.startPage(page, size);

        List<Map<String,Object>> list = pushLogMapper.list(params,order);
        PageInfo<Map<String,Object>> pageInfo = new PageInfo<>(list);
        return ResultGenerator.genSuccessResult(pageInfo);
    }

    @Override
    public Result needPlayGame(long userId) {
        GameInfoResult result = new GameInfoResult();

        Date currentDate = new Date(System.currentTimeMillis());

        UserConfig config = userConfigMapper.findByUid(userId);

        if (config != null && config.getScaleStart() != null && config.getScaleEnd() != null){
            try {
                Date scaleStart = simpleDateFormatScale.parse(config.getScaleStart());
                Date scaleEnd = simpleDateFormatScale.parse(config.getScaleEnd());
                Calendar scaleEndCalendarTop = Calendar.getInstance();
                scaleEndCalendarTop.setTime(scaleEnd);
                scaleEndCalendarTop.add(Calendar.DATE, 1);
                scaleEnd = scaleEndCalendarTop.getTime();
                if (currentDate.getTime() >= scaleStart.getTime() && currentDate.getTime() <= scaleEnd.getTime()){
                    //当前处于量表测试期间
                    //游戏逻辑处理
                    System.out.println(userId + "此用户目前在测量时间内");
                    GameConfig gameConfig = inThePeriod(gameConfigMapper.listUid(userId), currentDate);
                    if (gameConfig != null){
                        Calendar scaleStartCalendar = Calendar.getInstance();
                        scaleStartCalendar.setTime(currentDate);
                        scaleStartCalendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(gameConfig.getStartTime().split(":")[0]));
                        scaleStartCalendar.set(Calendar.MINUTE, Integer.parseInt(gameConfig.getStartTime().split(":")[1]));
                        scaleStartCalendar.set(Calendar.SECOND, 0);
                        Calendar scaleEndCalendar = Calendar.getInstance();
                        scaleEndCalendar.setTime(currentDate);
                        scaleEndCalendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(gameConfig.getEndTime().split(":")[0]));
                        scaleEndCalendar.set(Calendar.MINUTE, Integer.parseInt(gameConfig.getEndTime().split(":")[1]));
                        scaleEndCalendar.set(Calendar.SECOND, 0);

                        List<GamePlayTime> gamePlayTimeList = gamePlayTimeMapper.listUidAndInPeriod(userId, simpleDateFormatScale.format(scaleStartCalendar.getTime()), simpleDateFormatScale.format(scaleEndCalendar.getTime()));
                        if (gamePlayTimeList != null && gamePlayTimeList.size() != 0){
                            GamePlayTime time = gamePlayTimeList.get(0);

                            if (currentDate.getTime() >= simpleDateFormatScale.parse(time.getGameTime()).getTime()){
                                result.needDoGame = true;
                                result.playGameType = 0;
                                result.playGameId = time.getId();
                                result.gameConfigId = gameConfig.getId();

                                result.displayDuration = config.getShowTime();
                                result.intervalDuration = config.getHideTime();
                                result.correctNumberOccurrenceNumber = config.getCorrect();
                                result.errorNumberOccurrenceNumber = config.getSupporting();
                                result.practiseDuration = config.getPractice();
                                result.practiseRightNumber = config.getExerciseRight();
                                result.practiseOccurrenceNumber = config.getExercise();

                                String[] versionInfo = config.getVersion().split(",");
                                if (versionInfo.length <= 1)
                                    result.gameVersion = GameInfoResult.convertVersion(versionInfo[0]);
                                else{
                                    List<GameLog> gameLogs = gameLogMapper.listUid(userId);
                                    if (gameLogs.size() == 0){
                                        result.gameVersion = GameInfoResult.convertVersion(getRandomVersion(versionInfo));
                                    }else{
                                        int size = gameLogs.size() % versionInfo.length;
                                        if (size == 0){
                                            result.gameVersion = GameInfoResult.convertVersion(getRandomVersion(versionInfo));
                                        }else{
                                            int currentLogLength = getVersionGameCount(gameLogs, versionInfo[0]);
                                            result.gameVersion = GameInfoResult.convertVersion(versionInfo[0]);
                                            for (int i = 0; i < versionInfo.length; i ++){
                                                int versionCount = getVersionGameCount(gameLogs, versionInfo[i]);
                                                if (versionCount < currentLogLength)
                                                    result.gameVersion = GameInfoResult.convertVersion(versionInfo[i]);
                                            }
                                        }
                                    }
                                }
                                System.out.println(userId + "此用户需要做游戏");
                                return ResultGenerator.genSuccessResult(result);
                            }
                        }
                    }

                    //量表逻辑处理
                    Calendar startDate = Calendar.getInstance();
                    startDate.add(Calendar.HOUR_OF_DAY, -2);
                    Calendar endDate = Calendar.getInstance();
                    List<GamePlayTime> gamePlayTime = gamePlayTimeMapper.getScalePlayTime(userId, simpleDateFormatScale.format(startDate.getTime()), simpleDateFormatScale.format(endDate.getTime()));
                    if (gamePlayTime != null && gamePlayTime.size() > 0){
                        GamePlayTime playTime = gamePlayTime.get(0);
                        if (playTime.getDelay() > 3)
                            return ResultGenerator.genSuccessResult(result);

                        System.out.println(userId + "此用户需要做量表");

                        result.delay = playTime.getDelay();
                        result.needDoGame = true;
                        result.playGameType = 1;
                        result.playGameId = playTime.getId();
                        Calendar today = Calendar.getInstance();
                        today.add(Calendar.DATE, -1);
                        result.date = UtilFun.DateToString(today.getTime(), UtilFun.YYYYMMDDHHMMSS);

                        return ResultGenerator.genSuccessResult(result);
                    }
                }
            } catch (Exception e){
                e.printStackTrace();
            }
        }

        return ResultGenerator.genSuccessResult(result);
    }

    @Override
    public Result delayScale(Long gamePlayTimeId, int delayMin, String deviceId) {
        if (gamePlayTimeId != null){
            GamePlayTime gamePlayTime = gamePlayTimeMapper.selectByPrimaryKey(gamePlayTimeId);

            Calendar playCalendar = Calendar.getInstance();
            Date playDate = UtilFun.StringToDate(gamePlayTime.getGameTime(), UtilFun.YYYYMMDDHHMMSS);
            if (playDate != null) {
                playCalendar.setTime(playDate);
                Calendar newTime = Calendar.getInstance();
                newTime.add(Calendar.MINUTE, delayMin);
                if (newTime.get(Calendar.DAY_OF_YEAR) != playCalendar.get(Calendar.DAY_OF_YEAR) && delayMin != 0){
                    return new Result("無法推遲相應時間，請盡快完成量表");
                }else{
                    PushLog pushLog = new PushLog();
                    pushLog.setPushTime(new Date());
                    pushLog.setUid(gamePlayTime.getUid());
                    pushLog.setType(2);
                    pushLog.setDeviceId(deviceId);
                    pushLog.setMsgId(gamePlayTimeId + "");
                    pushLog.setStatus(ConstUser.PUSH_DELAY);
                    pushLogMapper.insert(pushLog);
                    gamePlayTime.setGameTime(UtilFun.DateToString(newTime.getTime(), UtilFun.YYYYMMDDHHMMSS));
                    gamePlayTime.setDelay(gamePlayTime.getDelay() + 1);
                    gamePlayTimeMapper.updateByPrimaryKey(gamePlayTime);

                    if (gamePlayTime.getDelay() > 3){
                        pushLog = new PushLog();
                        pushLog.setPushTime(new Date());
                        pushLog.setUid(gamePlayTime.getUid());
                        pushLog.setType(2);
                        pushLog.setDeviceId(deviceId);
                        pushLog.setMsgId(gamePlayTimeId + "");
                        pushLog.setStatus(ConstUser.PUSH_NO);
                        pushLogMapper.insert(pushLog);
                    }

                    return ResultGenerator.genSuccessResult();
                }
            }

        }

        return ResultGenerator.genFailResult();
    }

    @Override
    public Result enter(Long gamePlayTimeId, String deviceId, Integer type) {
        GamePlayTime gamePlayTime = gamePlayTimeMapper.selectByPrimaryKey(gamePlayTimeId);
        PushLog pushLog = new PushLog();
        pushLog.setPushTime(new Date());
        pushLog.setUid(gamePlayTime.getUid());
        pushLog.setType(type);
        pushLog.setDeviceId(deviceId);
        pushLog.setMsgId(gamePlayTimeId + "");
        pushLog.setStatus(ConstUser.PUSH_ING);
        pushLogMapper.insert(pushLog);
        return ResultGenerator.genSuccessResult();
    }

    @Override
    public Result delayGame(Long gamePlayTimeId, Long gameConfigId, int delayMin, String deviceId, Boolean trueDelay) {
        if (gamePlayTimeId != null && gameConfigId != null){
            GamePlayTime gamePlayTime = gamePlayTimeMapper.selectByPrimaryKey(gamePlayTimeId);
            GameConfig gameConfig = gameConfigMapper.selectByPrimaryKey(gameConfigId);
            if (gamePlayTime != null && gameConfig != null){
                try {
                    Calendar gamePlayCalendar = Calendar.getInstance();

                    Calendar gameConfigCalendar = Calendar.getInstance();
                    gameConfigCalendar.setTime(simpleDateFormatGameConfig.parse(gameConfig.getEndTime()));
                    gameConfigCalendar.set(Calendar.YEAR, gamePlayCalendar.get(Calendar.YEAR));
                    gameConfigCalendar.set(Calendar.MONTH, gamePlayCalendar.get(Calendar.MONTH));
                    gameConfigCalendar.set(Calendar.DAY_OF_MONTH, gamePlayCalendar.get(Calendar.DAY_OF_MONTH));

                    gamePlayCalendar.add(Calendar.MINUTE, delayMin);

                    long diff = gameConfigCalendar.getTime().getTime() - gamePlayCalendar.getTime().getTime();
                    if (gamePlayCalendar.before(gameConfigCalendar) && diff >= 10 * 60 * 1000){
                        gamePlayTime.setGameTime(simpleDateFormatScale.format(gamePlayCalendar.getTime()));
                        PushLog pushLog = new PushLog();
                        pushLog.setPushTime(new Date());
                        pushLog.setUid(gameConfig.getUid());
                        pushLog.setType(1);
                        pushLog.setDeviceId(deviceId);
                        pushLog.setMsgId(gamePlayTimeId + "");
                        pushLog.setStatus(ConstUser.PUSH_DELAY);
                        pushLogMapper.insert(pushLog);
                        gamePlayTimeMapper.updateByPrimaryKey(gamePlayTime);
                        return ResultGenerator.genSuccessResult();
                    }else {
                        if(trueDelay) {
                            PushLog pushLog = new PushLog();
                            pushLog.setPushTime(new Date());
                            pushLog.setUid(gameConfig.getUid());
                            pushLog.setType(1);
                            pushLog.setDeviceId(deviceId);
                            pushLog.setMsgId(gamePlayTimeId + "");
                            pushLog.setStatus(ConstUser.PUSH_NO);
                            pushLogMapper.insert(pushLog);
                            gamePlayTimeMapper.deleteByPrimaryKey(gamePlayTime.getId());
                            return ResultGenerator.genSuccessResult();
                        }else{
                            return new Result("1");
                        }
                    }


                } catch (Exception e){
                    e.printStackTrace();
                }
            }
        }



        return ResultGenerator.genFailResult();
    }

    @Override
    public List<Map<String, Object>> download(String search, String ordermap) {
        Map<String, Object> params = JSONUtils.json2map(search);
        Map<String, Object> order = JSONUtils.json2map(ordermap);

        for (String key : order.keySet()) {
            if (order.get(key) != null && order.get(key).equals("ascending")) order.put(key, "asc");
            if (order.get(key) != null && order.get(key).equals("descending")) order.put(key, "desc");
        }

        return pushLogMapper.list(params,order);
    }


    private boolean pushedThreeTimes(long gamePlayTimeId){
        List<PushLog> pushLogs = pushLogMapper.listByGamePlayId(gamePlayTimeId);
        List<PushLog> pushLogsDelay = new ArrayList<>();
        if(pushLogs != null && pushLogs.size() < 3){
            return false;
        }else if (pushLogs != null){
            for (PushLog pushLog : pushLogs)
                if (pushLog.getStatus() == ConstUser.PUSH_DELAY)
                    pushLogsDelay.add(pushLog);
            if (pushLogsDelay.size() >= 3)
                return true;
        }

        return false;
    }

    private String getRandomVersion(String[] versions){
        return versions[(int)(Math.random() * versions.length)];
    }

    private int getVersionGameCount(List<GameLog> gameLogs, String version){
        int result = 0;
        for (GameLog gameLog : gameLogs){
            if (gameLog.getVersion().equals(version))
                result ++;
        }
        return result;
    }

    private GameConfig inThePeriod(List<GameConfig> gameConfigs, Date currentDate) throws Exception{
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(currentDate);

        for (GameConfig gameConfig : gameConfigs){
            Calendar startTime = Calendar.getInstance();
            startTime.setTime(simpleDateFormatGameConfig.parse(gameConfig.getStartTime()));
            startTime.set(Calendar.DAY_OF_MONTH, calendar.get(Calendar.DAY_OF_MONTH));
            startTime.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
            startTime.set(Calendar.MONTH, calendar.get(Calendar.MONTH));

            Calendar endTime = Calendar.getInstance();
            endTime.setTime(simpleDateFormatGameConfig.parse(gameConfig.getEndTime()));
            endTime.set(Calendar.DAY_OF_MONTH, calendar.get(Calendar.DAY_OF_MONTH));
            endTime.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
            endTime.set(Calendar.MONTH, calendar.get(Calendar.MONTH));

            if (calendar.after(startTime) && calendar.before(endTime))
                return gameConfig;
        }

        return null;
    }
}