package com.izouma.awesomeadmin.service.impl;

import java.math.BigDecimal;
import java.util.*;

import com.izouma.awesomeadmin.dao.CompetitionSeasonMapper;
import com.izouma.awesomeadmin.dto.Result;
import com.izouma.awesomeadmin.model.*;
import com.izouma.awesomeadmin.service.*;
import com.izouma.awesomeadmin.util.DateTimeTool;
import com.izouma.awesomeadmin.util.MbappUtil;
import com.izouma.awesomeadmin.util.PushUtil;
import org.apache.commons.collections.CollectionUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.izouma.awesomeadmin.constant.AppConstant;
import com.izouma.awesomeadmin.dto.Page;
import com.izouma.awesomeadmin.dao.HouseInfoMapper;

/**
 * service接口实现类
 */
@Service
public class HouseInfoServiceImpl implements HouseInfoService {

    private static Logger logger = Logger.getLogger(HouseInfoServiceImpl.class);

    @Autowired
    private HouseInfoMapper          houseInfoMapper;
    @Autowired
    private CompetitionSeasonMapper  competitionSeasonMapper;
    @Autowired
    private UserInfoService          userInfoService;
    @Autowired
    private MemberCoinService        memberCoinService;
    @Autowired
    private PlayerInfoService        playerInfoService;
    @Autowired
    private SystemNoticeService      systemNoticeService;
    @Autowired
    private BonusRecordService       bonusRecordService;
    @Autowired
    private CompetitionService       competitionService;
    @Autowired
    private ParticipatingInfoService participatingInfoService;

    @Override
    public List<HouseInfo> getHouseInfoList(HouseInfo record) {

        logger.info("getHouseInfoList");
        try {

            return houseInfoMapper.queryAllHouseInfo(record);
        } catch (Exception e) {
            logger.error("getHouseInfoList", e);
        }

        return null;
    }

    @Override
    public List<HouseInfo> getHouseInfoByPage(Page page, HouseInfo record) {

        logger.info("getHouseInfoByPage");
        try {

            Map<String, Object> parameter = new HashMap<String, Object>();
            parameter.put("record", record);
            parameter.put(AppConstant.PAGE, page);

            return houseInfoMapper.queryHouseInfoByPage(parameter);
        } catch (Exception e) {
            logger.error("getHouseInfoByPage", e);
        }

        return null;
    }

    @Override
    public HouseInfo getHouseInfoById(String id) {

        logger.info("getHouseInfoyId");
        try {

            return houseInfoMapper.selectByPrimaryKey(Integer.valueOf(id));
        } catch (Exception e) {
            logger.error("getHouseInfoById", e);
        }

        return null;
    }

    @Override
    public HouseInfo getHouseInfoPlayerNum(String id) {

        logger.info("getHouseInfoPlayerNum");
        try {

            return houseInfoMapper.getHouseInfoPlayerNum(Integer.valueOf(id));
        } catch (Exception e) {
            logger.error("getHouseInfoPlayerNum", e);
        }

        return null;
    }

    @Override
    public HouseInfo getHouseInfo(HouseInfo record) {

        logger.info("getHouseInfo");
        try {

            return houseInfoMapper.queryHouseInfo(record);
        } catch (Exception e) {
            logger.error("getHouseInfo", e);
        }

        return null;
    }

    @Override
    public boolean createHouseInfo(HouseInfo record) {

        logger.info("createHouseInfo");
        try {
            record.setHouseCode(MbappUtil.getCodeByUUId());

            CompetitionSeason competitionSeason = new CompetitionSeason();
            competitionSeason.setGameId(record.getGameId());
            competitionSeason.setStatusFlag(AppConstant.SeasonStatus.START);
            competitionSeason = competitionSeasonMapper.queryCompetitionSeason(competitionSeason);
            if (competitionSeason != null) {
                record.setSeasonId(competitionSeason.getId());
            }

            int updates = houseInfoMapper.insertSelective(record);

            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("createHouseInfo", e);
        }

        return false;
    }

    @Override
    public boolean deleteHouseInfo(HouseInfo record) {

        logger.info("deleteHouseInfo");
        try {

            int updates = houseInfoMapper.delete(record);

            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("deleteHouseInfo", e);
        }

        return false;
    }

    @Override
    public boolean updateHouseInfo(HouseInfo record) {

        logger.info("updateHouseInfo");
        try {

            int updates = houseInfoMapper.updateByPrimaryKeySelective(record);

            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("updateHouseInfo", e);
        }

        return false;
    }

