package com.punchsettle.server.service.manager.impl;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

import com.punchsettle.server.atomic.entity.Account;
import com.punchsettle.server.atomic.entity.Reward;
import com.punchsettle.server.atomic.entity.RewardExchangeHistory;
import com.punchsettle.server.atomic.entity.User;
import com.punchsettle.server.atomic.service.IAccountService;
import com.punchsettle.server.atomic.service.IRewardExchangeHistoryService;
import com.punchsettle.server.atomic.service.IUserService;
import com.punchsettle.server.common.constant.CommonEnableStatusEnum;
import com.punchsettle.server.common.exception.BusinessException;
import com.punchsettle.server.common.utils.Assert;
import com.punchsettle.server.constant.RewardExchangeMethodEnum;
import com.punchsettle.server.constant.VersionStatusEnum;
import com.punchsettle.server.pojo.reward.RewardExchangeRequest;
import com.punchsettle.server.pojo.reward.RewardQuery;
import com.punchsettle.server.pojo.reward.RewardRequest;
import com.punchsettle.server.utiis.UserUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;

import com.punchsettle.server.atomic.service.IRewardService;
import com.punchsettle.server.pojo.reward.RewardVO;
import com.punchsettle.server.service.manager.IRewardManager;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

/**
 * @author tyuio
 * @version 1.0.0
 * @description 奖励 服务类
 * @date 2024/11/25 20:59
 */
@Service
public class RewardManagerImpl implements IRewardManager {

    @Autowired
    private IRewardService rewardService;

    @Autowired
    private IAccountService accountService;

    @Autowired
    private IRewardExchangeHistoryService rewardExchangeHistoryService;

    @Autowired
    private IUserService userService;

    @Override
    public List<RewardVO> queryRewardList() {
        // 查询奖励列表
        RewardQuery rewardQuery = new RewardQuery();
        rewardQuery.setUserId(UserUtils.getCurrentUserId());
        rewardQuery.setRewardStatus(VersionStatusEnum.ACTIVE);
        List<Reward> rewards = rewardService.queryByCondition(rewardQuery);

        if (CollectionUtils.isEmpty(rewards)) {
            return List.of();
        }

        return rewards.stream().map(reward -> {
            RewardVO rewardVO = new RewardVO();
            BeanUtils.copyProperties(reward, rewardVO);
            return rewardVO;
        }).toList();
    }

