package com.talentcard.server.business.payment;

import com.talentcard.server.business.BusinessIdGenerator;
import com.talentcard.server.business.DatabaseRows;
import com.talentcard.server.business.MoneyUtils;
import com.talentcard.server.business.order.OrderFundBoundaryService;
import com.talentcard.server.business.order.OrderRefundRequest;
import com.talentcard.server.business.payment.huifu.HuifuPaymentGatewayException;
import com.talentcard.server.business.payment.huifu.HuifuPayload;
import com.talentcard.server.business.payment.huifu.HuifuPaymentProperties;
import com.talentcard.server.business.payment.huifu.HuifuRefundCommand;
import com.talentcard.server.business.payment.huifu.HuifuRefundGateway;
import com.talentcard.server.common.BusinessException;
import com.talentcard.server.common.ErrorCode;
import org.springframework.jdbc.core.JdbcTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Service
public class HuifuRefundService {

    private static final String PROVIDER = "HUIFU";
    private static final DateTimeFormatter REQUEST_DATE = DateTimeFormatter.ofPattern("yyyyMMdd");
    private static final Logger log = LoggerFactory.getLogger(HuifuRefundService.class);

    private final JdbcTemplate jdbc;
    private final TransactionTemplate transactions;
    private final HuifuRefundGateway gateway;
    private final HuifuPaymentProperties huifuPaymentProperties;
    private final OrderFundBoundaryService orderFundBoundary;

    public HuifuRefundService(JdbcTemplate jdbc, TransactionTemplate transactions, HuifuRefundGateway gateway, HuifuPaymentProperties huifuPaymentProperties, OrderFundBoundaryService orderFundBoundary) {
        this.jdbc = jdbc;
        this.transactions = transactions;
        this.gateway = gateway;
        this.huifuPaymentProperties = huifuPaymentProperties;
        this.orderFundBoundary = orderFundBoundary;
    }

    public Map<String, Object> request(String orderNo, OrderRefundRequest request) {
        PreparedRefund prepared = transactions.execute(status -> prepare(orderNo, request, false));
        if (prepared == null) throw new BusinessException(ErrorCode.INTERNAL_ERROR, "Refund initialization failed");
        // 本地结清的退款在 prepare 的事务里就已经落定，没有通道答复要等（也没有通道可以问）。
        if (prepared.settledLocally()) return detail(prepared.refundNo());
        return submit(prepared);
    }

    /**
     * 悬账自动退款：通道确认收到、但订单已经取消的钱，原路退回付款人。
     *
     * <p>这是**窄口子**入口，只服务一种情形（{@code requireStrandedRefundable}）：订单已取消、通道确认
     * 收过钱、还没退、也没有退款记录。它有唯一正确的出路（退回付款人），没有需要人判断的地方；留人工只会
     * 让它一直挂在页面上。它**不绕过**资金边界：仍然先锁订单行，因此与撤销核销、交易确认、普通退款互相
     * 串行化，不会互踩。
     *
     * <p>它不返回通道的最终结论——退款本身也要等通道出结果，那由退款对账与读路径收敛。这里只回答
     * 「有没有把退款发出去」，因为调用方（定时消费者）据此决定是结掉问题记录还是升级告警。
     */
    public StrandedRefundOutcome refundStranded(String orderNo) {
        PreparedRefund prepared;
        try {
            prepared = transactions.execute(status -> prepare(orderNo, new OrderRefundRequest(
                    BigDecimal.ZERO, "订单取消后通道确认收款，自动退回付款人", "system"), true));
        } catch (BusinessException exception) {
            // 这条窄口子不适用（订单没取消、支付没有通道确认的成功事实、已经退过）：不是通道拒绝，
            // 不该升级告警，交回调用方按自己的规则处理。
            return StrandedRefundOutcome.NOT_APPLICABLE;
        }
        if (prepared == null) return StrandedRefundOutcome.NOT_APPLICABLE;
        try {
            submit(prepared);
            return StrandedRefundOutcome.SUBMITTED;
        } catch (BusinessException exception) {
            // 通道明确拒绝（例如商户基本户余额不足）：必须转人工，绝不能静默吞掉。
            log.warn("Stranded refund {} for order {} was rejected: {}",
                    prepared.refundNo(), orderNo, exception.getMessage());
            return StrandedRefundOutcome.REJECTED;
        }
    }

    /** 悬账自动退款的结论。 */
    public enum StrandedRefundOutcome {
        /** 退款请求已被通道受理：最终结果由退款对账与读路径收敛。 */
        SUBMITTED,
        /** 通道明确拒绝：要升级告警转人工。 */
        REJECTED,
        /** 没有可自动退的悬账：不需要处理。 */
        NOT_APPLICABLE
    }

