package com.talentcard.server.business.merchant;

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

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

import com.talentcard.server.business.PageResult;
import com.talentcard.server.business.merchant.auth.MerchantPrincipal;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ActiveProfiles;

@SpringBootTest
@ActiveProfiles("test")
class MerchantWorkServiceTests {

    @Autowired
    private JdbcTemplate jdbc;

    @Autowired
    private MerchantWorkService merchantWorkService;

    private Long merchantId;
    private Long storeId;
    private Long talentId;
    private MerchantPrincipal principal;

    @BeforeEach
    void prepareOrders() {
        String suffix = String.valueOf(System.nanoTime());
        jdbc.update("insert into merchant(merchant_name, status, can_login_merchant_app, deleted) values (?, 1, 1, 0)", "Order test merchant " + suffix);
        merchantId = jdbc.queryForObject("select max(id) from merchant", Long.class);
        jdbc.update("insert into merchant_store(merchant_id, store_name, status, deleted) values (?, ?, 1, 0)", merchantId, "Order test store");
        storeId = jdbc.queryForObject("select max(id) from merchant_store", Long.class);
        jdbc.update("insert into talent_user(openid, name, mobile, status, deleted) values (?, ?, ?, 1, 0)", "order-test-" + suffix, "订单测试用户", "13800000000");
        talentId = jdbc.queryForObject("select max(id) from talent_user", Long.class);
        principal = new MerchantPrincipal(9001L, merchantId, storeId, "operator");
        insertOrder("GROUP_BUY", 1, 0, LocalDateTime.of(2026, 7, 10, 9, 0));
        insertOrder("GROUP_BUY", 1, 1, LocalDateTime.of(2026, 7, 11, 9, 0));
        insertOrder("STORE_CONSUME", 0, 0, LocalDateTime.of(2026, 7, 12, 9, 0));
        insertOrder("FREE_STAY", 1, 1, LocalDateTime.of(2026, 7, 13, 9, 0));
    }

    @Test
    void filtersOrdersByCategoryStatusAndDateWithoutExposingFullMobile() {
        PageResult<Map<String, Object>> groupPending = merchantWorkService.orders(merchantId, storeId, 1, 10,
                new MerchantOrderQuery("group", "pending_verification", "2026-07-10", "2026-07-10"));
        PageResult<Map<String, Object>> storePending = merchantWorkService.orders(merchantId, storeId, 1, 10,
                new MerchantOrderQuery("store", "pending_payment", null, null));
        PageResult<Map<String, Object>> stays = merchantWorkService.orders(merchantId, storeId, 1, 10,
                new MerchantOrderQuery("stay", "all", null, null));

        assertThat(groupPending.total()).isEqualTo(1);
        assertThat(groupPending.records().get(0)).containsEntry("category", "group").containsEntry("status", "pending_verification");
        assertThat(String.valueOf(groupPending.records().get(0).get("customerMobile"))).isEqualTo("138****0000");
        assertThat(storePending.total()).isEqualTo(1);
        assertThat(storePending.records().get(0)).containsEntry("category", "store").containsEntry("status", "pending_payment");
        assertThat(stays.total()).isEqualTo(1);
        assertThat(stays.records().get(0)).containsEntry("category", "stay").containsEntry("status", "completed");
    }

    @Test
    void verifiesAndRevokesGroupBuyIdempotently() {
        String orderNo = insertOrder("GROUP_BUY", 1, 0, LocalDateTime.now());
        Long orderId = jdbc.queryForObject("select id from benefit_order where order_no = ?", Long.class, orderNo);

        Map<String, Object> verified = merchantWorkService.verify(orderNo, principal,
                new VerifyRequest("merchant", "test verification"), "verify-" + orderNo);
        Map<String, Object> repeatedVerification = merchantWorkService.verify(orderNo, principal,
                new VerifyRequest("merchant", "test verification"), "verify-" + orderNo);

        assertThat(verified).containsEntry("status", "completed");
        assertThat(repeatedVerification).containsEntry("status", "completed");
        assertThat(jdbc.queryForObject("select count(*) from verify_record where order_id = ?", Integer.class, orderId)).isEqualTo(1);

        String revokeKey = "revoke-" + orderNo;
        Map<String, Object> revoked = merchantWorkService.revokeVerification(principal,
                new MerchantRevokeVerificationRequest(String.valueOf(orderId), "test reversal"), revokeKey);
        Map<String, Object> repeatedRevoke = merchantWorkService.revokeVerification(principal,
                new MerchantRevokeVerificationRequest(String.valueOf(orderId), "test reversal"), revokeKey);

        assertThat(revoked).containsEntry("orderStatus", "pending_verification");
        assertThat(repeatedRevoke).containsEntry("orderStatus", "pending_verification");
        assertThat(jdbc.queryForObject("select verify_status from benefit_order where id = ?", Integer.class, orderId)).isZero();
        assertThat(jdbc.queryForObject("select status from verify_record where order_id = ?", Integer.class, orderId)).isEqualTo(2);
    }

