package com.ruoyi.system.controller;

import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.service.*;
import io.swagger.models.auth.In;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.beans.Transient;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author Losino
 * @version 1.0
 */
@RestController
@RequestMapping("/MHD")
public class MHDController {

    @Resource
    private ISysXPoolService poolService;

    @Resource
    private ISysXPrizesService prizesService;

    @Resource
    private ISysXProbabilitiesService probabilitiesService;

    @Resource
    private IDbUsersService usersService;

    @Resource
    private ISysXPoolCountService countService;

    @Resource
    private ISysXPrizesPackageService packageService;

    /**
     * 返回用户中奖背包
     * @param steamId
     * @return
     */
    @RequestMapping("/getPackage")
    public R getPackage(@RequestParam(name = "steamId", required = false) String steamId) {
        List<SysXPrizesPackage> packages = packageService.selectSysXPrizesPackageList(new SysXPrizesPackage()).stream().filter(res -> res.getSteamId().equals(steamId)).collect(Collectors.toList());

        return R.ok(packages);
    }

    /**
     * 抽奖
     *
     * @param steamId
     * @param poolId
     * @return
     */
    @RequestMapping("/startPrize")
    @Transient
    public R startPrize(@RequestParam(name = "steamId", required = false) String steamId,
                        @RequestParam(name = "id", required = false) Long poolId) {
        // 获取抽奖次数
        List<SysXPoolCount> poolCountList = countService.selectSysXPoolCountList(new SysXPoolCount()).stream().filter(res -> res.getSteamId().equals(steamId)).filter(res -> res.getPoolId().equals(poolId)).collect(Collectors.toList());
        SysXPoolCount poolCount = null;
        if (poolCountList.size() > 0) {
            poolCount = poolCountList.get(0);
        }

        if (poolCount == null || !(poolCount.getCount() > 0)) {
            return R.fail("后端校验抽奖次数不足，请重试");
        }

        // 获取卡池id对应概率
        List<SysXProbabilities> filterProbabilitiesList = probabilitiesService
                .selectSysXProbabilitiesList(new SysXProbabilities()).stream()
                .filter(res -> res.getPoolId().equals(poolId)).collect(Collectors.toList());

        // 获取获取卡池id对应奖池
        List<SysXPrizes> prizeList = prizesService.selectSysXPrizesList(new SysXPrizes()).stream()
                .filter(res -> res.getPoolId().equals(poolId)).collect(Collectors.toList());

        // 计算每个级别的概率和奖品数量
        Map<String, Integer> levelPrizeCountMap = prizeList.stream()
                .collect(Collectors.toMap(SysXPrizes::getQuality, prize -> 1, Integer::sum, LinkedHashMap::new));

        // 过滤掉无奖品的级别，并计算每个级别的概率
        Map<String, Long> levelProbabilityMap = new LinkedHashMap<>();
        for (SysXProbabilities probabilities : filterProbabilitiesList) {
            if (levelPrizeCountMap.containsKey(probabilities.getName())) {
                levelProbabilityMap.put(probabilities.getName(),
                        levelProbabilityMap.getOrDefault(probabilities.getName(), 0L) + probabilities.getValue());
            }
        }

        // 根据级别概率和奖品数量进行抽奖
        SysXPrizes drawnPrize = null;
        Random rand = new Random();
        List<String> levelList = new ArrayList<>();
        for (Map.Entry<String, Long> entry : levelProbabilityMap.entrySet()) {
            for (int i = 0; i < entry.getValue(); i++) {
                levelList.add(entry.getKey());
            }
        }
        Collections.shuffle(levelList);
        String selectedLevel = levelList.get(rand.nextInt(levelList.size()));
        // 根据级别随机选择一个奖品
        List<SysXPrizes> levelPrizes = prizeList.stream()
                .filter(prize -> prize.getQuality().equals(selectedLevel))
                .collect(Collectors.toList());
        if (!levelPrizes.isEmpty()) {
            drawnPrize = levelPrizes.get(rand.nextInt(levelPrizes.size()));
        }

        if (drawnPrize != null) {
            // 存入背包
            SysXPrizesPackage prizesPackage = new SysXPrizesPackage();

            // 获取用户信息
            DbUsers user = usersService.selectDbUsersBySteamID(steamId);
            // 获取卡池信息
            SysXPool pool = poolService.selectSysXPoolById(poolId);

            prizesPackage.setSteamId(steamId);
            prizesPackage.setZhanghao(user.getZhanghao());
            prizesPackage.setSteamName(user.getSteamName());
            prizesPackage.setPoolId(poolId);
            prizesPackage.setPoolName(pool.getTitle());
            prizesPackage.setPrizeId(drawnPrize.getId() + "");
            prizesPackage.setPrizeName(drawnPrize.getName());
            prizesPackage.setQuality(drawnPrize.getQuality());
            prizesPackage.setCreateTime(new Date());
            prizesPackage.setIsCheck(0L);

            int pageRow = packageService.insertSysXPrizesPackage(prizesPackage);

            // 抽中奖品后，减少一次该用户对应卡池的抽奖次数
            if (pageRow > 0) {
                poolCount.setCount(poolCount.getCount() - 1);
                countService.updateSysXPoolCount(poolCount);
            }


            return R.ok(drawnPrize);
        }
        else {
            return R.fail("未抽中任何奖品");
        }
    }

