package cn.lili.modules.lmk.service.impl;

import cn.lili.common.exception.ServiceException;
import cn.lili.common.security.AuthUser;
import cn.lili.common.security.context.UserContext;
import cn.lili.modules.lmk.domain.entity.PrizeClaimRecord;
import cn.lili.modules.lmk.domain.entity.StoreCoupon;
import cn.lili.modules.lmk.domain.entity.StoreCouponSingle;
import cn.lili.modules.lmk.domain.form.AddPrizeNumForm;
import cn.lili.modules.lmk.domain.vo.StorePrizeVO;
import cn.lili.modules.lmk.enums.general.*;
import cn.lili.modules.lmk.service.PrizeClaimRecordService;
import cn.lili.modules.lmk.service.PrizeService;
import cn.lili.modules.order.order.entity.enums.ClaimStatusEnum;
import cn.lili.utils.COSUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import cn.lili.modules.lmk.domain.entity.ScanPrize;
import cn.lili.modules.lmk.mapper.ScanPrizeMapper;
import cn.lili.modules.lmk.service.ScanPrizeService;
import cn.lili.base.Result;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import cn.lili.modules.lmk.domain.form.ScanPrizeForm;
import cn.lili.modules.lmk.domain.vo.ScanPrizeVO;
import cn.lili.modules.lmk.domain.query.ScanPrizeQuery;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
import cn.lili.utils.PageUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.util.Assert;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 店铺活动关联 服务实现类
 *
 * @author peng
 * @since 2025-09-30
 */
@Service
@RequiredArgsConstructor
public class ScanPrizeServiceImpl extends ServiceImpl<ScanPrizeMapper, ScanPrize> implements ScanPrizeService {

    private final ScanPrizeMapper scanPrizeMapper;
    private final RedissonClient redissonClient;
    private static final String STORE_PRIZE_GENERATE = "store_prize_generate:";
    private final PrizeClaimRecordService prizeClaimRecordService;
    private static final String STORE_PRIZE_CLAIM = "store_prize_claim:";
    private final PrizeService prizeService;
    private final COSUtil cosUtil;
    /**
     * 添加
     * @param form
     * @return
     */
    @Override
    public Result add(ScanPrizeForm form) {
        ScanPrize entity = ScanPrizeForm.getEntityByForm(form, null);
        entity.setStatus(StoreScanPrizeStausEnum.ENABLE.name());
        entity.setGenerateStatus(GenerateStorePrizeStausEnum.NOT_GENERATE.name());
        entity.setClaimNum(0);
        baseMapper.insert(entity);
        return Result.ok("添加成功");
    }

    /**
     * 修改
     * @param form
     * @return
     */
    @Override
    public Result update(ScanPrizeForm form) {
        ScanPrize entity = baseMapper.selectById(form.getId());

        // 为空抛IllegalArgumentException，做全局异常处理
        Assert.notNull(entity, "记录不存在");
        BeanUtils.copyProperties(form, entity);
        baseMapper.updateById(entity);
        return Result.ok("修改成功");
    }

    /**
     * 批量删除
     * @param ids
     * @return
     */
    @Override
    public Result remove(List<String> ids) {
        baseMapper.deleteBatchIds(ids);
        return Result.ok("删除成功");
    }

    /**
     * id删除
     * @param id
     * @return
     */
    @Override
    public Result removeById(String id) {
        baseMapper.deleteById(id);
        return Result.ok("删除成功");
    }

    /**
     * 分页查询
     * @param query
     * @return
     */
    @Override
    public Result page(ScanPrizeQuery query) {

        IPage<ScanPrizeVO> page = PageUtil.getPage(query, ScanPrizeVO.class);
        LambdaQueryWrapper<ScanPrize> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(Objects.nonNull(query.getStoreId()), ScanPrize::getStoreId, query.getStoreId());
        wrapper.eq(StringUtils.isNotBlank(query.getStatus()), ScanPrize::getStatus, query.getStatus());
        wrapper.eq(StringUtils.isNotBlank(query.getGenerateStatus()), ScanPrize::getGenerateStatus, query.getGenerateStatus());
        baseMapper.getPage(page, query);
        return Result.ok().data(page.getRecords()).total(page.getTotal());
    }

