package com.talentcard.server.business.merchant;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.util.Map;

import com.talentcard.server.business.merchant.auth.MerchantPrincipal;
import com.talentcard.server.common.BusinessException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.support.TransactionTemplate;

class MerchantVerificationOrderCodeTests {

    private JdbcTemplate jdbc;
    private TransactionTemplate transactions;
    private MerchantVerificationService service;
    private com.talentcard.server.business.order.OrderVerificationService orderVerification;
    private MerchantPrincipal principal;
    /** 每个用例用独立的订单号与核销码号，避免共享内存库互相踩。 */
    private static final java.util.concurrent.atomic.AtomicLong ORDER_SEQUENCE = new java.util.concurrent.atomic.AtomicLong(1000);
    private static final java.util.concurrent.atomic.AtomicLong ORDER_CODE_SEQUENCE = new java.util.concurrent.atomic.AtomicLong(1000);

    @BeforeEach
    void setUp() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource(
                "jdbc:h2:mem:order-code-verification-" + System.nanoTime()
                        + ";MODE=MySQL;DATABASE_TO_LOWER=TRUE;DB_CLOSE_DELAY=-1", "sa", "");
        jdbc = new JdbcTemplate(dataSource);
        transactions = new TransactionTemplate(new DataSourceTransactionManager(dataSource));
        jdbc.execute("""
                create table merchant_verification_attempt (
                    id bigint auto_increment primary key,
                    verification_id varchar(64) not null,
                    credential_type varchar(32) not null,
                    dynamic_code_id bigint,
                    order_verification_code_id bigint,
                    free_stay_verification_code_id bigint,
                    merchant_id bigint not null,
                    store_id bigint not null,
                    operator_id bigint not null,
                    expires_at timestamp,
                    status tinyint not null default 0,
                    verify_no varchar(64),
                    confirmed_at timestamp
                )
                """);
        jdbc.execute("""
                create table benefit_order (
                    id bigint primary key,
                    talent_id bigint not null,
                    card_id bigint,
                    benefit_id bigint,
                    order_no varchar(64) not null,
                    order_amount bigint not null,
                    subsidy_amount bigint not null,
                    pay_amount bigint not null,
                    order_status tinyint not null,
                    verify_status tinyint not null,
                    refund_status tinyint not null default 0,
                    merchant_id bigint not null,
                    store_id bigint,
                    collect_huifu_id varchar(32),
                    deleted tinyint not null default 0
                )
                """);
        jdbc.execute("""
                create table order_dynamic_verification_code (
                    id bigint primary key,
                    order_id bigint not null,
                    expires_at timestamp not null,
                    status tinyint not null
                )
                """);
        jdbc.execute("create table talent_card (id bigint primary key, card_level varchar(64), deleted tinyint not null default 0)");
        jdbc.execute("create table benefit (id bigint primary key, benefit_name varchar(128))");
        jdbc.execute("""
                create table verify_record (
                    id bigint auto_increment primary key,
                    verify_no varchar(64) not null,
                    order_id bigint,
                    talent_id bigint,
                    card_id bigint,
                    benefit_id bigint,
                    merchant_id bigint,
                    store_id bigint,
                    staff_id bigint,
                    verify_type varchar(32),
                    verify_amount bigint,
                    subsidy_amount bigint,
                    remark varchar(255),
                    idempotency_key varchar(64)
                )
                """);
        // 资金确认服务会按订单查支付流水，这里给出结构一致的最小表。
        jdbc.execute("""
                create table payment_transaction (
                    id bigint auto_increment primary key,
                    payment_no varchar(64) not null,
                    order_id bigint not null,
                    status varchar(32) not null,
                    amount bigint not null,
                    provider_huifu_id varchar(32),
                    provider_transaction_no varchar(128),
                    funds_confirmation_status varchar(16),
                    created_at timestamp not null default current_timestamp
                )
                """);
        // 用真实的核销实现：错误分支（未支付/已退款）必须由真实逻辑抛出，替身会把这些分支掩盖掉。
        com.talentcard.server.business.order.OrderVerificationService orderVerification =
                new com.talentcard.server.business.order.OrderVerificationService(jdbc,
                        new com.talentcard.server.business.order.OrderFundBoundaryService(jdbc),
                        new com.talentcard.server.business.payment.PaymentFundConfirmationService(jdbc, transactions,
                                org.mockito.Mockito.mock(com.talentcard.server.business.payment.huifu.HuifuDelayAccountGateway.class)));
        service = new MerchantVerificationService(jdbc, new ManualConsumptionService(jdbc, null), orderVerification);
        this.orderVerification = orderVerification;
        principal = new MerchantPrincipal(9L, 88L, 7L, "operator");
    }

    /**
     * 订单核销码过期后不再接受直接核销：持码人重新扫码即可（扫码会刷新码）。
     *
     * <p>此前的实现容忍过期，把已经失效的扫码码也当作可核销；现在统一由订单核销入口处理，
     * 过期就明确拒绝并把这次扫码尝试标记为失效，避免"拿着旧码也能核销"的模糊状态。
     */
    @Test
    void rejectsGroupOrderWhenTheScannedCodeHasExpired() {
        insertOrder("expired-group-order", 1);
        Long expiredOrderId = jdbc.queryForObject("select max(id) from benefit_order", Long.class);

        assertThatThrownBy(() -> confirm("expired-group-order"))
                .isInstanceOf(BusinessException.class)
                .hasMessageContaining("失效");
        assertThat(jdbc.queryForObject("select verify_status from benefit_order where id = ?", Integer.class, expiredOrderId)).isZero();
        assertThat(jdbc.queryForObject("select status from merchant_verification_attempt where verification_id = ?", Integer.class,
                "expired-group-order")).isZero();
    }

    @Test
    void stillRejectsUnpaidGroupOrder() {
        insertOrder("unpaid-group-order", 0);

        assertThatThrownBy(() -> confirm("unpaid-group-order"))
                .isInstanceOf(BusinessException.class)
                .hasMessageContaining("未支付");
    }

    @Test
    void rejectsGroupOrderThatWasRefundedWhileTheCodeWasOpen() {
        insertOrder("refunded-group-order", 1);
        Long refundedOrderId = jdbc.queryForObject("select max(id) from benefit_order", Long.class);
        jdbc.update("update benefit_order set refund_status = 2 where id = ?", refundedOrderId);

        assertThatThrownBy(() -> confirm("refunded-group-order"))
                .isInstanceOf(BusinessException.class)
                .hasMessageContaining("退款");
        assertThat(jdbc.queryForObject("select verify_status from benefit_order where id = ?", Integer.class, refundedOrderId)).isZero();
    }

    /** 未过期的订单核销码可以正常核销：置订单已核销、写核销记录、标记扫码尝试完成。 */
    @Test
    void confirmsGroupOrderWithAFreshScannedCode() {
        insertOrder("fresh-group-order", 1, LocalDateTime.now().plusMinutes(5));

        Map<String, Object> confirmed = confirm("fresh-group-order");
        long orderId = ((Number) confirmed.get("orderId")).longValue();

        assertThat(confirmed.get("verified")).isEqualTo(true);
        assertThat(jdbc.queryForObject("select status from order_dynamic_verification_code where order_id = ?", Integer.class, orderId)).isEqualTo(1);
        assertThat(jdbc.queryForObject("select verify_status from benefit_order where id = ?", Integer.class, orderId)).isEqualTo(1);
        assertThat(jdbc.queryForObject("select status from merchant_verification_attempt where verification_id = ?", Integer.class,
                "fresh-group-order")).isEqualTo(1);
        assertThat(jdbc.queryForObject("select count(*) from verify_record where verify_type = 'ORDER_CODE' and order_id = ?", Integer.class, orderId)).isEqualTo(1);
    }

    /**
     * 订单核销按订单行锁串行化，所以测试也必须在一个真实事务里调用它。
     *
     * <p>订单核销不再走 {@code verification/confirm}，改为调统一的订单核销实现，
     * 并把扫码尝试编号带过去标记尝试完成。
     */
    private Map<String, Object> confirm(String verificationId) {
        return transactions.execute(status -> {
            Map<String, Object> attempt = jdbc.queryForMap(
                    "select a.id, a.expires_at, c.order_id from merchant_verification_attempt a"
                            + " join order_dynamic_verification_code c on c.id = a.order_verification_code_id"
                            + " where a.verification_id = ?", verificationId);
            long attemptId = ((Number) attempt.get("id")).longValue();
            long orderId = ((Number) attempt.get("order_id")).longValue();
            java.time.LocalDateTime expiresAt = ((Timestamp) attempt.get("expires_at")).toLocalDateTime();
            String verifyNo = orderVerification.verifyByMerchant(principal.merchantId(), principal.storeId(),
                    principal.operatorId(), orderId, "ORDER_CODE", 8000L, 2000L, "订单动态核销码",
                    attemptId, "order-confirm-" + verificationId, expiresAt);
            return Map.of("verified", !verifyNo.isBlank(), "verifyNo", verifyNo, "orderId", orderId);
        });
    }

    private void insertOrder(String verificationId, int orderStatus) {
        insertOrder(verificationId, orderStatus, LocalDateTime.now().minusMinutes(1));
    }

    private void insertOrder(String verificationId, int orderStatus, LocalDateTime scanExpiresAt) {
        // 每个用例用独立订单号：共用同一个 id 时，前一个用例核销过的订单会让后一个用例直接失败。
        long orderId = ORDER_SEQUENCE.incrementAndGet();
        jdbc.update("insert into talent_card(id, card_level, deleted) values (10, '卓越人才卡', 0)");
        jdbc.update("""
                insert into benefit_order(id, talent_id, card_id, benefit_id, order_no, order_amount, subsidy_amount,
                                          pay_amount, order_status, verify_status, merchant_id, store_id, deleted)
                values (?, 1015, 10, null, ?, 10000, 3000, 7000, ?, 0, 88, 7, 0)
                """, orderId, "GROUP-" + verificationId, orderStatus);
        jdbc.update("""
                insert into order_dynamic_verification_code(id, order_id, expires_at, status)
                values (?, ?, ?, 2)
                """, ORDER_CODE_SEQUENCE.incrementAndGet(), orderId, Timestamp.valueOf(scanExpiresAt));
        Long codeId = jdbc.queryForObject("select max(id) from order_dynamic_verification_code", Long.class);
        jdbc.update("""
                insert into merchant_verification_attempt(verification_id, credential_type, order_verification_code_id,
                                                          merchant_id, store_id, operator_id, expires_at, status)
                values (?, 'ORDER_CODE', ?, 88, 7, 9, ?, 0)
                """, verificationId, codeId, Timestamp.valueOf(scanExpiresAt));
    }
}