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

import cn.lili.common.exception.ServiceException;
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.enums.general.*;
import cn.lili.modules.lmk.service.PrizeClaimRecordService;
import cn.lili.modules.order.order.entity.enums.ClaimStatusEnum;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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;

    /**
     * 添加
     * @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
    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;
    }
}