package com.talentcard.server.business.payment;

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

import com.alibaba.fastjson.JSON;
import com.talentcard.server.business.BusinessIdGenerator;
import com.talentcard.server.business.DatabaseRows;
import com.talentcard.server.business.payment.huifu.HuifuMiniProgramPaymentCommand;
import com.talentcard.server.business.payment.huifu.HuifuMiniProgramPaymentGateway;
import com.talentcard.server.business.payment.huifu.HuifuPaymentGatewayException;
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.support.TransactionTemplate;

@Service
public class HuifuPaymentService {

    private static final String PROVIDER = "HUIFU";
    private static final Logger log = LoggerFactory.getLogger(HuifuPaymentService.class);

    private final JdbcTemplate jdbc;
    private final TransactionTemplate transactions;
    private final HuifuMiniProgramPaymentGateway gateway;

    public HuifuPaymentService(
            JdbcTemplate jdbc,
            TransactionTemplate transactions,
            HuifuMiniProgramPaymentGateway gateway
    ) {
        this.jdbc = jdbc;
        this.transactions = transactions;
        this.gateway = gateway;
    }

    public Map<String, Object> beginMiniProgramPayment(String orderNo, Long talentId, int priceVersion, String idempotencyKey) {
        PreparedPayment prepared = transactions.execute(status -> prepare(orderNo, talentId, priceVersion, idempotencyKey));
        if (prepared == null) throw new BusinessException(ErrorCode.INTERNAL_ERROR, "支付初始化失败");
        if (prepared.completed()) return completedResult(prepared.paymentNo());
        if (prepared.processing()) return processingResult(prepared.paymentNo());
        if (!prepared.callProvider()) return pendingResult(prepared.paymentNo(), prepared.clientPayload());

        Map<String, Object> response;
        try {
            response = gateway.createMiniProgramPayment(new HuifuMiniProgramPaymentCommand(
                    prepared.paymentNo(), prepared.huifuId(), prepared.openId(), prepared.amountInCent(), prepared.goodsDescription(), prepared.expiresAt()));
        } catch (HuifuPaymentGatewayException exception) {
            if (exception.isOutcomeUnknown()) {
                transactions.executeWithoutResult(status -> markCreateUnknown(prepared.paymentNo(), "GATEWAY_UNKNOWN", exception.getMessage()));
            } else {
                transactions.executeWithoutResult(status -> markCreateFailed(prepared.paymentNo(), "GATEWAY_REJECTED", exception.getMessage()));
            }
            throw new BusinessException(ErrorCode.CONFLICT, exception.getMessage());
        } catch (BusinessException exception) {
            transactions.executeWithoutResult(status -> markCreateFailed(prepared.paymentNo(), "LOCAL_ERROR", exception.getMessage()));
            throw exception;
        } catch (RuntimeException exception) {
            transactions.executeWithoutResult(status -> markCreateUnknown(prepared.paymentNo(), "GATEWAY_UNKNOWN", "支付结果确认中"));
            throw exception;
        }
        if (!providerAccepted(response)) {
            String message = responseText(response, "支付服务暂不可用");
            transactions.executeWithoutResult(status -> markCreateFailed(prepared.paymentNo(), responseCode(response), message));
            throw new BusinessException(ErrorCode.CONFLICT, message);
        }
        String clientPayload = writeJson(clientPayload(response));
        transactions.executeWithoutResult(status -> markPrepayCreated(prepared.paymentNo(), responseCode(response), responseText(response, ""), clientPayload));
        return pendingResult(prepared.paymentNo(), clientPayload);
    }

