package com.tourguide.modules.order.service;

import com.tourguide.common.exception.BusinessException;
import com.tourguide.modules.order.domain.OrderStatus;
import com.tourguide.modules.order.entity.TourOrder;
import com.tourguide.modules.order.entity.TourOrderPaymentAttempt;
import com.tourguide.modules.order.mapper.TourOrderMapper;
import com.tourguide.modules.order.mapper.TourOrderPaymentAttemptMapper;
import com.tourguide.modules.order.payment.HuifuPaymentNotice;
import com.tourguide.modules.order.payment.OrderPaymentPreparation;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;

import java.math.BigDecimal;
import java.time.LocalDateTime;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class TourOrderPaymentServiceTest {
    private TourOrderMapper orderMapper;
    private TourOrderPaymentAttemptMapper paymentAttemptMapper;
    private GuideOrderMatchingService matchingService;
    private TourOrderPaymentService paymentService;

    @BeforeEach
    void setUp() {
        orderMapper = mock(TourOrderMapper.class);
        paymentAttemptMapper = mock(TourOrderPaymentAttemptMapper.class);
        matchingService = mock(GuideOrderMatchingService.class);
        paymentService = new TourOrderPaymentService(orderMapper, paymentAttemptMapper, matchingService);
    }

    @Test
    void repeatedPaymentShouldCreateNewRequestSequenceAndSyncOrder() {
        TourOrder order = pendingOrder();
        when(orderMapper.selectForUpdate(99L)).thenReturn(order);

        OrderPaymentPreparation first = paymentService.prepare(7L, 99L);
        OrderPaymentPreparation second = paymentService.prepare(7L, 99L);

        assertThat(first.getReqSeqId()).startsWith("PY").hasSize(32);
        assertThat(second.getReqSeqId()).startsWith("PY").hasSize(32);
        assertThat(second.getReqSeqId()).isNotEqualTo(first.getReqSeqId());
        assertThat(order.getPaymentOrderNo()).isEqualTo(second.getReqSeqId());
        assertThat(order.getPaymentMethod()).isEqualTo("WECHAT");

        ArgumentCaptor<TourOrderPaymentAttempt> captor = ArgumentCaptor.forClass(TourOrderPaymentAttempt.class);
        verify(paymentAttemptMapper, times(2)).insert(captor.capture());
        assertThat(captor.getAllValues()).extracting(TourOrderPaymentAttempt::getReqSeqId)
                .containsExactly(first.getReqSeqId(), second.getReqSeqId());
        assertThat(captor.getAllValues()).allSatisfy(attempt -> {
            assertThat(attempt.getOrderId()).isEqualTo(99L);
            assertThat(attempt.getAmount()).isEqualByComparingTo("36.00");
            assertThat(attempt.getStatus()).isEqualTo("CREATED");
        });
        verify(orderMapper, times(2)).updateById(order);
    }

    @Test
    void successCallbackShouldConfirmAttemptOnceAndStartMatching() {
        TourOrder order = pendingOrder();
        order.setPaymentOrderNo("PY-newer");
        TourOrderPaymentAttempt attempt = attempt("PY-paid", "CREATED");
        when(paymentAttemptMapper.selectByReqSeqIdForUpdate("PY-paid")).thenReturn(attempt);
        when(orderMapper.selectForUpdate(99L)).thenReturn(order);
        HuifuPaymentNotice notice = notice("PY-paid", new BigDecimal("36.00"));

        boolean confirmed = paymentService.confirm(notice);

        assertThat(confirmed).isTrue();
        assertThat(attempt.getStatus()).isEqualTo("SUCCEEDED");
        assertThat(attempt.getProviderTransactionId()).isEqualTo("hf-seq-1");
        assertThat(order.getPaymentOrderNo()).isEqualTo("PY-paid");
        assertThat(order.getStatus()).isEqualTo(OrderStatus.PENDING_ACCEPT.getCode());
        assertThat(order.getPaymentAmount()).isEqualByComparingTo("36.00");
        assertThat(order.getPaymentTime()).isEqualTo(notice.getPaidAt());
        verify(paymentAttemptMapper).updateById(attempt);
        verify(orderMapper).updateById(order);
        verify(matchingService).match(99L);
    }

    @Test
    void duplicateCallbackShouldNotMatchAgain() {
        TourOrder order = pendingOrder();
        order.setPaymentTime(LocalDateTime.now());
        order.setStatus(OrderStatus.PENDING_ACCEPT.getCode());
        TourOrderPaymentAttempt attempt = attempt("PY-paid", "SUCCEEDED");
        when(paymentAttemptMapper.selectByReqSeqIdForUpdate("PY-paid")).thenReturn(attempt);
        when(orderMapper.selectForUpdate(99L)).thenReturn(order);

        boolean confirmed = paymentService.confirm(notice("PY-paid", new BigDecimal("36.00")));

        assertThat(confirmed).isFalse();
        verify(paymentAttemptMapper, never()).updateById(attempt);
        verify(orderMapper, never()).updateById(order);
        verify(matchingService, never()).match(99L);
    }

    @Test
    void laterSuccessfulAttemptShouldBeRecordedWithoutDuplicateMatching() {
        TourOrder order = pendingOrder();
        order.setPaymentTime(LocalDateTime.now());
        order.setStatus(OrderStatus.PENDING_ACCEPT.getCode());
        TourOrderPaymentAttempt attempt = attempt("PY-late", "CREATED");
        when(paymentAttemptMapper.selectByReqSeqIdForUpdate("PY-late")).thenReturn(attempt);
        when(orderMapper.selectForUpdate(99L)).thenReturn(order);

        boolean confirmed = paymentService.confirm(notice("PY-late", new BigDecimal("36.00")));

        assertThat(confirmed).isFalse();
        assertThat(attempt.getStatus()).isEqualTo("SUCCEEDED");
        verify(paymentAttemptMapper).updateById(attempt);
        verify(orderMapper, never()).updateById(order);
        verify(matchingService, never()).match(99L);
    }

    @Test
    void callbackShouldRejectMismatchedAmount() {
        TourOrder order = pendingOrder();
        TourOrderPaymentAttempt attempt = attempt("PY-paid", "CREATED");
        when(paymentAttemptMapper.selectByReqSeqIdForUpdate("PY-paid")).thenReturn(attempt);
        when(orderMapper.selectForUpdate(99L)).thenReturn(order);

        assertThatThrownBy(() -> paymentService.confirm(notice("PY-paid", new BigDecimal("35.99"))))
                .isInstanceOf(BusinessException.class)
                .extracting("code")
                .isEqualTo(409);

        verify(paymentAttemptMapper, never()).updateById(attempt);
        verify(orderMapper, never()).updateById(order);
        verify(matchingService, never()).match(99L);
    }

    private TourOrder pendingOrder() {
        TourOrder order = new TourOrder();
        order.setId(99L);
        order.setOrderNo("MJ202608030001");
        order.setVisitorId(7L);
        order.setScenicName("Qingcheng Mountain");
        order.setPackageName("Group tour");
        order.setAmount(new BigDecimal("36.00"));
        order.setStatus(OrderStatus.PENDING_PAYMENT.getCode());
        return order;
    }

    private TourOrderPaymentAttempt attempt(String reqSeqId, String status) {
        TourOrderPaymentAttempt attempt = new TourOrderPaymentAttempt();
        attempt.setId(1L);
        attempt.setOrderId(99L);
        attempt.setReqSeqId(reqSeqId);
        attempt.setReqDate("20260803");
        attempt.setAmount(new BigDecimal("36.00"));
        attempt.setStatus(status);
        return attempt;
    }

    private HuifuPaymentNotice notice(String reqSeqId, BigDecimal amount) {
        return new HuifuPaymentNotice(reqSeqId, "merchant-1", "S", amount,
                "hf-seq-1", LocalDateTime.of(2026, 8, 3, 16, 0));
    }
}