package com.ruoyi.account.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.account.api.dto.CompanyAllocateRecordQueryDTO;
import com.ruoyi.account.api.model.TAppUserWhitelist;
import com.ruoyi.account.api.model.TChargingCard;
import com.ruoyi.account.api.model.TCompanyAllocateRecord;
import com.ruoyi.account.api.model.TVinManagement;
import com.ruoyi.account.api.vo.CompanyAllocateSummaryVO;
import com.ruoyi.account.mapper.TAppUserWhitelistMapper;
import com.ruoyi.account.mapper.TChargingCardMapper;
import com.ruoyi.account.mapper.TCompanyAllocateRecordMapper;
import com.ruoyi.account.mapper.TVinManagementMapper;
import com.ruoyi.account.service.TCompanyAllocateRecordService;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.security.utils.SecurityUtils;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 公司额度分配记录服务实现：对外提供分页查询与统一流水写入。
 * 写入方法被 VIN码/卡片/白名单的额度变更流程调用，与该次余额变更保持同一事务（或紧随其后的落库顺序）。
 */
@Service
public class TCompanyAllocateRecordServiceImpl
        extends ServiceImpl<TCompanyAllocateRecordMapper, TCompanyAllocateRecord>
        implements TCompanyAllocateRecordService {

    private static final Logger log = LoggerFactory.getLogger(TCompanyAllocateRecordServiceImpl.class);

    /** user_info / user_name 列长度（varchar(64)） */
    private static final int MAX_USER_TEXT_LENGTH = 64;
    /** remark 列长度（varchar(255)） */
    private static final int MAX_REMARK_LENGTH = 255;
    /** charging_order_code 列长度（varchar(64)） */
    private static final int MAX_ORDER_CODE_LENGTH = 64;

    /** 模式切换回收锁：与额度分配同前缀、按公司串行，防止切换与分配并发导致资金不一致 */
    private static final String RECYCLE_LOCK_PREFIX_VIN = "VIN_QUOTA:COMPANY:";
    private static final String RECYCLE_LOCK_PREFIX_CARD = "CHARGING_CARD_QUOTA:COMPANY:";
    private static final String RECYCLE_LOCK_PREFIX_WHITELIST = "APP_USER_WHITELIST_QUOTA:COMPANY:";
    /** 获取锁最长等待时间（秒） */
    private static final long LOCK_WAIT_SECONDS = 5L;
    /** 锁自动释放时间（秒），兜住异常未解锁的场景 */
    private static final long LOCK_LEASE_SECONDS = 30L;

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private TVinManagementMapper vinManagementMapper;

    @Resource
    private TChargingCardMapper chargingCardMapper;

    @Resource
    private TAppUserWhitelistMapper appUserWhitelistMapper;

    @Override
    public IPage<TCompanyAllocateRecord> selectRecordPage(CompanyAllocateRecordQueryDTO query) {
        CompanyAllocateRecordQueryDTO safe = query == null ? new CompanyAllocateRecordQueryDTO() : query;
        long pageNum = safe.getPageCurr() == null || safe.getPageCurr() < 1 ? 1 : safe.getPageCurr();
        long pageSize = safe.getPageSize() == null || safe.getPageSize() < 1 ? 10 : safe.getPageSize();
        return baseMapper.selectRecordPage(new Page<>(pageNum, pageSize), safe);
    }

    @Override
    public boolean recordAllocate(int userType, String userInfo, String userName, Integer companyId, int changeSource,
                                  BigDecimal beforeBalance, BigDecimal amount, String remark) {
        BigDecimal change = normalizeMoney(amount);
        if (companyId == null || change.signum() == 0) {
            return false;
        }
        BigDecimal before = normalizeMoney(beforeBalance);
        TCompanyAllocateRecord record = new TCompanyAllocateRecord();
        record.setCompanyId(companyId);
        record.setUserType(userType);
        record.setUserInfo(truncate(userInfo, MAX_USER_TEXT_LENGTH));
        record.setUserName(truncate(userName, MAX_USER_TEXT_LENGTH));
        record.setChangeSource(changeSource);
        record.setBeforeBalance(before);
        record.setAmount(change);
        record.setAfterBalance(before.add(change));
        record.setOperatorId(currentUserId());
        record.setOperatorName(currentUsername());
        record.setOperateTime(LocalDateTime.now());
        record.setRemark(truncate(remark, MAX_REMARK_LENGTH));
        record.setCreateTime(record.getOperateTime());
        return save(record);
    }

    @Override
    public boolean recordConsume(Integer companyId, Integer userType, String userInfo, String userName,
                                 BigDecimal beforeBalance, BigDecimal amount, String chargingOrderCode, String remark) {
        return doRecordConsume(companyId, userType, userInfo, userName, beforeBalance, amount, chargingOrderCode,
                remark, false);
    }

    @Override
    public boolean recordSettleConsume(Integer companyId, Integer userType, String userInfo, String userName,
                                       BigDecimal beforeBalance, BigDecimal amount, String chargingOrderCode,
                                       String remark) {
        return doRecordConsume(companyId, userType, userInfo, userName, beforeBalance, amount, chargingOrderCode,
                remark, true);
    }

    @Override
    public boolean existsConsumeRecord(String chargingOrderCode) {
        if (StringUtils.isBlank(chargingOrderCode)) {
            return false;
        }
        String orderCode = truncate(chargingOrderCode, MAX_ORDER_CODE_LENGTH);
        TCompanyAllocateRecord exists = lambdaQuery()
                .eq(TCompanyAllocateRecord::getChargingOrderCode, orderCode)
                .eq(TCompanyAllocateRecord::getChangeType, TCompanyAllocateRecord.CHANGE_TYPE_CONSUME)
                .last("limit 1")
                .one();
        return exists != null;
    }

    @Override
    public java.util.List<String> listConsumedOrderCodes(java.util.List<String> orderCodes) {
        if (orderCodes == null || orderCodes.isEmpty()) {
            return new java.util.ArrayList<>();
        }
        java.util.List<String> codes = new java.util.ArrayList<>();
        for (String orderCode : orderCodes) {
            if (StringUtils.isNotBlank(orderCode)) {
                String code = truncate(orderCode, MAX_ORDER_CODE_LENGTH);
                if (!codes.contains(code)) {
                    codes.add(code);
                }
            }
        }
        if (codes.isEmpty()) {
            return new java.util.ArrayList<>();
        }
        java.util.List<TCompanyAllocateRecord> records = lambdaQuery()
                .select(TCompanyAllocateRecord::getChargingOrderCode)
                .eq(TCompanyAllocateRecord::getChangeType, TCompanyAllocateRecord.CHANGE_TYPE_CONSUME)
                .in(TCompanyAllocateRecord::getChargingOrderCode, codes)
                .list();
        java.util.List<String> consumed = new java.util.ArrayList<>();
        if (records != null) {
            for (TCompanyAllocateRecord record : records) {
                if (record != null && StringUtils.isNotBlank(record.getChargingOrderCode())
                        && !consumed.contains(record.getChargingOrderCode())) {
                    consumed.add(record.getChargingOrderCode());
                }
            }
        }
        return consumed;
    }

    @Override
    public CompanyAllocateSummaryVO sumAllocatedBalance(Integer companyId) {
        CompanyAllocateSummaryVO summary = new CompanyAllocateSummaryVO();
        summary.setCompanyId(companyId);
        BigDecimal totalBalance = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
        BigDecimal totalLocked = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
        int balanceUserCount = 0;
        if (companyId == null) {
            return summary;
        }
        // VIN码（delFlag 逻辑删除由 @TableLogic 自动过滤）
        List<TVinManagement> vins = vinManagementMapper.selectList(
                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TVinManagement>()
                        .eq(TVinManagement::getCompanyId, companyId)
                        .gt(TVinManagement::getBalance, BigDecimal.ZERO));
        if (vins != null) {
            for (TVinManagement vin : vins) {
                totalBalance = totalBalance.add(normalizeMoney(vin.getBalance()));
                totalLocked = totalLocked.add(normalizeMoney(vin.getLockedAmount()));
                balanceUserCount++;
            }
        }
        // 刷卡卡
        List<TChargingCard> cards = chargingCardMapper.selectList(
                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TChargingCard>()
                        .eq(TChargingCard::getCompanyId, companyId)
                        .gt(TChargingCard::getBalance, BigDecimal.ZERO));
        if (cards != null) {
            for (TChargingCard card : cards) {
                totalBalance = totalBalance.add(normalizeMoney(card.getBalance()));
                totalLocked = totalLocked.add(normalizeMoney(card.getLockedAmount()));
                balanceUserCount++;
            }
        }
        // 白名单手机号
        List<TAppUserWhitelist> whitelists = appUserWhitelistMapper.selectList(
                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TAppUserWhitelist>()
                        .eq(TAppUserWhitelist::getCompanyId, companyId)
                        .gt(TAppUserWhitelist::getBalance, BigDecimal.ZERO));
        if (whitelists != null) {
            for (TAppUserWhitelist whitelist : whitelists) {
                totalBalance = totalBalance.add(normalizeMoney(whitelist.getBalance()));
                totalLocked = totalLocked.add(normalizeMoney(whitelist.getLockedAmount()));
                balanceUserCount++;
            }
        }
        summary.setTotalBalance(totalBalance);
        summary.setTotalLocked(totalLocked);
        summary.setBalanceUserCount(balanceUserCount);
        return summary;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public BigDecimal recycleAllocatedBalance(Integer companyId, String operatorName, String companyName,
                                              BigDecimal companyBalanceBefore) {
        if (companyId == null) {
            throw new ServiceException("公司ID不能为空");
        }
        String operator = truncate(operatorName, MAX_USER_TEXT_LENGTH);
        // 按固定顺序抢占三把公司级锁（与三类额度分配操作互斥，顺序固定避免死锁）
        RLock vinLock = redissonClient.getLock(RECYCLE_LOCK_PREFIX_VIN + companyId);
        RLock cardLock = redissonClient.getLock(RECYCLE_LOCK_PREFIX_CARD + companyId);
        RLock whitelistLock = redissonClient.getLock(RECYCLE_LOCK_PREFIX_WHITELIST + companyId);
        boolean vinLocked = tryRecycleLock(vinLock);
        boolean cardLocked = false;
        boolean whitelistLocked = false;
        try {
            cardLocked = tryRecycleLock(cardLock);
            try {
                whitelistLocked = tryRecycleLock(whitelistLock);
                return doRecycleAllocatedBalance(companyId, operator, companyName, companyBalanceBefore);
            } finally {
                unlockRecycle(whitelistLock, whitelistLocked);
            }
        } finally {
            unlockRecycle(cardLock, cardLocked);
            unlockRecycle(vinLock, vinLocked);
        }
    }

    /**
     * 锁内回收实现：清零三类主体余额并写流水（与余额清零同事务，异常整体回滚），返回实际回收总额。
     */
    private BigDecimal doRecycleAllocatedBalance(Integer companyId, String operator, String companyName,
                                                 BigDecimal companyBalanceBefore) {
        Long operatorId = currentUserId();
        BigDecimal total = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
        String remark = "账户模式切换为共享模式，回收分配余额至公司账户";
        // VIN码
        List<TVinManagement> vins = vinManagementMapper.selectList(
                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TVinManagement>()
                        .eq(TVinManagement::getCompanyId, companyId)
                        .gt(TVinManagement::getBalance, BigDecimal.ZERO));
        if (vins != null) {
            for (TVinManagement vin : vins) {
                BigDecimal before = normalizeMoney(vin.getBalance());
                if (vinManagementMapper.clearBalance(vin.getId(), operatorId) == 1) {
                    total = total.add(before);
                    recordModeSwitchRecord(companyId, TCompanyAllocateRecord.USER_TYPE_VIN, vin.getVin(),
                            vin.getPlateNumber(), operator, operatorId, before, before.negate(), remark);
                }
            }
        }
        // 刷卡卡
        List<TChargingCard> cards = chargingCardMapper.selectList(
                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TChargingCard>()
                        .eq(TChargingCard::getCompanyId, companyId)
                        .gt(TChargingCard::getBalance, BigDecimal.ZERO));
        if (cards != null) {
            for (TChargingCard card : cards) {
                BigDecimal before = normalizeMoney(card.getBalance());
                if (chargingCardMapper.clearBalance(card.getId(), operatorId) == 1) {
                    total = total.add(before);
                    recordModeSwitchRecord(companyId, TCompanyAllocateRecord.USER_TYPE_CARD, card.getCardNo(),
                            null, operator, operatorId, before, before.negate(), remark);
                }
            }
        }
        // 白名单手机号
        List<TAppUserWhitelist> whitelists = appUserWhitelistMapper.selectList(
                new com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper<TAppUserWhitelist>()
                        .eq(TAppUserWhitelist::getCompanyId, companyId)
                        .gt(TAppUserWhitelist::getBalance, BigDecimal.ZERO));
        if (whitelists != null) {
            for (TAppUserWhitelist whitelist : whitelists) {
                BigDecimal before = normalizeMoney(whitelist.getBalance());
                if (appUserWhitelistMapper.clearBalance(whitelist.getId(), operator) == 1) {
                    total = total.add(before);
                    recordModeSwitchRecord(companyId, TCompanyAllocateRecord.USER_TYPE_WHITELIST,
                            whitelist.getPhone(), whitelist.getName(), operator, operatorId, before,
                            before.negate(), remark);
                }
            }
        }
        // 企业账户正数流水：公司余额加回留痕（与用户负流水同事务）
        if (total.signum() > 0) {
            String companyInfo = StringUtils.isNotBlank(companyName) ? companyName : "企业账户";
            recordModeSwitchRecord(companyId, TCompanyAllocateRecord.USER_TYPE_COMPANY, companyInfo, null,
                    operator, operatorId, normalizeMoney(companyBalanceBefore), total, remark);
        }
        return total;
    }

    /** 写入一条模式切换回退流水（change_source=4），写入失败抛出异常由事务回滚保证与余额清零一致 */
    private void recordModeSwitchRecord(Integer companyId, int userType, String userInfo, String userName,
                                        String operator, Long operatorId, BigDecimal beforeBalance,
                                        BigDecimal amount, String remark) {
        BigDecimal before = normalizeMoney(beforeBalance);
        BigDecimal change = normalizeMoney(amount);
        TCompanyAllocateRecord record = new TCompanyAllocateRecord();
        record.setCompanyId(companyId);
        record.setUserType(userType);
        record.setUserInfo(truncate(userInfo, MAX_USER_TEXT_LENGTH));
        record.setUserName(truncate(userName, MAX_USER_TEXT_LENGTH));
        record.setChangeSource(TCompanyAllocateRecord.SOURCE_MODE_SWITCH);
        record.setChangeType(TCompanyAllocateRecord.CHANGE_TYPE_ALLOCATE);
        record.setBeforeBalance(before);
        record.setAmount(change);
        record.setAfterBalance(before.add(change));
        record.setOperatorId(operatorId);
        record.setOperatorName(operator);
        record.setOperateTime(LocalDateTime.now());
        record.setRemark(truncate(remark, MAX_REMARK_LENGTH));
        record.setCreateTime(record.getOperateTime());
        if (!save(record)) {
            throw new ServiceException("模式切换回退流水写入失败");
        }
    }

    /** 抢占回收并发锁，抢占失败抛出业务异常 */
    private boolean tryRecycleLock(RLock lock) {
        try {
            if (!lock.tryLock(LOCK_WAIT_SECONDS, LOCK_LEASE_SECONDS, TimeUnit.SECONDS)) {
                throw new ServiceException("公司额度变更操作正在处理中，请稍后重试");
            }
            return true;
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
            throw new ServiceException("公司额度变更操作正在处理中，请稍后重试");
        }
    }

    /** 释放回收并发锁（仅释放当前线程持有的锁，异常仅记录日志） */
    private void unlockRecycle(RLock lock, boolean locked) {
        if (!locked) {
            return;
        }
        try {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        } catch (Exception ex) {
            log.warn("模式切换回收锁释放失败，lockName={}", lock.getName(), ex);
        }
    }

    /**
     * 消费流水写入公共实现
     *
     * @param allowZeroAmount 是否允许 0 金额写流水（结算幂等标记场景为 true）
     */
    private boolean doRecordConsume(Integer companyId, Integer userType, String userInfo, String userName,
                                    BigDecimal beforeBalance, BigDecimal amount, String chargingOrderCode,
                                    String remark, boolean allowZeroAmount) {
        if (companyId == null || userType == null || StringUtils.isBlank(userInfo)
                || StringUtils.isBlank(chargingOrderCode) || amount == null
                || (!allowZeroAmount && amount.signum() == 0)) {
            log.warn("消费流水参数不完整，跳过写入：companyId={}, userType={}, userInfo={}, orderCode={}",
                    companyId, userType, userInfo, chargingOrderCode);
            return false;
        }
        String orderCode = truncate(chargingOrderCode, MAX_ORDER_CODE_LENGTH);
        TCompanyAllocateRecord exists = lambdaQuery()
                .eq(TCompanyAllocateRecord::getChargingOrderCode, orderCode)
                .eq(TCompanyAllocateRecord::getChangeType, TCompanyAllocateRecord.CHANGE_TYPE_CONSUME)
                .last("limit 1")
                .one();
        if (exists != null) {
            return true;
        }
        BigDecimal change = normalizeMoney(amount);
        BigDecimal before = normalizeMoney(beforeBalance);
        TCompanyAllocateRecord record = new TCompanyAllocateRecord();
        record.setCompanyId(companyId);
        record.setUserType(userType);
        record.setUserInfo(truncate(userInfo, MAX_USER_TEXT_LENGTH));
        record.setUserName(truncate(userName, MAX_USER_TEXT_LENGTH));
        record.setChangeSource(TCompanyAllocateRecord.SOURCE_ALLOCATE);
        record.setChangeType(TCompanyAllocateRecord.CHANGE_TYPE_CONSUME);
        record.setChargingOrderCode(orderCode);
        record.setBeforeBalance(before);
        record.setAmount(change);
        record.setAfterBalance(before.add(change));
        record.setOperatorId(currentUserId());
        record.setOperatorName(currentUsername());
        record.setOperateTime(LocalDateTime.now());
        record.setRemark(truncate(remark, MAX_REMARK_LENGTH));
        record.setCreateTime(record.getOperateTime());
        try {
            return save(record);
        } catch (org.springframework.dao.DuplicateKeyException ex) {
            log.warn("消费流水已存在（订单号{}），忽略重复写入", orderCode);
            return true;
        }
    }

    /** 金额统一保留 2 位小数，null 视为 0 */
    private BigDecimal normalizeMoney(BigDecimal amount) {
        return amount == null ? BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP)
                : amount.setScale(2, RoundingMode.HALF_UP);
    }

    private String truncate(String value, int maxLength) {
        if (value == null) {
            return null;
        }
        String trimmed = value.trim();
        return trimmed.length() > maxLength ? trimmed.substring(0, maxLength) : trimmed;
    }

    /** 操作人ID：无登录上下文（如设备链路）时记为空，不阻断业务 */
    private Long currentUserId() {
        try {
            Long userId = SecurityUtils.getUserId();
            return userId == null || userId == 0L ? null : userId;
        } catch (RuntimeException ex) {
            log.warn("分配记录获取登录用户ID失败，操作人ID记为空：{}", ex.getMessage());
            return null;
        }
    }

    /** 操作人：取登录账号 */
    private String currentUsername() {
        try {
            String username = SecurityUtils.getUsername();
            return StringUtils.isBlank(username) ? null : truncate(username, MAX_USER_TEXT_LENGTH);
        } catch (RuntimeException ex) {
            log.warn("分配记录获取登录账号失败，操作人记为空：{}", ex.getMessage());
            return null;
        }
    }
}