    /** 把一笔已准备好的退款发给通道，并记录通道的答复。 */
    private Map<String, Object> submit(PreparedRefund prepared) {
        Map<String, Object> response;
        try {
            response = gateway.createRefund(new HuifuRefundCommand(
                    prepared.refundNo(), prepared.huifuId(), prepared.paymentNo(), prepared.originalProviderNo(),
                    prepared.originalRequestDate(), prepared.refundAmount()));
        } catch (HuifuPaymentGatewayException exception) {
            if (!exception.isOutcomeUnknown()) {
                markFailed(prepared.refundNo(), prepared.orderId(), "GATEWAY_REJECTED", exception.getMessage());
                throw new BusinessException(ErrorCode.CONFLICT, "Refund request was rejected");
            }
            return detail(prepared.refundNo());
        } catch (BusinessException exception) {
            markFailed(prepared.refundNo(), prepared.orderId(), "LOCAL_ERROR", exception.getMessage());
            throw exception;
        } catch (RuntimeException exception) {
            return detail(prepared.refundNo());
        }

        ProviderResult result = ProviderResult.from(response);
        if (result.success()) {
            markSucceeded(prepared, result);
        } else if (result.failed()) {
            markFailed(prepared.refundNo(), prepared.orderId(), result.code(), result.message());
            throw new BusinessException(ErrorCode.CONFLICT, "Refund request was rejected");
        } else {
            updateProviderResult(prepared.refundNo(), result);
        }
        return detail(prepared.refundNo());
    }

    public Map<String, Object> query(String refundNo) {
        Map<String, Object> refund = detail(refundNo);
        if (number(refund.get("refundStatus")) != 1) return refund;
        HuifuRefundCommand command = new HuifuRefundCommand(
                refundNo,
                refundHuifuId(refund.get("providerHuifuId")),
                text(refund.get("providerOriginalReqSeqId")),
                text(refund.get("providerOriginalNo")),
                text(refund.get("providerOriginalReqDate")),
                number(refund.get("refundAmount")));
        try {
            ProviderResult result = ProviderResult.from(gateway.queryRefund(command, text(refund.get("providerRefundNo"))));
            if (result.success()) markSucceeded(new PreparedRefund(refundNo, number(refund.get("orderId")), number(refund.get("refundAmount"))), result);
            else if (result.failed()) markFailed(refundNo, number(refund.get("orderId")), result.code(), result.message());
            else updateProviderResult(refundNo, result);
        } catch (HuifuPaymentGatewayException ignored) {
            // Keep the refund pending when the provider outcome is unknown.
        }
        return detail(refundNo);
    }

    /** 刚提交的退款通道必然还在处理，留一点时间再去问，避免用户一打开页面就打通道。 */
    private static final int SUBMISSION_GRACE_SECONDS = 20;
    /** 一轮最多收敛几笔在途退款：正常用户同一时刻只有一笔，列表读路径不该被它拖长。 */
    public static final int PENDING_CONFIRM_LIMIT = 2;

    /**
     * 把这位人才名下还在途的退款各自向通道确认一次。
     *
     * <p>退款提交时通道多半只回「处理中」，最终结果只有通道知道；退款通知又会遇到和支付通知一样的
     * 问题——本地或内网环境收不到。于是在读订单/读订单列表之前问一次，把「退款中」尽快收敛成通道的
     * 最终答案，而不是等对账任务的下一个窗口（最长十分钟）。已经落定的退款连查都不查。
     *
     * <p>在自己的事务里执行，且必须是调用方事务里的**第一条**语句：调用方的事务要能读到收敛后的状态，
     * 而 MySQL 的一致性快照是在该事务的第一条读语句上定下的。单笔查询失败只跳过这一笔——读路径上的
     * 尽力收敛，查不到结果不该让订单列表打不开，剩下的交给对账任务和下一次读。
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public int confirmPendingRefunds(Long talentId, int limit) {
        return confirmPendingRefunds("o.talent_id", talentId, limit);
    }

    /** 同上，按商户归属收敛：商户端订单列表读之前调用，免得商户看到的退款状态比人才端晚几分钟。 */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public int confirmPendingRefundsOfMerchant(Long merchantId, int limit) {
        return confirmPendingRefunds("o.merchant_id", merchantId, limit);
    }