    /**
     * 根据id查找
     * @param id
     * @return
     */
    @Override
    public Result detail(String id) {
        ScanPrizeVO vo = baseMapper.getById(id);
        Assert.notNull(vo, "记录不存在");
        return Result.ok().data(vo);
    }

    /**
     * 列表
     * @return
     */
    @Override
    public Result all() {
        List<ScanPrize> entities = baseMapper.selectList(null);
        List<ScanPrizeVO> vos = entities.stream()
                .map(entity -> ScanPrizeVO.getVoByEntity(entity, null))
                .collect(Collectors.toList());
        return Result.ok().data(vos);
    }

    @Override
    public Result changeStatus(String id) {
        ScanPrize scanPrize = this.getById(id);
        if (scanPrize == null) {
            throw new ServiceException("当前店铺抽奖机会不存在");
        }
        String status = scanPrize.getStatus();
        if (StoreCouponStausEnum.ENABLE.name().equals(status)) {
            scanPrize.setStatus(StoreCouponStausEnum.DISABLE.name());
        }else if (StoreCouponStausEnum.DISABLE.name().equals(status)) {
            scanPrize.setStatus(StoreCouponStausEnum.ENABLE.name());
        }else {
            throw new ServiceException("当前店铺抽奖机会状态异常无法修改");
        }
        this.updateById(scanPrize);
        return Result.ok();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result generateStorePrize(String id) {

        RLock redissonLock = redissonClient.getLock(STORE_PRIZE_GENERATE + id);
        try {
            redissonLock.lock();
            LambdaQueryWrapper<ScanPrize> forUpdate = Wrappers.<ScanPrize>lambdaQuery().eq(ScanPrize::getId, id).last("FOR UPDATE");
            ScanPrize scanPrize = this.getOne(forUpdate);
            if (scanPrize == null) {
                throw new ServiceException("当前店铺抽奖机会不存在无法生成");
            }
            if (!GenerateCouponStausEnum.NOT_GENERATE.name().equals( scanPrize.getGenerateStatus())) {
                throw new ServiceException("当前店铺抽奖机会状态异常无法生成");
            }
            //生成优惠卷
            Integer generateNum = scanPrize.getGenerateNum();
            if (generateNum == null) {
                throw new ServiceException("发行数量为空不能生成");
            }
            List<PrizeClaimRecord> prizeClaimRecords = new ArrayList<>();
            for (int i = 1; i <= generateNum; i++) {
                PrizeClaimRecord prizeClaimRecord = getStoreCouponSingle(scanPrize, i);
                prizeClaimRecords.add(prizeClaimRecord);
            }
            if (!prizeClaimRecords.isEmpty()) {
                prizeClaimRecordService.saveBatch(prizeClaimRecords);
            }
            //更新状态生成状态
            scanPrize.setGenerateStatus(GenerateCouponStausEnum.GENERATE.name());
            this.updateById(scanPrize);
            return Result.ok();
        }finally {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
                @Override
                public void afterCommit() {
                    if (redissonLock.isHeldByCurrentThread()) {
                        redissonLock.unlock();
                    }
                }
                @Override
                public void afterCompletion(int status) {
                    if (redissonLock.isHeldByCurrentThread()) {
                        redissonLock.unlock();
                    }
                }
            });
        }
    }
    private static PrizeClaimRecord getStoreCouponSingle(ScanPrize scanPrize, int i) {
        PrizeClaimRecord prizeClaimRecord = new PrizeClaimRecord();
        prizeClaimRecord.setStorePrizeId(scanPrize.getId());
        prizeClaimRecord.setStoreId(scanPrize.getStoreId());
        prizeClaimRecord.setStoreName(scanPrize.getStoreName());
        prizeClaimRecord.setPrizeActivityId(scanPrize.getPrizeActivityId());
        prizeClaimRecord.setPrizeActivityName(scanPrize.getPrizeActivityName());
        prizeClaimRecord.setClaimStatus(ClaimStatusEnum.NOT_CLAIM.name());
        prizeClaimRecord.setNo(String.format("%08d", i));
        prizeClaimRecord.setMaterial(MaterialStatusEnum.NOT_GENERATE.name());
        return prizeClaimRecord;
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result claimPrize(String id) {
        AuthUser currentUser = UserContext.getCurrentUser();
        if (currentUser == null) {
            throw new ServiceException("当前用户没有登录无法领取");
        }
        String userId = currentUser.getId();
        String nickName = currentUser.getNickName();

        //锁住礼品码id
        RLock redissonLock = redissonClient.getLock(STORE_PRIZE_CLAIM + id);
        try {
            redissonLock.lock();
            LambdaQueryWrapper<PrizeClaimRecord> forUpdate = Wrappers.<PrizeClaimRecord>lambdaQuery()
                    .eq(PrizeClaimRecord::getId, id).last("FOR UPDATE");
            PrizeClaimRecord prizeClaimRecord = prizeClaimRecordService.getOne(forUpdate);
            if (prizeClaimRecord == null) {
                throw new ServiceException("当前领取抽奖机会二维码不存在");
            }
            if (!ClaimStatusEnum.NOT_CLAIM.name().equals(prizeClaimRecord.getClaimStatus())) {
                throw new ServiceException("当前领取抽奖机会状态异常");
            }
            //更新被领取的记录
            prizeClaimRecord.setClaimStatus(ClaimStatusEnum.CLAIM.name());
            prizeClaimRecord.setUserId(userId);
            prizeClaimRecord.setNickName(nickName);
            LambdaQueryWrapper<ScanPrize> storeCoupQuery = Wrappers.<ScanPrize>lambdaQuery()
                    .eq(ScanPrize::getId, prizeClaimRecord.getStorePrizeId()).last("FOR UPDATE");
            ScanPrize scanPrize = this.getOne(storeCoupQuery);
            AddPrizeNumForm addPrizeNumForm = new AddPrizeNumForm();
            addPrizeNumForm.setUserId(userId);
            addPrizeNumForm.setPrizeActivityId(prizeClaimRecord.getPrizeActivityId());
            addPrizeNumForm.setAddType(PrizeUserActionEnum.USER_SCAN_STORE.name());
            prizeService.addPrizeNum(addPrizeNumForm);
            if (scanPrize == null) {
                throw new ServiceException("当前店铺抽奖卷不存在");
            }
            if (!StoreScanPrizeStausEnum.ENABLE.name().equals(scanPrize.getStatus())) {
                throw new ServiceException("当前店铺抽奖卷状态异常");
            }
            //领取对应的优惠卷写入记录
            prizeClaimRecordService.updateById(prizeClaimRecord);
            LambdaUpdateWrapper<ScanPrize> updateStoreCoupon = Wrappers.<ScanPrize>lambdaUpdate()
                    .eq(ScanPrize::getId, scanPrize.getId())
                    .set(ScanPrize::getClaimNum, scanPrize.getClaimNum() + 1)
                    .ge(ScanPrize::getGenerateNum, scanPrize.getClaimNum() + 1);
            boolean update = this.update(updateStoreCoupon);
            if (!update) {
                throw new ServiceException("领取失败");
            }
            return Result.ok().data(0);

        } finally {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
                @Override
                public void afterCommit() {
                    if (redissonLock.isHeldByCurrentThread()) {
                        redissonLock.unlock();
                    }
                }

                @Override
                public void afterCompletion(int status) {
                    // 确保即使在事务回滚的情况下也能释放锁
                    if (redissonLock.isHeldByCurrentThread()) {
                        redissonLock.unlock();
                    }
                }

            });

        }
    }

    @Override
    public Result getStorePrize(String id) {
        StorePrizeVO storePrize = baseMapper.getStorePrize(id);
        if (storePrize == null) {
            throw new ServiceException("当前活动不存在");
        }
        Boolean popup = storePrize.getPopup();
        if (!Boolean.TRUE.equals(popup)) {
            throw new ServiceException("当前活动没有开启");
        }
        if (!PrizeActivityStatusEnum.ON.name().equals(storePrize.getEnableStatus())) {
            throw new ServiceException("当前活动没有开启");
        }
        if (!ClaimStatusEnum.NOT_CLAIM.name().equals(storePrize.getClaimStatus())) {
            throw new ServiceException("当前抽奖机会被领取");
        }

        String activityCover = storePrize.getActivityCover();
        if (StringUtils.isNotBlank(activityCover)&&!activityCover.contains("http")) {
            storePrize.setActivityCover(cosUtil.getPreviewUrl(activityCover));
        }
        return Result.ok().data(storePrize);
    }
}