    private PreparedPayment prepare(String orderNo, Long talentId, int priceVersion, String idempotencyKey) {
        if (idempotencyKey == null || idempotencyKey.isBlank() || idempotencyKey.length() > 128) {
            throw new BusinessException(ErrorCode.BAD_REQUEST, "缺少有效支付幂等键");
        }
        List<Map<String, Object>> orders = rows("""
                select o.id, o.order_no, o.talent_id, o.merchant_id, o.store_id, o.pay_amount, o.order_status, o.price_version,
                       o.expires_at, o.collect_huifu_id, coalesce(o.product_name_snapshot, o.order_type, '人才权益服务') goods_description,
                       t.openid
                from benefit_order o
                join talent_user t on t.id = o.talent_id and t.deleted = 0
                where o.deleted = 0 and o.order_no = ? and o.talent_id = ?
                limit 1 for update
                """, orderNo, talentId);
        if (orders.isEmpty()) throw new BusinessException(ErrorCode.NOT_FOUND, "订单不存在或无权支付");
        Map<String, Object> order = orders.get(0);
        long payAmount = number(order.get("payAmount"));
        if (number(order.get("orderStatus")) == 1) return new PreparedPayment("", "", "", 0, "", LocalDateTime.now(), false, true, "", false);
        if (number(order.get("orderStatus")) != 0) throw new BusinessException(ErrorCode.CONFLICT, "订单当前不可支付");
        if (number(order.get("priceVersion")) != priceVersion) throw new BusinessException(ErrorCode.CONFLICT, "订单金额已更新，请重新确认");
        LocalDateTime expiresAt = localDateTime(order.get("expiresAt"));
        if (expiresAt != null && !expiresAt.isAfter(LocalDateTime.now())) throw new BusinessException(ErrorCode.CONFLICT, "订单已超时，请重新下单");
        if (payAmount == 0) {
            jdbc.update("""
                    update benefit_order
                    set order_status = 1,
                        verify_status = case when order_type = 'STORE_CONSUME' then 1 else verify_status end
                    where id = ? and order_status = 0
                    """, number(order.get("id")));
            return new PreparedPayment("", "", "", 0, "", LocalDateTime.now(), false, true, "", false);
        }
        // 收款子商户在下单时已固定，支付请求只使用订单上的斗拱商户号。
        String huifuId = string(order.get("collectHuifuId"));
        if (huifuId.isBlank()) throw new BusinessException(ErrorCode.CONFLICT, "订单缺少收款子商户，请重新下单");
        String openId = string(order.get("openid"));
        if (openId.isBlank()) throw new BusinessException(ErrorCode.CONFLICT, "当前用户未完成微信支付授权");

        List<Map<String, Object>> existingRows = rows("""
                select payment_no, order_no, talent_id, status, attempt_no, client_payment_payload
                from payment_transaction
                where idempotency_key = ?
                order by attempt_no desc
                limit 1 for update
                """, idempotencyKey);
        if (!existingRows.isEmpty()) {
            Map<String, Object> existing = existingRows.get(0);
            if (!orderNo.equals(string(existing.get("orderNo"))) || talentId.longValue() != number(existing.get("talentId"))) {
                throw new BusinessException(ErrorCode.CONFLICT, "支付请求已被其他订单使用，请重新发起支付");
            }
            String status = string(existing.get("status"));
            String paymentNo = string(existing.get("paymentNo"));
            if ("SUCCEEDED".equals(status)) return new PreparedPayment(paymentNo, huifuId, "", 0, "", LocalDateTime.now(), false, true, "", false);
            if ("PREPAY_CREATED".equals(status)) {
                return new PreparedPayment(paymentNo, huifuId, "", 0, "", LocalDateTime.now(), false, false, string(existing.get("clientPaymentPayload")), false);
            }
            if ("CREATED".equals(status) || "CREATE_UNKNOWN".equals(status)) {
                return new PreparedPayment(paymentNo, huifuId, "", 0, "", LocalDateTime.now(), false, false, "", true);
            }
            int nextAttempt = (int) number(existing.get("attemptNo")) + 1;
            String retryPaymentNo = BusinessIdGenerator.next("P");
            insertPaymentTransaction(retryPaymentNo, order, orderNo, talentId, payAmount, huifuId, idempotencyKey, nextAttempt);
            return new PreparedPayment(retryPaymentNo, huifuId, openId, payAmount, string(order.get("goodsDescription")), expiryOrDefault(expiresAt), true, false, "", false);
        }

        String paymentNo = BusinessIdGenerator.next("P");
        insertPaymentTransaction(paymentNo, order, orderNo, talentId, payAmount, huifuId, idempotencyKey, 1);
        return new PreparedPayment(paymentNo, huifuId, openId, payAmount, string(order.get("goodsDescription")), expiryOrDefault(expiresAt), true, false, "", false);
    }

    private void insertPaymentTransaction(
            String paymentNo,
            Map<String, Object> order,
            String orderNo,
            Long talentId,
            long payAmount,
            String huifuId,
            String idempotencyKey,
            int attemptNo
    ) {
        jdbc.update("""
                insert into payment_transaction(payment_no, provider, order_id, order_no, talent_id, merchant_id,
                                                provider_huifu_id, amount, status, idempotency_key, attempt_no)
                values (?, ?, ?, ?, ?, ?, ?, ?, 'CREATED', ?, ?)
                """, paymentNo, PROVIDER, number(order.get("id")), orderNo, talentId, order.get("merchantId"), huifuId, payAmount, idempotencyKey, attemptNo);
    }