    private int confirmPendingRefunds(String ownerColumn, Long ownerId, int limit) {
        if (ownerId == null) return 0;
        List<Map<String, Object>> pending = rows("""
                select r.refund_no
                from order_refund r
                join benefit_order o on o.id = r.order_id
                where r.deleted = 0 and r.provider = ? and r.refund_status = 1
                  and o.deleted = 0 and %s = ?
                  and r.created_at <= date_sub(now(), interval ? second)
                order by r.id desc
                limit ?
                """.formatted(ownerColumn), PROVIDER, ownerId, SUBMISSION_GRACE_SECONDS, Math.max(1, limit));
        for (Map<String, Object> row : pending) {
            try {
                query(text(row.get("refundNo")));
            } catch (RuntimeException ignored) {
                // 这一笔这次问不到，保持在途；对账任务与下一次读会再来。
            }
        }
        return pending.size();
    }

    public Map<String, Object> detail(String refundNo) {
        List<Map<String, Object>> rows = rows("""
                select r.id, r.order_id, r.refund_no, r.order_no, r.order_type, r.paid_amount, r.refund_amount,
                       r.refundable_amount, r.refund_status, r.provider, r.provider_refund_no, r.provider_huifu_id,
                       r.provider_original_no, r.provider_original_req_seq_id, r.provider_original_req_date,
                       r.provider_response_code, r.provider_response_message, r.reason, r.operator_name, r.refund_time
                from order_refund r
                where r.deleted = 0 and r.refund_no = ?
                """, refundNo);
        if (rows.isEmpty()) throw new BusinessException(ErrorCode.NOT_FOUND, "Refund record not found");
        return rows.get(0);
    }

    /**
     * 无实付金额订单的回执：它不是通道说的，是本地结清时自己写的。
     *
     * <p>写进 {@code provider_response_*} 是为了让这条记录自解释——事后看到「退款成功、金额 0、通道退款号为空」
     * 时，能直接从这两列读出「它从来没有出过本地」，不必再去通道上找一笔不存在的退款。
     */
    private static final ProviderResult LOCAL_REFUND_RESULT = new ProviderResult(
            true, false, "LOCAL_NO_PAYABLE_AMOUNT", "订单无实付金额（由权益免费额度覆盖），本地退款，无需通道退款", "");