    /**
     * 房间比赛结果结算。
     *
     * @param record
     * @return
     */
    @Override
    public boolean settlementHouse(HouseInfo record) {
        logger.info("settlementHouse");
        try {
            HouseInfo houseInfo = new HouseInfo();
            houseInfo.setId(record.getId());
            houseInfo = houseInfoMapper.queryHouseInfo(houseInfo);

            if (houseInfo == null || !houseInfo.getStatusFlag().equals(AppConstant.HouseStatus.ANALYSIS)) {
                //只有结束比赛的才能结算
                return false;
            }

            List<PlayerInfo> playerInfos = playerInfoService.getHouseRank(record.getId());
            if (CollectionUtils.isEmpty(playerInfos)) {
                return false;
            }

            // Competition competition = competitionService.getCompetitionById(record.getCompetitionId().toString());

            for (PlayerInfo playerInfo : playerInfos) {
                double rankRate = playerInfo.getRank() * 100 / (double) playerInfos.size();
                double points = 0;
                if (playerInfo.getRank() == 1) {
                    points = 40;
                } else if (rankRate <= 10) {
                    points = 20;
                } else if (rankRate <= 20) {
                    points = 10;
                } else if (rankRate <= 30) {
                    points = 0;
                } else {
                    points = -10;
                }
                if (playerInfo.getRanking() != null && playerInfo.getRanking() == 1) {
                    points += 10;
                }
                playerInfo.setPoints(new BigDecimal(points));
                playerInfo.setHouseRank(playerInfo.getRank());

                String content = "你在" + DateTimeTool.dateTimeToTimeYYYYHHmmStr(houseInfo.getBeginTime())
                        + "开始的比赛\"" + houseInfo.getHouseName() + "\"中获得了第" + playerInfo.getHouseRank()
                        + "名，" + (points >= 0 ? "获得" : "扣除") + points + "积分。";
                SystemNotice systemNotice = new SystemNotice();
                systemNotice.setGameId(playerInfo.getGameId());
                systemNotice.setHouseId(playerInfo.getHouseId());
                systemNotice.setUserId(playerInfo.getUserId());
                systemNotice.setSeasonId(playerInfo.getSeasonId());
                systemNotice.setPlayerId(playerInfo.getId());
                systemNotice.setRemark("定时任务");

                systemNotice.setContent(content);
                systemNotice.setTypeFlag(AppConstant.NoticeType.RESULT);

                systemNoticeService.createSystemNotice(systemNotice);

                //推送
                try {
                    UserInfo userInfo = new UserInfo();
                    userInfo.setId(playerInfo.getUserId());
                    userInfo = userInfoService.getSingleUserInfo(userInfo);
                    if (userInfo != null) {
                        if ("Y".equals(userInfo.getNoticeFlag())) {
                            PushUtil.pushMsg(userInfo.getId().toString(), content);
                        }
                    }
                } catch (Exception e) {
                    logger.error("结算推送消息异常。", e);
                }

                if (AppConstant.PlayerStatus.PROCESSED == playerInfo.getStatusFlag()) {//如果正常结束的则更新状态
                    playerInfo.setStatusFlag(AppConstant.PlayerStatus.SETTLEMENT);

                }
                playerInfoService.updatePlayerInfo(playerInfo);
            }

            //更新为结算完成状态。
            houseInfo.setStatusFlag(AppConstant.HouseStatus.SETTLEMENT);
            houseInfoMapper.updateByPrimaryKeySelective(houseInfo);
        } catch (Exception e) {
            logger.error(e);
        }
        return false;
    }

