package com.ruoyi.order.controller;

import com.ruoyi.account.api.feignClient.AppUserClient;
import com.ruoyi.account.api.feignClient.AppUserTagClient;
import com.ruoyi.account.api.model.TAppUserTag;
import com.ruoyi.account.api.model.TAppUserCar;
import com.ruoyi.chargingPile.api.model.Site;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.order.api.query.ChargingOrderQuery;
import com.ruoyi.order.api.vo.TCharingOrderVO;
import com.ruoyi.order.dto.SixChargingDto;
import com.ruoyi.order.dto.EnterpriseChargingDetailVO;
import com.ruoyi.order.dto.FranchiseeDayStat;
import com.ruoyi.order.dto.FranchiseeUserAgg;
import com.ruoyi.order.export.EnterpriseChargingDetailExport;
import com.ruoyi.order.service.TChargingOrderService;
import com.ruoyi.other.api.domain.TUserTag;
import com.ruoyi.other.api.feignClient.UserTagClient;
import org.junit.jupiter.api.Test;
import org.springframework.test.util.ReflectionTestUtils;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.same;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;

class TChargingOrderControllerTest {

    @Test
    void franchiseeIncomeWanUsesManagementOrderSummaryIncome() {
        FranchiseeDayStat discountedOrder = new FranchiseeDayStat();
        discountedOrder.setPaymentAmount(new BigDecimal("90"));
        discountedOrder.setChargingIncome(new BigDecimal("104"));
        FranchiseeDayStat emptyIncomeOrder = new FranchiseeDayStat();

        assertEquals(new BigDecimal("0.0104"),
                TChargingOrderController.franchiseeIncomeWan(Arrays.asList(discountedOrder, emptyIncomeOrder)));
    }

    @Test
    void appUserIdsBySiteIdsDelegatesToOrderService() {
        TChargingOrderService chargingOrderService = mock(TChargingOrderService.class);
        TChargingOrderController controller = new TChargingOrderController();
        ReflectionTestUtils.setField(controller, "chargingOrderService", chargingOrderService);
        List<Integer> siteIds = Arrays.asList(11, 12);
        List<Long> userIds = Arrays.asList(101L, 102L);
        when(chargingOrderService.getAppUserIdsBySiteIds(siteIds)).thenReturn(userIds);

        com.ruoyi.common.core.domain.R<List<Long>> result = controller.getAppUserIdsBySiteIds(siteIds);

        assertEquals(userIds, result.getData());
        verify(chargingOrderService).getAppUserIdsBySiteIds(siteIds);
    }

    @Test
    void enterpriseChargingDetailExportContainsVisibleDetailColumns() {
        EnterpriseChargingDetailVO detail = new EnterpriseChargingDetailVO();
        detail.setLicensePlate("川JD20960");
        detail.setPartnerName("测试合作商");
        detail.setOrderSource(0);
        detail.setCreateTime(LocalDateTime.of(2026, 7, 29, 10, 20, 30));
        detail.setChargingCapacity(new BigDecimal("40.693"));
        detail.setElectrovalence(new BigDecimal("43.0857"));
        detail.setServiceCharge(new BigDecimal("16.2772"));
        detail.setEndMode(0);
        detail.setPeriodCount(1);

        EnterpriseChargingDetailExport export = ReflectionTestUtils.invokeMethod(
                new TChargingOrderController(), "buildEnterpriseChargingDetailExport", detail);

        assertEquals("川JD20960", export.getLicensePlate());
        assertEquals("测试合作商", export.getPartnerName());
        assertEquals("自有平台", export.getOrderSource());
        assertEquals("2026-07-29 10:20:30", export.getCreateTime());
        assertEquals(new BigDecimal("40.693"), export.getChargingCapacity());
        assertEquals(new BigDecimal("43.0857"), export.getElectrovalence());
        assertEquals(new BigDecimal("16.2772"), export.getServiceCharge());
        assertEquals("异常终止", export.getEndMode());
        assertEquals(1, export.getPeriodCount());
    }

    @Test
    void latestAdjacentMonthDataMovesTheSixMonthWindowForward() {
        SixChargingDto june = new SixChargingDto();
        june.setMonth("06");
        SixChargingDto july = new SixChargingDto();
        july.setMonth("07");

        LocalDate endMonth = TChargingOrderController.resolveStatisticsEndMonth(
                LocalDate.of(2026, 6, 30), Arrays.asList(june, july));
        List<SixChargingDto> months = TChargingOrderController.generateLastSixMonths(endMonth);

        assertEquals(LocalDate.of(2026, 7, 30), endMonth);
        assertEquals(Arrays.asList("02", "03", "04", "05", "06", "07"),
                months.stream().map(SixChargingDto::getMonth).collect(java.util.stream.Collectors.toList()));
    }

    @Test
    void blankPhoneDoesNotExpandQueryToAllUserIds() {
        TChargingOrderService chargingOrderService = mock(TChargingOrderService.class);
        AppUserClient appUserClient = mock(AppUserClient.class);
        TChargingOrderController controller = new TChargingOrderController();
        ReflectionTestUtils.setField(controller, "chargingOrderService", chargingOrderService);
        ReflectionTestUtils.setField(controller, "appUserClient", appUserClient);

        ChargingOrderQuery query = new ChargingOrderQuery();
        query.setPhone("");
        when(chargingOrderService.chargingOrder(same(query))).thenReturn(new TCharingOrderVO());

        controller.chargingOrder(query);

        assertNull(query.getUserIds());
        verify(chargingOrderService).chargingOrder(same(query));
        verifyNoInteractions(appUserClient);
    }