    /**
     * 准备一笔退款：锁定订单行、确认这笔退款合法、算出可退金额、落一条退款记录。
     *
     * <p>「支付键可见性」不是只看已成功流水：本地已关闭、但通道确认收过钱的那一类悬账
     * （{@code CLOSED} + 一条「取消后才收到钱」的问题记录）也必须能被定位到原支付流水，
     * 否则连退款都发起不了——而这类钱的唯一出路就是退回付款人。
     *
     * @param stranded 悬账退款（只服务「订单已取消 + 通道确认收款」）：走窄口子断言，跳过核销状态判断。
     */
    private PreparedRefund prepare(String orderNo, OrderRefundRequest request, boolean stranded) {
        List<Map<String, Object>> orders = rows("""
                select o.id, o.order_no, o.talent_id, o.card_id, o.benefit_id, o.merchant_id, o.order_type,
                       o.pay_amount, o.order_status, o.verify_status,
                       p.payment_no, p.provider_transaction_no, p.created_at as payment_created_at,
                       coalesce(p.provider_huifu_id, o.collect_huifu_id) as huifu_id
                from benefit_order o
                left join payment_transaction p on p.order_id = o.id and p.provider = ?
                     and (p.status = 'SUCCEEDED'
                          or (p.status = 'CLOSED'
                              and exists (select 1 from payment_reconciliation_issue i
                                          where i.issue_type = 'PAYMENT_ORDER_CANCELLED' and i.provider = p.provider
                                            and i.business_no = p.payment_no)))
                where o.deleted = 0 and o.order_no = ?
                order by (p.status = 'SUCCEEDED') desc, p.id desc
                limit 1 for update
                """, PROVIDER, orderNo);
        if (orders.isEmpty()) throw new BusinessException(ErrorCode.NOT_FOUND, "Order not found");
        Map<String, Object> order = orders.get(0);
        // 支付、核销、退款、提现锁定都按订单串行化：锁住订单行之后才判断能不能退款。
        OrderFundBoundaryService.LockedOrder locked = orderFundBoundary.lock(number(order.get("id")));
        if (stranded) {
            locked.requireStrandedRefundable();
        } else {
            locked.requireRefundable();
            if (locked.verifyStatus() == 1 && !"STORE_CONSUME".equals(text(order.get("orderType")))) {
                throw new BusinessException(ErrorCode.CONFLICT, "Verified orders cannot be refunded");
            }
        }

        // 部分退款：能不能退按金额算，而不是「有过退款记录就拒绝」。后者的副作用是首笔部分退款之后
        // 剩余金额永远退不了（审计 §14）。在途金额也要算进去，否则同一笔钱会被退两次。
        long paidAmount = number(order.get("payAmount"));
        long successfulRefund = refundedAmount(number(order.get("id")));
        long pendingRefund = pendingRefundAmount(number(order.get("id")));
        long refundableAmount = Math.max(paidAmount - successfulRefund - pendingRefund, 0);
        long requestedAmount = MoneyUtils.yuanToCent(request.refundAmount());
        long refundAmount = requestedAmount > 0 ? requestedAmount : refundableAmount;
        // 没有实付金额的订单（整单被权益免费额度覆盖、下单即 order_status=1 且从来没有支付尝试）里没有钱，
        // 通道那边也没有原交易可指。它仍然必须能退——要还回去的是那一次被占用的免费额度——所以它的出路是
        // 本地结清，而不是向通道发起退款：发起也只会得到「金额非法」，用户从此卡在待使用里出不去。
        // 悬账退款不在此列：悬账退的是通道真收过的钱，必须走通道。
        boolean settledLocally = !stranded && paidAmount <= 0 && refundAmount == 0;
        if (!settledLocally && (refundAmount <= 0 || refundAmount > refundableAmount)) throw new BusinessException(ErrorCode.BAD_REQUEST, "Invalid refund amount");

        String paymentNo = text(order.get("paymentNo"));
        String providerNo = text(order.get("providerTransactionNo"));
        if (!settledLocally && paymentNo.isBlank() && providerNo.isBlank()) throw new BusinessException(ErrorCode.CONFLICT, "Payment transaction is not ready for refund");
        String huifuId = settledLocally ? null : refundHuifuId(order.get("huifuId"));
        String refundNo = BusinessIdGenerator.next("R");
        String requestDate = settledLocally ? null : requestDate(order.get("paymentCreatedAt"));
        jdbc.update("""
                insert into order_refund(refund_no, order_id, order_no, talent_id, card_id, benefit_id, merchant_id,
                                         order_type, paid_amount, refund_amount, refundable_amount, refund_status,
                                         provider, provider_huifu_id, provider_original_no, provider_original_req_seq_id, provider_original_req_date,
                                         reason, operator_name)
                values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?)
                """,
                refundNo, order.get("id"), order.get("orderNo"), order.get("talentId"), order.get("cardId"),
                order.get("benefitId"), order.get("merchantId"), order.get("orderType"), paidAmount, refundAmount,
                refundableAmount - refundAmount, settledLocally ? null : PROVIDER, huifuId, providerNo, paymentNo,
                requestDate, request.reason(), request.operatorName());
        // 退款受理成功即刻生效：在结果确定前订单不再可核销，也不参与提现汇总。
        orderFundBoundary.markRefundInProgress(number(order.get("id")));
        PreparedRefund result = new PreparedRefund(refundNo, number(order.get("id")), huifuId, paymentNo, providerNo, requestDate, refundAmount, settledLocally);
        if (settledLocally) {
            // 与 prepare 同一事务里当场结清，不把订单留在「退款中」：那个状态的含义是等通道的结论，而这
            // 单没有通道那一侧，留在这里就永远等不到（退款对账只扫 provider = HUIFU 的在途行）。
            markSucceeded(result, LOCAL_REFUND_RESULT);
        }
        return result;
    }

    private void markSucceeded(PreparedRefund prepared, ProviderResult result) {
        transactions.executeWithoutResult(status -> {
            // 通道退款流水号只在发起退款的那次回执里有；退款查询的回执不带它。这里必须保留已有的号，
            // 否则查单确认会把唯一的通道凭证覆盖成空，退款排查和对账就失去定位依据。
            jdbc.update("""
                    update order_refund
                    set refund_status = 2, provider_refund_no = coalesce(nullif(?, ''), provider_refund_no),
                        provider_response_code = ?, provider_response_message = ?, refund_time = now()
                    where refund_no = ? and refund_status = 1
                    """, result.providerNo(), result.code(), result.message(), prepared.refundNo());
            jdbc.update("""
                    update benefit_order o
                    set o.order_status = 2
                    where o.id = ? and o.order_status = 1
                      and o.pay_amount <= (select coalesce(sum(r.refund_amount), 0) from order_refund r where r.order_id = o.id and r.refund_status = 2 and r.deleted = 0)
                    """, prepared.orderId());
            orderFundBoundary.markRefunded(prepared.orderId());
        });
    }