    public boolean settlementHouse_bak(HouseInfo record) {

        logger.info("settlementHouse");
        try {

            HouseInfo houseInfo = new HouseInfo();
            houseInfo.setId(record.getId());
            houseInfo = houseInfoMapper.queryHouseInfo(houseInfo);

            if (houseInfo == null || !houseInfo.getStatusFlag().equals(AppConstant.HouseStatus.ANALYSIS)) {
                //只有结束比赛的才能结算
                return false;
            }

            HouseLevel houseLevel = houseInfo.getHouseLevelInfo();

            BigDecimal firstRatio = houseLevel.getFirstRatio();
            BigDecimal secondRatio = houseLevel.getSecondRatio();
            BigDecimal thirdRatio = houseLevel.getThirdRatio();
            BigDecimal poolRatio = houseLevel.getPoolRatio();
            BigDecimal avgRatio = houseLevel.getAvgRatio();

            int winNum = 0;//吃鸡人数

            PlayerInfo param = new PlayerInfo();
            if (houseInfo.getScoreType() > 0) {
                param.setScoreType(1);
            }
            param.setHouseId(record.getId());

            List<PlayerInfo> playerInfoList = playerInfoService.getSettlementPlayer(param);

            if (CollectionUtils.isNotEmpty(playerInfoList)) {

                if (houseInfo.getScoreType() > 0) {//如果是平分模式，获取吃鸡人数。
                    param.setRanking(1);
                    List<PlayerInfo> winList = playerInfoService.getSettlementPlayer(param);
                    winNum = winList.size();
                }

                for (int i = 0; i < playerInfoList.size(); i++) {
                    PlayerInfo playerInfo = playerInfoList.get(i);
                    playerInfo.setHouseRank(i + 1);
                    BigDecimal bonus = BigDecimal.ZERO;
                    String content = "";
                    int typeFlag = AppConstant.NoticeType.RECEIVE;

                    if (AppConstant.PlayerStatus.PROCESSED_FAIL == playerInfo.getStatusFlag()) {

                        content = "很遗憾，你在" + DateTimeTool.dateTimeToTimeYYYYHHmmStr(houseInfo.getBeginTime())
                                + "开始的游戏竞赛 " + houseInfo.getHouseName()
                                + "，未解析到结果，无法获得奖励。";
                        typeFlag = AppConstant.NoticeType.RESULT;
                    } else if (AppConstant.PlayerStatus.OVERTIME == playerInfo.getStatusFlag()) {
                        content = "很遗憾，你在" + DateTimeTool.dateTimeToTimeYYYYHHmmStr(houseInfo.getBeginTime())
                                + "开始的游戏竞赛 " + houseInfo.getHouseName()
                                + "，比赛超时，无法获得奖励。";
                        typeFlag = AppConstant.NoticeType.RESULT;
                    } else {
                        if (houseInfo.getScoreType() == 0) {//吃鸡模式
                            if (playerInfo.getRanking() != null && 1 == playerInfo.getRanking()) {//只有吃鸡才能获得奖励

                                if (i == 0) {//第一名
                                    bonus = BigDecimal.valueOf((firstRatio.doubleValue() / 100) * houseInfo.getBonus().doubleValue());


                                }
                                if (i == 1) {//第二名
                                    bonus = BigDecimal.valueOf((secondRatio.doubleValue() / 100) * houseInfo.getBonus().doubleValue());
                                }
                                if (i == 2) {//第三名
                                    bonus = BigDecimal.valueOf((thirdRatio.doubleValue() / 100) * houseInfo.getBonus().doubleValue());
                                }

                                content = "恭喜你，在" + DateTimeTool.dateTimeToTimeYYYYHHmmStr(houseInfo.getBeginTime())
                                        + "开始的游戏竞赛 " + houseInfo.getHouseName() + "（吃鸡模式）获得了第" + playerInfo.getHouseRank()
                                        + "名，获得" + bonus + "积分，赶快领取你的奖励吧。";
                            } else {

                                content = "很遗憾，在" + DateTimeTool.dateTimeToTimeYYYYHHmmStr(houseInfo.getBeginTime())
                                        + "开始的游戏竞赛 " + houseInfo.getHouseName() + "（吃鸡模式）获得了第" + playerInfo.getHouseRank()
                                        + "名，但未能吃鸡,因此无法获得奖励。";
                                typeFlag = AppConstant.NoticeType.RESULT;
                            }
                        } else {
                            if (playerInfo.getRanking() != null && 1 == playerInfo.getRanking()) {//只有评分大于0才能获得奖励

                                if (winNum > 0) {//吃鸡人数大于0
                                    bonus = BigDecimal.valueOf(((avgRatio.doubleValue() / 100) * houseInfo.getBonus().doubleValue()) / winNum);
                                }

                                content = "恭喜你，在" + DateTimeTool.dateTimeToTimeYYYYHHmmStr(houseInfo.getBeginTime())
                                        + "开始的游戏竞赛 " + houseInfo.getHouseName() + "（平分模式）获得了第" + playerInfo.getHouseRank()
                                        + "名，获得" + bonus + "积分，赶快领取你的奖励吧。";
                            } else {
                                content = "很遗憾，在" + DateTimeTool.dateTimeToTimeYYYYHHmmStr(houseInfo.getBeginTime())
                                        + "开始的游戏竞赛 " + houseInfo.getHouseName() + "（平分模式）获得了第" + playerInfo.getHouseRank()
                                        + "名，但未吃鸡,因此无法获得奖励。";
                                typeFlag = AppConstant.NoticeType.RESULT;
                            }
                        }
                    }

                    //todo: 这里临时改成了积分
                    playerInfo.setPoints(bonus);

                    SystemNotice systemNotice = new SystemNotice();
                    systemNotice.setGameId(playerInfo.getGameId());
                    systemNotice.setHouseId(playerInfo.getHouseId());
                    systemNotice.setUserId(playerInfo.getUserId());
                    systemNotice.setSeasonId(playerInfo.getSeasonId());
                    systemNotice.setPlayerId(playerInfo.getId());
                    systemNotice.setRemark("定时任务");

                    systemNotice.setContent(content);
                    systemNotice.setTypeFlag(typeFlag);

                    systemNoticeService.createSystemNotice(systemNotice);

                    //推送
                    try {
                        UserInfo userInfo = new UserInfo();
                        userInfo.setId(playerInfo.getUserId());
                        userInfo = userInfoService.getSingleUserInfo(userInfo);
                        if (userInfo != null) {
                            if ("Y".equals(userInfo.getNoticeFlag())) {
                                String[] ids = new String[]{userInfo.getId().toString()};

                                PushUtil.pushMsg(ids, content);
                            }
                        }

                    } catch (Exception e) {
                        logger.error("结算推送消息异常。", e);
                    }

                    if (AppConstant.PlayerStatus.PROCESSED == playerInfo.getStatusFlag()) {//如果正常结束的则更新状态
                        playerInfo.setStatusFlag(AppConstant.PlayerStatus.SETTLEMENT);

                    }
                    playerInfoService.updatePlayerInfo(playerInfo);

                }
            }

            if (poolRatio.doubleValue() > 0) {
                //加入到赛季奖金池中
                try {

                    BigDecimal pool = BigDecimal.valueOf((poolRatio.doubleValue() / 100) * houseInfo.getBonus().doubleValue());

                    CompetitionSeason competitionSeason = competitionSeasonMapper.selectByPrimaryKey(houseInfo.getSeasonId());

                    if (competitionSeason != null) {


                        double balance = competitionSeason.getBonus().doubleValue();
                        double moneyCoin = balance + pool.doubleValue();

                        BonusRecord bonusRecord = new BonusRecord();
                        bonusRecord.setMoney(pool);
                        bonusRecord.setBonus(BigDecimal.valueOf(moneyCoin));
                        bonusRecord.setSeasonId(houseInfo.getSeasonId());
                        bonusRecord.setGameId(houseInfo.getGameId());
                        //todo: 这里临时改成了比赛id
                        bonusRecord.setCompetitionId(houseInfo.getId());
                        bonusRecord.setTypeFlag(0);
                        bonusRecord.setRemark(houseInfo.getHouseName() + "比赛结算，" + pool.doubleValue() + " 积分");
                        bonusRecordService.createBonusRecord(bonusRecord);

                        CompetitionSeason addBonus = new CompetitionSeason();
                        addBonus.setId(competitionSeason.getId());
                        addBonus.setBonus(pool);

                        competitionSeasonMapper.addBonus(addBonus);


                    }

                } catch (Exception e) {
                    logger.error("赛季奖金池添加奖金异常！", e);
                }
            }

            //更新为结算完成状态。
            houseInfo.setStatusFlag(AppConstant.HouseStatus.SETTLEMENT);
            houseInfoMapper.updateByPrimaryKeySelective(houseInfo);

            return true;
        } catch (Exception e) {
            logger.error("settlementHouse", e);
        }
        return false;
    }