    @RequestMapping("/login")
    public R login(@RequestParam String username,
                   @RequestParam String password) {
        List<DbUsers> users = usersService.selectDbUsersList(new DbUsers());

        for (DbUsers user : users) {
            String zhanghao = user.getZhanghao();
            String mima = user.getMima();

            if (zhanghao == null || mima == null) {
                continue;
            }

            if (zhanghao.equals(username)) {
                if (mima.equals(password)) {
                    return R.ok(user);
                }
                else {
                    return R.fail("密码错误");
                }
            }
        }

        return R.fail("账号不存在");
    }

    /**
     * 返回整理好卡池的结构
     */
    @RequestMapping("/list")
    public R<List<MHDPool>> list(@RequestParam(value = "steamId", required = false) String steamId) {
        List<SysXPool> sysXPools = poolService.selectSysXPoolList(new SysXPool());

        List<SysXPrizes> sysXPrizes = prizesService.selectSysXPrizesList(new SysXPrizes());

        List<SysXProbabilities> sysXProbabilities = probabilitiesService
                .selectSysXProbabilitiesList(new SysXProbabilities());

        List<MHDPool> mhdPools = new ArrayList<>();

        // 将sysXPool的属性直接覆盖到mhdPool
        for (SysXPool sysXPool : sysXPools) {
            Long poolId = sysXPool.getId();

            // 筛选奖池
            List<SysXPrizes> filterSysXPrizes = sysXPrizes.stream().filter(res -> res.getPoolId().equals(poolId))
                    .sorted((a, b) -> {
                        String[] order = {"史诗", "稀有", "精良", "普通"};
                        return order.length - 1 - order.length + Arrays.asList(order).indexOf(a.getQuality())
                                - Arrays.asList(order).indexOf(b.getQuality());
                    }).collect(Collectors.toList());

            // 筛选概率
            List<SysXProbabilities> filterSysXProbabilities = sysXProbabilities.stream()
                    .filter(res -> res.getPoolId().equals(poolId)).collect(Collectors.toList());

            MHDPool mhdPool = new MHDPool();
            mhdPool.setId(poolId);
            mhdPool.setTitle(sysXPool.getTitle());
            mhdPool.setPrice(sysXPool.getPrice());
            mhdPool.setDescription(sysXPool.getDescription());
            mhdPool.setBorderColor(sysXPool.getBorderColor());
            mhdPool.setBgColor(sysXPool.getBgColor());
            mhdPool.setTextColor(sysXPool.getTextColor());
            mhdPool.setFullDescription(sysXPool.getFullDescription());
            mhdPool.setPrizes(filterSysXPrizes);
            mhdPool.setProbabilities(filterSysXProbabilities);
            mhdPool.setPoolCount(sysXPool.getCount());
            mhdPool.setCount(0L);

            // 加入用户剩余抽奖次数
            if (steamId != null) {
                List<SysXPoolCount> countList = countService.selectSysXPoolCountList(new SysXPoolCount())
                        .stream()
                        .filter(res -> res.getSteamId().equals(steamId))
                        .filter(res -> res.getPoolId().equals(poolId))
                        .collect(Collectors.toList());
                if (countList.size() > 0) {
                    mhdPool.setCount(countList.get(0).getCount());
                }

            }

            mhdPools.add(mhdPool);
        }

        return R.ok(mhdPools);
    }

}