    public Map<String, Object> paymentStatus(String orderNo, Long talentId, String paymentNo) {
        List<Map<String, Object>> orders = rows("""
                select id, order_status
                from benefit_order
                where deleted = 0 and order_no = ? and talent_id = ?
                limit 1
                """, orderNo, talentId);
        if (orders.isEmpty()) throw new BusinessException(ErrorCode.NOT_FOUND, "订单不存在或无权查看");

        Map<String, Object> order = orders.get(0);
        if (number(order.get("orderStatus")) == 1) return completedResult(paymentNo == null ? "" : paymentNo);

        String filter = paymentNo == null || paymentNo.isBlank() ? "" : " and payment_no = ?";
        Object[] args = paymentNo == null || paymentNo.isBlank()
                ? new Object[] { orderNo, talentId }
                : new Object[] { orderNo, talentId, paymentNo };
        List<Map<String, Object>> transactions = rows("""
                select payment_no, status, provider_response_code, provider_response_message, paid_at
                from payment_transaction
                where order_no = ? and talent_id = ?
                """ + filter + " order by id desc limit 1", args);
        if (transactions.isEmpty()) return Map.of("paymentStatus", "NOT_STARTED");

        Map<String, Object> transaction = transactions.get(0);
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("paymentNo", transaction.get("paymentNo"));
        result.put("paymentStatus", statusText(string(transaction.get("status"))));
        result.put("providerCode", transaction.get("providerResponseCode"));
        result.put("providerMessage", transaction.get("providerResponseMessage"));
        result.put("paidAt", transaction.get("paidAt"));
        return result;
    }

    private void markPrepayCreated(String paymentNo, String responseCode, String responseMessage, String clientPayload) {
        jdbc.update("""
                update payment_transaction
                set status = 'PREPAY_CREATED', provider_response_code = ?, provider_response_message = ?, client_payment_payload = ?
                where payment_no = ? and status in ('CREATED', 'CREATE_FAILED')
                """, responseCode, responseMessage, clientPayload, paymentNo);
    }

    private void markCreateFailed(String paymentNo, String responseCode, String responseMessage) {
        jdbc.update("""
                update payment_transaction
                set status = 'CREATE_FAILED', provider_response_code = ?, provider_response_message = ?
                where payment_no = ? and status in ('CREATED', 'CREATE_FAILED')
                """, responseCode, responseMessage, paymentNo);
    }

    private void markCreateUnknown(String paymentNo, String responseCode, String responseMessage) {
        jdbc.update("""
                update payment_transaction
                set status = 'CREATE_UNKNOWN', provider_response_code = ?, provider_response_message = ?
                where payment_no = ? and status = 'CREATED'
                """, responseCode, responseMessage, paymentNo);
    }

    private Map<String, Object> pendingResult(String paymentNo, String payload) {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("paymentNo", paymentNo);
        result.put("paymentStatus", "PAYMENT_PENDING");
        result.put("paymentParams", parsePayload(payload));
        log.info("Mini-program payment response: paymentNo={}, payload={}", paymentNo, logPayload(result));
        return result;
    }

    private Map<String, Object> completedResult(String paymentNo) {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("paymentNo", paymentNo);
        result.put("paymentStatus", "PAID");
        return result;
    }

    private Map<String, Object> processingResult(String paymentNo) {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("paymentNo", paymentNo);
        result.put("paymentStatus", "PAYMENT_PROCESSING");
        return result;
    }

    private String statusText(String status) {
        return switch (status) {
            case "SUCCEEDED" -> "PAID";
            case "CLOSED" -> "CANCELLED";
            case "CREATE_FAILED" -> "PAYMENT_CREATE_FAILED";
            case "CREATED", "PREPAY_CREATED" -> "PAYMENT_PENDING";
            case "CREATE_UNKNOWN" -> "PAYMENT_CONFIRMING";
            default -> "UNKNOWN";
        };
    }