    /**
     * 加入房间
     *
     * @param record
     * @return
     */
    @Override
    public Result joinHouseInfo(PlayerInfo record) {

        logger.info("joinHouseInfo");
        try {

            if (record.getUserId() == null) {
                return new Result(false, "加入失败，用户不存在！");
            }

            if (record.getHouseId() == null) {
                return new Result(false, "加入失败，房间不存在！");
            }

            UserInfo userInfo = new UserInfo();
            userInfo.setId(record.getUserId());
            userInfo = userInfoService.getSingleUserInfo(userInfo);

            if (userInfo == null) {
                return new Result(false, "加入失败，用户不存在！");
            }

            HouseInfo houseInfo = new HouseInfo();
            houseInfo.setId(record.getHouseId());
            houseInfo = houseInfoMapper.queryHouseInfo(houseInfo);
            if (houseInfo == null) {
                return new Result(false, "加入失败，房间不存在！");
            }

            if (houseInfo.getStatusFlag() > AppConstant.HouseStatus.READY) {

                return new Result(false, "加入失败，游戏已开始！");
            }

            //检查是否重复加入
            PlayerInfo playerInfo = playerInfoService.getPlayerInfo(record);
            if (playerInfo != null) {
                return new Result(false, "加入失败，不能重复加入");
            }

            //todo: 检查剩余次数

            //todo: 使用道具

            double entryCoin = 0;
            double moneyCoin = userInfo.getMoneyCoin();


            record.setGameId(houseInfo.getGameId());
            record.setHouseId(houseInfo.getId());
            record.setJoinTime(new Date());
            record.setPrincipal(BigDecimal.valueOf(entryCoin));
            record.setSeasonId(houseInfo.getSeasonId());
            record.setCompetitionId(houseInfo.getCompetitionId());

            playerInfoService.createPlayerInfo(record);

            // 只能用余额支付

            MemberCoin memberCoin = new MemberCoin();
            memberCoin.setCreateUser("系统");
            memberCoin.setHouseId(houseInfo.getId());
            memberCoin.setUserId(userInfo.getId());
            memberCoin.setGameId(houseInfo.getGameId());
            memberCoin.setSeasonId(houseInfo.getSeasonId());
            memberCoin.setPlayerId(record.getId());

            memberCoin.setMoney(BigDecimal.valueOf(-entryCoin));
            memberCoin.setBalance(BigDecimal.valueOf(moneyCoin - entryCoin));
            memberCoin.setTypeFlag(AppConstant.CoinType.CONSUMPTION);
            memberCoin.setRemark("加入房间：" + houseInfo.getHouseCode());
            memberCoinService.createMemberCoin(memberCoin);


            UserInfo updateUser = new UserInfo();
            updateUser.setId(userInfo.getId());
            updateUser.setMoneyCoin(moneyCoin - entryCoin);
            userInfoService.updateUserInfo(updateUser);


            HouseInfo joinHouseInfo = new HouseInfo();
            joinHouseInfo.setId(houseInfo.getId());
            joinHouseInfo.setPlayerNumber(1);
            joinHouseInfo.setBonus(BigDecimal.valueOf(entryCoin));

            houseInfoMapper.joinHouseInfo(joinHouseInfo);


            // 创建联赛参赛信息
            ParticipatingInfo participatingInfo = participatingInfoService.participate(record.getUserId(), houseInfo.getCompetitionId());

            return new Result(true, "加入成功");


        } catch (Exception e) {
            logger.error("joinHouseInfo", e);
        }

        return new Result(false, "加入失败");
    }