    /** 退款失败没有资金变动，订单回到未退款状态（可再次核销或再次退款）。 */
    private void markFailed(String refundNo, long orderId, String code, String message) {
        transactions.executeWithoutResult(status -> {
            int failed = jdbc.update("update order_refund set refund_status = 3, provider_response_code = ?, provider_response_message = ? where refund_no = ? and refund_status = 1", code, message, refundNo);
            // 只有本事务真的把这笔退款置为失败，才把订单退回未退款状态；否则会覆盖并发的退款成功。
            if (failed == 1) orderFundBoundary.markRefundFailed(orderId);
        });
    }

    private void updateProviderResult(String refundNo, ProviderResult result) {
        jdbc.update("update order_refund set provider_refund_no = coalesce(?, provider_refund_no), provider_response_code = ?, provider_response_message = ? where refund_no = ? and refund_status = 1", result.providerNo(), result.code(), result.message(), refundNo);
    }

    private long refundedAmount(long orderId) {
        Long total = jdbc.queryForObject("select coalesce(sum(refund_amount), 0) from order_refund where deleted = 0 and refund_status = 2 and order_id = ?", Long.class, orderId);
        return total == null ? 0 : total;
    }

    /** 已经发出去、还没有最终结果的退款金额：它同样不能再退一次。 */
    private long pendingRefundAmount(long orderId) {
        Long total = jdbc.queryForObject("select coalesce(sum(refund_amount), 0) from order_refund where deleted = 0 and refund_status = 1 and order_id = ?", Long.class, orderId);
        return total == null ? 0 : total;
    }

    /**
     * The merchant a refund must be requested from: the sub-merchant fixed on the payment or the
     * order. Payments made before the collecting sub-merchant was recorded were collected by the
     * configured platform merchant, so those fall back to it instead of the refund failing.
     */
    private String refundHuifuId(Object storedHuifuId) {
        String resolved = text(storedHuifuId);
        return resolved.isBlank() ? text(huifuPaymentProperties.getMerchantId()) : resolved;
    }

    private String requestDate(Object value) {
        if (value instanceof LocalDateTime dateTime) return REQUEST_DATE.format(dateTime);
        if (value instanceof LocalDate date) return date.format(DateTimeFormatter.BASIC_ISO_DATE);
        return REQUEST_DATE.format(LocalDateTime.now());
    }

    private List<Map<String, Object>> rows(String sql, Object... args) { return DatabaseRows.normalize(jdbc.queryForList(sql, args)); }
    private long number(Object value) { return value instanceof Number number ? number.longValue() : 0; }
    private String text(Object value) { return value == null ? "" : String.valueOf(value).trim(); }

    private record PreparedRefund(String refundNo, long orderId, String huifuId, String paymentNo, String originalProviderNo, String originalRequestDate, long refundAmount, boolean settledLocally) {
        private PreparedRefund(String refundNo, long orderId, long refundAmount) { this(refundNo, orderId, "", "", "", "", refundAmount, false); }
    }

    private record ProviderResult(boolean success, boolean failed, String code, String message, String providerNo) {
        private static ProviderResult from(Map<String, Object> response) {
            Map<String, Object> data = response.get("data") instanceof Map<?, ?> map ? (Map<String, Object>) map : response;
            String status = textValue(data.get("trans_stat"));
            String code = textValue(data.get("sub_resp_code"));
            if (code.isBlank()) code = textValue(data.get("resp_code"));
            String message = textValue(data.get("sub_resp_desc"));
            if (message.isBlank()) message = textValue(data.get("resp_desc"));
            String providerNo = textValue(data.get("hf_seq_id"));
            boolean codeSuccess = "00000000".equals(code) || "10000".equals(code) || "0".equals(code) || "SUCCESS".equalsIgnoreCase(code);
            boolean success = codeSuccess && (status.isBlank() || "S".equalsIgnoreCase(status) || "SUCCESS".equalsIgnoreCase(status) || "PAID".equalsIgnoreCase(status));
            // 语义未定的码一律不判失败。判失败会把订单解锁成「可以再退一次」，万一通道那边第一次其实
            // 已经出款，第二次就是重复出款；停在在途最多是让对账/人工多收敛一轮。
            boolean failed = !success && !HuifuPayload.undeterminedCode(code)
                    && !("P".equalsIgnoreCase(status) || "PROCESSING".equalsIgnoreCase(status) || "PENDING".equalsIgnoreCase(status));
            return new ProviderResult(success, failed, code, message, providerNo);
        }
        private static String textValue(Object value) { return value == null ? "" : String.valueOf(value).trim(); }
    }
}