    @Test
    void derivesConsistentDiscountBreakdownForLegacyOrderSnapshots() {
        String orderNo = "LEGACY-" + System.nanoTime();
        jdbc.update("""
                insert into benefit_order(order_no, talent_id, merchant_id, store_id, order_type, order_amount,
                                          subsidy_amount, base_pay_amount, coupon_amount, pay_amount,
                                          order_status, verify_status, deleted)
                values (?, ?, ?, ?, 'GROUP_BUY', 14800, 0, 14800, 0, 1, 1, 0, 0)
                """, orderNo, talentId, merchantId, storeId);

        Map<String, Object> detail = merchantWorkService.order(orderNo, merchantId, storeId);

        assertThat(detail).containsEntry("talentDiscountAmount", 14799L)
                .containsEntry("couponAmount", 0L)
                .containsEntry("subsidyAmount", 14799L);
    }

    @Test
    void aCancelledOrderIsShownAsCancelledInsteadOfWaitingToBeVerified() {
        String orderNo = insertOrder("GROUP_BUY", 2, 0, LocalDateTime.now());

        assertThat(recordOf(list("group", "all"), orderNo))
                .containsEntry("status", "cancelled")
                .containsEntry("statusText", "已取消");
        assertThat(orderNos(list("group", "pending_verification")))
                .as("已取消的订单不是待核销：商户照它去核销只会被资金边界拒绝")
                .doesNotContain(orderNo);
        assertThat(orderNos(list("group", "closed"))).contains(orderNo);
    }

    @Test
    void aRefundedOrderIsShownAsRefundedAndStopsWaitingToBeVerified() {
        String orderNo = insertOrder("GROUP_BUY", 1, 0, LocalDateTime.now());
        jdbc.update("update benefit_order set refund_status = 2 where order_no = ?", orderNo);

        assertThat(recordOf(list("group", "all"), orderNo))
                .containsEntry("status", "refunded")
                .containsEntry("statusText", "已退款");
        assertThat(orderNos(list("group", "pending_verification"))).doesNotContain(orderNo);
        assertThat(orderNos(list("group", "closed"))).contains(orderNo);
    }

    @Test
    void aRefundInFlightIsShownAsRefunding() {
        String orderNo = insertOrder("GROUP_BUY", 1, 0, LocalDateTime.now());
        jdbc.update("update benefit_order set refund_status = 1 where order_no = ?", orderNo);

        assertThat(recordOf(list("group", "all"), orderNo)).containsEntry("statusText", "退款中");
        assertThat(orderNos(list("group", "pending_verification"))).doesNotContain(orderNo);
    }

    @Test
    void theOrderDetailCarriesTheSameClosedState() {
        String orderNo = insertOrder("GROUP_BUY", 1, 0, LocalDateTime.now());
        jdbc.update("update benefit_order set refund_status = 1 where order_no = ?", orderNo);

        assertThat(merchantWorkService.order(orderNo, merchantId, storeId))
                .containsEntry("status", "refunded")
                .containsEntry("statusText", "退款中");
        assertThat(merchantWorkService.order(insertOrder("GROUP_BUY", 2, 0, LocalDateTime.now()), merchantId, storeId))
                .containsEntry("status", "cancelled");
    }

    private PageResult<Map<String, Object>> list(String category, String status) {
        return merchantWorkService.orders(merchantId, storeId, 1, 50, new MerchantOrderQuery(category, status, null, null));
    }

    private Map<String, Object> recordOf(PageResult<Map<String, Object>> page, String orderNo) {
        return page.records().stream()
                .filter(record -> orderNo.equals(String.valueOf(record.get("orderNo"))))
                .findFirst()
                .orElseThrow(() -> new AssertionError("Order " + orderNo + " is missing from the merchant order list"));
    }

    private java.util.List<String> orderNos(PageResult<Map<String, Object>> page) {
        return page.records().stream().map(record -> String.valueOf(record.get("orderNo"))).toList();
    }

    private String insertOrder(String type, int orderStatus, int verifyStatus, LocalDateTime createdAt) {
        String orderNo = "ORDER-" + System.nanoTime();
        jdbc.update("""
                insert into benefit_order(order_no, talent_id, merchant_id, store_id, order_type, order_amount,
                                          subsidy_amount, pay_amount, order_status, verify_status, created_at, deleted)
                values (?, ?, ?, ?, ?, 10000, 1000, 9000, ?, ?, ?, 0)
                """, orderNo, talentId, merchantId, storeId, type, orderStatus, verifyStatus,
                Timestamp.valueOf(createdAt));
        return orderNo;
    }
}