    @Override
    public Result autoBegin(HouseInfo record) {

        logger.info("autoBegin");
        try {

            List<HouseInfo> houseInfoList = houseInfoMapper.autoBeginHouseInfo(record);

            for (HouseInfo houseInfo : houseInfoList) {

                houseInfo.setStatusFlag(AppConstant.HouseStatus.START);
                houseInfo.setBeginTime(new Date());
                houseInfoMapper.updateByPrimaryKeySelective(houseInfo);
            }

            return new Result(true, "开始成功");


        } catch (Exception e) {
            logger.error("autoBegin", e);
        }

        return new Result(false, "开始失败");
    }

    @Override
    public Result handBegin(HouseInfo record) {

        logger.info("handBegin");
        try {

            HouseInfo houseInfo = houseInfoMapper.queryHouseInfo(record);
            if (houseInfo != null) {
                if (AppConstant.HouseStatus.START > houseInfo.getStatusFlag()) {//房间为未开始状态


                    houseInfo.setStatusFlag(AppConstant.HouseStatus.START);
                    houseInfo.setBeginTime(new Date());
                    houseInfoMapper.updateByPrimaryKeySelective(houseInfo);

                    return new Result(true, "开始成功");
                }
            }

        } catch (Exception e) {
            logger.error("handBegin", e);
        }

        return new Result(false, "开始失败");
    }

    @Override
    public Result autoEnd(HouseInfo record) {

        logger.info("autoEnd");
        try {

            List<HouseInfo> houseInfoList = houseInfoMapper.autoEndHouseInfo(record);

            for (HouseInfo houseInfo : houseInfoList) {

                houseInfo.setStatusFlag(AppConstant.HouseStatus.END);
                houseInfo.setEndTime(new Date());
                houseInfoMapper.updateByPrimaryKeySelective(houseInfo);

                //更新比赛超时的
                PlayerInfo playerInfo = new PlayerInfo();
                playerInfo.setHouseId(houseInfo.getId());
                playerInfoService.overTimePlayer(playerInfo);

                //settlementHouse(houseInfo);//比赛结果结算。
            }

            return new Result(true, "结束成功");


        } catch (Exception e) {
            logger.error("autoEnd", e);
        }

        return new Result(false, "结束失败");
    }


