package com.talentcard.server.service;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.talentcard.server.business.BusinessIdGenerator;
import com.talentcard.server.request.BenefitVerificationCodeRequest;
import com.talentcard.server.common.BusinessException;
import com.talentcard.server.common.ErrorCode;
import com.talentcard.server.entity.BenefitCinemaCoupon;
import com.talentcard.server.entity.BenefitCinemaCouponClaim;
import com.talentcard.server.entity.BenefitFreeStayVerificationCode;
import com.talentcard.server.entity.BenefitFreeStayVoucher;
import com.talentcard.server.entity.BenefitMerchant;
import com.talentcard.server.mapper.BenefitCinemaCouponClaimMapper;
import com.talentcard.server.mapper.BenefitCinemaCouponMapper;
import com.talentcard.server.mapper.BenefitFreeStayVerificationCodeMapper;
import com.talentcard.server.mapper.BenefitFreeStayVoucherMapper;
import com.talentcard.server.mapper.BenefitMerchantMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BenefitVerificationCodeService {
    public static final int CODE_SECONDS = 300;
    public static final String MOVIE_TOKEN_PREFIX = "MV2";
    public static final String HOTEL_TOKEN_PREFIX = "HV2";

    private final BenefitQuotaService quotaService;
    private final BenefitMerchantMapper merchantMapper;
    private final BenefitCinemaCouponMapper couponMapper;
    private final BenefitCinemaCouponClaimMapper claimMapper;
    private final BenefitFreeStayVoucherMapper voucherMapper;
    private final BenefitFreeStayVerificationCodeMapper freeStayCodeMapper;

    public BenefitVerificationCodeService(
            BenefitQuotaService quotaService,
            BenefitMerchantMapper merchantMapper,
            BenefitCinemaCouponMapper couponMapper,
            BenefitCinemaCouponClaimMapper claimMapper,
            BenefitFreeStayVoucherMapper voucherMapper,
            BenefitFreeStayVerificationCodeMapper freeStayCodeMapper
    ) {
        this.quotaService = quotaService;
        this.merchantMapper = merchantMapper;
        this.couponMapper = couponMapper;
        this.claimMapper = claimMapper;
        this.voucherMapper = voucherMapper;
        this.freeStayCodeMapper = freeStayCodeMapper;
    }

    @Transactional
    public Map<String, Object> generate(BenefitVerificationCodeRequest request, String idempotencyKey) {
        String benefitType = quotaService.normalizeBenefitType(request.benefitType());
        if (BenefitQuotaService.MOVIE_TICKET.equals(benefitType)) {
            return generateMovieCode(request, idempotencyKey);
        }
        return generateHotelFreeStayCode(request);
    }

    private Map<String, Object> generateMovieCode(BenefitVerificationCodeRequest request, String idempotencyKey) {
        Long merchantId = requirePositive(request.merchantId(), "商户ID不能为空");
        expireExpiredMovieCodes(merchantId);

        BenefitQuotaService.QuotaSnapshot quota = quotaService.requireAvailable(
                BenefitQuotaService.MOVIE_TICKET, request.cardId(), request.talentId(), merchantId, null, 1);
        MovieCouponChoice choice = movieCouponForUpdate(merchantId, quota.cardLevel(), quota.sharedCardIds());
        BenefitCinemaCoupon coupon = choice.coupon();
        Long couponId = coupon.getId();
        int dailyLimit = choice.dailyLimit();
        int dailyUsed = choice.dailyUsed();

        String token = MOVIE_TOKEN_PREFIX + UUID.randomUUID().toString().replace("-", "").toUpperCase(Locale.ROOT);
        String claimKey = claimIdempotencyKey(idempotencyKey, token);
        BenefitCinemaCouponClaim idempotent = movieClaimByIdempotencyKey(claimKey);
        if (idempotent != null) {
            ensureSameMovieClaim(idempotent, couponId, merchantId, quota.cardId());
            if (activeMovieCode(idempotent) && startsWithMoviePrefix(idempotent.getExchangeCode())) {
                return movieCodeResponse(idempotent, coupon, quota, dailyLimit, dailyUsed, false);
            }
            throw new BusinessException(ErrorCode.CONFLICT, "幂等键对应的电影票核销码已过期或已使用");
        }

        BenefitCinemaCouponClaim existing = movieClaimForUpdate(couponId, quota.talentId());
        Long claimId;
        if (existing != null) {
            String status = upper(existing.getCodeStatus());
            if ("USED".equals(status)) {
                throw new BusinessException(ErrorCode.CONFLICT, "电影票已核销");
            }
            if (activeMovieCode(existing) && startsWithMoviePrefix(existing.getExchangeCode())) {
                return movieCodeResponse(existing, coupon, quota, dailyLimit, dailyUsed, false);
            }
            boolean stockAlreadyReserved = "ACTIVE".equals(status) && !startsWithMoviePrefix(existing.getExchangeCode());
            if (!stockAlreadyReserved) {
                decrementMovieStock(couponId, merchantId);
            }
            BenefitCinemaCouponClaim update = new BenefitCinemaCouponClaim();
            update.setId(existing.getId());
            update.setExchangeCode(token);
            update.setCodeStatus("ACTIVE");
            update.setStatus("RECEIVED");
            update.setUsedAt(null);
            update.setValidEnd(coupon.getValidEnd());
            update.setIdempotencyKey(claimKey);
            claimMapper.updateById(update);
            claimId = existing.getId();
        } else {
            decrementMovieStock(couponId, merchantId);
            BenefitCinemaCouponClaim claim = new BenefitCinemaCouponClaim();
            claim.setClaimNo(BusinessIdGenerator.next("MC"));
            claim.setCouponId(couponId);
            claim.setMerchantId(merchantId);
            claim.setTalentId(quota.talentId());
            claim.setCardId(quota.cardId());
            claim.setCardNo(quota.cardNo());
            claim.setValidEnd(coupon.getValidEnd());
            claim.setStatus("RECEIVED");
            claim.setExchangeCode(token);
            claim.setCodeStatus("ACTIVE");
            claim.setIdempotencyKey(claimKey);
            claim.setDeleted(0);
            claimMapper.insert(claim);
            claimId = claim.getId();
        }
        BenefitCinemaCouponClaim claim = movieClaimById(claimId);
        return movieCodeResponse(claim, couponMapper.selectById(couponId), quota, dailyLimit, dailyUsed + 1, true);
    }

    private Map<String, Object> generateHotelFreeStayCode(BenefitVerificationCodeRequest request) {
        Long merchantId = requirePositive(request.merchantId(), "商户ID不能为空");
        ensureHotelMerchant(merchantId);
        BenefitQuotaService.QuotaSnapshot quota = quotaService.requireAvailable(
                BenefitQuotaService.HOTEL, request.cardId(), request.talentId(), merchantId, null, 1);
        BenefitFreeStayVoucher voucher = voucherForUpdate(quota.primaryTalentId(), merchantId, quota.primaryCardId(), quota.total());
        if (intValue(voucher.getStatus()) != 1 || expiredDate(voucher.getValidEnd())) {
            throw new BusinessException(ErrorCode.CONFLICT, "酒店权益券当前不可用");
        }
        if (intValue(voucher.getUsedCount()) >= Math.min(intValue(voucher.getTotalCount()), quota.total())) {
            throw new BusinessException(ErrorCode.CONFLICT, "酒店权益次数已用完");
        }
        freeStayCodeMapper.update(null, new UpdateWrapper<BenefitFreeStayVerificationCode>()
                .set("status", 2)
                .eq("voucher_id", voucher.getId())
                .eq("status", 0));

        BenefitFreeStayVerificationCode code = new BenefitFreeStayVerificationCode();
        code.setCodeToken(hotelFreeStayToken(quota.cardId()));
        code.setVoucherId(voucher.getId());
        code.setExpiresAt(LocalDateTime.now().plusSeconds(CODE_SECONDS));
        code.setStatus(0);
        freeStayCodeMapper.insert(code);
        return hotelCodeResponse(code, voucher, quota);
    }

    private MovieCouponChoice movieCouponForUpdate(Long merchantId, String cardLevel, List<Long> sharedCardIds) {
        ensureCinemaMerchant(merchantId);
        List<BenefitCinemaCoupon> coupons = couponMapper.selectList(new QueryWrapper<BenefitCinemaCoupon>()
                .eq("merchant_id", merchantId)
                .eq("deleted", 0)
                .eq("status", 1)
                .gt("stock", 0)
                .and(wrapper -> wrapper.isNull("valid_end").or().ge("valid_end", LocalDate.now()))
                .orderByAsc("sort_no", "id")
                .last("for update"));
        if (coupons.isEmpty()) {
            throw new BusinessException(ErrorCode.CONFLICT, "未找到可用电影票权益券");
        }
        List<String> aliases = quotaService.cardLevelAliases(cardLevel);
        boolean cardLevelSupported = false;
        for (BenefitCinemaCoupon coupon : coupons) {
            if (!supportsCard(coupon.getTalentLevels(), aliases)) {
                continue;
            }
            cardLevelSupported = true;
            int dailyLimit = Math.max(1, intValue(coupon.getPerUserLimit()));
            int dailyUsed = dailyMovieClaims(sharedCardIds, coupon.getId());
            if (dailyUsed < dailyLimit) {
                return new MovieCouponChoice(coupon, dailyLimit, dailyUsed);
            }
        }
        if (!cardLevelSupported) {
            throw new BusinessException(ErrorCode.CONFLICT, "当前卡类型不适用该电影票权益券");
        }
        throw new BusinessException(ErrorCode.CONFLICT, "当天电影票领取次数已达上限");
    }

    private void decrementMovieStock(Long couponId, Long merchantId) {
        int updated = couponMapper.update(null, new UpdateWrapper<BenefitCinemaCoupon>()
                .setSql("stock = stock - 1")
                .eq("id", couponId)
                .eq("merchant_id", merchantId)
                .eq("deleted", 0)
                .eq("status", 1)
                .gt("stock", 0));
        if (updated != 1) {
            throw new BusinessException(ErrorCode.CONFLICT, "电影票权益券库存不足");
        }
    }

    private int dailyMovieClaims(List<Long> sharedCardIds, Long couponId) {
        Long count = claimMapper.selectCount(new QueryWrapper<BenefitCinemaCouponClaim>()
                .eq("deleted", 0)
                .in("card_id", sharedCardIds)
                .eq("coupon_id", couponId)
                .apply("((upper(coalesce(code_status, 'ACTIVE')) = 'USED' and used_at >= current_date) or "
                        + "(upper(coalesce(code_status, 'ACTIVE')) = 'ACTIVE' and updated_at >= current_date "
                        + "and updated_at > date_sub(now(), interval 300 second)))"));
        return intValue(count);
    }

    private void expireExpiredMovieCodes(Long merchantId) {
        List<BenefitCinemaCouponClaim> expired = claimMapper.selectList(new QueryWrapper<BenefitCinemaCouponClaim>()
                .eq("deleted", 0)
                .eq("merchant_id", merchantId)
                .apply("upper(coalesce(code_status, 'ACTIVE')) = 'ACTIVE'")
                .likeRight("exchange_code", MOVIE_TOKEN_PREFIX)
                .isNull("used_at")
                .apply("updated_at <= date_sub(now(), interval 300 second)")
                .last("for update"));
        for (BenefitCinemaCouponClaim claim : expired) {
            int updated = claimMapper.update(null, new UpdateWrapper<BenefitCinemaCouponClaim>()
                    .set("code_status", "EXPIRED")
                    .set("status", "EXPIRED")
                    .eq("id", claim.getId())
                    .eq("deleted", 0)
                    .apply("upper(coalesce(code_status, 'ACTIVE')) = 'ACTIVE'"));
            if (updated == 1) {
                couponMapper.update(null, new UpdateWrapper<BenefitCinemaCoupon>()
                        .setSql("stock = stock + 1")
                        .eq("id", claim.getCouponId())
                        .eq("deleted", 0));
            }
        }
    }

    private BenefitCinemaCouponClaim movieClaimByIdempotencyKey(String key) {
        return claimMapper.selectOne(new QueryWrapper<BenefitCinemaCouponClaim>()
                .eq("deleted", 0)
                .eq("idempotency_key", key)
                .last("limit 1 for update"));
    }

    private BenefitCinemaCouponClaim movieClaimForUpdate(Long couponId, Long talentId) {
        return claimMapper.selectOne(new QueryWrapper<BenefitCinemaCouponClaim>()
                .eq("deleted", 0)
                .eq("coupon_id", couponId)
                .eq("talent_id", talentId)
                .last("limit 1 for update"));
    }

    private BenefitCinemaCouponClaim movieClaimById(Long claimId) {
        BenefitCinemaCouponClaim claim = claimMapper.selectOne(new QueryWrapper<BenefitCinemaCouponClaim>()
                .eq("deleted", 0)
                .eq("id", claimId)
                .last("limit 1"));
        if (claim == null) {
            throw new BusinessException(ErrorCode.INTERNAL_ERROR, "电影票领取记录保存失败");
        }
        return claim;
    }

    private void ensureSameMovieClaim(BenefitCinemaCouponClaim claim, Long couponId, Long merchantId, Long cardId) {
        if (!couponId.equals(claim.getCouponId()) || !merchantId.equals(claim.getMerchantId()) || !cardId.equals(claim.getCardId())) {
            throw new BusinessException(ErrorCode.CONFLICT, "幂等键已被其他电影票核销码请求使用");
        }
    }

    private void ensureCinemaMerchant(Long merchantId) {
        BenefitMerchant merchant = merchantMapper.selectById(merchantId);
        if (merchant == null || intValue(merchant.getDeleted()) != 0 || intValue(merchant.getStatus()) != 1
                || !"cinema".equalsIgnoreCase(String.valueOf(merchant.getMerchantType()))) {
            throw new BusinessException(ErrorCode.CONFLICT, "未找到有效影院商户");
        }
    }

    private void ensureHotelMerchant(Long merchantId) {
        BenefitMerchant merchant = merchantMapper.selectById(merchantId);
        if (merchant == null || intValue(merchant.getDeleted()) != 0 || intValue(merchant.getStatus()) != 1
                || !"hotel".equalsIgnoreCase(String.valueOf(merchant.getMerchantType()))) {
            throw new BusinessException(ErrorCode.CONFLICT, "未找到有效酒店商户");
        }
    }

    private BenefitFreeStayVoucher voucherForUpdate(Long primaryTalentId, Long merchantId, Long primaryCardId, int totalCount) {
        BenefitFreeStayVoucher voucher = voucherMapper.selectOne(new QueryWrapper<BenefitFreeStayVoucher>()
                .eq("talent_id", primaryTalentId)
                .eq("merchant_id", merchantId)
                .last("limit 1 for update"));
        LocalDate validEnd = LocalDate.now().plusYears(1);
        if (voucher == null) {
            voucher = new BenefitFreeStayVoucher();
            voucher.setVoucherNo(BusinessIdGenerator.next("FSV"));
            voucher.setTalentId(primaryTalentId);
            voucher.setMerchantId(merchantId);
            voucher.setCardId(primaryCardId);
            voucher.setTotalCount(totalCount);
            voucher.setUsedCount(0);
            voucher.setValidEnd(validEnd);
            voucher.setStatus(1);
            voucherMapper.insert(voucher);
            return voucher;
        }
        if (intValue(voucher.getStatus()) != 1 || expiredDate(voucher.getValidEnd())) {
            voucher.setTotalCount(totalCount);
            voucher.setUsedCount(0);
            voucher.setValidEnd(validEnd);
            voucher.setStatus(1);
            voucherMapper.updateById(voucher);
        } else if (intValue(voucher.getTotalCount()) < totalCount) {
            voucher.setTotalCount(totalCount);
            voucherMapper.updateById(voucher);
        }
        return voucher;
    }

    private Map<String, Object> movieCodeResponse(BenefitCinemaCouponClaim claim, BenefitCinemaCoupon coupon,
                                                  BenefitQuotaService.QuotaSnapshot quota,
                                                  int dailyLimit, int dailyUsed, boolean newlyReserved) {
        LocalDateTime updatedAt = claim.getUpdatedAt() == null ? LocalDateTime.now() : claim.getUpdatedAt();
        LocalDateTime expiresAt = updatedAt.plusSeconds(CODE_SECONDS);
        BenefitMerchant merchant = merchantMapper.selectById(claim.getMerchantId());
        Map<String, Object> result = baseResponse(BenefitQuotaService.MOVIE_TICKET, claim.getExchangeCode(), expiresAt, quota);
        result.put("displayCode", claim.getExchangeCode());
        result.put("sourceType", "CINEMA_COUPON_CLAIM");
        result.put("sourceId", claim.getId());
        result.put("merchantId", claim.getMerchantId());
        result.put("merchantName", merchant == null ? "" : merchant.getMerchantName());
        result.put("couponId", claim.getCouponId());
        result.put("couponName", coupon == null ? "" : coupon.getCouponName());
        result.put("stockRemaining", coupon == null ? null : coupon.getStock());
        result.put("dailyLimit", dailyLimit);
        result.put("dailyUsed", dailyUsed);
        result.put("dailyRemaining", Math.max(dailyLimit - dailyUsed, 0));
        result.put("quotaEffect", newlyReserved ? "RESERVED_ON_CODE_GENERATION" : "EXISTING_ACTIVE_CODE");
        return result;
    }

    private Map<String, Object> hotelCodeResponse(BenefitFreeStayVerificationCode code, BenefitFreeStayVoucher voucher,
                                                  BenefitQuotaService.QuotaSnapshot quota) {
        Map<String, Object> result = baseResponse(BenefitQuotaService.HOTEL, code.getCodeToken(), code.getExpiresAt(), quota);
        result.put("displayCode", shortDisplayCode(code.getCodeToken()));
        result.put("sourceType", "FREE_STAY_VERIFICATION_CODE");
        result.put("sourceId", code.getId());
        result.put("merchantId", voucher.getMerchantId());
        result.put("voucherId", voucher.getId());
        result.put("voucherNo", voucher.getVoucherNo());
        result.put("voucherTotal", voucher.getTotalCount());
        result.put("voucherUsed", voucher.getUsedCount());
        result.put("quotaEffect", "DEDUCT_ON_VERIFICATION");
        return result;
    }

    private Map<String, Object> baseResponse(String benefitType, Object codeToken, LocalDateTime expiresAt,
                                             BenefitQuotaService.QuotaSnapshot quota) {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("benefitType", benefitType);
        result.put("verifyCode", codeToken);
        result.put("expiresAt", expiresAt);
        result.put("expiresAtEpochMillis", expiresAt.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());
        result.put("expiresInSeconds", Math.max(0, java.time.Duration.between(LocalDateTime.now(), expiresAt).toSeconds()));
        result.put("refreshAfterSeconds", CODE_SECONDS);
        result.put("sharedQuotaMode", "AUTO_DEDUCT");
        result.put("sourceCardId", quota.cardId());
        result.put("sourceTalentId", quota.talentId());
        result.put("sourceCardType", quota.cardType());
        result.put("familyCard", quota.familyCard());
        result.put("primaryCardId", quota.primaryCardId());
        result.put("primaryTalentId", quota.primaryTalentId());
        result.put("primaryCardNo", quota.primaryCardNo());
        result.put("cardLevel", quota.cardLevel());
        result.put("quotaTotal", quota.total());
        result.put("quotaUsed", quota.used());
        result.put("quotaRemainingBefore", quota.remaining());
        result.put("quotaResetCycle", quota.resetCycle());
        result.put("quotaWindowStart", quota.windowStart());
        return result;
    }

    private String hotelFreeStayToken(Long sourceCardId) {
        long card = sourceCardId == null ? 0 : sourceCardId;
        return HOTEL_TOKEN_PREFIX + "C" + card + "P0_" + UUID.randomUUID().toString().replace("-", "").toUpperCase(Locale.ROOT);
    }

    private boolean activeMovieCode(BenefitCinemaCouponClaim claim) {
        return "ACTIVE".equals(upper(claim.getCodeStatus())) && !movieCodeExpired(claim.getUpdatedAt());
    }

    private boolean movieCodeExpired(LocalDateTime updatedAt) {
        return updatedAt != null && !updatedAt.plusSeconds(CODE_SECONDS).isAfter(LocalDateTime.now());
    }

    private boolean startsWithMoviePrefix(String code) {
        return code != null && code.startsWith(MOVIE_TOKEN_PREFIX);
    }

    private String claimIdempotencyKey(String raw, String token) {
        if (raw == null || raw.isBlank()) {
            return "VCODE-" + token;
        }
        String key = raw.trim();
        if (key.length() > 100) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, "幂等键长度不能超过限制");
        }
        return "VCODE-" + key;
    }

    private boolean supportsCard(String levels, List<String> aliases) {
        String configured = levels == null ? "" : levels.trim();
        if (configured.isBlank()) {
            return true;
        }
        for (String alias : aliases) {
            if (alias != null && !alias.isBlank() && configured.contains(alias)) {
                return true;
            }
        }
        return false;
    }

    private String shortDisplayCode(String token) {
        if (token == null || token.length() <= 8) {
            return token;
        }
        return token.substring(token.length() - 8);
    }

    private Long requirePositive(Long value, String message) {
        if (value == null || value <= 0) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, message);
        }
        return value;
    }

    private boolean expiredDate(LocalDate value) {
        return value != null && value.isBefore(LocalDate.now());
    }

    private String upper(String value) {
        return value == null ? "" : value.trim().toUpperCase(Locale.ROOT);
    }

    private int intValue(Object value) {
        return value instanceof Number number ? number.intValue() : 0;
    }

    private record MovieCouponChoice(BenefitCinemaCoupon coupon, int dailyLimit, int dailyUsed) {
    }
}