    @Override
    public RewardVO queryReward(Long id) {
        Assert.isNullInBusiness(id, "请传入奖励ID");

        Reward reward = Optional.ofNullable(rewardService.getById(id)).orElseThrow(() -> BusinessException.fail("无法查询到该奖励"));
        RewardVO rewardVO = new RewardVO();
        BeanUtils.copyProperties(reward, rewardVO);
        return rewardVO;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveReward(RewardRequest request) {
        Assert.isNullInBusiness(request, "请传入奖励信息");

        if (CommonEnableStatusEnum.ENABLED.equals(request.getAutoStatus()) && Objects.isNull(request.getAutoExchangeCount())) {
            BusinessException.throwFail("启用了自动兑换，自动兑换次数不能为空");
        }

        // 新增奖励数据
        Reward addReward = new Reward();
        BeanUtils.copyProperties(request, addReward);
        addReward.setId(null);
        addReward.setUserId(UserUtils.getCurrentUserId());
        addReward.setRewardStatus(VersionStatusEnum.ACTIVE);
        addReward.setRewardVersion(1);

        // 如果奖励已存在，则更新任务版本号、设置唯一ID、旧数据归档
        if (Objects.nonNull(request.getId())) {
            Reward oldReward = Optional.ofNullable(rewardService.getById(request.getId())).orElseThrow(() -> BusinessException.fail("无法查询到该奖励"));
            addReward.setRewardVersion(oldReward.getRewardVersion() + 1);
            addReward.setRewardUniqueId(oldReward.getRewardUniqueId());

            Reward updateReward = new Reward();
            updateReward.setId(oldReward.getId());
            updateReward.setRewardStatus(VersionStatusEnum.ARCHIVE);
            rewardService.update(updateReward);
        }

        rewardService.insert(addReward);
        if (Objects.isNull(addReward.getRewardUniqueId())) {
            Reward updateReward = new Reward();
            updateReward.setId(addReward.getId());
            updateReward.setRewardUniqueId(addReward.getId());
            rewardService.update(updateReward);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteReward(Long id) {
        Assert.isNullInBusiness(id, "请传入奖励ID");

        // 新增奖励数据
        Reward addReward = copyAndArchive(id);
        addReward.setRewardStatus(VersionStatusEnum.DELETE);
        rewardService.insert(addReward);
    }

    private Reward copyAndArchive(Long id) {
        // 获取旧数据
        Reward oldReward = Optional.ofNullable(rewardService.getById(id)).orElseThrow(() -> BusinessException.fail("无法查询到该奖励"));

        // 旧数据归档
        Reward updateReward = new Reward();
        updateReward.setId(oldReward.getId());
        updateReward.setRewardStatus(VersionStatusEnum.ARCHIVE);
        rewardService.update(updateReward);

        // 新的奖励信息
        Reward reward = new Reward();
        BeanUtils.copyProperties(oldReward, reward);
        reward.setRewardStatus(VersionStatusEnum.ACTIVE);
        reward.setRewardVersion(Optional.ofNullable(oldReward.getRewardVersion()).orElse(0) + 1);
        return reward;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void exchangeReward(RewardExchangeRequest request) {
        Assert.isNullInBusiness(request, "请传入奖励兑换信息");

        // 获取奖励信息
        Reward reward = Optional.ofNullable(rewardService.getById(request.getRewardId())).orElseThrow(() -> BusinessException.fail("无法查询到该奖励"));
        // 获取账户信息
        Account account = Optional.ofNullable(accountService.getById(request.getAccountId())).orElseThrow(() -> BusinessException.fail("无法查询到该账户"));

        // 兑换所需积分
        Integer exchangePoints = Optional.ofNullable(reward.getExchangePoints()).orElse(0);
        // 兑换所需总积分
        Integer exchangeTotalPoints = exchangePoints * request.getExchangeCount();
        // 兑换前账户中的积分
        Integer accountPointsBeforeExchange = Optional.ofNullable(account.getPoints()).orElse(0);
        if (accountPointsBeforeExchange.compareTo(exchangeTotalPoints) < 0) {
            BusinessException.throwFail("账户积分不足，无法兑换");
        }
        // 兑换后账户中的积分
        Integer accountPointsAfterExchange = accountPointsBeforeExchange - exchangeTotalPoints;

        // 获取用户信息
        User user = Optional.ofNullable(userService.getById(UserUtils.getCurrentUserId())).orElseThrow(() -> BusinessException.fail("无法查询到当前用户信息"));
        // 兑换前未使用积分
        Integer unusedPointsBeforeExchange = Optional.ofNullable(user.getUnusedPoints()).orElse(0);
        if (exchangeTotalPoints.compareTo(unusedPointsBeforeExchange) < 0) {
            BusinessException.throwFail("用户积分不足，无法兑换");
        }
        // 兑换前已使用积分
        Integer usedPointsBeforeExchange = Optional.ofNullable(user.getUsedPoints()).orElse(0);
        // 兑换后未使用积分
        Integer unusedPointsAfterExchange = unusedPointsBeforeExchange - exchangeTotalPoints;
        // 兑换后已使用积分
        Integer usedPointsAfterExchange = usedPointsBeforeExchange + exchangeTotalPoints;

        // 新增兑换记录
        RewardExchangeHistory addRewardExchangeHistory = new RewardExchangeHistory();
        addRewardExchangeHistory.setUserId(UserUtils.getCurrentUserId());
        addRewardExchangeHistory.setRewardId(reward.getId());
        addRewardExchangeHistory.setExchangeMethod(RewardExchangeMethodEnum.AUTO);
        addRewardExchangeHistory.setExchangeCount(request.getExchangeCount());
        addRewardExchangeHistory.setExchangeTotalPoints(exchangeTotalPoints);
        addRewardExchangeHistory.setAccountId(account.getId());
        addRewardExchangeHistory.setAccountPointsBeforeExchange(accountPointsBeforeExchange);
        addRewardExchangeHistory.setAccountPointsAfterExchange(accountPointsAfterExchange);
        addRewardExchangeHistory.setUnusedPointsBeforeExchange(unusedPointsBeforeExchange);
        addRewardExchangeHistory.setUnusedPointsAfterExchange(unusedPointsAfterExchange);
        addRewardExchangeHistory.setUsedPointsBeforeExchange(usedPointsBeforeExchange);
        addRewardExchangeHistory.setUsedPointsAfterExchange(usedPointsAfterExchange);
        rewardExchangeHistoryService.insert(addRewardExchangeHistory);

        User updateUser = new User();
        updateUser.setId(user.getId());
        updateUser.setUnusedPoints(unusedPointsAfterExchange);
        updateUser.setUsedPoints(usedPointsAfterExchange);
        userService.updateById(updateUser);

        Account updateAccount = new Account();
        updateAccount.setId(account.getId());
        updateAccount.setPoints(accountPointsAfterExchange);
        accountService.batchUpdate(Arrays.asList(updateAccount));
    }
}