    @Test
    void partnerFilterIncludesPrimaryAndVenueSitesRegardlessOfPartnerType() {
        Site primarySite = new Site();
        primarySite.setId(11);
        primarySite.setPartnerId(9);
        Site venueSite = new Site();
        venueSite.setId(12);
        venueSite.setPartnerId(3);
        venueSite.setVenuePartnerId(9);
        Site unrelatedSite = new Site();
        unrelatedSite.setId(13);
        unrelatedSite.setPartnerId(4);

        List<Integer> result = TChargingOrderController.filterPlatformRevenueSiteIdsByPartner(
                Arrays.asList(11, 12, 13), Arrays.asList(primarySite, venueSite, unrelatedSite), 9);

        assertEquals(Arrays.asList(11, 12), result);
    }

    @Test
    void partnerFilterReturnsImpossibleSiteWhenPartnerHasNoAuthorizedSites() {
        Site unrelatedSite = new Site();
        unrelatedSite.setId(13);
        unrelatedSite.setPartnerId(4);

        List<Integer> result = TChargingOrderController.filterPlatformRevenueSiteIdsByPartner(
                Arrays.asList(13), Arrays.asList(unrelatedSite), 9);

        assertEquals(Arrays.asList(-1), result);
    }

    @Test
    void franchiseeUserTagsUsesPersistedUserTagsInsteadOfChargeFrequency() {
        TChargingOrderController controller = new TChargingOrderController();
        AppUserTagClient appUserTagClient = mock(AppUserTagClient.class);
        UserTagClient userTagClient = mock(UserTagClient.class);
        ReflectionTestUtils.setField(controller, "appUserTagClient", appUserTagClient);
        ReflectionTestUtils.setField(controller, "userTagClient", userTagClient);

        TUserTag oldUser = new TUserTag();
        oldUser.setId(1);
        oldUser.setName("老用户");
        TUserTag activeUser = new TUserTag();
        activeUser.setId(2);
        activeUser.setName("活跃用户");
        when(userTagClient.getAllUserTag()).thenReturn(R.ok(Arrays.asList(oldUser, activeUser)));

        TAppUserTag oldUserTag = new TAppUserTag();
        oldUserTag.setAppUserId(101L);
        oldUserTag.setUserTagId(1);
        TAppUserTag duplicateOldUserTag = new TAppUserTag();
        duplicateOldUserTag.setAppUserId(101L);
        duplicateOldUserTag.setUserTagId(1);
        TAppUserTag activeUserTag = new TAppUserTag();
        activeUserTag.setAppUserId(101L);
        activeUserTag.setUserTagId(2);
        when(appUserTagClient.listByUserIds(org.mockito.ArgumentMatchers.anyList()))
                .thenReturn(R.ok(Arrays.asList(oldUserTag, duplicateOldUserTag, activeUserTag)));

        FranchiseeUserAgg firstAgg = new FranchiseeUserAgg();
        firstAgg.setAppUserId(101L);
        FranchiseeUserAgg repeatAgg = new FranchiseeUserAgg();
        repeatAgg.setAppUserId(101L);
        FranchiseeUserAgg untaggedAgg = new FranchiseeUserAgg();
        untaggedAgg.setAppUserId(102L);

        @SuppressWarnings("unchecked")
        List<java.util.Map<String, Object>> result = ReflectionTestUtils.invokeMethod(controller,
                "franchiseeUserTags", Arrays.asList(firstAgg, repeatAgg, untaggedAgg));

        assertEquals(2, result.size());
        assertEquals("老用户", result.get(0).get("name"));
        assertEquals(1L, result.get(0).get("value"));
        assertEquals("活跃用户", result.get(1).get("name"));
        assertEquals(1L, result.get(1).get("value"));
        verify(appUserTagClient).listByUserIds(org.mockito.ArgumentMatchers.anyList());
    }

    @Test
    void franchiseeVehicleClassCountsOrdersInsteadOfDistinctVehicles() {
        TAppUserCar privateCar = new TAppUserCar();
        privateCar.setId(1L);
        privateCar.setVehicleUse("私家车");
        TAppUserCar companyCar = new TAppUserCar();
        companyCar.setId(2L);
        companyCar.setVehicleUse("企业车");
        List<FranchiseeUserAgg> aggs = new java.util.ArrayList<>();
        for (int i = 0; i < 10; i++) {
            FranchiseeUserAgg agg = new FranchiseeUserAgg();
            agg.setAppUserCarId(1L);
            agg.setOrderCount(1L);
            aggs.add(agg);
        }
        for (int i = 0; i < 3; i++) {
            FranchiseeUserAgg agg = new FranchiseeUserAgg();
            agg.setAppUserCarId(2L);
            agg.setOrderCount(1L);
            aggs.add(agg);
        }

        @SuppressWarnings("unchecked")
        List<java.util.Map<String, Object>> result = ReflectionTestUtils.invokeMethod(
                new TChargingOrderController(), "franchiseeOrderCarGroup", aggs,
                Arrays.asList(privateCar, companyCar),
                (java.util.function.Function<TAppUserCar, String>) TAppUserCar::getVehicleUse,
                "未知用途", 5);

        assertEquals("私家车", result.get(0).get("name"));
        assertEquals(10L, result.get(0).get("value"));
        assertEquals("企业车", result.get(1).get("name"));
        assertEquals(3L, result.get(1).get("value"));
    }
}