    /**
     * 自动结算
     *
     * @param record
     * @return
     */
    @Override
    public Result autoSettlement(HouseInfo record) {

        logger.info("autoSettlement");
        try {

            record.setStatusFlag(AppConstant.HouseStatus.ANALYSIS);//获取解析完成带结算的房间。
            List<HouseInfo> houseInfoList = houseInfoMapper.queryAllHouseInfo(record);

            for (HouseInfo houseInfo : houseInfoList) {
                settlementHouse(houseInfo);//比赛结果结算。
            }
            return new Result(true, "结束成功");
        } catch (Exception e) {
            logger.error("autoSettlement", e);
        }
        return new Result(false, "结束失败");
    }

    @Override
    public Result updateToAnalysis(HouseInfo record) {

        logger.info("updateToAnalysis");
        try {

            int updates = houseInfoMapper.updateToAnalysis(record);

            if (updates > 0) {

                return new Result(true, "更新成功");
            }


        } catch (Exception e) {
            logger.error("updateToAnalysis", e);
        }

        return new Result(false, "更新失败");
    }

    @Override
    public Result handEnd(HouseInfo record) {

        logger.info("handEnd");
        try {

            HouseInfo houseInfo = houseInfoMapper.queryHouseInfo(record);
            if (houseInfo != null) {
                if (AppConstant.HouseStatus.START == houseInfo.getStatusFlag()) {//房间为开始状态

                    houseInfo.setStatusFlag(AppConstant.HouseStatus.END);
                    houseInfo.setEndTime(new Date());
                    houseInfoMapper.updateByPrimaryKeySelective(houseInfo);

                    //更新比赛超时的
                    PlayerInfo playerInfo = new PlayerInfo();
                    playerInfo.setHouseId(houseInfo.getId());
                    playerInfoService.overTimePlayer(playerInfo);

                    //settlementHouse(houseInfo);//比赛结果结算。

                    return new Result(true, "结束成功");
                }
            }


        } catch (Exception e) {
            logger.error("handEnd", e);
        }

        return new Result(false, "结束失败");
    }


    @Override
    public Result autoNoStartPlay(HouseInfo record) {

        logger.info("autoNoStartPlay");
        try {

            List<PlayerInfo> playerInfoList = playerInfoService.getNoStartPlayer(record);

            for (PlayerInfo playerInfo : playerInfoList) {

                playerInfo.setStatusFlag(AppConstant.PlayerStatus.NO_MATCH);
                playerInfo.setExamineUser("系统定时任务");
                playerInfo.setExamineTime(new Date());
                playerInfo.setExamineType(AppConstant.ExamineType.NO_MATCH);

                playerInfoService.updatePlayerInfo(playerInfo);

                SystemNotice systemNotice = new SystemNotice();
                systemNotice.setGameId(playerInfo.getGameId());
                systemNotice.setHouseId(playerInfo.getHouseId());
                systemNotice.setUserId(playerInfo.getUserId());
                systemNotice.setSeasonId(playerInfo.getSeasonId());
                systemNotice.setPlayerId(playerInfo.getId());
                systemNotice.setRemark("定时任务");
                systemNotice.setContent("房间比赛开始未按规定时间开始游戏，未参赛！");
                systemNotice.setTypeFlag(AppConstant.NoticeType.NO_MATCH);

                systemNoticeService.createSystemNotice(systemNotice);

                //推送
                try {
                    UserInfo userInfo = new UserInfo();
                    userInfo.setId(playerInfo.getUserId());
                    userInfo = userInfoService.getSingleUserInfo(userInfo);
                    if (userInfo != null) {
                        if ("Y".equals(userInfo.getNoticeFlag())) {
                            String[] ids = new String[]{userInfo.getId().toString()};

                            PushUtil.pushMsg(ids, "房间比赛开始未按规定时间开始游戏，未参赛！");
                        }

                    }


                } catch (Exception e) {
                    logger.error("推送消息异常。", e);
                }

            }

            return new Result(true, "开始成功");


        } catch (Exception e) {
            logger.error("autoNoStartPlay", e);
        }

        return new Result(false, "开始失败");
    }
}