shouyoudianjing/src/main/java/com/izouma/awesomeadmin/service/impl/HouseInfoServiceImpl.java

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 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;

    @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) {

                if (houseInfo.getStatusFlag() == AppConstant.HouseStatus.END) {//只有结束比赛的才能结束

                    HouseLevel houseLevel = houseInfo.getHouseLevelInfo();

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


                    PlayerInfo param = new PlayerInfo();
                    param.setHouseId(record.getId());
                    List<PlayerInfo> playerInfoList = playerInfoService.getSettlementPlayer(param);

                    if (CollectionUtils.isNotEmpty(playerInfoList)) {
                        for (int i = 0; i < playerInfoList.size(); i++) {
                            PlayerInfo playerInfo = playerInfoList.get(i);
                            playerInfo.setHouseRank(i + 1);
                            BigDecimal bonus = BigDecimal.ZERO;
                            if (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());
                                }
                            }
                            playerInfo.setBonus(bonus);

                            if (AppConstant.PlayerStatus.END == playerInfo.getStatusFlag()) {//如果是正常结束的则更新为结束完成
                                playerInfo.setStatusFlag(AppConstant.PlayerStatus.SETTLEMENT);

                                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("定时任务");
                                String content = "恭喜你，在" + DateTimeTool.dateTimeToTimeYYYYHHmmStr(houseInfo.getBeginTime())
                                        + "开始的游戏竞赛 " + houseInfo.getHouseName() + "获得了第" + playerInfo.getHouseRank()
                                        + "名，赶快领取你的奖励吧。";
                                systemNotice.setContent(content);
                                systemNotice.setTypeFlag(AppConstant.NoticeType.RESULT);

                                systemNoticeService.createSystemNotice(systemNotice);
                            }

                            playerInfoService.updatePlayerInfo(playerInfo);


                        }
                    }

                    if (poolRatio.doubleValue() > 0) {
                        BigDecimal pool = BigDecimal.valueOf((poolRatio.doubleValue() / 100) * houseInfo.getBonus().doubleValue());

                        //TODO 加入到赛季奖金池中
                    }

                    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, "加入失败，不能重复加入");
            }

            double entryCoin = 50;

            HouseLevel houseLevel = houseInfo.getHouseLevelInfo();
            if (houseLevel != null) {
                entryCoin = houseLevel.getEntryCoin().doubleValue();
            }

            /**
             * 余额
             */
            double moneyCoin = userInfo.getMoneyCoin();

            if (entryCoin > moneyCoin) {
                return new Result(false, "加入失败，余额不足");
            }


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

            playerInfoService.createPlayerInfo(record);

            // 只能用余额支付
            if (entryCoin > 0) {

                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);

            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, "结束失败");
    }

    @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);


            }

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


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

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