    private Object clientPayload(Map<String, Object> response) {
        Map<String, Object> data = businessData(response);
        Object payInfo = data.get("pay_info");
        if (payInfo == null) payInfo = data.get("payInfo");
        if (payInfo instanceof String text && !text.isBlank()) {
            try {
                return JSON.parse(text);
            } catch (Exception ignored) {
                return Map.of("payInfo", text);
            }
        }
        return payInfo == null ? data : payInfo;
    }

    private boolean providerAccepted(Map<String, Object> response) {
        Map<String, Object> data = businessData(response);
        String status = string(data.get("trans_stat"));
        if (status.isBlank()) status = string(data.get("transStat"));
        Object payInfo = data.get("pay_info");
        if (payInfo == null) payInfo = data.get("payInfo");
        return payInfo != null && !String.valueOf(payInfo).isBlank()
                && ("P".equalsIgnoreCase(status) || "S".equalsIgnoreCase(status));
    }

    private String responseCode(Map<String, Object> response) {
        Map<String, Object> data = businessData(response);
        Object value = data.get("resp_code");
        if (value == null) value = data.get("code");
        if (value == null) value = data.get("sub_resp_code");
        return value == null ? "" : String.valueOf(value);
    }

    private String responseText(Map<String, Object> response, String fallback) {
        Map<String, Object> data = businessData(response);
        Object value = data.get("resp_desc");
        if (value == null) value = data.get("message");
        if (value == null) value = data.get("sub_resp_desc");
        return value == null || String.valueOf(value).isBlank() ? fallback : String.valueOf(value);
    }

    @SuppressWarnings("unchecked")
    private Map<String, Object> businessData(Map<String, Object> response) {
        Object data = response.get("data");
        return data instanceof Map<?, ?> map ? (Map<String, Object>) map : response;
    }

    private String writeJson(Object value) {
        try {
            return JSON.toJSONString(value);
        } catch (Exception exception) {
            throw new BusinessException(ErrorCode.INTERNAL_ERROR, "支付参数保存失败");
        }
    }

    private Object parsePayload(String payload) {
        if (payload == null || payload.isBlank()) return Map.of();
        try {
            return JSON.parse(payload);
        } catch (Exception exception) {
            return Map.of();
        }
    }

    private String logPayload(Object value) {
        try {
            return JSON.toJSONString(maskPaymentPayload(value));
        } catch (Exception ignored) {
            return "{\"log_error\":\"Unable to serialize payment response\"}";
        }
    }

    private Object maskPaymentPayload(Object value) {
        if (value instanceof Map<?, ?> source) {
            Map<String, Object> result = new LinkedHashMap<>();
            for (Map.Entry<?, ?> entry : source.entrySet()) {
                String key = String.valueOf(entry.getKey());
                result.put(key, sensitiveLogKey(key) ? maskLogValue(String.valueOf(entry.getValue())) : maskPaymentPayload(entry.getValue()));
            }
            return result;
        }
        if (value instanceof List<?> source) return source.stream().map(this::maskPaymentPayload).toList();
        if (value instanceof String text && (text.startsWith("{") || text.startsWith("["))) {
            try {
                return maskPaymentPayload(JSON.parse(text));
            } catch (Exception ignored) {
                return text;
            }
        }
        return value;
    }

    private boolean sensitiveLogKey(String key) {
        String normalized = key == null ? "" : key.toLowerCase();
        return normalized.contains("sign") || normalized.contains("secret") || normalized.contains("openid") || normalized.contains("authorization");
    }

    private String maskLogValue(String value) {
        if (value == null || value.isBlank()) return "";
        if (value.length() <= 8) return "***";
        return value.substring(0, 4) + "***" + value.substring(value.length() - 4);
    }

    private LocalDateTime expiryOrDefault(LocalDateTime expiresAt) {
        return expiresAt == null ? LocalDateTime.now().plusMinutes(15) : expiresAt;
    }

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

    private LocalDateTime localDateTime(Object value) {
        return value instanceof LocalDateTime time ? time : null;
    }

    private String string(Object value) {
        return value == null ? "" : String.valueOf(value).trim();
    }

    private List<Map<String, Object>> rows(String sql, Object... args) {
        return DatabaseRows.normalize(jdbc.queryForList(sql, args));
    }

    private record PreparedPayment(
            String paymentNo,
            String huifuId,
            String openId,
            long amountInCent,
            String goodsDescription,
            LocalDateTime expiresAt,
            boolean callProvider,
            boolean completed,
            String clientPayload,
            boolean processing
    ) {}
}