package com.ruoyi.order.service.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.chargingPile.api.model.TAccountingStrategy;
import com.ruoyi.order.api.model.TChargingOrder;
import com.ruoyi.order.mapper.TChargingOrderMapper;
import com.ruoyi.other.api.domain.TVip;
import com.ruoyi.payment.api.feignClient.IcbcPaymentClient;
import com.ruoyi.payment.api.vo.IcbcPaymentResp;
import com.ruoyi.system.api.model.LoginUserApplet;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.springframework.test.util.ReflectionTestUtils;

import java.math.BigDecimal;
import java.util.Map;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class TChargingOrderPaymentConfirmationTest {
    private static final String ORDER_CODE = "CD202607160001";
    private static final String BANK_ORDER_ID = "231011990056000012345";

    private TChargingOrderServiceImpl service;
    private IcbcPaymentClient icbcPaymentClient;

    @BeforeEach
    void setUp() {
        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), TChargingOrder.class);
        service = spy(new TChargingOrderServiceImpl());
        TokenService tokenService = mock(TokenService.class);
        icbcPaymentClient = mock(IcbcPaymentClient.class);
        LoginUserApplet loginUser = new LoginUserApplet();
        loginUser.setUserId(88L);
        when(tokenService.getLoginUserApplet()).thenReturn(loginUser);
        ReflectionTestUtils.setField(service, "tokenService", tokenService);
        ReflectionTestUtils.setField(service, "icbcPaymentClient", icbcPaymentClient);
    }

    @Test
    @SuppressWarnings("unchecked")
    void paidBankOrderActivelyRunsBusinessCallback() {
        TChargingOrder order = pendingIcbcOrder();
        doReturn(order).when(service).getOne(any(Wrapper.class));
        IcbcPaymentResp payment = bankPayment("0");
        when(icbcPaymentClient.query(ORDER_CODE)).thenReturn(R.ok(payment));
        doReturn(AjaxResult.success()).when(service)
                .chargingOrderCallback(1, ORDER_CODE, BANK_ORDER_ID, "1");

        AjaxResult result = service.confirmIcbcPayment(ORDER_CODE);

        Map<String, Object> data = (Map<String, Object>) result.get("data");
        assertEquals(200, result.get("code"));
        assertTrue((Boolean) data.get("confirmed"));
        verify(service).chargingOrderCallback(1, ORDER_CODE, BANK_ORDER_ID, "1");
    }

    @Test
    @SuppressWarnings("unchecked")
    void pendingBankOrderReturnsUnconfirmedWithoutRunningCallback() {
        doReturn(pendingIcbcOrder()).when(service).getOne(any(Wrapper.class));
        when(icbcPaymentClient.query(ORDER_CODE)).thenReturn(R.ok(bankPayment("1")));

        AjaxResult result = service.confirmIcbcPayment(ORDER_CODE);

        Map<String, Object> data = (Map<String, Object>) result.get("data");
        assertEquals(200, result.get("code"));
        assertFalse((Boolean) data.get("confirmed"));
        verify(service, never()).chargingOrderCallback(eq(1), eq(ORDER_CODE), any(), eq("1"));
    }

    @Test
    void localBalancePaymentUsesSavedOrderWithoutImmediateReadBack() {
        TChargingOrderMapper mapper = mock(TChargingOrderMapper.class);
        ReflectionTestUtils.setField(service, "baseMapper", mapper);
        TChargingOrder order = new TChargingOrder();
        order.setId(9001L);
        order.setCode("CD-BALANCE-WHITELIST");
        order.setRechargePaymentStatus(1);
        when(mapper.update(isNull(), any(Wrapper.class))).thenReturn(0);

        AjaxResult result = service.completeChargingOrderPayment(order, "WHITELIST");

        assertEquals(200, result.get("code"));
        verify(service, never()).getOne(any(Wrapper.class));
        verify(mapper).update(isNull(), any(Wrapper.class));
    }

    @Test
    void internalMemberEightZheIsStoredAsPointEight() {
        TVip vip = new TVip();
        vip.setType(2);
        vip.setDiscount(new BigDecimal("8"));

        BigDecimal discount = service.resolveChargingVipDiscount(vip, null);

        assertEquals(0, discount.compareTo(new BigDecimal("0.8")));
    }

    @Test
    void regularMemberKeepsAccountingStrategyFactor() {
        TVip vip = new TVip();
        vip.setType(1);
        TAccountingStrategy strategy = new TAccountingStrategy();
        strategy.setDiscount(new BigDecimal("0.85"));

        BigDecimal discount = service.resolveChargingVipDiscount(vip, strategy);

        assertEquals(0, discount.compareTo(new BigDecimal("0.85")));
    }

    @Test
    void zeroDiscountAmountDoesNotConsumeMemberUse() {
        assertFalse(service.shouldConsumeVipDiscount(BigDecimal.ZERO));
    }

    @Test
    void positiveDiscountAmountConsumesMemberUse() {
        assertTrue(service.shouldConsumeVipDiscount(new BigDecimal("1.25")));
    }

    private TChargingOrder pendingIcbcOrder() {
        TChargingOrder order = new TChargingOrder();
        order.setCode(ORDER_CODE);
        order.setAppUserId(88L);
        order.setSourceName("ICBC");
        order.setRechargePaymentStatus(1);
        order.setDelFlag(false);
        return order;
    }

    private IcbcPaymentResp bankPayment(String payStatus) {
        IcbcPaymentResp payment = new IcbcPaymentResp();
        payment.setOrderId(ORDER_CODE);
        payment.setTradeNo(BANK_ORDER_ID);
        payment.setStatus(payStatus);
        payment.setRawResponse("{\"returnCode\":0,\"pay_status\":\"" + payStatus
                + "\",\"out_trade_no\":\"" + ORDER_CODE + "\",\"order_id\":\"" + BANK_ORDER_ID + "\"}");
        return payment;
    }
}