foodie-server/ruoyi-system/src/main/java/com/ruoyi/system/service/PaymentMethodGateService.java

package com.ruoyi.system.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.MessageUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.InfoBankCard;
import com.ruoyi.system.domain.InfoUser;
import com.ruoyi.system.domain.PaymentMethodConfig;
import com.ruoyi.system.domain.PosStoreLinePay;
import com.ruoyi.system.domain.PosStoreOmg;
import com.ruoyi.system.domain.PosStore;
import com.ruoyi.system.mapper.InfoBankCardMapper;
import com.ruoyi.system.mapper.InfoUserMapper;
import com.ruoyi.system.mapper.PaymentMethodConfigMapper;
import com.ruoyi.system.mapper.PosStoreLinePayMapper;
import com.ruoyi.system.mapper.PosStoreOmgMapper;
import com.ruoyi.system.mapper.PosStoreMapper;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 支付方式闸门服务（031 可配置支付方式）——全系统唯一的支付方式可用性判定入口。
 *
 * <p>三层闸门：某支付方式可用 = 平台开关（方式×维度，缺行=开）
 * ∩ 收款方选择（普通商家/骑手在 info_user，摊位在 pos_store；NULL=全部）
 * ∩ 就绪度（门店凭证或对应归属的启用银行卡）。
 * 所有下单入口（用户餐饮下单、商家建单、闪送下单）与 bankInfo 必须统一调用
 * {@link #assertUsable(String, GateScope, Long, Long)}，禁止在各自入口重复实现判定逻辑，
 * 保证闸门规则变化只改本类、全部入口行为一致（spec FR-004）。</p>
 *
 * <p>刻意不加缓存：开关表最多 4×2 行的小表索引查询，直查天然满足"保存后下一次查询即生效"
 * （SC-001），避免缓存失效复杂度。</p>
 */
@Service
public class PaymentMethodGateService {

    /** 支付方式组代码：到付（payType=1）。 */
    public static final String GROUP_COD = "COD";
    /** 支付方式组代码：信用卡+Apple Pay 同组（payType=2、5，OMG 渠道同开同关）。 */
    public static final String GROUP_CARD_OMG = "CARD_OMG";
    /** 支付方式组代码：LINE Pay（payType=3）。 */
    public static final String GROUP_LINE_PAY = "LINE_PAY";
    /** 支付方式组代码：线下转账（payType=6）。 */
    public static final String GROUP_OFFLINE = "OFFLINE_TRANSFER";
    /** 支付方式组代码：现金（payType=4）；平台开关管控用户自取/堂食口径，叠加商家勾选；无就绪度要求（031 US7/FR-006）。 */
    public static final String GROUP_CASH = "CASH";

    /** 现金 payType=4：原 assertUsable 路径（商家建单/闪送缺省现金）直接放行；用户单经 assertUsableForOrder 按订单类型管控。 */
    public static final String PAY_TYPE_CASH = "4";

    /** payType 数值 → 组代码；不在表内的值视为非法（现金"4"仅走专门分支，不进映射）。 */
    private static final Map<String, String> PAY_TYPE_TO_GROUP = Map.of(
            "1", GROUP_COD,
            "2", GROUP_CARD_OMG,
            "3", GROUP_LINE_PAY,
            "5", GROUP_CARD_OMG,
            "6", GROUP_OFFLINE);

    /** 各维度可管控的组集合；RIDER_FLASH 无线上卡支付（闪送资金直达骑手）且不含现金（缺省支付不经勾选）。 */
    private static final Map<GateScope, List<String>> SCOPE_GROUPS = Map.of(
            GateScope.MERCHANT, List.of(GROUP_COD, GROUP_CARD_OMG, GROUP_LINE_PAY, GROUP_OFFLINE, GROUP_CASH),
            GateScope.RIDER_FLASH, List.of(GROUP_COD, GROUP_LINE_PAY, GROUP_OFFLINE));

    /** 闸门维度：商家餐饮单（用户向商家付款）与骑手闪送（用户直达骑手）独立开关。 */
    public enum GateScope {
        MERCHANT, RIDER_FLASH
    }

    /**
     * 供结算页渲染的一项可选支付方式。
     * CARD_OMG 组按 payType 展开为 2（信用卡）、5（Apple Pay）两项，组内 ready 一致。
     */
    public static class PayMethodOption {
        /** 支付方式组代码。 */
        private final String methodCode;
        /** 对外 payType 数值（"1"/"2"/"3"/"5"/"6"）。 */
        private final String payType;
        /** 就绪度：false 表示当前不可实际使用（如线下转账无启用卡），前端应置灰或不渲染。 */
        private final boolean ready;

        public PayMethodOption(String methodCode, String payType, boolean ready) {
            this.methodCode = methodCode;
            this.payType = payType;
            this.ready = ready;
        }

        public String getMethodCode() { return methodCode; }
        public String getPayType() { return payType; }
        public boolean isReady() { return ready; }
    }

    private final PaymentMethodConfigMapper configMapper;
    private final InfoUserMapper userMapper;
    private final InfoBankCardMapper bankCardMapper;
    private final PosStoreOmgMapper omgMapper;
    private final PosStoreLinePayMapper linePayMapper;
    private final PosStoreMapper storeMapper;
    @org.springframework.beans.factory.annotation.Autowired
    private IInfoRiderLinePayService riderLinePayService;

    public PaymentMethodGateService(PaymentMethodConfigMapper configMapper,
                                    InfoUserMapper userMapper,
                                    InfoBankCardMapper bankCardMapper,
                                    PosStoreOmgMapper omgMapper,
                                    PosStoreLinePayMapper linePayMapper,
                                    PosStoreMapper storeMapper) {
        this.configMapper = configMapper;
        this.userMapper = userMapper;
        this.bankCardMapper = bankCardMapper;
        this.omgMapper = omgMapper;
        this.linePayMapper = linePayMapper;
        this.storeMapper = storeMapper;
    }

    /**
     * 校验支付方式可用，不可用抛出国际化异常；三下单入口与 bankInfo 统一调用（唯一入口）。
     *
     * @param payType 支付方式数值（与订单 payType 同域）
     * @param scope 闸门维度
     * @param storeId 门店 ID（MERCHANT 维度线上渠道就绪度用：pos_store_omg/pos_store_line_pay 为门店级凭证）
     * @param payeeUserId 收款方用户 ID（普通商家主账号；摊位传夜市主账号也不会继承其支付设置；闪送下单时无收款方传 null）
     */
    public void assertUsable(String payType, GateScope scope, Long storeId, Long payeeUserId) {
        if (!isUsable(payType, scope, storeId, payeeUserId)) {
            throw new ServiceException(MessageUtils.message("pay.method.not.available"));
        }
    }

    /**
     * 带订单类型的校验重载（031 US7）：用户餐饮下单统一调用。
     * 现金在此口径下按订单类型与商家勾选管控：自取/堂食查商家选择，外送拒绝，
     * orderType 缺失（商家建单/闪送缺省现金）与原 {@link #assertUsable} 口径一致放行。
     *
     * @param orderType 订单类型（PosOrder.type：0外送 1自取 2堂食）；无类型上下文传 null
     */
    public void assertUsableForOrder(String payType, GateScope scope, Long storeId, Long payeeUserId, Long orderType) {
        if (!isUsableForOrder(payType, scope, storeId, payeeUserId, orderType)) {
            throw new ServiceException(MessageUtils.message("pay.method.not.available"));
        }
    }

    /** 现金订单类型口径的单一判定；非现金支付方式与原 isUsable 完全同路径。 */
    private boolean isUsableForOrder(String payType, GateScope scope, Long storeId, Long payeeUserId, Long orderType) {
        if (PAY_TYPE_CASH.equals(payType)) {
            if (orderType == null || scope == GateScope.RIDER_FLASH) return true;
            if (orderType != 1L && orderType != 2L) return false;
            if (platformDisabledMap(scope).containsKey(GROUP_CASH)) return false;
            Set<String> selected = selectedGroups(scope, storeId, payeeUserId);
            return selected == null || selected.contains(GROUP_CASH);
        }
        return isUsable(payType, scope, storeId, payeeUserId);
    }

    /**
     * 列出某维度对收款方当前可用的支付方式（结算页可选项、骑手端可选集共用）。
     * 返回平台开关 ∩ 收款方选择并附就绪度；已知骑手还须具备对应收款配置。
     * 骑手未定（用户下单）仅服从平台开关，接单接口再校验具体收款人。
     */
    public List<PayMethodOption> listAvailable(GateScope scope, Long storeId, Long payeeUserId) {
        return listAvailable(scope, storeId, payeeUserId, null);
    }

    /**
     * orderType 感知重载（031 US7）：MERCHANT 维度且 orderType∈{1自取,2堂食} 时结果含现金项
     * （仍受商家勾选约束）；其余 orderType 或原签名口径不含现金，老客户端零变化。
     */
    public List<PayMethodOption> listAvailable(GateScope scope, Long storeId, Long payeeUserId, Long orderType) {
        Map<String, Boolean> disabled = platformDisabledMap(scope);
        Set<String> selected = selectedGroups(scope, storeId, payeeUserId);
        boolean cashVisible = scope == GateScope.MERCHANT && orderType != null
                && (orderType == 1L || orderType == 2L);
        List<PayMethodOption> result = new ArrayList<>();
        for (String group : SCOPE_GROUPS.get(scope)) {
            if (GROUP_CASH.equals(group) && !cashVisible) continue;
            if (disabled.containsKey(group)) continue;
            if (selected != null && !selected.contains(group)) continue;
            boolean ready = isReady(group, scope, storeId, payeeUserId);
            for (String payType : payTypesOf(group)) {
                result.add(new PayMethodOption(group, payType, ready));
            }
        }
        return result;
    }

    /** 单一判定实现：assertUsable 与调用方需要的布尔语义共用，保证两口径永不分裂。 */
    private boolean isUsable(String payType, GateScope scope, Long storeId, Long payeeUserId) {
        // 现金仅商家建单场景使用，明确不纳入管控（spec FR-006）。
        if (PAY_TYPE_CASH.equals(payType)) return true;
        String group = PAY_TYPE_TO_GROUP.get(payType);
        if (group == null || !SCOPE_GROUPS.get(scope).contains(group)) return false;
        if (platformDisabledMap(scope).containsKey(group)) return false;
        Set<String> selected = selectedGroups(scope, storeId, payeeUserId);
        if (selected != null && !selected.contains(group)) return false;
        return isReady(group, scope, storeId, payeeUserId);
    }

    /** 平台已关闭的组集合（该维度）；缺行=开，仅 enabled=0 的行进集合。 */
    private Map<String, Boolean> platformDisabledMap(GateScope scope) {
        List<PaymentMethodConfig> rows = configMapper.selectList(
                new QueryWrapper<PaymentMethodConfig>().eq("scope", scope.name()));
        Map<String, Boolean> disabled = new HashMap<>();
        for (PaymentMethodConfig row : rows) {
            if (Integer.valueOf(0).equals(row.getEnabled())) {
                disabled.put(row.getMethodCode(), Boolean.TRUE);
            }
        }
        return disabled;
    }

    /** 收款方接受的组集合；摊位按 storeId 读，普通商家/骑手按用户读；NULL/空=全部接受。 */
    private Set<String> selectedGroups(GateScope scope, Long storeId, Long payeeUserId) {
        String csv;
        PosStore store = scope == GateScope.MERCHANT && storeId != null ? storeMapper.selectById(storeId) : null;
        if (store != null && Integer.valueOf(1).equals(store.getIsStall())) {
            // 摊位的 pos_store.user_id 是夜市主，不能读取其个人支付选择。
            csv = store.getPayMethods();
        } else {
            if (payeeUserId == null) return null;
            InfoUser user = userMapper.selectById(payeeUserId);
            if (user == null) return null;
            csv = scope == GateScope.MERCHANT ? user.getPayMethods() : user.getFlashPayMethods();
        }
        if (StringUtils.isEmpty(csv) || csv.trim().isEmpty()) return null;
        Set<String> groups = new java.util.HashSet<>();
        for (String part : csv.split(",")) {
            String value = part.trim();
            if (!value.isEmpty()) groups.add(value);
        }
        return groups.isEmpty() ? null : groups;
    }

    /**
     * 商家支付设置页可选集：平台开放全集（不按商家已有选择过滤——页面本身用于修改选择），
     * 就绪度按名下门店聚合——线上渠道任一门店有启用凭证即算就绪，线下转账看主账号启用卡。
     * 摊位设置页传 ownerUserId=null、唯一 storeId，只读取该摊位的银行卡；普通商家保持主账号归属。
     * 供 GET /system/merchantPayMethods 使用；结算页口径见 {@link #listAvailable}。
     */
    public List<PayMethodOption> listAvailableForMerchantSettings(Long ownerUserId, List<Long> storeIds) {
        Map<String, Boolean> disabled = platformDisabledMap(GateScope.MERCHANT);
        List<PayMethodOption> result = new ArrayList<>();
        for (String group : SCOPE_GROUPS.get(GateScope.MERCHANT)) {
            if (disabled.containsKey(group)) continue;
            boolean ready;
            if (GROUP_CARD_OMG.equals(group) || GROUP_LINE_PAY.equals(group)) {
                ready = false;
                if (storeIds != null) {
                    for (Long storeId : storeIds) {
                        if (storeCredentialReady(group, storeId)) { ready = true; break; }
                    }
                }
            } else if (GROUP_OFFLINE.equals(group)) {
                if (ownerUserId == null && storeIds != null && storeIds.size() == 1) {
                    // 摊位设置页传唯一 storeId；卡归属摊位而非夜市主账号。
                    ready = bankCardMapper.selectCount(new QueryWrapper<InfoBankCard>()
                            .eq("store_id", storeIds.get(0)).eq("is_active", 1)) > 0;
                } else {
                    ready = ownerUserId != null && bankCardMapper.selectCount(
                            new QueryWrapper<InfoBankCard>().eq("user_id", ownerUserId).eq("is_active", 1)) > 0;
                }
            } else {
                ready = true;
            }
            for (String payType : payTypesOf(group)) {
                result.add(new PayMethodOption(group, payType, ready));
            }
        }
        return result;
    }

    /**
     * 商家设置页独立的只读说明；不扩展共用 PayMethodOption，以保持用户结算和骑手接口原样。
     * 普通商家和摊位读取同一份平台说明，商家保存支付选择时不能改写此配置。
     */
    public Map<String, String> listMerchantRemarks() {
        Map<String, String> remarks = new HashMap<>();
        for (PaymentMethodConfig row : configMapper.selectList(new QueryWrapper<PaymentMethodConfig>()
                .eq("scope", GateScope.MERCHANT.name()))) {
            if (GateScope.MERCHANT.name().equals(row.getScope())
                    && SCOPE_GROUPS.get(GateScope.MERCHANT).contains(row.getMethodCode())
                    && StringUtils.isNotBlank(row.getRemark())) {
                remarks.put(row.getMethodCode(), row.getRemark());
            }
        }
        return remarks;
    }

    /**
     * 就绪度判定：MERCHANT 维度线上渠道看门店级凭证、线下转账按普通商家或摊位归属看启用卡；
     * RIDER_FLASH 维度线上收款要求启用的骑手凭证，线下转账要求启用卡。
     */
    private boolean isReady(String group, GateScope scope, Long storeId, Long payeeUserId) {
        if (group.equals(GROUP_COD) || group.equals(GROUP_CASH)) return true;
        if (scope == GateScope.RIDER_FLASH) {
            // 待抢列表和接单使用同一闸门，不让无 LINE Pay 收款资格的骑手抢线上单。
            if (GROUP_LINE_PAY.equals(group) && payeeUserId != null) {
                return riderLinePayService.getEnabledCurrent(payeeUserId) != null;
            }
            // 线下转账：骑手身份已知（抢单池/骑手端可选集）要求启用卡；用户下单骑手未定（null）放行
            return !GROUP_OFFLINE.equals(group) || payeeUserId == null || bankCardMapper.selectCount(
                    new QueryWrapper<InfoBankCard>().eq("user_id", payeeUserId).eq("is_active", 1)) > 0;
        }
        switch (group) {
            case GROUP_CARD_OMG:
            case GROUP_LINE_PAY:
                return storeId != null && storeCredentialReady(group, storeId);
            case GROUP_OFFLINE:
                PosStore store = storeId == null ? null : storeMapper.selectById(storeId);
                if (store != null && Integer.valueOf(1).equals(store.getIsStall())) {
                    return bankCardMapper.selectCount(new QueryWrapper<InfoBankCard>()
                            .eq("store_id", storeId).eq("is_active", 1)) > 0;
                }
                return payeeUserId != null && bankCardMapper.selectCount(
                        new QueryWrapper<InfoBankCard>().eq("user_id", payeeUserId).eq("is_active", 1)) > 0;
            default:
                return false;
        }
    }

    /** 门店级线上渠道凭证就绪：存在 is_enabled=1 的 OMG/LINE Pay 配置行。 */
    private boolean storeCredentialReady(String group, Long storeId) {
        if (GROUP_CARD_OMG.equals(group)) {
            return omgMapper.selectCount(
                    new QueryWrapper<PosStoreOmg>().eq("store_id", storeId).eq("is_enabled", 1)) > 0;
        }
        return linePayMapper.selectCount(
                new QueryWrapper<PosStoreLinePay>().eq("store_id", storeId).eq("is_enabled", 1)) > 0;
    }

    /** 组代码 → 对外 payType 展开顺序（保持稳定展示顺序）；供抢单过滤等调用方展开。 */
    public static List<String> payTypesOf(String group) {
        switch (group) {
            case GROUP_COD: return List.of("1");
            case GROUP_CARD_OMG: return List.of("2", "5");
            case GROUP_LINE_PAY: return List.of("3");
            case GROUP_OFFLINE: return List.of("6");
            case GROUP_CASH: return List.of(PAY_TYPE_CASH);
            default: return List.of();
        }
    }

    /** 全部合法组代码（平台设置页与保存校验用）。 */
    public static List<String> allGroups() {
        return Arrays.asList(GROUP_COD, GROUP_CARD_OMG, GROUP_LINE_PAY, GROUP_OFFLINE);
    }

    /** 维度合法组集合（保存收款方选择时校验值域用）。 */
    public static List<String> groupsOf(GateScope scope) {
        return SCOPE_GROUPS.get(scope);
    }

    /** 平台开关矩阵的组集合：与维度组一致（现金进商家维度矩阵，标注仅自取/堂食；骑手维度本就无现金）。 */
    public static List<String> platformGroupsOf(GateScope scope) {
        return groupsOf(scope);
    }

    /** payType → 组代码映射查询（保存/展示场景用）；未知返回 null。 */
    public static String groupOfPayType(String payType) {
        return PAY_TYPE_TO_GROUP.get(payType);
    }
}